vibe-editor 0.0.0

package/src/scripts/js/utils/MEIOperations.js

@@ -0,0 +1,2112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setArticulation = exports.getTimestamp = exports.getElementTimestampById = exports.insertTempo = exports.insertMeter = exports.replaceMeterInScoreDef = exports.insertKey = exports.replaceKeyInScoreDef = exports.insertClef = exports.replaceClefinScoreDef = exports.paste = exports.createTuplet = exports.removeStaff = exports.addStaff = exports.removeMeasure = exports.addMeasure = exports.cleanUp = exports.elementIsOverfilling = exports.changeDur = exports.changeDurationsInLayer = exports.fillLayerWithRests = exports.fillWithRests = exports.disableFeatures = exports.changeMeter = exports.transposeByStep = exports.mergeArticToParent = exports.mergeSectionScoreDefToLayer = exports.adjustAccids = exports.extrapolateMeter = exports.getAbsoluteRatio = exports.connectNotes = exports.addToMEI = exports.getMeterRatioLocal = exports.removeFromMEI = void 0;
+const meiConverter = require("./MEIConverter");
+const random_1 = require("./random");
+const constants_1 = require("../constants");
+const mappings_1 = require("./mappings");
+const mei_template_1 = require("../assets/mei_template");
+const MeasureMatrix_1 = require("../datastructures/MeasureMatrix");
+const countableNoteUnitSelector = ":scope > *[dur]:not([grace])";
+const overfillMeasure = false;
+const siblingNames = ["note", "chord", "clef", "beam"];
+// ":scope > note:not([grace])," +
+// ":scope > chord," +
+// ":scope > beam > chord," +
+// ":scope > beam > note:not([grace])," +
+// ":scope > rest"
+////// DELETE //////
+/**
+ * Remove Elements from MEI.
+ * Some Elements (such as accid...) could are not represeented as elements in the current MEI.
+ * These have to be found in the parent element which have these as an attribute.
+ * @param scoreElements Array of Elements which are marked in the SVG Representation (notes, chords, slur, tie, accid etc..)
+ * @param currentMEI
+ * @returns
+ */
+function removeFromMEI(scoreElements, currentMEI) {
+    return new Promise((resolve) => {
+        scoreElements.forEach(se => {
+            var _a;
+            if (currentMEI.getElementById(se === null || se === void 0 ? void 0 : se.id) !== null) { // this only applies for <note> and <rest>
+                //do not remove completely, replace with rest
+                //currentMEI.getElementById(note.id).remove()
+                if (["note", "chord"].some(s => se.classList.contains(s))) {
+                    replaceWithRest(se, currentMEI);
+                }
+                else {
+                    currentMEI.getElementById(se.id).remove(); // possibility to remove rests entirely
+                }
+                // remove all tie/ harms etc when startid is no more a note or is deleted
+                //currentMEI.querySelectorAll("tie").forEach(t => {
+                currentMEI.querySelectorAll("[startid]").forEach(t => {
+                    var _a;
+                    if (t.getAttribute("startid").includes(se.id)) {
+                        if (currentMEI.getElementById(se.id) === null) {
+                            (_a = currentMEI.querySelector(t.getAttribute("endid"))) === null || _a === void 0 ? void 0 : _a.remove();
+                        }
+                        t.remove();
+                    }
+                });
+            }
+            else {
+                //may be some of the following: accid
+                var closestNote = currentMEI.getElementById((_a = se === null || se === void 0 ? void 0 : se.closest(".note")) === null || _a === void 0 ? void 0 : _a.id);
+                if (closestNote !== null) {
+                    //console.log("removing ", se)
+                    var attrName = se.classList.item(0).toLowerCase();
+                    closestNote.removeAttribute(attrName);
+                    if (attrName === "accid") {
+                        closestNote.removeAttribute("accid.ges");
+                    }
+                }
+                else if (se.closest(".tuplet") !== null) {
+                    var tuplet = currentMEI.querySelector("#" + se.closest(".tuplet").id);
+                    if (tuplet !== null)
+                        tuplet.outerHTML = tuplet.innerHTML; //the element could be gone in current mei, but se is still present
+                }
+            }
+        });
+        //removeEmptyElements(currentMEI)
+        // For now: No Shifts (22.07.2021)
+        // if($(".measure").length > 1){
+        //   checkDeleteShifts(currentMEI);
+        // }
+        cleanUp(currentMEI);
+        //fillWithRests(currentMEI)
+        // Warum ist das ein Problem?
+        currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+        resolve(currentMEI);
+    });
+}
+exports.removeFromMEI = removeFromMEI;
+function checkDeleteShifts(currentMEI) {
+    var meterRatio = getMeterRatioGlobal(currentMEI);
+    var shifters = new Array;
+    var elements = currentMEI.getElementsByTagName("layer");
+    Array.from(elements).forEach(layer => {
+        var actualMeterFill = getAbsoluteRatio(layer);
+        var layerLevel = layer.getAttribute("n");
+        var staffLevel = layer.closest("staff").getAttribute("n");
+        var nextSibling = layer.closest("measure").nextElementSibling;
+        if (actualMeterFill < meterRatio && nextSibling !== null) {
+            let hasStaff = nextSibling.querySelector("staff[n$='" + staffLevel + "'") !== null ? true : false;
+            let hasLayer = nextSibling.querySelector("layer[n$='" + layerLevel + "'") !== null ? true : false;
+            if (hasStaff && hasLayer) {
+                nextSibling = nextSibling.querySelector("staff[n$='" + staffLevel + "'").querySelector("layer[n$='" + layerLevel + "'");
+                Array.from(nextSibling.querySelectorAll(countableNoteUnitSelector)).forEach(node => {
+                    if (actualMeterFill < meterRatio) {
+                        shifters.push(node);
+                    }
+                    actualMeterFill += 1 / parseInt(node.getAttribute("dur"));
+                });
+            }
+        }
+        if (shifters.length > 0) {
+            doShiftLeft(shifters, meterRatio);
+            shifters.length = 0;
+            checkDeleteShifts(currentMEI);
+        }
+    });
+}
+function getMeterRatioGlobal(currentMEI) {
+    var staffDef = currentMEI.getElementsByTagName("staffDef").item(0);
+    var meterRatio = null;
+    //Do I know the meter?
+    if (staffDef.getAttribute(constants_1.constants._METERCOUNT_) !== null && staffDef.getAttribute(constants_1.constants._METERUNIT_) !== null) {
+        meterRatio = parseInt(staffDef.getAttribute(constants_1.constants._METERCOUNT_)) / parseInt(staffDef.getAttribute(constants_1.constants._METERUNIT_));
+    }
+    else {
+        meterRatio = extrapolateMeter(currentMEI);
+    }
+    return meterRatio;
+}
+/**
+ *
+ * @param currentMEI
+ * @param refElement Must be a staff-Element at most
+ */
+function getMeterRatioLocal(currentMEI, refElement) {
+    var _a, _b;
+    var staffElement;
+    if (refElement.tagName !== "staff") {
+        if (refElement.closest("staff") === null) {
+            staffElement = ((_a = currentMEI.getElementById(refElement.id)) === null || _a === void 0 ? void 0 : _a.closest("staff")) || ((_b = currentMEI.getElementById(refElement.parentElement.id)) === null || _b === void 0 ? void 0 : _b.closest("staff"));
+        }
+        else {
+            staffElement = refElement.closest("staff");
+        }
+    }
+    else {
+        staffElement = refElement;
+    }
+    if (staffElement === null || staffElement == undefined) {
+        throw new Error("RefElement must be a staff-Element at most");
+    }
+    var mm = new MeasureMatrix_1.default();
+    mm.populateFromMEI(currentMEI);
+    var measureIdx = staffElement.closest("measure").getAttribute("n");
+    var staffIdx = staffElement.getAttribute("n");
+    var mmStaff = mm.get(measureIdx, staffIdx);
+    return parseInt(mmStaff.meterSig.count) / parseInt(mmStaff.meterSig.unit);
+}
+exports.getMeterRatioLocal = getMeterRatioLocal;
+//////// INSERT ////////// 
+/**
+ * Insert given sound event into MEI
+ * @param newSound NewNote or NewChord to be inserted
+ * @param currentMEI MEI as Document
+ * @param replace Switching to replaceMode (default: False)
+ * @param scoreGraph
+ * @returns mei
+ */
+function addToMEI(newSound, currentMEI, replace = false, scoreGraph = null) {
+    var _a, _b;
+    //return new Promise<Document>((resolve): void => {
+    var currMeiClone = currentMEI.cloneNode(true);
+    var newElem;
+    var nearestNoteIsSameDurRest = false;
+    if (newSound.hasOwnProperty("pname")) {
+        var newNote = newSound;
+        if (newNote.rest) {
+            newElem = currentMEI.createElement("rest");
+        }
+        else {
+            newElem = currentMEI.createElement("note");
+            newElem.setAttribute("pname", newNote.pname);
+            newElem.setAttribute("oct", newNote.oct);
+            if (newNote.accid != undefined) {
+                newElem.setAttribute("accid.ges", newNote.accid);
+            }
+        }
+        newElem.setAttribute("dur", newNote.dur);
+        if (newNote.dots != undefined) {
+            newElem.setAttribute("dots", newNote.dots);
+        }
+        if (newNote.id != undefined && newNote.id !== null) {
+            newElem.setAttribute("id", newNote.id);
+        }
+        //break up an cache beams for easier processing
+        //later all the beams will be reastablished
+        var beams = new Array();
+        currentMEI.querySelector("#" + newNote.nearestNoteId).closest("layer").querySelectorAll("beam").forEach(b => {
+            beams.push(b.cloneNode(true));
+            Array.from(b.children).forEach(e => {
+                b.parentElement.insertBefore(e, b);
+            });
+            b.remove();
+        });
+        //Do sthm with chords
+        if (newNote.chordElement != undefined && !newNote.rest) {
+            var chord;
+            var meiChordEl = currentMEI.getElementById(newNote.chordElement.id);
+            if (newNote.chordElement.classList.contains("chord") || newNote.chordElement.tagName === "chord") {
+                chord = meiChordEl;
+                chord.appendChild(newElem);
+            }
+            else {
+                chord = document.createElement("chord");
+                chord.setAttribute("id", random_1.uuidv4());
+                chord.setAttribute("dur", meiChordEl.getAttribute("dur"));
+                if (meiChordEl.getAttribute("dots") !== null) {
+                    chord.setAttribute("dots", meiChordEl.getAttribute("dots"));
+                }
+                chord.appendChild(newElem);
+                meiChordEl.parentElement.insertBefore(chord, meiChordEl);
+                chord.appendChild(meiChordEl);
+            }
+            chord.childNodes.forEach((n) => {
+                n.removeAttribute("dur");
+                n.removeAttribute("dots");
+            });
+            // check for existing ties within the chord and make one for the new element as well
+            currentMEI.querySelectorAll("tie").forEach(t => {
+                if (Array.from(chord.querySelectorAll("note")).some(n => t.getAttribute("startid") === "#" + n.id)) {
+                    if (!currentMEI.querySelector("tie[startid='#" + newNote.id + "']")) { // just make the tie once (since this can be called twice in recursion)
+                        var addToChord = Object.assign({}, newNote);
+                        addToChord.id = random_1.uuidv4();
+                        var tieEnd = currentMEI.querySelector(t.getAttribute("endid"));
+                        tieEnd = tieEnd.closest("chord") || tieEnd;
+                        addToChord.chordElement = tieEnd;
+                        addToMEI(addToChord, currentMEI, replace);
+                        connectNotes(currentMEI.querySelector("#" + newNote.id), currentMEI.querySelector("#" + addToChord.id), "tie");
+                    }
+                }
+            });
+        }
+        else if (newNote.nearestNoteId !== null) {
+            var sibling = currentMEI.getElementById(newNote.nearestNoteId);
+            if (sibling === null)
+                return;
+            nearestNoteIsSameDurRest = sibling.tagName === "rest" && sibling.getAttribute("dur") === newElem.getAttribute("dur") && sibling.getAttribute("dots") === newElem.getAttribute("dots");
+            //special rule for first element in layer
+            if (sibling.tagName === "layer") {
+                if (scoreGraph !== null) {
+                    sibling = (_a = currentMEI.getElementById(scoreGraph.getCurrentNode().getRight().getId())) === null || _a === void 0 ? void 0 : _a.parentElement;
+                }
+                var firstChild = sibling.firstChild;
+                sibling.insertBefore(newElem, firstChild);
+                if (replace) {
+                    changeDurationsInLayer(currentMEI, [firstChild], newElem);
+                }
+            }
+            else {
+                var parentLayer = sibling.closest("layer");
+                var trueParent = sibling.parentElement;
+                var isTrueSibling = parentLayer == trueParent;
+                var trueSibling = sibling;
+                if (!isTrueSibling) {
+                    var currParent = trueParent;
+                    while (!isTrueSibling) {
+                        trueSibling = currParent;
+                        currParent = currParent === null || currParent === void 0 ? void 0 : currParent.parentElement;
+                        isTrueSibling = currParent.tagName === "layer";
+                    }
+                }
+                if (replace) {
+                    let ms = Array.from(trueSibling.parentElement.querySelectorAll("note:not(chord note), chord, rest, mRest")); //querySelectorAll(":scope > *")
+                    if (newNote.relPosX === "left") {
+                        var measureSiblings = ms.filter((_, i) => i >= ms.indexOf(trueSibling));
+                        trueSibling.parentElement.insertBefore(newElem, trueSibling);
+                        changeDurationsInLayer(currentMEI, measureSiblings, newElem);
+                    }
+                    else {
+                        if (["clef"].every(el => { var _a; return ((_a = trueSibling.nextElementSibling) === null || _a === void 0 ? void 0 : _a.tagName) !== el; }) && trueSibling.nextElementSibling !== null) {
+                            var measureSiblings = ms.filter((_, i) => i >= ms.indexOf(trueSibling.nextElementSibling));
+                            trueSibling.parentElement.insertBefore(newElem, trueSibling.nextElementSibling);
+                            changeDurationsInLayer(currentMEI, measureSiblings, newElem);
+                        }
+                        else {
+                            trueSibling.parentElement.insertBefore(newElem, trueSibling.nextElementSibling);
+                        }
+                    }
+                }
+                else {
+                    if (newNote.relPosX === "left") {
+                        trueSibling.parentElement.insertBefore(newElem, trueSibling);
+                    }
+                    else {
+                        trueSibling.parentElement.insertBefore(newElem, trueSibling.nextElementSibling);
+                    }
+                }
+            }
+        }
+        else {
+            currentMEI.getElementById(newNote.staffId).querySelector("layer").appendChild(newElem);
+        }
+    }
+    else { // is newChord
+        //TODO
+        var newChord = newSound;
+        newElem = convertToElement(newChord, currentMEI);
+        var nearestElem = currentMEI.getElementById(newChord.nearestNoteId);
+        if ((nearestElem === null || nearestElem === void 0 ? void 0 : nearestElem.tagName) === "layer") {
+            nearestElem.insertBefore(newElem, nearestElem.firstChild);
+        }
+        else if (newChord.relPosX === "left") {
+            nearestElem.parentElement.insertBefore(newElem, currentMEI.getElementById(newChord.nearestNoteId));
+        }
+        else {
+            nearestElem.parentElement.insertBefore(newElem, currentMEI.getElementById(newChord.nearestNoteId).nextSibling);
+        }
+    }
+    // if measure overfills tie note to next measure
+    var currentLayer = newElem.closest("layer");
+    if (!overfillMeasure) {
+        var newMeasureRatio = getAbsoluteRatio(newElem.closest("layer"));
+        var measureRatio = getMeterRatioLocal(currMeiClone, newElem);
+        if (newMeasureRatio > measureRatio) {
+            //currentMEI = currMeiClone as Document
+            // Decide if next measure should be created and what should be added
+            var lastElement = Array.from(currentLayer.querySelectorAll(":scope > :is(note, chord)")).reverse()[0];
+            var lastElementRatio = getAbsoluteRatio(lastElement);
+            var measureOverhead = newMeasureRatio - measureRatio;
+            var newRatio = lastElementRatio - measureOverhead;
+            if (newRatio > 0) {
+                changeDur(lastElement, newRatio);
+                // create new Element and if needed, new measure
+                var splittedElement = lastElement.tagName === "note" ? convertToNewNote(lastElement) : convertToNewChord(lastElement);
+                splittedElement.id = random_1.uuidv4();
+                var newDur = ratioToDur(measureOverhead);
+                splittedElement.dur = newDur[0].toString();
+                splittedElement.dots = newDur[1].toString();
+                if (currentLayer.closest("measure") === currentLayer.closest("section").lastElementChild) {
+                    addMeasure(currentMEI);
+                }
+                var newLayer = currentMEI.querySelector("measure[n='" + (parseInt(currentLayer.closest("measure").getAttribute("n")) + 1).toString() + "'] layer[n='" + currentLayer.getAttribute("n") + "']");
+                splittedElement.nearestNoteId = newLayer.id;
+                splittedElement.staffId = newLayer.closest("staff").id;
+                splittedElement.relPosX = "left";
+                addToMEI(splittedElement, currentMEI, replace);
+                connectNotes(lastElement, currentMEI.querySelector("#" + splittedElement.id), "tie");
+            }
+            else if (newRatio == 0 && measureOverhead > 0) { // if the measure is perfectly fine and there should be no tie, modify the newsound (push it one position to the right) and compute again
+                currentMEI = currMeiClone;
+                if (currentLayer.closest("measure").nextElementSibling === null) { // add measure if there is none to extend into
+                    addMeasure(currentMEI);
+                }
+                var cl = currentMEI.getElementById(currentLayer.id);
+                newSound.nearestNoteId = (_b = cl.closest("measure").nextElementSibling.querySelector("staff[n='" + cl.closest("staff").getAttribute("n") + "'] layer[n='" + cl.getAttribute("n") + "'] :is(chord, note, rest, mRest)")) === null || _b === void 0 ? void 0 : _b.id;
+                newSound.relPosX = "left";
+                if (newSound.nearestNoteId !== null) {
+                    currentMEI = addToMEI(newSound, currentMEI, replace);
+                }
+            }
+        }
+    }
+    newElem = currentMEI.querySelector("#" + newElem.id);
+    fillLayerWithRests(currentLayer, currentMEI);
+    //reestablish beams
+    beams.forEach(b => {
+        var first;
+        var last;
+        Array.from(b.children).forEach(bc => {
+            var existingChild = currentMEI.querySelector("#" + bc.id);
+            if (existingChild !== null) {
+                if (first == undefined) {
+                    first = bc;
+                }
+                else {
+                    last = bc;
+                }
+            }
+            else if (first == undefined) {
+                first = newElem;
+            }
+        });
+        if (last == undefined) {
+            last = newElem;
+        }
+        if (first != undefined && last != undefined) {
+            var newBeam = currentMEI.createElement("beam");
+            newBeam.id = b.id;
+            var beamElements = currentMEI.querySelectorAll("#" + first.id + ", #" + first.id + "~ *:not(#" + last.id + "~ *)"); // all elements in between first and last
+            beamElements[0].insertAdjacentElement("beforebegin", newBeam);
+            beamElements.forEach(be => {
+                newBeam.append(be);
+            });
+        }
+    });
+    cleanUp(currentMEI);
+    adjustAccids(currentMEI);
+    currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+    return currentMEI;
+}
+exports.addToMEI = addToMEI;
+/**
+ * Check if notes have to be shifted after insertion
+ * @param currentMEI
+ */
+function checkInsertShifts(currentMEI) {
+    var staffDef = currentMEI.getElementsByTagName("staffDef").item(0);
+    var meterRatio = parseInt(staffDef.getAttribute(constants_1.constants._METERCOUNT_)) / parseInt(staffDef.getAttribute(constants_1.constants._METERUNIT_));
+    if (staffDef.getAttribute(constants_1.constants._METERCOUNT_) !== null && staffDef.getAttribute(constants_1.constants._METERUNIT_) !== null) {
+        meterRatio = parseInt(staffDef.getAttribute(constants_1.constants._METERCOUNT_)) / parseInt(staffDef.getAttribute(constants_1.constants._METERUNIT_));
+    }
+    else {
+        meterRatio = extrapolateMeter(currentMEI);
+    }
+    var shifters = new Array;
+    var elements = currentMEI.getElementsByTagName("layer");
+    Array.from(elements).forEach(layer => {
+        var i = 0;
+        var layerChildern = layer.querySelectorAll(countableNoteUnitSelector);
+        Array.from(layerChildern).forEach(node => {
+            i += getAbsoluteRatio(node); //1/parseInt(node.getAttribute("dur"))
+            if (i > meterRatio) {
+                shifters.push(node);
+            }
+        });
+        if (shifters.length > 0) {
+            doShiftRight(shifters, meterRatio, layer);
+            shifters.length = 0;
+            checkInsertShifts(currentMEI);
+        }
+    });
+}
+/**
+ * Shift all Elements to the right (according to measure borders)
+ * @param arr Array of Elements to be shifted
+ * @param meterRatio
+ * @param currentLayer
+ */
+function doShiftRight(arr, meterRatio, currentLayer) {
+    arr.forEach((element, elementIdx) => {
+        var parentMeasure = element.closest("measure");
+        var parentMeasureSibling = null;
+        parentMeasureSibling = parentMeasure.nextElementSibling;
+        if (parentMeasureSibling === null) {
+            parentMeasureSibling = parentMeasure.parentElement.appendChild(createEmptyCopy(parentMeasure));
+        }
+        var layerLevel = element.closest("layer").getAttribute("n");
+        var staffLevel = element.closest("staff").getAttribute("n");
+        var targetStaff = parentMeasureSibling.querySelector("staff[n$='" + staffLevel + "'");
+        var targetLayer;
+        if (targetStaff.querySelector("layer[n$='" + layerLevel + "'") !== null) {
+            targetLayer = targetStaff.querySelector("layer[n$='" + layerLevel + "'");
+        }
+        else {
+            targetLayer = document.createElement("layer");
+            targetLayer.setAttribute("id", "layer-" + random_1.uuidv4());
+            targetLayer.setAttribute("n", layerLevel);
+            targetStaff.appendChild(targetLayer);
+        }
+        var absLayerRatio = getAbsoluteRatio(currentLayer);
+        var elementRatio = getAbsoluteRatio(element);
+        var chunkDurRight = absLayerRatio - meterRatio;
+        var chunkDurLeft = elementRatio - chunkDurRight;
+        if (chunkDurRight > elementRatio) {
+            chunkDurRight = elementRatio;
+            chunkDurLeft = 0;
+        }
+        //check if note must be split
+        if ((absLayerRatio + elementRatio) > meterRatio && chunkDurRight * chunkDurLeft !== 0) {
+            //check for dots
+            if (Number.isInteger(1 / chunkDurLeft) && Number.isInteger(1 / chunkDurRight)) {
+                element.removeAttribute("dots");
+                var splitRightElement = element.cloneNode(true);
+                splitRightElement.setAttribute("id", random_1.uuidv4());
+                splitRightElement.setAttribute("dur", (Math.abs(1 / chunkDurRight)).toString());
+                var beforeElement = elementIdx === 0 ? targetLayer.firstChild : targetLayer.children.item(elementIdx);
+                targetLayer.insertBefore(splitRightElement, beforeElement);
+                //change already existing element
+                element.setAttribute("dur", (Math.abs(1 / chunkDurLeft)).toString());
+            }
+            else {
+                var dottedElements = splitDottedNote(element, chunkDurLeft, chunkDurRight);
+                dottedElements.left.forEach(lel => currentLayer.appendChild(lel));
+                var beforeElement = elementIdx === 0 ? targetLayer.firstChild : targetLayer.children.item(elementIdx);
+                dottedElements.right.forEach(rel => {
+                    rel.setAttribute("id", random_1.uuidv4());
+                    if (rel.tagName === "chord") {
+                        rel.querySelectorAll("note").forEach(rl => {
+                            rl.setAttribute("id", random_1.uuidv4());
+                        });
+                    }
+                    targetLayer.insertBefore(rel, beforeElement);
+                });
+                element.remove();
+            }
+        }
+        else {
+            var beforeElement = elementIdx === 0 ? targetLayer.firstChild : targetLayer.children.item(elementIdx);
+            targetLayer.insertBefore(element, beforeElement);
+        }
+    });
+}
+function createEmptyCopy(element) {
+    let copy = element.cloneNode(true);
+    let childrenToDelete = Array.from(copy.querySelectorAll("layer > *, measure > slur"));
+    childrenToDelete.forEach(child => {
+        child.parentNode.removeChild(child);
+    });
+    //set new ids for everything
+    copy.setAttribute("id", random_1.uuidv4());
+    copy.setAttribute("n", (parseInt(element.getAttribute("n")) + 1).toString());
+    let allElements = copy.querySelectorAll("*");
+    allElements.forEach(e => e.setAttribute("id", random_1.uuidv4()));
+    return copy;
+}
+function connectNotes(left, right, connectionShape) {
+    var leftpname = left.getAttribute("pname");
+    var leftoct = left.getAttribute("oct");
+    var leftAccid = left.getAttribute("accid") || left.getAttribute("accid.ges");
+    var rightpname = right.getAttribute("pname");
+    var rightoct = right.getAttribute("oct");
+    var rightAccid = right.getAttribute("accid") || right.getAttribute("accid.ges");
+    if (!(leftpname === rightpname && leftoct === rightoct && leftAccid === rightAccid)) {
+        connectionShape = "slur";
+    }
+    var currentMEI = left.getRootNode();
+    var connections = currentMEI.querySelectorAll("tie, slur");
+    var deleted = false;
+    connections.forEach(c => {
+        var sid = c.getAttribute("startid").replace("#", "");
+        var eid = c.getAttribute("endid").replace("#", "");
+        if (sid === left.id && eid === right.id) {
+            c.remove();
+            deleted = true;
+        }
+    });
+    if (!deleted) {
+        var tieElement = currentMEI.createElementNS(constants_1.constants._MEINS_, connectionShape);
+        tieElement.setAttribute("startid", "#" + left.id);
+        tieElement.setAttribute("endid", "#" + right.id);
+        tieElement.setAttribute("id", random_1.uuidv4());
+        currentMEI.getElementById(left.id).closest("measure").append(tieElement);
+    }
+}
+exports.connectNotes = connectNotes;
+///// GENERAL OPERATIONS /////
+function getAbsoluteRatio(el) {
+    var i = 0;
+    var arr;
+    if (el === null) {
+        return 0;
+    }
+    if (el.tagName !== "layer") { //if single Element is given, eg. chord, note
+        arr = [el];
+    }
+    else {
+        arr = Array.from(el.querySelectorAll(countableNoteUnitSelector));
+    }
+    arr.forEach(node => {
+        i += 1 / parseInt(node.getAttribute("dur"));
+        let baseDur = parseInt(node.getAttribute("dur"));
+        if (node.getAttribute("dots") !== null) {
+            let dots = parseInt(node.getAttribute("dots"));
+            i += dots == 0 ? 0 : (dots * 2 - 1) / (baseDur * 2 * dots);
+        }
+    });
+    return i;
+}
+exports.getAbsoluteRatio = getAbsoluteRatio;
+function ratioToDur(ratio) {
+    var dur;
+    var dots = 0;
+    //1. next smallest ratio of basedur
+    var basedur = 1;
+    while (basedur > ratio) {
+        basedur = basedur / 2;
+    }
+    dur = 1 / basedur;
+    ratio -= basedur;
+    if (ratio > 0) {
+        if (ratio > dur / 2) {
+            dots = 2;
+        }
+        else {
+            dots = 1;
+        }
+    }
+    return [dur, dots];
+}
+/**
+ * Shift Elements to left (according to measure borders)
+ * @param arr Array of Elements to shift
+ * @param meterRatio meterRatio of the piece
+ */
+function doShiftLeft(arr, meterRatio) {
+    arr.forEach(element => {
+        var parentMeasure = element.closest("measure");
+        var parentMeasureSibling = parentMeasure.previousElementSibling;
+        var layerLevel = element.closest("layer").getAttribute("n");
+        var targetLayer = parentMeasureSibling.querySelector("layer[n$='" + layerLevel + "'"); // should be <layer>
+        var absLayerRatio = getAbsoluteRatio(targetLayer);
+        var elementRatio = getAbsoluteRatio(element);
+        //check if note must be split
+        if ((absLayerRatio + elementRatio) > meterRatio) {
+            var chunkDurLeft = meterRatio - absLayerRatio;
+            var chunkDurRight = elementRatio - chunkDurLeft;
+            //check for dots
+            if (Number.isInteger(1 / chunkDurLeft) && Number.isInteger(1 / chunkDurRight)) {
+                element.removeAttribute("dots");
+                var splitLeftElement = element.cloneNode(true);
+                splitLeftElement.setAttribute("id", random_1.uuidv4());
+                splitLeftElement.setAttribute("dur", (Math.abs(1 / chunkDurLeft)).toString());
+                targetLayer.appendChild(splitLeftElement);
+                //change already existing element
+                element.setAttribute("dur", (Math.abs(1 / chunkDurRight)).toString());
+            }
+            else {
+                var elements = splitDottedNote(element, chunkDurLeft, chunkDurRight);
+                elements.left.forEach(lel => {
+                    lel.setAttribute("id", random_1.uuidv4());
+                    if (lel.tagName === "chord") {
+                        lel.querySelectorAll("note").forEach(ll => {
+                            ll.setAttribute("id", random_1.uuidv4());
+                        });
+                    }
+                    targetLayer.appendChild(lel);
+                });
+                elements.right.forEach(rel => element.parentElement.insertBefore(rel, element));
+                element.remove();
+            }
+        }
+        else {
+            targetLayer.appendChild(element);
+            //is current Layer empty and should be deleted? if split occured this should not be the case
+            var parentLayer = parentMeasure.querySelector("layer[n$='" + layerLevel + "'"); // should always be <layer>
+            // if(parentLayer.childNodes.length === 0){
+            //    parentMeasure.remove();
+            // }
+        }
+    });
+}
+/**
+ * Operations to split dotted notes
+ * @param note reference note elements
+ * @param chunkLeftDur calculated ratio left
+ * @param chunkRightDur calculated ratio right
+ * @returns collection of right ans left elements
+ */
+function splitDottedNote(note, chunkLeftDur, chunkRightDur) {
+    let gcdLeft = gcd(chunkLeftDur);
+    let gcdRight = gcd(chunkRightDur);
+    let countLeftSubNotes = findDotsRecursive(chunkLeftDur, gcdLeft); //return z.B.: [8, 16]
+    let countRightSubNotes = findDotsRecursive(chunkRightDur, gcdRight); //return z.B. [2, 8, 16]
+    let newLeftElement = createElementsFromSubNotes(note, countLeftSubNotes);
+    let newRightElement = createElementsFromSubNotes(note, countRightSubNotes);
+    return { left: newLeftElement, right: newRightElement };
+}
+/**
+ * Create actual XML Elements from sequence of dotted notes
+ * @param note
+ * @param subNoteDurs
+ * @returns
+ */
+function createElementsFromSubNotes(note, subNoteDurs) {
+    let newElements = new Array();
+    //find sliceBoundaries in array
+    let arraySliceIdx = new Array();
+    for (var i = 0; i < subNoteDurs.length; i++) {
+        if (i > 0) {
+            if (subNoteDurs[i] !== subNoteDurs[i - 1] * 2) {
+                arraySliceIdx.push(i);
+            }
+        }
+    }
+    //find actual slices 
+    let durSlices = new Array();
+    for (var i = 0; i < arraySliceIdx.length + 1; i++) {
+        if (i === 0) {
+            durSlices.push(subNoteDurs.slice(0, arraySliceIdx[i]));
+        }
+        else if (i === arraySliceIdx.length) {
+            durSlices.push(subNoteDurs.slice(arraySliceIdx[i - 1]));
+        }
+        else {
+            durSlices.push(subNoteDurs.slice(arraySliceIdx[i - 1], arraySliceIdx[i]));
+        }
+    }
+    //create notes
+    let createArr = durSlices.length > 0 ? durSlices : [subNoteDurs];
+    createArr.forEach(durs => {
+        let newElement = note.cloneNode(true);
+        newElement.removeAttribute("dots"); //eventual dots could be in original note value
+        newElement.setAttribute("dur", Math.abs(durs[0]).toString());
+        let dots = 0;
+        durs.forEach((dur, i) => {
+            if (i > 0) {
+                dots += 1;
+            }
+        });
+        if (dots > 0) {
+            newElement.setAttribute("dots", dots.toString());
+        }
+        newElements.push(newElement);
+    });
+    return newElements;
+}
+/**
+ * Compute greatest integer divisor
+ * @param chunkDur Duration of given Chunk
+ * @returns
+ */
+function gcd(chunkDur) {
+    var largestModulo = null;
+    var baseValue = 1;
+    var mod = 0;
+    while (largestModulo === null) {
+        mod = chunkDur % baseValue;
+        if (mod === 0) {
+            largestModulo = baseValue;
+        }
+        baseValue = baseValue / 2;
+    }
+    return largestModulo;
+}
+/**
+ * Splits duration of given chunk into possible dotted sequences
+ * @param chunk
+ * @param smallestUnit = greatest integer divisor
+ * @returns
+ */
+function findDotsRecursive(chunk, smallestUnit) {
+    var arr = new Array();
+    var sliceChunk = chunk / smallestUnit;
+    if (Math.floor(sliceChunk) > 1) {
+        arr = arr.concat(findDotsRecursive(chunk, smallestUnit * 2));
+    }
+    else if (Math.floor(sliceChunk) < 1) {
+        arr = arr.concat(findDotsRecursive(chunk, smallestUnit / 2));
+    }
+    else if (!Number.isInteger(sliceChunk)) {
+        arr.push(1 / 1 / smallestUnit);
+        arr = arr.concat(findDotsRecursive(chunk - smallestUnit, smallestUnit));
+    }
+    else {
+        arr.push(1 / 1 / smallestUnit);
+    }
+    return arr; //.sort((a,b) => a-b)
+}
+/**
+ * Extrapolates meter, if is not given in scoreDef. Iterates through each staff to get the mostly found ratio
+ * @param currentMEI
+ * @returns meter ratio
+ */
+function extrapolateMeter(currentMEI) {
+    var ratioMap = new Map();
+    var xmlCopy = currentMEI.cloneNode(true);
+    var layers = Array.from(xmlCopy.querySelectorAll("layer"));
+    var mostlyUsedRatio = 0;
+    layers.forEach(layer => {
+        if (layer.childElementCount === 0) {
+            return;
+        }
+        //strip all unnecessary elements: garce notes, beams 
+        //which do not contribute to count of measure duration
+        var beams = Array.from(layer.querySelectorAll("beam"));
+        beams.forEach(beam => {
+            Array.from(beam.children).forEach(c => {
+                beam.parentElement.append(c);
+            });
+            xmlCopy.getElementById(beam.id).remove();
+        });
+        var graceNotes = Array.from(layer.querySelectorAll("[grace]"));
+        graceNotes.forEach(g => {
+            xmlCopy.getElementById(g.id).remove();
+        });
+        var childElements = Array.from(layer.children);
+        var ratio = 0;
+        childElements.forEach(element => {
+            ratio += getAbsoluteRatio(element);
+        });
+        if (!ratioMap.has(ratio)) {
+            ratioMap.set(ratio, 1);
+        }
+        else {
+            ratioMap.set(ratio, ratioMap.get(ratio) + 1);
+        }
+        var prevItCount = 0;
+        for (const [key, value] of ratioMap.entries()) {
+            if (value > prevItCount) {
+                prevItCount = value;
+                mostlyUsedRatio = key;
+            }
+        }
+    });
+    return mostlyUsedRatio;
+}
+exports.extrapolateMeter = extrapolateMeter;
+/**
+ * Adjust all accids according to key signature
+ * e.g. after changing global Key
+ * @param currentMEI
+ * @returns
+ */
+function adjustAccids(currentMEI) {
+    var measureMatrix = new MeasureMatrix_1.default();
+    measureMatrix.populateFromMEI(currentMEI);
+    var prevAccidMap = new Map(); // key: pname+oct
+    var currentLayer = "1";
+    var currentStaff = "1";
+    var currentMeasure = "1";
+    currentMEI.querySelectorAll("note").forEach(note => {
+        var layerN = note.closest("layer").getAttribute("n");
+        var staffN = note.closest("staff").getAttribute("n");
+        var measureN = note.closest("measure").getAttribute("n");
+        if (layerN !== currentLayer || staffN !== currentStaff || measureN !== currentMeasure) {
+            prevAccidMap = new Map(); // key: pname+oct
+            currentLayer = layerN;
+            currentStaff = staffN;
+            currentMeasure = measureN;
+        }
+        var sig = measureMatrix.get(measureN, staffN).keysig;
+        var sigSymbol = sig.charAt(1);
+        var signedNotes = mappings_1.keysigToNotes.get(sig);
+        var accid = note.getAttribute("accid") || note.getAttribute("accid.ges");
+        accid = accid === "n" || accid === "" ? null : accid;
+        // remove all accids so I don't have to look it up several times
+        note.removeAttribute("accid");
+        note.removeAttribute("accid.ges");
+        var pname = note.getAttribute("pname");
+        var oct = note.getAttribute("oct");
+        var mapKey = pname + oct;
+        var noteInKey = signedNotes.some(sn => sn === pname);
+        if (accid === null) { // "I have no accid"
+            accid = "n";
+            if (prevAccidMap.has(mapKey)) { // "does someone before me has any accid?"
+                if (prevAccidMap.get(mapKey) === "n") {
+                    prevAccidMap.delete(mapKey);
+                }
+                else {
+                    note.setAttribute("accid", accid);
+                    prevAccidMap.set(mapKey, accid);
+                }
+            }
+            else if (noteInKey) {
+                note.setAttribute("accid", accid);
+                prevAccidMap.set(mapKey, accid);
+            }
+        }
+        else { // "I have accid" 
+            if (prevAccidMap.has(mapKey)) {
+                if (prevAccidMap.get(mapKey) === accid) {
+                    note.setAttribute("accid.ges", accid);
+                    prevAccidMap.set(mapKey, accid);
+                }
+                else {
+                    note.setAttribute("accid", accid);
+                    prevAccidMap.set(mapKey, accid);
+                }
+            }
+            else {
+                if (noteInKey) {
+                    if (sigSymbol === accid) {
+                        if (prevAccidMap.has(mapKey)) {
+                            if (prevAccidMap.get(mapKey) === accid) {
+                                note.setAttribute("accid.ges", accid);
+                                prevAccidMap.set(mapKey, accid);
+                            }
+                            else {
+                                note.setAttribute("accid", accid);
+                                prevAccidMap.set(mapKey, accid);
+                            }
+                        }
+                        else {
+                            if (sigSymbol === accid) {
+                                note.setAttribute("accid.ges", accid);
+                                prevAccidMap.set(mapKey, accid);
+                            }
+                            else {
+                                note.setAttribute("accid", accid);
+                                prevAccidMap.set(mapKey, accid);
+                            }
+                        }
+                    }
+                    else {
+                        note.setAttribute("accid", accid);
+                        prevAccidMap.set(mapKey, accid);
+                    }
+                }
+                else {
+                    note.setAttribute("accid", accid);
+                    prevAccidMap.set(mapKey, accid);
+                }
+            }
+        }
+    });
+    return currentMEI;
+}
+exports.adjustAccids = adjustAccids;
+/**
+ * Merge all scoreDefs in sections in the respective layers, e.g. when importing a file.
+ * This is important since MeasureMartrix only handles signature elements (keySig, meterSig, clef) in layers
+ * @param currentMEI
+ */
+function mergeSectionScoreDefToLayer(currentMEI) {
+    var mei;
+    if (typeof currentMEI === "string") {
+        mei = new DOMParser().parseFromString(currentMEI, "text/xml");
+    }
+    else {
+        mei = currentMEI;
+    }
+    mei.querySelectorAll("section").forEach(sec => {
+        var secChildren = sec.querySelectorAll(":scope > *");
+        secChildren.forEach((e, i) => {
+            if (e.tagName === "scoreDef") {
+                secChildren[i + 1].querySelectorAll("layer").forEach(layer => {
+                    e.querySelectorAll(":scope > *").forEach(sig => {
+                        var newElem = sig.cloneNode(true);
+                        layer.prepend(newElem);
+                    });
+                });
+            }
+        });
+        sec.querySelectorAll(":scope > scoreDef").forEach(sd => sd.remove());
+    });
+    return mei;
+}
+exports.mergeSectionScoreDefToLayer = mergeSectionScoreDefToLayer;
+function mergeArticToParent(currentMEI) {
+    currentMEI.querySelectorAll("artic").forEach(a => {
+        a.parentElement.setAttribute("artic", a.getAttribute("artic"));
+        a.remove();
+    });
+    return currentMEI;
+}
+exports.mergeArticToParent = mergeArticToParent;
+/**
+ * Transpose marked notes according to direcion (up or down)
+ * @param currentMEI
+ * @param direction
+ * @returns
+ */
+function transposeByStep(currentMEI, direction) {
+    //document.querySelectorAll(".activeContainer #vrvSVG :is(.note.marked, .note.lastAdded)").forEach(nm => {
+    document.querySelectorAll(".activeContainer :is(.note.marked, .note.lastAdded)").forEach(nm => {
+        if (nm.id === null || nm.id == undefined || nm.id === "")
+            return; // make shure that only the id is taken from the verovio svg so that the element will only be effected once
+        var id = nm.id;
+        var noteMEI = currentMEI.getElementById(id);
+        var pname = noteMEI.getAttribute("pname");
+        var oct = parseInt(noteMEI.getAttribute("oct"));
+        var accid = noteMEI.getAttribute("accid") || noteMEI.getAttribute("accid.ges");
+        if (accid === null || typeof accid == "undefined" || accid === "n") {
+            accid = "";
+        }
+        var nextNote;
+        if (direction === "up") {
+            nextNote = mappings_1.nextStepUp.get(pname + accid);
+        }
+        else if (direction === "down") {
+            nextNote = mappings_1.nextStepDown.get(pname + accid);
+        }
+        noteMEI.setAttribute("pname", nextNote.charAt(0));
+        if (nextNote.charAt(1) !== "") {
+            noteMEI.setAttribute("accid", nextNote.charAt(1));
+        }
+        else {
+            noteMEI.removeAttribute("accid");
+            noteMEI.removeAttribute("accid.ges");
+        }
+        //Change Octave
+        if (["c", "cf"].includes(pname + accid) && direction === "down") {
+            noteMEI.setAttribute("oct", (oct - 1).toString());
+        }
+        if (["b", "bs"].includes(pname + accid) && direction === "up") {
+            noteMEI.setAttribute("oct", (oct + 1).toString());
+        }
+    });
+    return adjustAccids(currentMEI);
+}
+exports.transposeByStep = transposeByStep;
+/**
+ * Change Meter according to #timeUnit and #timeCount in side bar option.
+ * @param currentMEI
+ * @returns changed mei; null, if input has no valid values
+ */
+function changeMeter(currentMEI) {
+    var timeCount = document.querySelector(".activeElement #timeCount");
+    var timeUnit = document.querySelector(".activeElement #timeUnit");
+    //@ts-ignore
+    var timeCountValue = timeCount.value; //getAttribute("value")
+    //@ts-ignore
+    var timeUnitValue = timeUnit.value; //getAttribute("value")
+    if (timeCountValue !== null && timeUnitValue !== null) {
+        timeCountValue = timeCountValue.trim();
+        timeUnitValue = timeUnitValue.trim();
+        if (!isNaN(parseInt(timeCountValue)) && !isNaN(parseInt(timeUnitValue))) {
+            var oldMeterRatio = getMeterRatioGlobal(currentMEI);
+            currentMEI.querySelectorAll("staffDef").forEach(sd => {
+                sd.setAttribute("meter.count", timeCountValue);
+                sd.setAttribute("meter.unit", timeUnitValue);
+            });
+            // adjust noteposition 
+            var newMeterRatio = getMeterRatioGlobal(currentMEI);
+            if (oldMeterRatio > newMeterRatio) {
+                checkInsertShifts(currentMEI);
+            }
+            else if (oldMeterRatio < newMeterRatio) {
+                checkDeleteShifts(currentMEI);
+            }
+            if (oldMeterRatio !== newMeterRatio) {
+                return currentMEI;
+            }
+        }
+    }
+    return currentMEI; //null  
+}
+exports.changeMeter = changeMeter;
+/**
+ * disable features if necesseray (only supposed to be used for debugging)
+ * @param features Array of TagNames and AttributeNames which have to be disabled (deleted)
+ * @param currentMEI  mei
+ * @returns
+ */
+function disableFeatures(features, currentMEI) {
+    //console.log("Features disabled:", features)
+    features.forEach(f => {
+        var elements = Array.from(currentMEI.getElementsByTagName(f));
+        elements.forEach(e => {
+            let parent = e.parentElement;
+            e.remove();
+            if (parent.childElementCount === 0) {
+                parent.remove();
+            }
+        });
+        elements = Array.from(currentMEI.querySelectorAll("*[" + f + "]"));
+        elements.forEach(e => {
+            let parent = e.parentElement;
+            e.remove();
+            if (parent.childElementCount === 0) {
+                parent.remove();
+            }
+        });
+    });
+    return currentMEI;
+}
+exports.disableFeatures = disableFeatures;
+/**
+ * When a note is shortened, fill old remaining duration with rests
+ * @param newElement
+ * @param oldElement
+ * @param currentMEI
+ */
+function fillWithRests(newElement, oldElement, currentMEI) {
+    var newRatio = getAbsoluteRatio(newElement);
+    var oldRatio = getAbsoluteRatio(oldElement);
+    if (newRatio < oldRatio) {
+        var remainRatio = oldRatio - newRatio;
+        var smallestUnit = gcd(remainRatio);
+        var restDur = ratioToDur(smallestUnit)[0];
+        var restCount = remainRatio / smallestUnit;
+        newElement.classList.add("changed");
+        for (var i = 0; i < restCount; i++) {
+            var rest = createNewRestElement(restDur);
+            currentMEI.getElementById(newElement.id).parentElement.insertBefore(rest, newElement.nextElementSibling);
+        }
+    }
+    return currentMEI;
+}
+exports.fillWithRests = fillWithRests;
+function fillLayerWithRests(layer, currentMEI) {
+    var targetDur = getMeterRatioLocal(currentMEI, layer);
+    var currentDur = getAbsoluteRatio(layer);
+    if (currentDur < targetDur) {
+        var remainRatio = targetDur - currentDur;
+        var smallestUnit = gcd(remainRatio);
+        var restDur = ratioToDur(smallestUnit)[0];
+        var restCount = remainRatio / smallestUnit;
+        for (var i = 0; i < restCount; i++) {
+            var rest = createNewRestElement(restDur);
+            Array.from(layer.querySelectorAll("note, chord, rest")).reverse()[0].insertAdjacentElement("afterend", rest);
+        }
+    }
+}
+exports.fillLayerWithRests = fillLayerWithRests;
+/**
+ * Fill Empty Space with rest
+ * @deprecated
+ * @param currentMEI
+ */
+function _fillWithRests(currentMEI) {
+    var staffDef = currentMEI.getElementsByTagName("staffDef").item(0);
+    var meterCount;
+    var meterUnit;
+    var meterRatio;
+    if (staffDef.getAttribute(constants_1.constants._METERCOUNT_) !== null && staffDef.getAttribute(constants_1.constants._METERUNIT_) !== null) {
+        meterCount = staffDef.getAttribute(constants_1.constants._METERCOUNT_);
+        meterUnit = staffDef.getAttribute(constants_1.constants._METERUNIT_);
+        meterRatio = parseInt(meterCount) / parseInt(meterUnit);
+    }
+    else {
+        var meterRatio = getMeterRatioGlobal(currentMEI);
+        meterCount = (meterRatio * 4).toString();
+        meterUnit = "4";
+    }
+    currentMEI.querySelectorAll("measure").forEach(m => {
+        m.querySelectorAll("staff").forEach(s => {
+            s.querySelectorAll("layer").forEach((l, idx) => {
+                //mRest for empty Layer
+                if (l.childElementCount === 0) {
+                    if (idx === 0) {
+                        var restEl = document.createElementNS(constants_1.constants._MEINS_, "mRest");
+                        l.appendChild(restEl);
+                    }
+                    else { // remove 1+ empty layer
+                        l.remove();
+                    }
+                }
+                else {
+                    var actualMeterFill = getAbsoluteRatio(l);
+                    var ratioDiff = Math.abs(actualMeterFill - meterRatio);
+                    var smallestValue = gcd(ratioDiff);
+                    //var restDurs = findDotsRecursive(ratioDiff, gcd(ratioDiff))
+                    if (Number.isInteger(ratioDiff / smallestValue) && ratioDiff > 0) {
+                        var leftRatio = ratioDiff;
+                        var durArr = new Array();
+                        while (!Number.isInteger(1 / leftRatio)) {
+                            var leftRatio = ratioDiff - smallestValue;
+                            durArr.push(1 / smallestValue);
+                        }
+                        durArr.push(1 / leftRatio);
+                        durArr = durArr.reverse();
+                        durArr.forEach(dur => {
+                            var newRest = currentMEI.createElementNS(constants_1.constants._MEINS_, "rest");
+                            newRest.setAttribute("dur", dur.toString());
+                            l.appendChild(newRest);
+                        });
+                    }
+                    //console.log(document.getElementById(l.id), ratioDiff, gcd(ratioDiff), durArr)
+                }
+            });
+        });
+    });
+}
+/**
+ * Replace given id with rest
+ * @param element element from svg
+ * @param currentMEI
+ */
+function replaceWithRest(element, currentMEI) {
+    var elmei = currentMEI.getElementById(element.id);
+    //var closestChord: Element = currentMEI .getElementById(element.id).closest("chord")
+    //if(closestChord !== null){elmei = closestChord}
+    var dur = elmei.getAttribute("dur");
+    var dots = elmei.getAttribute("dots");
+    var newRest = currentMEI.createElementNS(constants_1.constants._MEINS_, "rest");
+    newRest.setAttribute("dur", dur);
+    if (dots !== null) {
+        newRest.setAttribute("dots", dots);
+    }
+    elmei.parentElement.insertBefore(newRest, elmei);
+    elmei.remove();
+}
+/**
+ * @deprecated
+ * Change duration of the following sound events. Elements to change duration are determined by the class to be "marked".
+ * @param currentMEI  Current MEI as Document
+ * @param additionalElements Elements to be considered to be changed.
+ * @param refElement Reference Element after which all determined elements (.marked and additionElements) will be changed (e.g. replacing duration during a note insert).
+ * If no refElement is given, filter the additionalElements to exclude the refElement
+ * @param marked Consider marked elements
+ * @returns
+ */
+function _changeDuration(currentMEI, additionalElements = new Array(), refElement = null) {
+    var currMeiClone = currentMEI.cloneNode(true);
+    var changedFlag = "changed";
+    var multiplier;
+    var elmei;
+    var i = refElement === null ? 1 : 0;
+    for (i; i < additionalElements.length; i++) {
+        elmei = currentMEI.getElementById(additionalElements[i].id);
+        var elmeiRatio = getAbsoluteRatio(elmei);
+        var chord = elmei.closest("chord");
+        //Dur is attribute of chord and all notes will be changed accordingly
+        if (chord !== null) {
+            if (chord.classList.contains(changedFlag)) {
+                return;
+            }
+            else {
+                elmei = chord;
+                elmei.classList.add(changedFlag);
+            }
+        }
+        var dur = parseInt(elmei.getAttribute("dur"));
+        var dots = parseInt(elmei.getAttribute("dots")); // is NaN if elmei has no dots
+        if (dur > 0) {
+            var layerRatio = getAbsoluteRatio(elmei.closest("layer")); // current ratio of layer with already inserted new sound event
+            var localRatio = getMeterRatioLocal(currentMEI, elmei); //getMeterRatioGlobal(currentMEI )
+            var danglingRatio = layerRatio - localRatio;
+            if (danglingRatio > 0) {
+                var nextElementRatio = getAbsoluteRatio(elmei);
+                var neNewRatio = nextElementRatio - danglingRatio;
+                if (neNewRatio > 0) {
+                    var durArr = ratioToDur(neNewRatio);
+                    elmei.setAttribute("dur", durArr[0].toString());
+                    if (durArr[1] > 0) {
+                        elmei.setAttribute("dots", durArr[1].toString());
+                    }
+                    else {
+                        elmei.removeAttribute("dots");
+                    }
+                }
+                else {
+                    elmei.remove();
+                }
+            }
+            if ((layerRatio <= localRatio && refElement === null) || (layerRatio < localRatio && refElement !== null)) {
+                var nextElementRatio = getAbsoluteRatio(elmei);
+                var neNewRatio;
+                if (refElement !== null) {
+                    neNewRatio = nextElementRatio - getAbsoluteRatio(refElement);
+                }
+                else {
+                    var addRatios = (function (elements) {
+                        var r = 0;
+                        elements.forEach((v, i) => {
+                            if (i > 0) {
+                                r += getAbsoluteRatio(v);
+                            }
+                        });
+                        return r;
+                    });
+                    neNewRatio = nextElementRatio - (layerRatio - addRatios(additionalElements) - getAbsoluteRatio(additionalElements[0]));
+                }
+                if (neNewRatio > 0) {
+                    var durArr = ratioToDur(neNewRatio);
+                    elmei.setAttribute("dur", durArr[0].toString());
+                    if (durArr[1] > 0) {
+                        elmei.setAttribute("dots", durArr[1].toString());
+                    }
+                    else {
+                        elmei.removeAttribute("dots");
+                    }
+                }
+                else {
+                    elmei.remove();
+                }
+            }
+        }
+    }
+    if (!overfillMeasure && elmei != undefined && (elmei === null || elmei === void 0 ? void 0 : elmei.closest("layer")) !== null) {
+        var newMeasureRatio = getAbsoluteRatio(elmei.closest("layer"));
+        var localRatio = getMeterRatioLocal(currentMEI, elmei);
+        if (newMeasureRatio > localRatio) { //getMeterRatioGlobal(currentMEI )){
+            currentMEI = currMeiClone;
+        }
+    }
+    //clean up after changing durations
+    currentMEI.querySelectorAll(".changed").forEach(c => c.classList.remove(changedFlag));
+    cleanUp(currentMEI);
+    return currentMEI;
+}
+function addRatios(elements) {
+    var r = 0;
+    elements.forEach((v, i) => {
+        //if(i > 0){
+        r += getAbsoluteRatio(v);
+        //}
+    });
+    return r;
+}
+/**
+ *
+ * @param currentMEI current used MEI to be changed
+ * @param additionalElements elements which duration has to be changed which occur after the refElement in the same layer
+ * @param refElement actual current Element which will be changed in duration
+ * @param remainRatio remaining ratio of the current layer
+ * @param meiToReset MEI which can be used to reset the whole process
+ * @returns
+ */
+function changeDurationsInLayer(currentMEI, additionalElements = new Array(), refElement = null, remainRatio = null, meiToReset = null) {
+    var meiCopy = meiToReset || currentMEI.cloneNode(true);
+    let ms = Array.from(refElement.parentElement.querySelectorAll("note:not(chord note), chord, rest")); // querySelectorAll("note:not(chord note), chord, beam, rest")
+    var measureSiblings = ms.filter((_, i) => i <= ms.indexOf(refElement));
+    var ratioUpTpRef = addRatios(measureSiblings);
+    var refElementRatio = getAbsoluteRatio(refElement);
+    var remainBarRatio = getMeterRatioLocal(currentMEI, refElement) - ratioUpTpRef;
+    if (getAbsoluteRatio(refElement.parentElement) === getMeterRatioLocal(currentMEI, refElement)) { // bar has right size, 
+        return currentMEI;
+    }
+    if (additionalElements.length > 0) {
+        var nextNote = additionalElements.shift();
+        var nnRatio = getAbsoluteRatio(nextNote);
+        remainRatio = remainRatio || refElementRatio;
+        var currEl;
+        var harm;
+        if (remainRatio < nnRatio) {
+            var diffRatio = nnRatio - remainRatio;
+            var nextNoteMEI = currentMEI.getElementById(nextNote.id);
+            //var dur = ratioToDur(diffRatio)
+            // currentMEI.getElementById(nextNote.id).setAttribute("dur", dur.shift().toString())
+            // if (dur.length > 0) {
+            //   currentMEI.getElementById(nextNote.id).setAttribute("dots", dur.shift().toString())
+            // }
+            changeDur(nextNoteMEI, diffRatio);
+            harm = currentMEI.querySelector('harm[startid="' + nextNote.id + '"]');
+            if (harm !== null) {
+                harm.setAttribute("startid", refElement.id);
+            }
+        }
+        else if (remainRatio === nnRatio) {
+            currEl = currentMEI.getElementById(nextNote.id);
+            harm = currentMEI.querySelector('harm[startid="' + nextNote.id + '"]');
+            //if(currEl.tagName === "rest" && harm !== null){
+            if (harm !== null) {
+                harm.setAttribute("startid", refElement.id);
+            }
+            currEl.remove();
+        }
+        else {
+            currEl = currentMEI.getElementById(nextNote.id);
+            harm = currentMEI.querySelector('harm[startid="' + nextNote.id + '"]');
+            //if(currEl.tagName === "rest" && harm !== null){
+            if (harm !== null) {
+                harm.setAttribute("startid", refElement.id);
+            }
+            remainRatio = remainRatio - nnRatio;
+            currEl.remove();
+            changeDurationsInLayer(currentMEI, additionalElements, refElement, remainRatio, meiCopy);
+        }
+    }
+    cleanUp(currentMEI);
+    return currentMEI;
+}
+exports.changeDurationsInLayer = changeDurationsInLayer;
+/**
+ * Change duration attributes for given Element for the given ratio.
+ * Will also change dot attribute if necessary
+ * @param element
+ * @param ratio
+ */
+function changeDur(element, ratio) {
+    var dur = ratioToDur(ratio);
+    element.setAttribute("dur", dur.shift().toString());
+    if (dur.length > 0) {
+        element.setAttribute("dots", dur.shift().toString());
+    }
+}
+exports.changeDur = changeDur;
+/**
+ * Check if elment is overfilling the current layer element. Must provide previous MEI for reference.
+ * Violate rule: true; follow rules: false
+ * @param element
+ * @param currMeiClone
+ * @returns
+ */
+function elementIsOverfilling(element, currMeiClone) {
+    if (!overfillMeasure) {
+        var newMeasureRatio = getAbsoluteRatio(element.closest("layer"));
+        var localRatio = getMeterRatioLocal(currMeiClone, element);
+        if (newMeasureRatio > localRatio) { //getMeterRatioGlobal(currMeiClone)){
+            return true;
+        }
+    }
+    return false;
+}
+exports.elementIsOverfilling = elementIsOverfilling;
+/**
+ * Clean up mei after changing values
+ * @param currentMEI
+ */
+function cleanUp(currentMEI) {
+    deleteDefSequences(currentMEI);
+    reorganizeBeams(currentMEI);
+    removeEmptyElements(currentMEI);
+    adjustRests(currentMEI);
+    redistributeHarms(currentMEI);
+}
+exports.cleanUp = cleanUp;
+/**
+ * Delete all redundant definition sequences in staffDefs and layers
+ * @param currentMEI
+ */
+function deleteDefSequences(currentMEI) {
+    var staffCount = currentMEI.querySelectorAll("staffDef").length;
+    for (var i = 0; i < staffCount; i++) {
+        var n = (i + 1).toString();
+        var prevElement = null;
+        var prevShape = null;
+        var prevLine = null;
+        currentMEI.querySelectorAll("staffDef[n=\"" + n + "\"] clef, staff[n=\"" + n + "\"] clef").forEach(clefElement => {
+            var shape = clefElement.getAttribute("shape");
+            var line = clefElement.getAttribute("line");
+            if (prevElement != null) {
+                prevShape = prevElement.getAttribute("shape");
+                prevLine = prevElement.getAttribute("line");
+                if (prevShape === shape && prevLine === line) {
+                    clefElement.remove();
+                }
+                else {
+                    prevElement = clefElement;
+                }
+            }
+            else {
+                prevElement = clefElement;
+            }
+        });
+        prevElement = null;
+        var prevSig = null;
+        currentMEI.querySelectorAll("staffDef[n=\"" + n + "\"] keySig, staff[n=\"" + n + "\"] keySig").forEach(sigElement => {
+            var sig = sigElement.getAttribute("sig");
+            if (prevElement != null) {
+                prevSig = prevElement.getAttribute("sig");
+                if (prevSig === sig) {
+                    sigElement.remove();
+                }
+                else {
+                    prevElement = sigElement;
+                }
+            }
+            else {
+                prevElement = sigElement;
+            }
+        });
+        prevElement = null;
+        currentMEI.querySelectorAll("staffDef[n=\"" + n + "\"] meterSig, staff[n=\"" + n + "\"] meterSig").forEach(meterElement => {
+            var count = meterElement.getAttribute("count");
+            var unit = meterElement.getAttribute("unit");
+            if (prevElement != null) {
+                var lastCount = prevElement.getAttribute("count");
+                var lastUnit = prevElement.getAttribute("unit");
+                if (lastCount === count && lastUnit === unit) {
+                    meterElement.remove();
+                }
+                else {
+                    prevElement = meterElement;
+                }
+            }
+            else {
+                prevElement = meterElement;
+            }
+        });
+    }
+}
+function reorganizeBeams(currentMEI) {
+    // if beams have elements, which shouldn be there
+    currentMEI.querySelectorAll("beam").forEach(b => {
+        var beamNotes = Array.from(b.children);
+        if (!beamNotes.every(c => parseInt(c.getAttribute("dur")) >= 8) && beamNotes.length > 0) {
+            beamNotes.forEach(n => {
+                if (parseInt(n.getAttribute("dur")) >= 8) {
+                    if (n.previousElementSibling !== null) {
+                        if (n.previousElementSibling.tagName === "beam") { // check for previous beams to merge with
+                            n.previousElementSibling.appendChild(n);
+                        }
+                    }
+                    else { // else make new beam
+                        var newBeam = currentMEI.createElementNS(constants_1.constants._MEINS_, "beam");
+                        newBeam.setAttribute("id", random_1.uuidv4());
+                        n.parentElement.insertBefore(newBeam, n);
+                        newBeam.append(n);
+                    }
+                }
+            });
+            //set all inner elements outseide of old beam
+            b.outerHTML = b.innerHTML;
+        }
+    });
+}
+/**
+ * After manipulating elements in the score, some elements could be empty
+ * @param currentMEI
+ */
+function removeEmptyElements(currentMEI) {
+    Array.from(currentMEI.querySelectorAll("beam")).forEach(b => {
+        var _a;
+        if (b.childElementCount === 0) {
+            (_a = currentMEI.getElementById(b.id)) === null || _a === void 0 ? void 0 : _a.remove();
+        }
+        if (b.childElementCount === 1) {
+            //b.parentElement.insertBefore(b, b.firstChild)
+            //b.remove()
+            b.outerHTML = b.innerHTML;
+        }
+        var bArr = Array.from(b.children);
+        if (bArr.every(c => c.tagName === "rest") && bArr.length > 0) {
+            // Array.from(b.children).forEach(c => {
+            //   b.parentElement.insertBefore(c, b)
+            // })
+            // b.remove()
+            b.outerHTML = b.innerHTML;
+        }
+        // Avoids that unvalid rests will be displayed as double full notes
+        Array.from(currentMEI.querySelectorAll("rest")).forEach(r => {
+            if (r.getAttribute("dur") === "0" || r.getAttribute("dur") === null) {
+                r.removeAttribute("dur");
+                r.removeAttribute("dots");
+                r.outerHTML = r.outerHTML.replace("rest>", "mRest>");
+            }
+        });
+        Array.from(currentMEI.querySelectorAll("*[xmlns]")).forEach(x => {
+            var attr = x.getAttribute("xmlns");
+            if (attr === "" || attr === null || attr == undefined) {
+                x.removeAttribute("xmlns");
+            }
+        });
+    });
+    // allow no empty and rest-note element chord elements
+    Array.from(currentMEI.querySelectorAll("chord")).forEach(c => {
+        if (c.childElementCount === 0) {
+            currentMEI.getElementById(c.id).remove();
+        }
+        else if (c.childElementCount === 1) {
+            c.outerHTML = c.innerHTML;
+        }
+        else if (c.childElementCount === 2 && c.querySelector("rest") !== null && c.querySelector("note") !== null) {
+            c.querySelector("note").setAttribute("dur", c.getAttribute("dur"));
+            c.querySelector("rest").remove();
+            c.outerHTML = c.innerHTML;
+        }
+    });
+    // Empty harms could be somewhere
+    Array.from(currentMEI.querySelectorAll("harm")).forEach(h => {
+        if (h.childElementCount > 0) {
+            if (h.firstElementChild.childElementCount === 0)
+                h.remove();
+        }
+        else if (h.textContent === "") {
+            h.remove();
+        }
+    });
+    // remove all xmlns since they are someties empty and also are not parsable sometimes
+    Array.from(currentMEI.querySelectorAll("*")).forEach(el => {
+        if (el.tagName.toLowerCase() === "xml")
+            return;
+        el.removeAttribute("xmlns");
+    });
+    // Array.from(currentMEI .querySelectorAll("measure")).forEach(m => {
+    //   if(m.querySelectorAll("note, chord").length === 0){
+    //     currentMEI .getElementById(m.id).remove()
+    //   }
+    // })
+}
+/**
+ * Apply some additional rules for rests, Elements where added
+ * @param currentMEI
+ */
+function adjustRests(currentMEI) {
+    //mRest and any Element with dur attribute are not allowed in the same layer
+    currentMEI.querySelectorAll("layer").forEach(l => {
+        var hasAnyDurAttributes = l.querySelectorAll("*[dur]").length > 0;
+        var hasTags = l.querySelectorAll("clef, keySig").length > 0;
+        var hasMrest = l.querySelectorAll("mRest").length > 0;
+        if (l.children.length === 0 || (hasTags && !hasAnyDurAttributes && !hasMrest)) {
+            //no layer should be empty, has at least an mRest (therefore: mRests are virtually not deletable)
+            var newMrest = new mei_template_1.default().createMRest();
+            l.append(newMrest);
+        }
+        else {
+            Array.from(l.children).forEach(cn => {
+                if (cn.tagName === "mRest" && hasAnyDurAttributes) {
+                    cn.remove();
+                }
+            });
+        }
+    });
+}
+/**
+ * Give harm new start id if related note was included in chord during process
+ * @param currentMEI
+ */
+function redistributeHarms(currentMEI) {
+    currentMEI.querySelectorAll("harm").forEach(h => {
+        var startid = h.getAttribute("startid");
+        if (startid !== null) {
+            var note = currentMEI.getElementById(startid);
+            if ((note === null || note === void 0 ? void 0 : note.parentElement.tagName) === "chord")
+                h.setAttribute("startid", note.parentElement.id);
+        }
+    });
+}
+/**
+ * Remove tie from all layers if length of layer exceeds global Ratio
+ * @param currentMEI
+ */
+function removeTiesFromDoc(currentMEI) {
+    var globalRatio = getMeterRatioGlobal(currentMEI);
+    currentMEI.querySelectorAll("layer").forEach(l => {
+        var layerRatio = getAbsoluteRatio(l);
+        if (layerRatio > globalRatio) {
+            var m = l.closest("measure");
+            m.querySelectorAll("tie").forEach(t => {
+                var _a;
+                (_a = l.querySelector(t.getAttribute("endid"))) === null || _a === void 0 ? void 0 : _a.remove();
+                t.remove();
+            });
+        }
+    });
+}
+function addMeasure(currentMEI) {
+    var lastMeasure = Array.from(currentMEI.querySelectorAll("measure")).reverse()[0];
+    var staffCounts = Array.from(lastMeasure.querySelectorAll("staff")).map(s => { return parseInt(s.getAttribute("n")); });
+    var staffCount = Math.max.apply(Math, staffCounts);
+    var layerCounts = Array.from(lastMeasure.querySelectorAll("layer")).map(s => { return parseInt(s.getAttribute("n")); });
+    var layerCount = Math.max.apply(Math, layerCounts);
+    var newMeasure = new mei_template_1.default().createMeasure(1, staffCount, layerCount);
+    lastMeasure.parentElement.append(newMeasure);
+    var i = 1;
+    currentMEI.querySelectorAll("measure").forEach(m => {
+        m.setAttribute("n", i.toString());
+        i++;
+    });
+    newMeasure.setAttribute("id", random_1.uuidv4());
+    newMeasure.querySelectorAll("*").forEach(el => {
+        if (el.id === null || el.id === "") {
+            el.setAttribute("id", random_1.uuidv4());
+        }
+    });
+    cleanUp(currentMEI);
+}
+exports.addMeasure = addMeasure;
+function removeMeasure(currentMEI) {
+    var measures = Array.from(currentMEI.querySelectorAll("measure")).reverse();
+    if (measures.length > 1) {
+        measures[0].remove();
+    }
+    else {
+        measures[0].querySelectorAll("layer").forEach(l => {
+            l.innerHTML = "";
+            l.appendChild(currentMEI.createElement("mRest"));
+        });
+    }
+    cleanUp(currentMEI);
+}
+exports.removeMeasure = removeMeasure;
+function addStaff(currentMEI, referenceStaff, relPos) {
+    var staffNum = referenceStaff.getAttribute("n");
+    var refn;
+    var refElement;
+    currentMEI.querySelectorAll("staff[n=\"" + staffNum + "\"]").forEach(s => {
+        var _a;
+        var newStaff = new mei_template_1.default().createStaff(1, 1);
+        switch (relPos) {
+            case "above":
+                refElement = s;
+                break;
+            case "below":
+                refElement = s.nextElementSibling || s;
+                break;
+            default:
+                console.error(relPos, " was never an option");
+        }
+        if (relPos === "below" && refElement === s) { // => new staff at the end
+            s.parentElement.append(newStaff);
+        }
+        else {
+            s.parentElement.insertBefore(newStaff, refElement);
+        }
+        //copy elements from the current Staff that have to appear in new staff
+        var newLayer = newStaff.querySelector("layer");
+        var copyMeter = (_a = s.querySelector("meterSig")) === null || _a === void 0 ? void 0 : _a.cloneNode(true);
+        if (copyMeter != undefined && copyMeter !== null) {
+            newLayer.insertBefore(copyMeter, newLayer.firstChild);
+        }
+        refn = (refElement === null || refElement === void 0 ? void 0 : refElement.getAttribute("n")) || staffNum; // s.getAttribute("n")
+    });
+    //new StaffDef
+    var refStaffDef = currentMEI.querySelector("staffDef[n=\"" + refn + "\"]");
+    var refCopy = refStaffDef.cloneNode(true);
+    refCopy.querySelectorAll("*[id]").forEach(i => {
+        i.removeAttribute("id");
+    });
+    refStaffDef.parentElement.insertBefore(refCopy, refStaffDef);
+    currentMEI.querySelectorAll("measure").forEach(m => {
+        var i = 1;
+        m.querySelectorAll("staff").forEach(s => {
+            s.setAttribute("n", i.toString());
+            i++;
+        });
+    });
+    var i = 1;
+    currentMEI.querySelectorAll("staffDef").forEach(sd => {
+        sd.setAttribute("n", i.toString());
+        i++;
+    });
+    cleanUp(currentMEI);
+}
+exports.addStaff = addStaff;
+function removeStaff(currentMEI, referenceStaff, relPos) {
+    var staff = currentMEI.getElementById(referenceStaff.id);
+    var staffNum = staff.getAttribute("n");
+    var refn;
+    currentMEI.querySelectorAll("staff[n=\"" + staffNum + "\"]").forEach(s => {
+        switch (relPos) {
+            case "above":
+                refn = s.previousElementSibling.getAttribute("n");
+                s.previousElementSibling.remove();
+                break;
+            case "below":
+                refn = s.nextElementSibling.getAttribute("n");
+                s.nextElementSibling.remove();
+                break;
+            default:
+                console.error(relPos, " was never an option");
+        }
+    });
+    currentMEI.querySelector("staffDef[n=\"" + refn + "\"]").remove();
+    currentMEI.querySelectorAll("measure").forEach(m => {
+        var i = 1;
+        m.querySelectorAll("staff").forEach(s => {
+            s.setAttribute("n", i.toString());
+            i++;
+        });
+    });
+    var i = 1;
+    currentMEI.querySelectorAll("staffDef").forEach(sd => {
+        sd.setAttribute("n", i.toString());
+        i++;
+    });
+    cleanUp(currentMEI);
+}
+exports.removeStaff = removeStaff;
+/**
+ * Create a tuplet out of given Elements.
+ * Tuplet duration and kind will be derived from number and attributes of the given notes.
+ * E.g.: Selecting 3 Notes will make a triplet, 4 Notes will make a quadruplet, etc. The after the tuplet the missing durations will be added as rests
+ * @param meiElements
+ */
+function createTuplet(meiElements, currentMEI) {
+    meiElements = meiElements.filter(me => {
+        if (me != undefined) {
+            return me.getAttribute("dur") !== null;
+        }
+        return;
+    });
+    console.log("create tuplets:", meiElements);
+    var arrCopy = [...meiElements];
+    var minDurElement = arrCopy.sort((a, b) => parseFloat(b.getAttribute("dur")) - parseFloat(a.getAttribute("dur")))[0];
+    var ratioTotal = 0;
+    meiElements.forEach(me => ratioTotal += getAbsoluteRatio(me));
+    var ratioMinElement = getAbsoluteRatio(minDurElement);
+    var numMinNotes = (ratioTotal / ratioMinElement);
+    var numTarget = numMinNotes - 1;
+    var ratio = numTarget * getAbsoluteRatio(minDurElement);
+    var [dur, dots] = ratioToDur(ratio);
+    var tuplet = currentMEI.createElement("tuplet");
+    tuplet.setAttribute("dur", dur.toString());
+    if (dots > 0) {
+        tuplet.setAttribute("dots.ges", dots.toString());
+    }
+    tuplet.setAttribute("num", numMinNotes.toString());
+    tuplet.setAttribute("numbase", numTarget.toString());
+    currentMEI.querySelector("#" + meiElements[0].id).insertAdjacentElement("beforebegin", tuplet);
+    meiElements.forEach(me => tuplet.append(me));
+    // fill missing values with rest
+    var [durRest, dotsRest] = ratioToDur((numMinNotes * getAbsoluteRatio(minDurElement)) - ratio);
+    if (ratio < 1) {
+        if (durRest > 0) {
+            var rest = currentMEI.createElement("rest");
+            rest.setAttribute("id", random_1.uuidv4());
+            rest.setAttribute("dur", durRest.toString());
+            if (dotsRest > 0) {
+                rest.setAttribute("dots", dotsRest.toString());
+            }
+            tuplet.insertAdjacentElement("afterend", rest);
+        }
+    }
+}
+exports.createTuplet = createTuplet;
+/**
+ * Paste copied ids. First position to which the Elements are copied is the Element according to the refId (= RefElement).
+ * If multiple staffs are copied, overhanging staffs will be pasted to the staffs below the staff of the RefElement, if definedstaffs exist.
+ * Else these copiedId will be not pasted.
+ * @param ids
+ * @param refId
+ */
+function paste(ids, refId, currentMEI) {
+    var _a;
+    //ordered by staff
+    var meiElements = new Array();
+    ids.forEach(id => {
+        var el = currentMEI.getElementById(id);
+        //order copiable elements by staff
+        if (["CHORD", "NOTE", "REST"].includes(el === null || el === void 0 ? void 0 : el.tagName.toUpperCase())) {
+            if (!(el.tagName.toUpperCase() === "NOTE" && el.closest("chord") !== null)) {
+                var staff = el.closest("staff");
+                var num = parseInt(staff.getAttribute("n")) - 1;
+                if (meiElements[num] == undefined) {
+                    meiElements[num] = new Array();
+                }
+                var cel = el.cloneNode(true);
+                cel.setAttribute("id", random_1.uuidv4());
+                meiElements[num].push(cel);
+            }
+        }
+    });
+    var refElement = currentMEI.getElementById(refId);
+    refElement = (refElement === null || refElement === void 0 ? void 0 : refElement.closest("chord")) || refElement;
+    var refStaff = refElement === null || refElement === void 0 ? void 0 : refElement.closest("staff");
+    var refLayer = refElement === null || refElement === void 0 ? void 0 : refElement.closest("layer");
+    var refMeasure = refElement === null || refElement === void 0 ? void 0 : refElement.closest("measure");
+    var currentMeasure;
+    let anyNew;
+    //console.log(...meiElements)
+    meiElements.forEach((staff, staffIdx) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (refElement === null)
+            return;
+        currentMeasure = refElement.closest("measure");
+        staff.forEach((element, elementIdx) => {
+            var _a, _b;
+            if (["NOTE", "REST"].includes(element.tagName.toUpperCase())) {
+                var newNote = convertToNewNote(element);
+                newNote.nearestNoteId = refElement.id;
+                newNote.relPosX = "right";
+                anyNew = newNote;
+            }
+            else if (element.tagName.toUpperCase() === "CHORD") {
+                var newChord = convertToNewChord(element);
+                newChord.nearestNoteId = refElement.id;
+                newChord.relPosX = "right";
+                anyNew = newChord;
+                var elementArr = Array.from(element.querySelectorAll("note"));
+            }
+            var replace = ((_b = (_a = document.querySelector(".activeContainer")) === null || _a === void 0 ? void 0 : _a.querySelector("#insertToggle")) === null || _b === void 0 ? void 0 : _b.checked) || true;
+            addToMEI(anyNew, currentMEI, replace);
+            refElement = convertToElement(anyNew, currentMEI); //element
+        });
+        //when changing next staff, refElement musst be staff + 1
+        var targetStaffN = (_c = (parseInt((_b = (_a = currentMEI.getElementById(refElement.id)) === null || _a === void 0 ? void 0 : _a.closest("staff")) === null || _b === void 0 ? void 0 : _b.getAttribute("n")) + 1)) === null || _c === void 0 ? void 0 : _c.toString();
+        var refLayerN = (_e = (_d = currentMEI.getElementById(refElement.id)) === null || _d === void 0 ? void 0 : _d.closest("layer")) === null || _e === void 0 ? void 0 : _e.getAttribute("n");
+        var refMeasureN = (_g = (_f = currentMEI.getElementById(refElement.id)) === null || _f === void 0 ? void 0 : _f.closest("measure")) === null || _g === void 0 ? void 0 : _g.getAttribute("n");
+        refElement = currentMEI.querySelector("measure[n=\"" + refMeasureN + "\"] > staff[n=\"" + targetStaffN + "\"] > layer[n=\"" + refLayerN + "\"]");
+    });
+    //Element gets replaced in all other modes except keymode/textmode
+    if (!document.querySelector(".activeContainer").classList.contains("textmode") && ((_a = currentMEI.getElementById(refId)) === null || _a === void 0 ? void 0 : _a.tagName) !== "LAYER") {
+        removeFromMEI([currentMEI.getElementById(refId)], currentMEI);
+    }
+    return anyNew === null || anyNew === void 0 ? void 0 : anyNew.id;
+}
+exports.paste = paste;
+/**
+ * Replace clef in main/ first score definition
+ * @param targetid
+ * @param newClef
+ * @param currentMEI
+ * @returns
+ */
+function replaceClefinScoreDef(target, newClef, currentMEI) {
+    var staffN = document.querySelector(".activeContainer #vrvSVG #" + target.id).closest(".staff").getAttribute("n");
+    var staffDefClef = currentMEI.querySelector("staffDef[n=\"" + staffN + "\"] > clef");
+    staffDefClef.setAttribute("shape", newClef.charAt(0));
+    staffDefClef.setAttribute("line", mappings_1.clefToLine.get(newClef.charAt(0)));
+    cleanUp(currentMEI);
+    currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+    return currentMEI;
+}
+exports.replaceClefinScoreDef = replaceClefinScoreDef;
+/**
+ * Layer to which a new clef object has to be inserted
+ * @param targetid Usually a barline before which new clef should stand
+ * @param newClef Name of new Clef to be inserted
+ */
+function insertClef(target, newClef, currentMEI) {
+    var _a, _b;
+    var targetStaffId = ((_a = target.closest(".measure").querySelector(".staff[n=\"" + target.getAttribute("n") + "\"]")) === null || _a === void 0 ? void 0 : _a.id) || ((_b = target.closest(".staff")) === null || _b === void 0 ? void 0 : _b.id);
+    var targetLayerId = currentMEI.getElementById(targetStaffId).querySelector("layer").id;
+    currentMEI.getElementById(targetLayerId).querySelectorAll("clef").forEach(c => c.remove());
+    var clefElement = currentMEI.createElement("clef");
+    clefElement.setAttribute("id", random_1.uuidv4());
+    clefElement.setAttribute("shape", newClef.charAt(0));
+    clefElement.setAttribute("line", mappings_1.clefToLine.get(newClef.charAt(0)));
+    currentMEI.getElementById(targetLayerId).append(clefElement);
+    cleanUp(currentMEI);
+    currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+    return currentMEI;
+}
+exports.insertClef = insertClef;
+function findAttributeRecursive(element, attributeName, currentValue = null) {
+    var value = currentValue || element.getAttribute(attributeName);
+    if (value === null) {
+        Array.from(element.children).forEach(c => {
+            if (value !== null)
+                return;
+            value = findAttributeRecursive(c, attributeName, value);
+        });
+    }
+    console.log(element, value);
+    return value;
+}
+/**
+ * If Key is already defined in scoreDef, replace values
+ * @param target
+ * @param newSig
+ * @param currentMEI
+ * @returns
+ */
+function replaceKeyInScoreDef(target, newSig, currentMEI) {
+    var _a;
+    var staffN = document.querySelector(".activeContainer #vrvSVG #" + target.id).closest(".staff").getAttribute("n");
+    var staffDefSig = currentMEI.querySelector("staffDef[n=\"" + staffN + "\"] > keySig");
+    if (staffDefSig !== null) {
+        staffDefSig.setAttribute("sig", mappings_1.keyIdToSig.get(newSig));
+    }
+    else {
+        var newSigElement = new mei_template_1.default().createKeySig("major", mappings_1.keyIdToSig.get(newSig));
+        (_a = currentMEI.querySelector("staffDef[n=\"" + staffN + "\"]")) === null || _a === void 0 ? void 0 : _a.append(newSigElement);
+    }
+    adjustAccids(currentMEI);
+    cleanUp(currentMEI);
+    currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+    return currentMEI;
+}
+exports.replaceKeyInScoreDef = replaceKeyInScoreDef;
+/**
+ * Create a whole new Sig Element and Insert to MEI at given target
+ * @param target
+ * @param newSig
+ * @param currentMEI
+ * @returns
+ */
+function insertKey(target, newSig, currentMEI) {
+    var _a, _b;
+    console.log("insertKey", target, newSig);
+    var targetStaff = target.closest(".measure").querySelector(".staff[n=\"" + target.getAttribute("n") + "\"]") || target.closest(".staff");
+    var staffN = targetStaff.getAttribute("n");
+    var parentMeasure = currentMEI.getElementById(targetStaff.id).closest("measure");
+    var pmn = parseInt(parentMeasure.getAttribute("n")) + 1;
+    var targetLayerId = (_a = parentMeasure.parentElement.querySelector("measure[n=\"" + pmn.toString() + "\"] > staff[n=\"" + staffN + "\"] > layer")) === null || _a === void 0 ? void 0 : _a.id;
+    (_b = currentMEI.getElementById(targetLayerId).querySelectorAll("keySig")) === null || _b === void 0 ? void 0 : _b.forEach(c => c.remove());
+    var newSigElement = new mei_template_1.default().createKeySig("major", mappings_1.keyIdToSig.get(newSig));
+    currentMEI.getElementById(targetLayerId).insertBefore(newSigElement, currentMEI.getElementById(targetLayerId).firstElementChild);
+    adjustAccids(currentMEI);
+    cleanUp(currentMEI);
+    currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+    return currentMEI;
+}
+exports.insertKey = insertKey;
+function replaceMeterInScoreDef(target, currentMEI) {
+    var staffN = document.querySelector(".activeContainer #vrvSVG #" + target.id).closest(".staff").getAttribute("n");
+    var staffDefMeter = currentMEI.querySelector("staffDef[n=\"" + staffN + "\"]");
+    var count = document.querySelector(".activeContainer #timeCount").value;
+    var unit = document.querySelector(".activeContainer #timeUnit").value;
+    staffDefMeter.setAttribute("meter.count", count);
+    staffDefMeter.setAttribute("meter.unit", unit);
+    cleanUp(currentMEI);
+    currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+    return currentMEI;
+}
+exports.replaceMeterInScoreDef = replaceMeterInScoreDef;
+function insertMeter(target, currentMEI) {
+    var targetStaff = target.closest(".measure").querySelector(".staff[n=\"" + target.getAttribute("n") + "\"]") || target.closest(".staff");
+    var parentMeasure = currentMEI.getElementById(targetStaff.id).closest("measure");
+    var pmn = parseInt(parentMeasure.getAttribute("n")) + 1;
+    var targetLayers = parentMeasure.parentElement.querySelectorAll("measure[n=\"" + pmn.toString() + "\"] layer");
+    targetLayers.forEach(tl => {
+        var _a;
+        (_a = currentMEI.getElementById(tl.id).querySelectorAll("meterSig")) === null || _a === void 0 ? void 0 : _a.forEach(c => c.remove());
+    });
+    var count = document.querySelector(".activeContainer #selectTime #timeCount").value;
+    var unit = document.querySelector(".activeContainer #selectTime #timeUnit").value;
+    // change for all layers in given measure
+    targetLayers.forEach(tl => {
+        let newMeterElement = new mei_template_1.default().createMeterSig(count, unit); // must be in loop, otherwise same reference gets reassigned every time
+        currentMEI.getElementById(tl.id).insertBefore(newMeterElement, currentMEI.getElementById(tl.id).firstElementChild);
+    });
+    cleanUp(currentMEI);
+    currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+    return currentMEI;
+}
+exports.insertMeter = insertMeter;
+function insertTempo(target, currentMEI) {
+    var measure = currentMEI.getElementById(target.id).closest("measure");
+    var existingTempo = measure.querySelectorAll("tempo");
+    var sameTempos = Array.from(existingTempo).filter(et => {
+        var hasSameTimeStamp = parseFloat(et.getAttribute("timeStamp")) === getElementTimestampById(target.id, currentMEI);
+        var hasSameStartId = et.getAttribute("startId") === target.id;
+        return hasSameTimeStamp || hasSameStartId;
+    });
+    var mmUnit = document.querySelector(".activeContainer #selectTempo #timeCount").value;
+    var mm = document.querySelector(".activeContainer #selectTempo #timeUnit").value;
+    measure.appendChild(new mei_template_1.default().createTempo(mm, mmUnit, getElementTimestampById(target.id, currentMEI).toString(), target.id));
+    sameTempos.forEach(st => st.remove());
+    cleanUp(currentMEI);
+    currentMEI = meiConverter.restoreXmlIdTags(currentMEI);
+    return currentMEI;
+}
+exports.insertTempo = insertTempo;
+/**
+ * Gets timestamp of element. Computes it, if no such attribute is present for the element
+ * @param id
+ * @param currentMEI
+ * @returns
+ */
+function getElementTimestampById(id, currentMEI) {
+    var element = currentMEI.getElementById(id);
+    var timestamp = element.getAttribute("tstamp");
+    if (timestamp === null) {
+        var parentLayer = element.closest("layer");
+        var count = 0;
+        var units = parentLayer.querySelectorAll(countableNoteUnitSelector);
+        for (var i = 0; i < units.length; i++) {
+            if (units[i].getAttribute("dur") !== null) {
+                if (units[i].id === id) {
+                    var fraction = 4;
+                    if (currentMEI.querySelector("meterSig") !== null) {
+                        fraction = parseInt(currentMEI.querySelector("meterSig").getAttribute("unit"));
+                    }
+                    timestamp = (count * fraction + 1).toString(); // add 1 to accomodate for shift ratio sum
+                    break;
+                }
+                count += getAbsoluteRatio(units[i]);
+            }
+        }
+    }
+    return parseFloat(timestamp);
+}
+exports.getElementTimestampById = getElementTimestampById;
+/**
+ * Get Timestamp in specific layer
+ * @param note
+ * @returns
+ */
+function getTimestamp(note) {
+    var layer = note.closest("layer");
+    var elements = Array.from(layer.querySelectorAll("*[dur]"));
+    elements = elements.filter((v, i) => i <= elements.indexOf(note));
+    var tstamp;
+    elements.forEach(e => {
+        var dur = parseInt(e.getAttribute("dur"));
+        tstamp += 4 / dur;
+        var dots = e.getAttribute("dots");
+        var add = dur;
+        if (dots !== null) {
+            for (var i = 0; i < parseInt(dots); i++) {
+                add = add / 2;
+                tstamp += add;
+            }
+        }
+    });
+    return tstamp;
+}
+exports.getTimestamp = getTimestamp;
+function setArticulation(currentMEI, artic) {
+    document.querySelectorAll(".activeContainer #vrvSVG :is(.chord.marked, .note.marked, .note.lastAdded").forEach(note => {
+        var meiElement = currentMEI.querySelector("#" + note.id);
+        if (meiElement === null)
+            return;
+        if (meiElement.tagName !== "note")
+            return;
+        if (meiElement.tagName === "note" && meiElement.parentElement.tagName === "chord") {
+            meiElement = meiElement.parentElement;
+        }
+        if (meiElement.getAttribute("artic") === null || meiElement.getAttribute("artic") !== artic) {
+            meiElement.setAttribute("artic", artic);
+        }
+        else {
+            meiElement.removeAttribute("artic");
+        }
+    });
+    return currentMEI;
+}
+exports.setArticulation = setArticulation;
+//PRIVATE
+function convertToNewNote(element) {
+    var newNote = {
+        id: random_1.uuidv4(),
+        pname: element.getAttribute("pname"),
+        dur: element.getAttribute("dur"),
+        dots: element.getAttribute("dots"),
+        oct: element.getAttribute("oct"),
+        accid: element.getAttribute("accid") || element.getAttribute("accid.ges"),
+        rest: element.tagName.toUpperCase() === "REST" ? true : false
+    };
+    return newNote;
+}
+function convertToElement(n, currentMEI) {
+    var nn;
+    var newElement;
+    if (n.hasOwnProperty("pname")) {
+        nn = n;
+        newElement = currentMEI.createElement("note");
+        newElement.setAttribute("pname", nn.pname);
+        newElement.setAttribute("oct", nn.oct);
+        newElement.setAttribute("accid", nn.accid);
+    }
+    else {
+        nn = n;
+        newElement = currentMEI.createElement("chord");
+        nn.noteElements.forEach(ne => {
+            newElement.append(convertToElement(ne, currentMEI));
+        });
+    }
+    newElement.setAttribute("id", nn.id);
+    newElement.setAttribute("dur", nn.dur);
+    newElement.setAttribute("dots", nn.dots);
+    return newElement;
+}
+function convertToNewChord(element) {
+    var newNotes = Array.from(element.querySelectorAll("note")).map(n => {
+        return convertToNewNote(n);
+    });
+    var newChord = {
+        id: random_1.uuidv4(),
+        dur: element.getAttribute("dur"),
+        dots: element.getAttribute("dots"),
+        noteElements: newNotes
+    };
+    return newChord;
+}
+function createNewRestElement(dur, dots = undefined) {
+    var newElem = document.createElementNS(constants_1.constants._MEINS_, "rest");
+    newElem.setAttribute("dur", dur.toString());
+    if (dots != undefined)
+        newElem.setAttribute("dots", dots.toString());
+    newElem.setAttribute("id", random_1.uuidv4());
+    return newElem;
+}