@datagrok-libraries/bio 5.39.29 → 5.40.1

package/src/utils/{units-handler.js → seq-handler.js}

@@ -1,17 +1,19 @@
 import * as DG from 'datagrok-api/dg';
 import wu from 'wu';
-import { NOTATION, candidateAlphabets, positionSeparator } from './macromolecule';
-import { detectAlphabet, getSplitterForColumn, getSplitterWithSeparator, splitterAsFasta, splitterAsFastaSimple, splitterAsHelm } from './macromolecule/utils';
+import { NOTATION, candidateAlphabets, positionSeparator, splitterAsFasta, getSplitterWithSeparator, splitterAsHelm, } from './macromolecule';
+import { GAP_SYMBOL, } from './macromolecule/types';
+import { detectAlphabet, splitterAsFastaSimple, StringListSeqSplitted } from './macromolecule/utils';
 import { mmDistanceFunctions, MmDistanceFunctionsNames } from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import { getMonomerLibHelper } from '../monomer-works/monomer-utils';
 import { HELM_WRAPPERS_REGEXP, PHOSPHATE_SYMBOL } from './const';
-export const Temps = new class {
+export const SeqTemps = new class {
     constructor() {
-        /** Column's temp slot name for a UnitsHandler object */
-        this.uh = `units-handler.${DG.SEMTYPE.MACROMOLECULE}`;
+        /** Column's temp slot name for a SeqHandler object */
+        this.seqHandler = `seq-handler`;
+        this.notationProvider = `seq-handler.notation-provider`;
     }
 }();
-export const GapSymbols = {
+export const GapOriginals = {
     [NOTATION.FASTA]: '-',
     [NOTATION.SEPARATOR]: '',
     [NOTATION.HELM]: '*',
@@ -19,12 +21,67 @@ export const GapSymbols = {
 /** Class for handling notation units in Macromolecule columns and
  * conversion of notation systems in Macromolecule columns
  */
-export class UnitsHandler {
+export class SeqHandler {
+    constructor(col) {
+        this._splitter = null;
+        this.cached = true;
+        this._splitted = null;
+        this.columnVersion = null;
+        this._stats = null;
+        this._maxLength = null;
+        this._posList = null;
+        this._joiner = undefined;
+        if (col.type !== DG.TYPE.STRING)
+            throw new Error(`Unexpected column type '${col.type}', must be '${DG.TYPE.STRING}'.`);
+        this._column = col;
+        this._columnVersion = col.version;
+        const units = this._column.getTag(DG.TAGS.UNITS);
+        if (units !== null && units !== undefined)
+            this._units = units;
+        else
+            throw new Error('Units are not specified in column');
+        this._notation = this.getNotation();
+        this._defaultGapOriginal = (this.isFasta()) ? GapOriginals[NOTATION.FASTA] :
+            (this.isHelm()) ? GapOriginals[NOTATION.HELM] :
+                GapOriginals[NOTATION.SEPARATOR];
+        if (!this.column.tags.has("aligned" /* TAGS.aligned */) || !this.column.tags.has("alphabet" /* TAGS.alphabet */) ||
+            (!this.column.tags.has(".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */) && !this.isHelm() && this.alphabet === "UN" /* ALPHABET.UN */)) {
+            // The following detectors and setters are to be called because the column is likely
+            // as the UnitsHandler constructor was called on the column.
+            if (this.isFasta())
+                SeqHandler.setUnitsToFastaColumn(this);
+            else if (this.isSeparator()) {
+                const separator = col.getTag("separator" /* TAGS.separator */);
+                SeqHandler.setUnitsToSeparatorColumn(this, separator);
+            }
+            else if (this.isHelm())
+                SeqHandler.setUnitsToHelmColumn(this);
+            else
+                throw new Error(`Unexpected units '${this.column.getTag(DG.TAGS.UNITS)}'.`);
+        }
+        // if (!this.column.tags.has(TAGS.alphabetSize)) {
+        //   if (this.isHelm())
+        //     throw new Error(`For column '${this.column.name}' of notation '${this.notation}' ` +
+        //       `tag '${TAGS.alphabetSize}' is mandatory.`);
+        //   else if (['UN'].includes(this.alphabet))
+        //     throw new Error(`For column '${this.column.name}' of alphabet '${this.alphabet}' ` +
+        //       `tag '${TAGS.alphabetSize}' is mandatory.`);
+        // }
+        if (!this.column.tags.has(".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */)) {
+            if (this.isHelm())
+                this.column.setTag(".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */, 'true');
+            else if (['UN'].includes(this.alphabet)) {
+                throw new Error(`For column '${this.column.name}' of alphabet '${this.alphabet}' ` +
+                    `tag '${".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */}' is mandatory.`);
+            }
+        }
+        this.notationProvider = this.column.temp[SeqTemps.notationProvider] ?? null;
+    }
     static setUnitsToFastaColumn(uh) {
         if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE || uh.column.getTag(DG.TAGS.UNITS) !== NOTATION.FASTA)
             throw new Error(`The column of notation '${NOTATION.FASTA}' must be '${DG.SEMTYPE.MACROMOLECULE}'.`);
         uh.column.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
-        UnitsHandler.setTags(uh);
+        SeqHandler.setTags(uh);
     }
     static setUnitsToSeparatorColumn(uh, separator) {
         if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE || uh.column.getTag(DG.TAGS.UNITS) !== NOTATION.SEPARATOR)
@@ -33,13 +90,13 @@ export class UnitsHandler {
             throw new Error(`The column of notation '${NOTATION.SEPARATOR}' must have the separator tag.`);
         uh.column.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
         uh.column.setTag("separator" /* TAGS.separator */, separator);
-        UnitsHandler.setTags(uh);
+        SeqHandler.setTags(uh);
     }
     static setUnitsToHelmColumn(uh) {
         if (uh.column.semType !== DG.SEMTYPE.MACROMOLECULE)
             throw new Error(`The column of notation '${NOTATION.HELM}' must be '${DG.SEMTYPE.MACROMOLECULE}'`);
         uh.column.setTag(DG.TAGS.UNITS, NOTATION.HELM);
-        UnitsHandler.setTags(uh);
+        SeqHandler.setTags(uh);
     }
     /** From detectMacromolecule */
     static setTags(uh) {
@@ -69,9 +126,10 @@ export class UnitsHandler {
         }
     }
     get column() { return this._column; }
+    get length() { return this._column.length; }
     get units() { return this._units; }
     get notation() { return this._notation; }
-    get defaultGapSymbol() { return this._defaultGapSymbol; }
+    get defaultGapOriginal() { return this._defaultGapOriginal; }
     get separator() {
         const separator = this.column.getTag("separator" /* TAGS.separator */) ?? undefined;
         if (this.notation === NOTATION.SEPARATOR && separator === undefined)
@@ -132,35 +190,57 @@ export class UnitsHandler {
         else
             return this.column.getTag(".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */) === 'true';
     }
-    /** */
-    get splitted() {
-        if (this._splitted === null) {
-            const splitter = this.getSplitter();
-            const colLength = this._column.length;
-            this._splitted = new Array(colLength);
-            const catIdxList = this._column.getRawData();
-            const catList = this._column.categories;
-            for (let rowI = 0; rowI < colLength; rowI++) {
-                const seq = catList[catIdxList[rowI]];
-                this._splitted[rowI] = splitter(seq);
+    // /** */
+    // public get splitted(): ISeqSplitted[] {
+    //   // TODO: Disable cache or invalidate on changing data
+    //   if (this._splitted === null) {
+    //     const splitter = this.splitter;
+    //     const colLength: number = this._column.length;
+    //     this._splitted = new Array(colLength);
+    //     const catIdxList = this._column.getRawData();
+    //     const catList: string[] = this._column.categories;
+    //     for (let rowIdx: number = 0; rowIdx < colLength; rowIdx++) {
+    //       const seq: string = catList[catIdxList[rowIdx]];
+    //       this._splitted[rowIdx] = splitter(seq);
+    //     }
+    //   }
+    //   return this._splitted;
+    // }
+    getSplitted(rowIdx) {
+        if (!this.cached) {
+            const seq = this.column.get(rowIdx);
+            return this.splitter(seq);
+        }
+        else {
+            if (this.column.version !== this.columnVersion || this._splitted === null) {
+                this.columnVersion = this.column.version;
+                this._splitted = new Array(this.column.length);
+            }
+            let resSS = this._splitted[rowIdx] ? this._splitted[rowIdx].deref() : undefined;
+            if (!resSS) {
+                const seq = this.column.get(rowIdx);
+                resSS = this.splitter(seq);
+                this._splitted[rowIdx] = new WeakRef(resSS);
             }
+            return resSS;
         }
-        return this._splitted;
     }
     get stats() {
         if (this._stats === null) {
             const freq = {};
             let sameLength = true;
             let firstLength = null;
-            for (const mSeq of this.splitted) {
+            const colLen = this.column.length;
+            for (let rowIdx = 0; rowIdx < colLen; ++rowIdx) {
+                const mSeq = this.getSplitted(rowIdx);
                 if (firstLength == null)
                     firstLength = mSeq.length;
                 else if (mSeq.length !== firstLength)
                     sameLength = false;
-                for (const m of mSeq) {
-                    if (!(m in freq))
-                        freq[m] = 0;
-                    freq[m] += 1;
+                for (const cm of mSeq.canonicals) {
+                    if (!(cm in freq))
+                        freq[cm] = 0;
+                    freq[cm] += 1;
                 }
             }
             this._stats = { freq: freq, sameLength: sameLength };
@@ -169,8 +249,8 @@ export class UnitsHandler {
     }
     get maxLength() {
         if (this._maxLength === null) {
-            this._maxLength = this.splitted.length === 0 ? 0 :
-                Math.max(...this.splitted.map((seqS) => seqS.length));
+            this._maxLength = this.column.length === 0 ? 0 :
+                Math.max(...wu.count(0).take(this.column.length).map((rowIdx) => this.getSplitted(rowIdx).length));
         }
         return this._maxLength;
     }
@@ -190,9 +270,12 @@ export class UnitsHandler {
     isPeptide() { return this.alphabet === "PT" /* ALPHABET.PT */; }
     isMsa() { return this.aligned ? this.aligned.toUpperCase().includes('MSA') : false; }
     isHelmCompatible() { return this.helmCompatible === 'true'; }
-    isGap(m) {
-        return !m || (this.units === NOTATION.FASTA && m === GapSymbols[NOTATION.FASTA]) ||
-            (this.units === NOTATION.HELM && m === GapSymbols[NOTATION.HELM]);
+    /** Checks {@link om} for being a gap
+     * @param {string} om Original monomer of sequence symbol
+     * @return {boolean}
+     */
+    isGap(om) {
+        return !om || om === this._defaultGapOriginal;
     }
     /** Associate notation types with the corresponding units */
     /**
@@ -246,7 +329,9 @@ export class UnitsHandler {
         const srcAligned = col.getTag("aligned" /* TAGS.aligned */);
         if (srcAligned)
             newColumn.setTag("aligned" /* TAGS.aligned */, srcAligned);
-        const srcAlphabet = col.getTag("alphabet" /* TAGS.alphabet */);
+        let srcAlphabet = col.getTag("alphabet" /* TAGS.alphabet */);
+        if (!srcAlphabet && this.notation === NOTATION.HELM && tgtNotation !== NOTATION.HELM)
+            srcAlphabet = "UN" /* ALPHABET.UN */;
         if (srcAlphabet != null)
             newColumn.setTag("alphabet" /* TAGS.alphabet */, srcAlphabet);
         let srcAlphabetSize = col.getTag(".alphabetSize" /* TAGS.alphabetSize */);
@@ -261,8 +346,9 @@ export class UnitsHandler {
         }
         return newColumn;
     }
-    getNewColumnFromList(name, list) {
-        return this.getNewColumn(this.notation, this.separator, name, list);
+    /** Creates a new column on data of {@link seqList} with the same tags */
+    getNewColumnFromList(name, seqList) {
+        return this.getNewColumn(this.notation, this.separator, name, seqList);
     }
     /**
      * Create a new empty column using templateCol as a template
@@ -272,7 +358,7 @@ export class UnitsHandler {
      * @return {DG.Column}
      */
     static getNewColumn(templateCol) {
-        const col = UnitsHandler.getOrCreate(templateCol);
+        const col = SeqHandler.forColumn(templateCol);
         const targetNotation = col.notation;
         return col.getNewColumn(targetNotation);
     }
@@ -302,7 +388,7 @@ export class UnitsHandler {
         // WARNING: in this implementation is is impossible to verify the uniqueness
         // of the new column's name
         // TODO: verify the validity of units parameter
-        if (!UnitsHandler.unitsStringIsValid(units))
+        if (!SeqHandler.unitsStringIsValid(units))
             throw new Error('Invalid format of \'units\' parameter');
         const newColumn = DG.Column.fromList('string', name, new Array(len).fill(''));
         newColumn.semType = DG.SEMTYPE.MACROMOLECULE;
@@ -311,6 +397,10 @@ export class UnitsHandler {
     }
     /** Gets function to split seq value to monomers */
     getSplitter(limit) {
+        let splitter = null;
+        splitter = this.notationProvider ? this.notationProvider.splitter : null;
+        if (splitter)
+            return splitter;
         if (this.units.toLowerCase().startsWith(NOTATION.FASTA)) {
             const alphabet = this.column.getTag("alphabet" /* TAGS.alphabet */);
             if (alphabet !== null && !this.getAlphabetIsMultichar())
@@ -326,6 +416,9 @@ export class UnitsHandler {
             throw new Error(`Unexpected units ${this.units} .`);
         // TODO: Splitter for HELM
     }
+    split(seq) {
+        return this.splitter(seq);
+    }
     getDistanceFunctionName() {
         // TODO add support for helm and separator notation
         if (!this.isFasta())
@@ -333,10 +426,10 @@ export class UnitsHandler {
         if (this.isMsa())
             return MmDistanceFunctionsNames.HAMMING;
         switch (this.alphabet) {
-            // As DNA and RNA scoring matrices are same as identity matrices(mostly),
-            // we can use very fast and optimized Levenshtein distance library
             case "DNA" /* ALPHABET.DNA */:
             case "RNA" /* ALPHABET.RNA */:
+                // As DNA and RNA scoring matrices are same as identity matrices(mostly),
+                // we can use very fast and optimized Levenshtein distance library
                 return MmDistanceFunctionsNames.LEVENSHTEIN;
             case "PT" /* ALPHABET.PT */:
                 return MmDistanceFunctionsNames.LEVENSHTEIN;
@@ -353,7 +446,7 @@ export class UnitsHandler {
         // check first for the column tag to avoid extra processing
         if (this.column.tags.has(".isHelmCompatible" /* TAGS.isHelmCompatible */))
             return this.column.getTag(".isHelmCompatible" /* TAGS.isHelmCompatible */) === 'true';
-        // get the monolmer lib and check against the column
+        // get the monomer lib and check against the column
         const monomerLibHelper = await getMonomerLibHelper();
         const bioLib = monomerLibHelper.getBioLib();
         // retrieve peptides
@@ -363,14 +456,21 @@ export class UnitsHandler {
         // get splitter for given separator and check if all monomers are in the lib
         const splitterFunc = getSplitterWithSeparator(this.separator);
         // iterate over the columns, split them and check if all monomers are in the lib
-        //TODO maybe add missing threshhold so that if there are not too many missing monomers
+        //TODO maybe add missing threshold so that if there are not too many missing monomers
         // the column is still considered helm compatible
-        for (const row of this.column.categories) {
-            const monomers = splitterFunc(row);
-            for (const monomer of monomers) {
-                if (!peptidesSet.has(monomer)) {
-                    this.column.setTag(".isHelmCompatible" /* TAGS.isHelmCompatible */, 'false');
-                    return false;
+        const catIdxSet = new Set();
+        const rowCount = this.column.length;
+        const colRawData = this.column.getRawData();
+        for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx) {
+            const catI = colRawData[rowIdx];
+            if (!(catI in catIdxSet)) {
+                catIdxSet.add(catI);
+                const monomers = this.getSplitted(rowIdx);
+                for (const cm of monomers.canonicals) {
+                    if (!peptidesSet.has(cm)) {
+                        this.column.setTag(".isHelmCompatible" /* TAGS.isHelmCompatible */, 'false');
+                        return false;
+                    }
                 }
             }
         }
@@ -380,7 +480,7 @@ export class UnitsHandler {
     // -- Notation Converter --
     get splitter() {
         if (this._splitter === null)
-            this._splitter = getSplitterForColumn(this.column);
+            this._splitter = this.getSplitter();
         return this._splitter;
     }
     toFasta(targetNotation) { return targetNotation === NOTATION.FASTA; }
@@ -389,38 +489,38 @@ export class UnitsHandler {
     /**
      *  Convert HELM string to FASTA/SEPARATOR
      *
-     * @param {string} helmPolymer    A string to be converted
+     * @param {string} srcSeq    A string to be converted
      * @param {string} tgtNotation    Target notation: FASTA or SEPARATOR
      * @param {string} tgtSeparator   Optional target separator (for HELM ->
-     * @param {string | null} tgtGapSymbol   Optional target gap symbol
+     * @param {string | null} tgtGapOriginal   Optional target gap symbol
      * SEPARATOR)
      * @return {string} Converted string
      */
-    convertHelmToFastaSeparator(helmPolymer, tgtNotation, tgtSeparator, tgtGapSymbol) {
-        if (!tgtGapSymbol) {
-            tgtGapSymbol = (this.toFasta(tgtNotation)) ?
-                GapSymbols[NOTATION.FASTA] :
-                GapSymbols[NOTATION.SEPARATOR];
+    convertHelmToFastaSeparator(srcSeq, tgtNotation, tgtSeparator, tgtGapOriginal) {
+        if (!tgtGapOriginal) {
+            tgtGapOriginal = (this.toFasta(tgtNotation)) ?
+                GapOriginals[NOTATION.FASTA] :
+                GapOriginals[NOTATION.SEPARATOR];
         }
         if (!tgtSeparator)
             tgtSeparator = (this.toFasta(tgtNotation)) ? '' : this.separator;
-        const isNucleotide = helmPolymer.startsWith('RNA');
+        const isNucleotide = srcSeq.startsWith('RNA');
         // items can be monomers or helms
-        const helmItemsArray = this.splitter(helmPolymer);
+        const helmItemsArray = this.splitter(srcSeq);
         const tgtMonomersArray = [];
-        for (let i = 0; i < helmItemsArray.length; i++) {
-            let item = helmItemsArray[i];
+        for (let posIdx = 0; posIdx < helmItemsArray.length; ++posIdx) {
+            let om = helmItemsArray.getOriginal(posIdx);
             if (isNucleotide)
-                item = item.replace(HELM_WRAPPERS_REGEXP, '');
-            if (item === GapSymbols[NOTATION.HELM])
-                tgtMonomersArray.push(tgtGapSymbol);
-            else if (this.toFasta(tgtNotation) && item.length > 1) {
+                om = om.replace(HELM_WRAPPERS_REGEXP, '');
+            if (om === GapOriginals[NOTATION.HELM])
+                tgtMonomersArray.push(tgtGapOriginal);
+            else if (this.toFasta(tgtNotation) && om.length > 1) {
                 // the case of a multi-character monomer converted to FASTA
-                const monomer = '[' + item + ']';
+                const monomer = '[' + om + ']';
                 tgtMonomersArray.push(monomer);
             }
             else
-                tgtMonomersArray.push(item);
+                tgtMonomersArray.push(om);
         }
         return tgtMonomersArray.join(tgtSeparator);
     }
@@ -431,14 +531,15 @@ export class UnitsHandler {
      * @return {DG.Column}                Converted column
      */
     convert(tgtNotation, tgtSeparator) {
-        const convert = this.getConverter(tgtNotation, tgtSeparator);
+        // Get joiner from the source column units handler (this) knowing about the source sequence.
+        // For example, converting DNA Helm to fasta requires removing the r(X)p decoration.
+        const joiner = this.getJoiner({ notation: tgtNotation, separator: tgtSeparator });
         const newColumn = this.getNewColumn(tgtNotation, tgtSeparator);
         // assign the values to the newly created empty column
-        newColumn.init((rowI) => {
-            const sourceSequence = this.column.get(rowI);
-            return sourceSequence ? convert(sourceSequence) : sourceSequence;
+        newColumn.init((rowIdx) => {
+            const srcSS = this.getSplitted(rowIdx);
+            return joiner(srcSS);
         });
-        // newColumn.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
         return newColumn;
     }
     /**
@@ -449,20 +550,20 @@ export class UnitsHandler {
     getRegion(startIdx, endIdx, name) {
         const regCol = this.getNewColumn(this.notation, this.separator);
         regCol.name = name;
-        const maxLength = Math.max(...this.splitted.map((seqS) => seqS.length));
         const startIdxVal = startIdx ?? 0;
         const endIdxVal = endIdx ?? this.maxLength - 1;
-        const join = this.getJoiner();
+        const joiner = this.getJoiner();
         const regLength = endIdxVal - startIdxVal + 1;
+        const gapOM = GapOriginals[this.notation];
         regCol.init((rowI) => {
-            const seqS = this.splitted[rowI];
+            const seqS = this.getSplitted(rowI);
             // Custom slicing instead of array method to maintain gaps
-            const regMList = new Array(regLength);
+            const regOMList = new Array(regLength);
             for (let regJPos = 0; regJPos < regLength; ++regJPos) {
                 const seqJPos = startIdxVal + regJPos;
-                regMList[regJPos] = seqJPos < seqS.length ? seqS[seqJPos] : GapSymbols[this.notation];
+                regOMList[regJPos] = seqJPos < seqS.length ? seqS.getOriginal(seqJPos) : gapOM;
             }
-            return join(regMList);
+            return joiner(new StringListSeqSplitted(regOMList, gapOM));
         });
         const getRegionOfPositionNames = (str) => {
             const srcPosList = str.split(',').map((p) => p.trim());
@@ -481,159 +582,140 @@ export class UnitsHandler {
             regCol.setTag(".positionLabels" /* TAGS.positionLabels */, getRegionOfPositionNames(srcPositionLabelsStr));
         return regCol;
     }
-    getJoiner() {
-        if (this._joiner === undefined) {
-            const srcUh = this;
-            if (this.notation === NOTATION.FASTA)
-                this._joiner = function (srcS) { return joinToFasta(srcUh, srcS); };
-            else if (this.notation === NOTATION.SEPARATOR)
-                this._joiner = function (srcS) { return joinToSeparator(srcUh, srcS, srcUh.separator); };
-            else if (this.notation === NOTATION.HELM) {
-                const isDnaOrRna = srcUh.alphabet === "DNA" /* ALPHABET.DNA */ || srcUh.alphabet === "RNA" /* ALPHABET.RNA */;
-                this._joiner = function (srcS) { return joinToHelm(srcUh, srcS, isDnaOrRna); };
+    get joiner() {
+        if (!this._joiner)
+            this._joiner = this.getJoiner();
+        return this._joiner;
+    }
+    getJoiner(opts) {
+        const notation = opts ? opts.notation : this.notation;
+        const separator = opts ? opts.separator : this.separator;
+        let res;
+        const srcSh = this;
+        switch (notation) {
+            case NOTATION.FASTA: {
+                res = function (srcSS) { return srcSh.joinToFasta(srcSS, srcSh.isHelm()); };
+                break;
             }
-            else
-                throw new Error();
+            case NOTATION.SEPARATOR: {
+                if (!separator)
+                    throw new Error(`Separator is mandatory for notation '${notation}'.`);
+                res = function (srcSS) { return joinToSeparator(srcSS, separator, srcSh.isHelm()); };
+                break;
+            }
+            case NOTATION.HELM: {
+                const isDnaOrRna = srcSh.alphabet === "DNA" /* ALPHABET.DNA */ || srcSh.alphabet === "RNA" /* ALPHABET.RNA */;
+                const wrappers = srcSh.getHelmWrappers();
+                res = function (srcSS) { return joinToHelm(srcSS, wrappers, isDnaOrRna); };
+                break;
+            }
+            default:
+                throw new Error(`Unexpected notation '${notation}'.`);
         }
-        return this._joiner;
+        return res;
     }
     getConverter(tgtUnits, tgtSeparator = undefined) {
         if (tgtUnits === NOTATION.SEPARATOR && !tgtSeparator)
             throw new Error(`Target separator is not specified for target units '${NOTATION.SEPARATOR}'.`);
-        const srcUh = this;
+        const srcSh = this;
         if (tgtUnits === NOTATION.FASTA)
-            return function (src) { return convertToFasta(srcUh, src); };
+            return function (srcSeq) { return srcSh.convertToFasta(srcSeq); };
         if (tgtUnits === NOTATION.HELM)
-            return function (src) { return convertToHelm(srcUh, src); };
+            return function (srcSeq) { return srcSh.convertToHelm(srcSeq); };
         else if (tgtUnits === NOTATION.SEPARATOR)
-            return function (src) { return convertToSeparator(srcUh, src, tgtSeparator); };
+            return function (srcSeq) { return srcSh.convertToSeparator(srcSeq, tgtSeparator); };
         else
             throw new Error();
     }
-    constructor(col) {
-        this._splitter = null;
-        this._splitted = null;
-        this._stats = null;
-        this._maxLength = null;
-        this._posList = null;
-        this._joiner = undefined;
-        if (col.type !== DG.TYPE.STRING)
-            throw new Error(`Unexpected column type '${col.type}', must be '${DG.TYPE.STRING}'.`);
-        this._column = col;
-        const units = this._column.getTag(DG.TAGS.UNITS);
-        if (units !== null && units !== undefined)
-            this._units = units;
-        else
-            throw new Error('Units are not specified in column');
-        this._notation = this.getNotation();
-        this._defaultGapSymbol = (this.isFasta()) ? GapSymbols[NOTATION.FASTA] :
-            (this.isHelm()) ? GapSymbols[NOTATION.HELM] :
-                GapSymbols[NOTATION.SEPARATOR];
-        if (!this.column.tags.has("aligned" /* TAGS.aligned */) || !this.column.tags.has("alphabet" /* TAGS.alphabet */) ||
-            (!this.column.tags.has(".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */) && !this.isHelm() && this.alphabet === "UN" /* ALPHABET.UN */)) {
-            // The following detectors and setters are to be called because the column is likely
-            // as the UnitsHandler constructor was called on the column.
-            if (this.isFasta())
-                UnitsHandler.setUnitsToFastaColumn(this);
-            else if (this.isSeparator()) {
-                const separator = col.getTag("separator" /* TAGS.separator */);
-                UnitsHandler.setUnitsToSeparatorColumn(this, separator);
-            }
-            else if (this.isHelm())
-                UnitsHandler.setUnitsToHelmColumn(this);
-            else
-                throw new Error(`Unexpected units '${this.column.getTag(DG.TAGS.UNITS)}'.`);
+    /** Gets a column's UnitsHandler object from temp slot or creates a new and stores it to the temp slot. */
+    static forColumn(col) {
+        // TODO: Invalidate col.temp[Temps.uh] checking column's metadata
+        let res = col.temp[SeqTemps.seqHandler];
+        if (!res || res.columnVersion !== col.version)
+            res = col.temp[SeqTemps.seqHandler] = new SeqHandler(col);
+        return res;
+    }
+    // -- joiners & converters --
+    joinToFasta(seqS, isHelm) {
+        const resMList = new Array(seqS.length);
+        for (let posIdx = 0; posIdx < seqS.length; ++posIdx) {
+            const cm = seqS.getOriginal(posIdx);
+            let om = seqS.getOriginal(posIdx);
+            if (isHelm)
+                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
+            if (cm === GAP_SYMBOL)
+                om = GapOriginals[NOTATION.FASTA];
+            else if (cm === PHOSPHATE_SYMBOL)
+                om = '';
+            else if (om.length > 1)
+                om = '[' + om + ']';
+            resMList[posIdx] = om;
         }
-        // if (!this.column.tags.has(TAGS.alphabetSize)) {
-        //   if (this.isHelm())
-        //     throw new Error(`For column '${this.column.name}' of notation '${this.notation}' ` +
-        //       `tag '${TAGS.alphabetSize}' is mandatory.`);
-        //   else if (['UN'].includes(this.alphabet))
-        //     throw new Error(`For column '${this.column.name}' of alphabet '${this.alphabet}' ` +
-        //       `tag '${TAGS.alphabetSize}' is mandatory.`);
-        // }
-        if (!this.column.tags.has(".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */)) {
-            if (this.isHelm())
-                this.column.setTag(".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */, 'true');
-            else if (['UN'].includes(this.alphabet)) {
-                throw new Error(`For column '${this.column.name}' of alphabet '${this.alphabet}' ` +
-                    `tag '${".alphabetIsMultichar" /* TAGS.alphabetIsMultichar */}' is mandatory.`);
+        return resMList.join('');
+    }
+    convertToFasta(src) {
+        const srcUhSplitter = this.splitter;
+        const srcSS = this.isHelm() ? this.splitterAsHelmNucl(src) : srcUhSplitter(src);
+        return this.joinToFasta(srcSS, this.isHelm());
+    }
+    convertToSeparator(src, tgtSeparator) {
+        const srcSS = this.isHelm() ? this.splitterAsHelmNucl(src) : this.splitter(src);
+        return joinToSeparator(srcSS, tgtSeparator, this.isHelm());
+    }
+    convertToHelm(src) {
+        const wrappers = this.getHelmWrappers();
+        const isDnaOrRna = src.startsWith('DNA') || src.startsWith('RNA');
+        const srcSS = this.splitter(src);
+        return joinToHelm(srcSS, wrappers, isDnaOrRna);
+    }
+    /** Splits Helm sequence adjusting nucleotides to single char symbols. (!) Removes lone phosphorus. */
+    splitterAsHelmNucl(src) {
+        const srcMList = this.splitter(src);
+        const tgtMList = new Array(srcMList.length);
+        const isDna = src.startsWith('DNA');
+        const isRna = src.startsWith('RNA');
+        for (let posIdx = 0; posIdx < srcMList.length; ++posIdx) {
+            let om = srcMList.getOriginal(posIdx);
+            if (isDna || isRna) {
+                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
+                om = om === PHOSPHATE_SYMBOL ? null : om;
             }
+            tgtMList[posIdx] = om ? om : null;
         }
+        return new StringListSeqSplitted(tgtMList.filter((om) => !!om), GapOriginals[NOTATION.HELM]);
     }
-    /** Gets a column's UnitsHandler object from temp slot or creates a new and stores it to the temp slot. */
-    static getOrCreate(col) {
-        let res = col.temp[Temps.uh];
-        if (!res)
-            res = col.temp[Temps.uh] = new UnitsHandler(col);
-        return res;
-    }
-}
-function joinToFasta(srcUh, seqS) {
-    const resMList = new Array(seqS.length);
-    for (const [srcM, mI] of wu.enumerate(seqS)) {
-        let m = srcM;
-        if (srcUh.isHelm())
-            m = srcM.replace(HELM_WRAPPERS_REGEXP, '$1');
-        if (srcUh.isGap(m))
-            m = GapSymbols[NOTATION.FASTA];
-        else if (m.length > 1)
-            m = '[' + seqS[mI] + ']';
-        resMList[mI] = m;
-    }
-    return resMList.join('');
 }
-function convertToFasta(srcUh, src) {
-    const srcMList = srcUh.isHelm() ? splitterAsHelmNucl(srcUh, src) : srcUh.getSplitter()(src);
-    return joinToFasta(srcUh, srcMList);
-}
-function joinToSeparator(srcUh, seqS, tgtSeparator) {
+// -- joiners --
+function joinToSeparator(seqS, tgtSeparator, isHelm) {
     const resMList = new Array(seqS.length);
-    for (const [srcM, mI] of wu.enumerate(seqS)) {
-        let m = srcM;
-        if (srcUh.isGap(m))
-            m = GapSymbols[NOTATION.SEPARATOR];
-        resMList[mI] = m;
-    }
-    return resMList.map((m) => m ?? '').join(tgtSeparator);
+    for (let posIdx = 0; posIdx < seqS.length; ++posIdx) {
+        const cm = seqS.getCanonical(posIdx);
+        let om = seqS.getOriginal(posIdx);
+        if (isHelm)
+            om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
+        if (cm === GAP_SYMBOL)
+            om = GapOriginals[NOTATION.SEPARATOR];
+        else if (cm === PHOSPHATE_SYMBOL)
+            om = '';
+        resMList[posIdx] = om;
+    }
+    return resMList.join(tgtSeparator);
 }
-function convertToSeparator(srcUh, src, tgtSeparator) {
-    const srcMList = srcUh.isHelm() ? splitterAsHelmNucl(srcUh, src) : srcUh.getSplitter()(src);
-    return joinToSeparator(srcUh, srcMList, tgtSeparator);
-}
-function joinToHelm(srcUh, seqS, isDnaOrRna) {
-    const [prefix, leftWrapper, rightWrapper, postfix] = srcUh.getHelmWrappers();
-    const resMList = wu(seqS).map((srcM) => {
-        let m = srcM;
-        if (srcUh.isGap(m))
-            m = GapSymbols[NOTATION.HELM];
-        else if (isDnaOrRna)
-            m = m.replace(HELM_WRAPPERS_REGEXP, '$1');
-        else
-            m = srcM.length == 1 ? `${leftWrapper}${srcM}${rightWrapper}` : `${leftWrapper}[${srcM}]${rightWrapper}`;
-        return m;
-    }).toArray();
-    return `${prefix}${resMList.join('.')}${postfix}`;
-}
-function convertToHelm(srcUh, src) {
-    const isDnaOrRna = src.startsWith('DNA') || src.startsWith('RNA');
-    const srcS = srcUh.getSplitter()(src);
-    return joinToHelm(srcUh, srcS, isDnaOrRna);
-}
-/** Splits Helm sequence adjusting nucleotides to single char symbols. (!) Removes lone phosphorus. */
-function splitterAsHelmNucl(srcUh, src) {
-    const srcMList = srcUh.getSplitter()(src);
-    const tgtMList = new Array(srcMList.length);
-    const isDna = src.startsWith('DNA');
-    const isRna = src.startsWith('RNA');
-    for (const [srcM, mI] of wu.enumerate(srcMList)) {
-        let m = srcM;
-        if (isDna || isRna) {
-            m = m.replace(HELM_WRAPPERS_REGEXP, '$1');
-            m = m === PHOSPHATE_SYMBOL ? null : m;
+function joinToHelm(srcSS, wrappers, isDnaOrRna) {
+    const [prefix, leftWrapper, rightWrapper, postfix] = wrappers;
+    const resOMList = new Array(srcSS.length);
+    for (let posIdx = 0; posIdx < srcSS.length; ++posIdx) {
+        const cm = srcSS.getCanonical(posIdx);
+        let om = srcSS.getOriginal(posIdx);
+        if (cm === GAP_SYMBOL)
+            om = GapOriginals[NOTATION.HELM];
+        else {
+            if (isDnaOrRna)
+                om = om.replace(HELM_WRAPPERS_REGEXP, '$1');
+            om = om.length === 1 ? `${leftWrapper}${om}${rightWrapper}` : `${leftWrapper}[${om}]${rightWrapper}`;
         }
-        tgtMList[mI] = m;
+        resOMList[posIdx] = om;
     }
-    return tgtMList.filter((m) => m !== null);
+    return `${prefix}${resOMList.join('.')}${postfix}`;
 }
-//# sourceMappingURL=units-handler.js.map
+//# sourceMappingURL=seq-handler.js.map