";
+ }
+ document.getElementsByClassName("maskOption")[0].classList.add("maskOptionSelected");
+ selectedMask = document.getElementsByClassName("maskOption")[0].id.replace("maskName", "");
+ document.getElementById("selectedFramePreview").innerHTML = "Selected: " + frameList[selectedFrame].displayName + " frame with a " + selectedMask + " mask";
+ }
+}
+function maskOptionClicked(event) {
+ //Determines which mask was selected, and stores that value under 'selectedMask'
+ var clickedElement = event.target;
+ if (clickedElement.nodeName == "IMG") {
+ clickedElement = event.target.parentElement;
+ }
+ var maskOptionList = document.getElementsByClassName("maskOption");
+ for (var i = 0; i < maskOptionList.length; i++) {
+ maskOptionList[i].classList.remove("maskOptionSelected");
+ }
+ clickedElement.classList.add("maskOptionSelected");
+ selectedMask = clickedElement.id.replace("maskName", "");
+ document.getElementById("selectedFramePreview").innerHTML = "Selected: " + frameList[selectedFrame].displayName + " frame with a " + selectedMask + " mask";
+}
+function addFrameToCardMaster(right = "") {
+ //Takes the stored selectedFrame and selectedMask to add the frame w/ mask to the card master!
+ if (selectedFrame > -1 && selectedMask != "") {
+ //In order to both keep input values and insert new frames before old ones, they must be added like so:
+ cardMaster.insertBefore(frameList[selectedFrame].cardMasterElement(selectedMask + right), cardMaster.children[newFrameInsertionLocation]);
+ cardMasterUpdated();
+ }
+}
+function deleteCardMasterElement(event) {
+ event.target.parentElement.parentElement.removeChild(event.target.parentElement);
+ cardMasterUpdated();
+}
+function addNewFrameOption(imageSource) {
+ var availableMasks = "";
+ for (var i = 2; i < maskNameList.length; i++) {
+ availableMasks += maskNameList[i] + "-0-0-" + cardWidth + "-" + cardHeight + ";";
+ }
+ availableMasks = availableMasks.substring(0, availableMasks.length - 1);
+ frameList[frameList.length] = new frameImage("Custom", imageSource, availableMasks, "Eternal;Custom ");
+ frameList[frameList.length - 1].image.customVar = frameList.length - 1;
+ frameList[frameList.length - 1].image.onload = function() {
+ frameList[this.customVar].framePickerElement();
+ }
+}
+
+
+/* Card Master Cool Stuff! */
+function cardMasterUpdated() {
+// console.log("The card master is updating!");
+ frameFinalContext.clearRect(0, 0, cardWidth, cardHeight);
+ for (var i = cardMaster.children.length - 1; i >= 0; i--) {
+ var targetChild = cardMaster.children[i];
+ if (parseInt(targetChild.id.replace("frameIndex", "")) == -1) {
+ //The card art placeholder is manually set to -1 and cannot be removed :)
+ frameFinalContext.drawImage(cardArt, version.artX + getValue("inputCardArtX"), version.artY + getValue("inputCardArtY"), cardArt.width * getValue("inputCardArtZoom") / 100, cardArt.height * getValue("inputCardArtZoom") / 100);
+ } else if (parseInt(targetChild.id.replace("frameIndex", "")) == -2) {
+ if (i == 0) {
+ newFrameInsertionLocation = 1;
+ } else {
+ newFrameInsertionLocation = 0;
+ }
+ frameFinalContext.drawImage(watermarkCanvas, 0, 0, cardWidth, cardHeight)
+ frameFinalContext.drawImage(textCanvas, 0, 0, cardWidth, cardHeight);
+ } else {
+ var frameToDraw = frameList[parseInt(targetChild.id.replace("frameIndex", ""))];
+ var opacityToDraw = targetChild.children[1].children[1].value / 100;
+ var maskName = targetChild.innerHTML.slice(targetChild.innerHTML.indexOf("(") + 1, targetChild.innerHTML.indexOf(")"));
+ var sectionMask = "none"
+ if (maskName.includes(" - ")) {
+ sectionMask = maskName.split(" - ")[1];
+ maskName = maskName.split(" - ")[0];
+ }
+ var maskIndex = frameToDraw.maskOptionList.indexOf(maskName);
+ var maskImageIndex = maskNameList.indexOf(maskName)
+ //Clears the temporary mask canvas, draws the mask, draws the image over it, then copies it to the final frame canvas
+ frameMaskContext.globalCompositeOperation = "source-over";
+ frameMaskContext.clearRect(0, 0, cardWidth, cardHeight);
+ frameMaskContext.drawImage(maskList[maskImageIndex], 0, 0, cardWidth, cardHeight);
+ frameMaskContext.globalCompositeOperation = "source-in";
+ if (sectionMask != "none") {
+ frameMaskContext.drawImage(maskList[maskNameList.indexOf(sectionMask)], 0, 0, cardWidth, cardHeight);
+ }
+ frameMaskContext.drawImage(frameToDraw.image, frameToDraw.xList[maskIndex], frameToDraw.yList[maskIndex], frameToDraw.widthList[maskIndex], frameToDraw.heightList[maskIndex]);
+ if (targetChild.children[1].children[2].checked == true) {
+ frameFinalContext.globalCompositeOperation = "destination-out";
+ }
+ frameFinalContext.globalAlpha = opacityToDraw;
+ frameFinalContext.drawImage(frameMaskCanvas, 0, 0, cardWidth, cardHeight);
+ frameFinalContext.globalAlpha = 1;
+ if (targetChild.children[1].children[2].checked == true) {
+ frameFinalContext.globalCompositeOperation = "destination-over";
+ frameFinalContext.drawImage(cardArt, version.artX + getValue("inputCardArtX"), version.artY + getValue("inputCardArtY"), cardArt.width * getValue("inputCardArtZoom") / 100, cardArt.height * getValue("inputCardArtZoom") / 100);
+ }
+ frameFinalContext.globalCompositeOperation = "source-over";
+ }
+ }
+ updateBottomInfoCanvas();
+}
+
+
+/* Overall card stuff */
+function cardImageUpdated() {
+ //Clear the canvases
+ cardFinalContext.fillStyle = "black";
+ cardFinalContext.fillRect(0, 0, cardWidth, cardHeight);
+ displayContext.clearRect(0, 0, cardWidth, cardHeight);
+ //Draw the art, frame, text, bottom info, mana cost, watermark, and set symbol
+ // cardFinalContext.drawImage(cardArt, version.artX + getValue("inputCardArtX"), version.artY + getValue("inputCardArtY"), cardArt.width * getValue("inputCardArtZoom") / 100, cardArt.height * getValue("inputCardArtZoom") / 100)
+ cardFinalContext.drawImage(frameFinalCanvas, 0, 0, cardWidth, cardHeight);
+ if (version.currentVersion == "planeswalker") {
+ cardFinalContext.drawImage(planeswalkerCanvas, 0, 0, cardWidth, cardHeight);
+ }
+ cardFinalContext.drawImage(bottomInfoCanvas, 0, 0, cardWidth, cardHeight);
+// cardFinalContext.drawImage(textCanvas, 0, 0, cardWidth, cardHeight);
+ cardFinalContext.drawImage(setSymbolCanvas, 0, 0, cardWidth, cardHeight)
+ cardFinalContext.drawManaCost(document.getElementById("inputManaCost").value, version.manaCostX, version.manaCostY, version.manaCostDiameter, version.manaCostDistance, version.manaCostDirection, version.manaCostVersion)
+ //Clear the corners
+ cardFinalContext.globalCompositeOperation = "destination-out"
+ cardFinalContext.drawImage(maskList[1], 0, 0, cardWidth, cardHeight)
+ cardFinalContext.globalCompositeOperation = "source-over"
+ //Copy it to the visible canvas
+ displayContext.drawImage(cardFinalCanvas, 0, 0, cardWidth, cardHeight);
+}
+
+
+/* Loading/manipulating card versions */
+function changeVersionTo(versionToChangeTo) {
+ loadScript("data/versions/" + versionToChangeTo + ".js");
+}
+function finishChangingVersion(targetCSV = false) {
+ for (var i = 0; i < version.masksToAdd.length; i++) {
+ if (!maskNameList.includes(version.masksToAdd[i])) {
+ maskNameList[maskNameList.length] = version.masksToAdd[i];
+ maskList[maskList.length] = new Image();
+ maskList[maskList.length - 1].crossOrigin = "anonymous";
+ maskList[maskList.length - 1].src = "data/images/masks/" + version.masksToAdd[i].replace(/ /g, "") + ".png";
+ }
+ }
+ document.getElementById("inputWhichTextTabs").innerHTML = ""
+ for (var i = 0; i < version.textList.length; i ++) {
+ document.getElementById("inputWhichTextTabs").innerHTML += "
" + version.textList[i][0] + "
"
+ if (i == 0) {
+ document.getElementsByClassName("textTabButton")[0].classList.add("activeTextTab")
+ }
+ }
+ console.log("version changed, time to load the image csv")
+ if (targetCSV != false) {
+ loadImageCSV(targetCSV);
+ }
+}
+
+
+/* Text functions! */
+function textTabFunction(event, target) {
+ var textTabButtons = document.getElementsByClassName("textTabButton")
+ for (var i = 0; i < textTabButtons.length; i++) {
+ textTabButtons[i].classList.remove("activeTextTab")
+ }
+ event.target.classList.add("activeTextTab")
+ for (var i = 0; i < version.textList.length; i ++) {
+ if (version.textList[i][0] == target.replace("option", "")) {
+ whichTextIndex = i
+ document.getElementById("inputText").value = version.textList[whichTextIndex][1]
+ }
+
+ }
+}
+function updateText() {
+ version.textList[whichTextIndex][1] = document.getElementById("inputText").value
+ clearTimeout(updateTextDelay)
+ updateTextDelay = setTimeout(rewriteText, 250);
+}
+function rewriteText() {
+ textContext.clearRect(0, 0, cardWidth, cardHeight)
+ for (var i = 0; i < version.textList.length; i ++) {
+ if (version.textList[i][10]) {
+ if (version.textList[i][10] != "ignore") {
+ window[version.textList[i][10]]();
+ }
+ } else {
+ textContext.writeText(version.textList[i][1], version.textList[i][2], version.textList[i][3], version.textList[i][4], version.textList[i][5], version.textList[i][6], version.textList[i][7], version.textList[i][8], version.textList[i][9]);
+ }
+ }
+ cardMasterUpdated()
+}
+
+
+/* functions for all the little parts of the card */
+function updateBottomInfoCanvas() {
+ window[version.bottomInfoFunction]()
+}
+
+
+/* Misc/general convenient little functions */
+function scale(input) {
+ return input * cardWidth / 744;
+}
+function getValue(elementId) {
+ return parseFloat(document.getElementById(elementId).value)
+}
+function beforeAfter(targetString, beforeString, afterString) {
+ if (targetString.includes(beforeString) && targetString.includes(afterString)) {
+ return targetString.split(beforeString)[1].split(afterString)[0];
+ } else {
+ return "";
+ }
+}
+
+
+/* Functions that make stuff */
+function newCanvas(newCanvasName, padding = 0) {
+ window[newCanvasName + "Canvas"] = document.createElement("canvas");
+ window[newCanvasName + "Canvas"].width = cardWidth + padding * 2;
+ window[newCanvasName + "Canvas"].height = cardHeight + padding * 2;
+ window[newCanvasName + "Context"] = window[newCanvasName + "Canvas"].getContext("2d");
+}
+
+
+/* Functions that manage the website */
+function toggleTabs(event, targetTab, tabSubject) {
+ var tabList = document.getElementsByClassName(tabSubject);
+ for (var i = 0; i < tabList.length; i++) {
+ tabList[i].classList.remove("tabVisible");
+ tabList[i].classList.remove("tabOptionSelected");
+ }
+ document.getElementById(targetTab).classList.add("tabVisible");
+ event.target.classList.add("tabOptionSelected");
+}
+function loadScript(scriptPath){
+ var script = document.createElement("script");
+ script.setAttribute("type","text/javascript");
+ script.setAttribute("src", scriptPath);
+ if (typeof script != "undefined") {
+ document.getElementsByTagName("head")[0].appendChild(script);
+ }
+}
+
+
+
+
+/*
+ Directly taken (with small edits) from previous version.
+ sort these!!!
+*/
+
+
+
+
+
+//figures out the placing of the set symbol
+function updateSetSymbol() {
+ setSymbolContext.clearRect(0, 0, cardWidth, cardHeight)
+ var setSymbolWidth, setSymbolHeight, setSymbolX, setSymbolY
+ if (version.setSymbolWidth / version.setSymbolHeight < setSymbol.width / setSymbol.height) {
+ //wider
+ setSymbolWidth = version.setSymbolWidth
+ setSymbolHeight = version.setSymbolWidth / setSymbol.width * setSymbol.height
+ setSymbolX = version.setSymbolRight - setSymbolWidth
+ setSymbolY = version.setSymbolVertical - setSymbolHeight / 2
+ } else {
+ //taller
+ setSymbolHeight = version.setSymbolHeight
+ setSymbolWidth = version.setSymbolHeight / setSymbol.height * setSymbol.width
+ setSymbolX = version.setSymbolRight - setSymbolWidth
+ setSymbolY = version.setSymbolVertical - setSymbolHeight / 2
+ }
+ if (version.currentVersion == "future") {
+ //Also center the set symbol horizontally
+ setSymbolX = version.setSymbolRight - setSymbolWidth / 2;
+ }
+ setSymbolContext.drawImage(setSymbol, setSymbolX, setSymbolY, setSymbolWidth, setSymbolHeight)
+ cardImageUpdated()
+}
+function updateWatermark() {
+ if (document.getElementById("inputWatermarkPrimary").value != "none") {
+ watermarkContext.clearRect(0, 0, cardWidth, cardHeight)
+ var watermarkX, watermarkY, watermarkWidth, watermarkHeight
+ if (version.watermarkWidth / version.watermarkHeight < watermark.width / watermark.height) {
+ //wider
+ watermarkWidth = version.watermarkWidth
+ watermarkHeight = version.watermarkWidth / watermark.width * watermark.height
+ watermarkX = cardWidth / 2 - watermarkWidth / 2
+ watermarkY = version.watermarkY - watermarkHeight / 2
+ } else {
+ //taller
+ watermarkHeight = version.watermarkHeight
+ watermarkWidth = version.watermarkHeight / watermark.height * watermark.width
+ watermarkX = cardWidth / 2 - watermarkWidth / 2
+ watermarkY = version.watermarkY - watermarkHeight / 2
+ }
+ watermarkContext.drawImage(watermark, watermarkX, watermarkY, watermarkWidth, watermarkHeight)
+ watermarkContext.globalCompositeOperation = "source-in"
+ if (document.getElementById("inputWatermarkPrimary").value != "default") {
+ watermarkContext.fillStyle = document.getElementById("inputWatermarkPrimary").value
+ watermarkContext.fillRect(0, 0, cardWidth, cardHeight)
+ }
+ if (document.getElementById("inputWatermarkSecondary").value != "none") {
+ watermarkContext.globalCompositeOperation = "source-atop"
+ tempContext.clearRect(0, 0, cardWidth, cardHeight)
+ tempContext.drawImage(maskList[0], 0, 0, cardWidth, cardHeight)
+ tempContext.globalCompositeOperation = "source-in"
+ if (document.getElementById("inputWatermarkSecondary").value == "default") {
+ tempContext.drawImage(watermark, watermarkX, watermarkY, watermarkWidth, watermarkHeight)
+ } else {
+ tempContext.fillStyle = document.getElementById("inputWatermarkSecondary").value
+ tempContext.fillRect(0, 0, cardWidth, cardHeight)
+ }
+ tempContext.globalCompositeOperation = "source-over"
+ watermarkContext.drawImage(tempCanvas, 0, 0, cardWidth, cardHeight)
+ }
+ watermarkContext.globalCompositeOperation = "source-over"
+ } else {
+ watermarkContext.clearRect(0, 0, cardWidth, cardHeight)
+ }
+ cardMasterUpdated();
+}
+
+//Custom text function! This acts on any codes and makes things look nice :)
+CanvasRenderingContext2D.prototype.writeText = function(text = "", textX = 0, textY = 0, textWidth = cardWidth, textHeight = cardHeight, textFont = "belerenbsc", inputTextSize = 38, textColor="black", other="", completionFunction) {
+ paragraphContext.clearRect(0, 0, cardWidth, cardHeight)
+ var textSize = inputTextSize
+ lineContext.font = textSize + "px " + textFont
+ lineContext.fillStyle = textColor
+ var otherParameters = other.split(",")
+ var outline, shadow = 0, oneLine = false, outlineWidth = 2, textAlign = "left", verticalAlign = true, lineSpace = 1, userHorizontalShift = 0
+ for (var i = 0; i < otherParameters.length; i ++) {
+ eval(otherParameters[i])
+ }
+ lineContext.strokeStyle = outline
+ lineContext.lineWidth = outlineWidth
+ var currentLineX = textCanvasesPadding + userHorizontalShift
+ var currentLineY = textY + (textSize * 0.45) //+ textCanvasesPadding
+ var uniqueSplitter = "9dn57gwbt4sh"
+ var splitString = text.replace(/\n/g, "{line}").replace(/ /g, uniqueSplitter + " " + uniqueSplitter).replace(/{/g, uniqueSplitter + "{").replace(/}/g, "}" + uniqueSplitter).split(uniqueSplitter)
+ splitString[splitString.length] = " "
+ var lastWordAdded = ""
+ for (var i = 0; i < splitString.length; i++) {
+ if (splitString[i] != "") {
+ var wordToWrite = splitString[i]
+ var finishLine = false
+ if (splitString[i].includes("{") && splitString[i].includes("}")) {
+ //It may be a code
+ wordToWrite = ""
+ possibleCodeLower = splitString[i].toLowerCase().replace("{", "").replace("}", "")
+ if (possibleCodeLower == "line" && !oneLine) {
+ finishLine = true
+ currentLineY += textSize * 0.35
+ } else if (possibleCodeLower == "linenospace" && ! oneLine) {
+ finishLine = true
+ } else if (possibleCodeLower == "bar" || possibleCodeLower == "flavor") {
+ finishLine = true
+ var barWidth = manaSymbolImageList[63].width
+ var barHeight = manaSymbolImageList[63].height
+ lineContext.drawImage(manaSymbolImageList[63], textX + textWidth / 2 - barWidth / 2, currentLineY + textSize * 0.6, barWidth, barHeight)
+ currentLineY += textSize * 0.8
+ if (possibleCodeLower == "flavor") {
+ lineContext.font = "italic " + (textSize - 3) + "px " + textFont
+ }
+ } else if (possibleCodeLower.includes("fontsize")) {
+ textSize += parseInt(possibleCodeLower.slice(8, possibleCodeLower.length))
+ lineContext.font = textSize + "px " + textFont
+ } else if (possibleCodeLower == "i") {
+ lineContext.font = "italic " + textSize + "px " + textFont
+ } else if (possibleCodeLower == "/i") {
+ lineContext.font = textSize + "px " + textFont
+ } else if (possibleCodeLower == "center") {
+ textAlign = "center"
+ } else if (possibleCodeLower == "right") {
+ textAlign = "right"
+ } else if (possibleCodeLower == "left") {
+ textAlign = "left"
+ } else if (possibleCodeLower.includes("up")) {
+ currentLineY -= (parseInt(possibleCodeLower.slice(2, possibleCodeLower.length)))
+ } else if (possibleCodeLower.includes("down")) {
+ currentLineY += (parseInt(possibleCodeLower.slice(4, possibleCodeLower.length)))
+ } else if (possibleCodeLower.includes("left")) {
+ userHorizontalShift -= (parseInt(possibleCodeLower.slice(4, possibleCodeLower.length)));
+ currentLineX -= (parseInt(possibleCodeLower.slice(4, possibleCodeLower.length)));
+ } else if (possibleCodeLower.includes("right")) {
+ userHorizontalShift += (parseInt(possibleCodeLower.slice(5, possibleCodeLower.length)));
+ currentLineX += (parseInt(possibleCodeLower.slice(5, possibleCodeLower.length)));
+ } else if (possibleCodeLower == "artistbrush") {
+ var artistBrushWidth = textSize * 1.2
+ lineContext.drawImage(manaSymbolImageList[62], currentLineX, currentLineY - artistBrushWidth * 0.58, artistBrushWidth, artistBrushWidth * 13 / 21)
+ currentLineX += artistBrushWidth * 1.1
+ } else if (possibleCodeLower == "oldartistbrush") {
+ var artistBrushWidth = textSize * 2.4
+ if (lineContext.fillStyle == "#ffffff" || lineContext.fillStyle == "white") {
+ lineContext.drawImage(manaSymbolImageList[64], currentLineX, currentLineY - artistBrushWidth * 13 / 63, artistBrushWidth, artistBrushWidth * 13 / 63);
+ } else {
+ lineContext.drawImage(manaSymbolImageList[65], currentLineX, currentLineY - artistBrushWidth * 13 / 63, artistBrushWidth, artistBrushWidth * 13 / 63);
+ }
+ currentLineX += artistBrushWidth * 1.1
+ } else if (possibleCodeLower.includes("fontcolor")) {
+ lineContext.fillStyle = possibleCodeLower.slice(9, possibleCodeLower.length)
+ } else if (possibleCodeLower.includes("font")) {
+ textFont = possibleCodeLower.slice(5, possibleCodeLower.length)
+ lineContext.font = textSize + "px " + textFont
+ } else if (possibleCodeLower.includes("outline:")) {
+ outline = true;
+ lineContext.strokeStyle = possibleCodeLower.replace("outline:", "").split(",")[0];
+ lineContext.lineWidth = parseInt(possibleCodeLower.replace("outline:", "").split(",")[1]);
+ } else if (possibleCodeLower.includes("shadow")) {
+ shadow = parseInt(possibleCodeLower.replace("shadow", ""));
+ } else if (manaSymbolCodeList.includes(possibleCodeLower.split("/").join(""))) {
+ //THIS HAS TO BE THE LAST ONE
+ var manaSymbolDiameter = textSize * 0.77
+ lineContext.drawImage(manaSymbolImageList[manaSymbolCodeList.indexOf(possibleCodeLower.split("/").join(""))], currentLineX, currentLineY - manaSymbolDiameter * 0.95, manaSymbolDiameter, manaSymbolDiameter)
+ currentLineX += manaSymbolDiameter * 1.02
+ } else {
+ wordToWrite = splitString[i]
+ }
+ }
+ if (wordToWrite != "" || finishLine == true) {
+ //We're left with a word. Write it.
+ var currentWordWidth = lineContext.measureText(wordToWrite).width
+ if (i == splitString.length - 1) {
+ //forces the last artificially added space to be too wide, making sure the last line is drawn in.
+ currentWordWidth = textWidth + 1
+ }
+ if (currentLineX - textCanvasesPadding + currentWordWidth > textWidth || finishLine) {
+ //Finish the line
+ if (oneLine && i != splitString.length - 1 && inputTextSize > 1) {
+ lineContext.clearRect(0, 0, cardWidth + 2 * textCanvasesPadding, cardHeight + 2 * textCanvasesPadding)
+ this.writeText(text, textX, textY, textWidth, textHeight, textFont, inputTextSize - 1, textColor, other)
+ return
+ }
+ var alignAdjust = 0
+ if (textAlign == "center" || textAlign == "right") {
+ if (lastWordAdded == " ") {
+ currentLineX -= textContext.measureText(" ").width
+ }
+ if (textAlign == "center") {
+ alignAdjust = textWidth / 2 - (currentLineX - textCanvasesPadding) / 2 + textX
+ } else if (textAlign == "right") {
+ alignAdjust = textWidth + textX - currentLineX + textCanvasesPadding
+ }
+ } else {
+ alignAdjust += textX
+ }
+ paragraphContext.drawImage(lineCanvas, 0 + alignAdjust - textCanvasesPadding, 0, cardWidth + 2 * textCanvasesPadding, cardHeight + 2 * textCanvasesPadding)
+ lineContext.clearRect(0, 0, cardWidth + 2 * textCanvasesPadding, cardHeight + 2 * textCanvasesPadding)
+ currentLineY += textSize * lineSpace
+ currentLineX = textCanvasesPadding + userHorizontalShift
+ if (wordToWrite == " ") {
+ currentWordWidth = 0
+ }
+ }
+ //Whether or not the current line is finished, write to it.
+ if (shadow > 0) {
+ lineContext.fillStyle = "black";
+ lineContext.fillText(wordToWrite, currentLineX + shadow, currentLineY + shadow);
+ lineContext.fillStyle = textColor;
+ }
+ if (outline != undefined) {
+ lineContext.strokeText(wordToWrite, currentLineX, currentLineY)
+ }
+ lineContext.fillText(wordToWrite, currentLineX, currentLineY)
+ currentLineX += currentWordWidth
+ lastWordAdded = wordToWrite
+ }
+ }
+ }
+ verticalAdjust = 0
+ if (verticalAlign) {
+ verticalAdjust = (textHeight + textY - currentLineY + textSize) / 2
+ }
+ this.drawImage(paragraphCanvas, 0, 0 + verticalAdjust, cardWidth, cardHeight)
+ if (text != "") {
+// console.log(text)
+ }
+ if (completionFunction) {
+ window[completionFunction]();
+ }
+ return "done"
+}
+//Loads up all the mana symbol images
+function loadManaSymbolImages() {
+ for (var i = 0; i < manaSymbolCodeList.length; i++) {
+ manaSymbolImageList[i] = new Image()
+ manaSymbolImageList[i].crossOrigin = "anonymous";
+ manaSymbolImageList[i].src = "data/images/manaSymbols/" + i + ".png"
+ }
+}
+//Draws a mana cost
+CanvasRenderingContext2D.prototype.drawManaCost = function(text, symbolsX, symbolsY, diameter = 50, distance = -50, direction = "horizontal", version = "m15") {
+ var splitManaCost = text.toLowerCase().replace(/{/g, " ").replace(/}/g, " ").split("/").join("").split(" ")
+ if (version == "future") {
+ splitManaCost.reverse();
+ }
+ var currentSymbolIndex = 0
+ var currentX = symbolsX
+ var currentY = symbolsY
+ var realManaCostIndex = 0;
+ for (var i = splitManaCost.length - 1; i >= 0; i --) {
+ if (manaSymbolCodeList.includes(splitManaCost[i])) {
+// console.log(realManaCostIndex, splitManaCost[i])
+ if (Array.isArray(direction) && realManaCostIndex < direction.length) {
+ currentX = direction[realManaCostIndex][0]
+ currentY = direction[realManaCostIndex][1]
+ }
+ if (version == "m15") {
+ this.fillStyle = "black"
+ this.beginPath()
+ this.arc(currentX + diameter / 2.13, currentY + diameter / 1.7, diameter / 2, 0, 2 * Math.PI, false)
+ this.fill()
+ this.drawImage(manaSymbolImageList[manaSymbolCodeList.indexOf(splitManaCost[i])], currentX, currentY, diameter, diameter)
+ } else if (version == "justTheSymbol") {
+ this.drawImage(manaSymbolImageList[manaSymbolCodeList.indexOf(splitManaCost[i])], currentX, currentY, diameter, diameter)
+ } else if (version == "seventh") {
+ this.drawImage(manaSymbolImageList[manaSymbolCodeList.indexOf(splitManaCost[i])], currentX, currentY, diameter, diameter)
+ } else if (version == "future") {
+ if (realManaCostIndex < direction.length) {
+ if (window.version.futureManaSymbolNameList.includes(splitManaCost[i]) && window.version.futureManaSymbolImageList[window.version.futureManaSymbolNameList.indexOf(splitManaCost[i])]) {
+ this.drawImage(window.version.futureManaSymbolImageList[window.version.futureManaSymbolNameList.indexOf(splitManaCost[i])], currentX, currentY, diameter, diameter)
+ } else {
+ this.drawImage(manaSymbolImageList[manaSymbolCodeList.indexOf(splitManaCost[i])], currentX, currentY, diameter, diameter)
+ }
+ }
+ }
+ if (direction == "horizontal") {
+ currentX += distance
+ } else if (direction == "vertical") {
+ currentY += distance
+ }
+ realManaCostIndex += 1;
+ }
+ }
+}
+
+//Removes all the white pixels in an image
+var whiteThreshold = 250
+function whiteToTransparent(targetImage, source = targetImage.src) {
+ //Create image, size canvas, draw image
+ var imgTempTarget = new Image()
+ imgTempTarget.crossOrigin = "anonymous"
+ imgTempTarget.src = source
+ imgTempTarget.onload = function() {
+ if (imgTempTarget.width > 0 && imgTempTarget.height > 0) {
+ transparentCanvas.width = imgTempTarget.width
+ transparentCanvas.height = imgTempTarget.height
+ transparentContext.drawImage(imgTempTarget, 0, 0)
+ //declare variables
+ var width = transparentCanvas.width
+ var height = transparentCanvas.height
+ var imageData = transparentContext.getImageData(0, 0, transparentCanvas.width, transparentCanvas.height)
+ var x, y, index
+ //Go through every pixel and
+ for (y = 0; y < height; y++) {
+ for (x = 0; x < width; x++) {
+ index = (y * width + x) * 4
+ if (imageData.data[index] >= whiteThreshold && imageData.data[index + 1] >= whiteThreshold && imageData.data[index + 2] >= whiteThreshold) {
+ imageData.data[index + 3] = 0
+ }
+ }
+ }
+ transparentContext.clearRect(0, 0, width, height)
+ transparentContext.putImageData(imageData, 0, 0)
+ targetImage.src = transparentCanvas.toDataURL()
+ autocrop(targetImage)
+ }
+ }
+}
+//Removes all the whitespace in an image
+function autocrop(targetImage, source = targetImage.src) {
+ //Create image, size canvas, draw image
+ var imgTempTarget = new Image()
+ imgTempTarget.crossOrigin = "anonymous"
+ imgTempTarget.src = source
+ imgTempTarget.onload = function() {
+ if (imgTempTarget.width > 0 && imgTempTarget.height > 0) {
+ cropCanvas.width = imgTempTarget.width
+ cropCanvas.height = imgTempTarget.height
+ cropContext.drawImage(imgTempTarget, 0, 0)
+ //declare variables
+ var width = cropCanvas.width
+ var height = cropCanvas.height
+ var pix = {x:[], y:[]}
+ var imageData = cropContext.getImageData(0, 0, cropCanvas.width, cropCanvas.height)
+ var x, y, index
+ if (imageData.data.length > 4) {
+ //Go through every pixel and
+ for (y = 0; y < height; y++) {
+ for (x = 0; x < width; x++) {
+ //(y * width + x) * 4 + 3 calculates the index at which the alpha value of the pixel at x, y is given
+ index = (y * width + x) * 4 + 3
+ if (imageData.data[index] > 0) {
+ //pix is the image object that stores two arrays of x and y coordinates. These stored coordinates are all the visible pixels
+ pix.x.push(x)
+ pix.y.push(y)
+ }
+ }
+ }
+ //sorts the arrays numerically
+ pix.x.sort(function(a,b){return a-b});
+ pix.y.sort(function(a,b){return a-b});
+ var n = pix.x.length - 1;
+ //Finds the difference between the leftmost and rightmost visible pixels, and the topmost and bottommost pixels, cuts out a section of the canvas
+ width = pix.x[n] - pix.x[0];
+ height = pix.y[n] - pix.y[0];
+ var cropped = cropContext.getImageData(pix.x[0], pix.y[0], width + 1, height + 1);
+ //Resizes the canvas and draws cropped image
+ cropCanvas.width = width + 1;
+ cropCanvas.height = height + 1;
+ cropContext.putImageData(cropped, 0, 0);
+ //Saves the newly cropped image to the given image
+ setTimeout(function() {targetImage.src = cropCanvas.toDataURL();}, 100)
+ }
+ }
+ }
+}
+//The next several functions are all about loading images!
+function uploadImage(event, destination) {
+ var input = event.target;
+ var reader = new FileReader();
+ reader.onload = function() {
+ var dataURL = reader.result;
+ destination.src = dataURL;
+ if (destination == setSymbol) {
+ autocrop(setSymbol)
+ }
+ }
+ reader.readAsDataURL(input.files[0]);
+}
+function retrieveLocalURL(event) {
+ var input = event.target;
+ var reader = new FileReader();
+ reader.onload = function() {
+ addNewFrameOption(reader.result)
+ // return reader.result;
+ }
+ reader.readAsDataURL(input.files[0]);
+}
+var savedArtList = [], cardArtUrlList = [], cardArtArtistList = []
+function inputCardArtName(cardArtNameInput) {
+ var xhttp = new XMLHttpRequest()
+ xhttp.onreadystatechange = function() {
+ if (this.readyState == 4 && this.status == 200) {
+ savedArtList = this.responseText.split('"art_crop":"')
+ savedArtList.splice(0, 1)
+ document.getElementById("inputCardArtNameNumber").max = savedArtList.length
+ document.getElementById("inputCardArtNameNumber").value = 1
+ for (i = 0; i < savedArtList.length; i ++) {
+ cardArtUrlList[i] = savedArtList[i].split('","border_crop":')[0]
+ }
+ for (i = 0; i < savedArtList.length; i ++) {
+ cardArtArtistList[i] = savedArtList[i].slice(savedArtList[i].indexOf('"artist":"') + 10, savedArtList[i].indexOf('","artist_id'));
+ // cardArtArtistList[i] = cardArtArtistList[i].slice(0, cardArtArtistList[i].indexOf('","artist_id'))
+ }
+ inputCardArtNameNumber(1)
+ } else if (this.readyState == 4 && this.status == 404) {
+ alert("Sorry, but we can't seem to find any art for '" + cardArtNameInput + "'")
+ }
+ }
+ xhttp.open("GET", "https://api.scryfall.com/cards/search?order=released&unique=art&q=name%3D" + cardArtNameInput.replace(/ /g, "_"), true)
+ xhttp.send()
+}
+function inputCardArtNameNumber(cardArtNameNumberInput) {
+ cardArt.src = cardArtUrlList[cardArtNameNumberInput - 1]
+ document.getElementById("inputInfoArtist").value = cardArtArtistList[cardArtNameNumberInput - 1]
+ updateBottomInfoCanvas()
+}
+//Downloads the image!
+function downloadCardImage(linkElement) {
+ if (document.getElementById("inputInfoArtist").value.replace(/ /g, "") != "") {
+ linkElement.download = version.textList[0][1].toLowerCase().replace(/ /g, "_") + ".png"
+ if (linkElement.download == ".png") {
+ linkElement.download = "card.png"
+ }
+ } else {
+ event.preventDefault()
+ alert("You must properly credit an artist before downloading")
+ }
+ var cardImageData = cardFinalCanvas.toDataURL()
+ if (cardImageData == undefined) {
+ alert("Sorry, it seems that you cannot download your card. Please try using a different browser/device.")
+ }
+ linkElement.href = cardImageData
+}
+
+
+
+
+// function setCookie(cookieName, cookieValue, cookieTime = (5 * 365 * 24 * 60 * 60 * 1000)) { //years*days*hours*minutes*seconds*milliseconds
+// var tempDate = new Date();
+// tempDate.setTime(tempDate.getTime() + cookieTime);
+// var expires = "expires=" + tempDate.toUTCString();
+// document.cookie = cookieName + "=" + cookieValue + ";" + expires + ";path=/";
+// }
+// function getCookie(cookieName) {
+// var name = cookieName + "=";
+// var cookieArray = document.cookie.split(";");
+// for(var i = 0; i < cookieArray.length; i++) {
+// var tempCookie = cookieArray[i];
+// while (tempCookie.charAt(0) == " ") {
+// tempCookie = tempCookie.substring(1);
+// }
+// if (tempCookie.indexOf(name) == 0) {
+// return tempCookie.substring(name.length, tempCookie.length);
+// }
+// }
+// return "";
+// }
+// function checkCookies() {
+// if (getCookie("tooltipsToggled") == "false") {
+// toggleTooltips(false)
+// document.getElementById("tooltipToggler").checked = false
+// }
+// if (getCookie("advancedBorders") == "true") {
+// document.getElementById("checkboxAdvanced").checked = true
+// hideShowFrameTypes()
+// }
+// }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function textCodeTutorial() {
+ var textCodeTutorialString = `line-skips to the next line
+ _linenospace-skips to the next line, but doesn't add spacing
+ _bar-skips to the next line, and adds the flavor text bar
+ _flavor-skips to the next line, adds the flavor text bar, and italicizes the following text
+ _i-italicizes the following text
+ _/i-removes italics from the following text
+ _fontsize#-changes the font size to # pixels
+ _fontcolor#-changes the color to #. Can use color names, or hex codes
+ _left-justifies text to the left
+ _center-justifies text to the center
+ _right-justifies text to the right
+ _up#-moves the following text # pixels up
+ _down#-moves the following text # pixels down
+ _left#-moves the following text # pixels left
+ _right#-moves the following text # pixels right
+ _SYMBOL-creates a mana symbol, where SYMBOL can be: w, u, b, r, g, 1, 2, 3, etc...
+ _outline:*,#-outlines the following text with # thickness and * color
+ _shadow#-creates a text shadow # pixels left and # pixels right`
+ var textCodeTutorialArray = textCodeTutorialString.split("_")
+ for (var i = 0; i < textCodeTutorialArray.length; i ++) {
+ document.getElementById("textCodeTutorial").innerHTML += "
{" + textCodeTutorialArray[i].split("-")[0] + "}
" + textCodeTutorialArray[i].split("-")[1] + "
"
+ }
+}
+
+// //textCodeTutorial()
+textCodeTutorial()
+loadSampleImages()
+
+
+
+
+function filterFramePicker(classToShow) {
+ var framePickerList = document.getElementsByClassName("frameOption")
+ for (var i = 0; i < framePickerList.length; i++) {
+ if (!framePickerList[i].classList.contains("hidden") && !framePickerList[i].classList.contains(classToShow) && !framePickerList[i].classList.contains("frameClassEternal")) {
+ framePickerList[i].classList.add("hidden")
+ } else if (framePickerList[i].classList.contains(classToShow) && framePickerList[i].classList.contains("hidden")) {
+ framePickerList[i].classList.remove("hidden")
+ }
+ }
+}
+
+
+function loadSampleImages() {
+ var availableSamples = 12;
+ var samplesToLoad = [0,0,0];
+ for (var i = 1; i <= samplesToLoad.length; i ++) {
+ var sampleImage = new Image()
+ sampleImage.customVarIndex = i;
+ var randomIndex = 0;
+ sampleImage.onload = function() {
+ document.getElementById(("sample" + this.customVarIndex)).src = this.src;
+ }
+ while(samplesToLoad[i - 1] == 0) {
+ randomIndex = Math.floor(Math.random() * (availableSamples)) + 1;
+ if (!samplesToLoad.includes(randomIndex)) {
+ samplesToLoad[i - 1] = randomIndex;
+ }
+ }
+ sampleImage.src = "data/site/images/samples/" + randomIndex + ".png";
+ }
+ //Donate card stuff!
+ var cardWishlist = [["Riku of Two Reflections", "https://img.scryfall.com/cards/large/front/7/1/716d0b3b-bac9-4fb8-882e-bd6171864043.jpg?1562916032"], ["Klothys, God of Destiny", "https://img.scryfall.com/cards/large/front/4/d/4d747889-04db-4e7a-ad4c-7549514b5112.jpg?1577968427"], ["Ramunap Excavator", "https://img.scryfall.com/cards/large/front/9/0/90a54d18-8403-441d-a115-ee462fabdabb.jpg?1562806928"], ["Birds of Paradise", "https://img.scryfall.com/cards/large/front/f/e/feefe9f0-24a6-461c-9ef1-86c5a6f33b83.jpg?1576382980"], ["Xantcha, Sleeper Agent", "https://img.scryfall.com/cards/large/front/8/9/89b03b9a-7e20-47cb-bc64-23513acea855.jpg?1566340797"],["Adobe Photoshop... Wait, that's not a card! Regardless, I would love to see what frames I could add if I had photoshop","https://i0.wp.com/www.keysbundle.com/wp-content/uploads/2019/09/768px-Adobe_Photoshop_CC_icon.svg.png?fit=768%2C749&ssl=1"]];
+ var randomWishlistCard = cardWishlist[Math.floor(Math.random() * cardWishlist.length)];
+ document.getElementById("wishlistCardName").innerHTML = randomWishlistCard[0];
+ var wishlistCardImage = new Image();
+ wishlistCardImage.onload = function() {
+ document.getElementById("wishlistCardImage").src = this.src;
+ }
+ wishlistCardImage.src = randomWishlistCard[1];
+}
+
+
+
+function toggleFrameOptionVisibility() {
+ var frameOptionList = document.getElementsByClassName("frameOption")
+ if (document.getElementById("inputCheckboxHideFrames").checked) {
+ for (var i = 0; i < frameOptionList.length; i ++) {
+ frameOptionList[i].classList.remove("visibilityOverride");
+ }
+ } else {
+ for (var i = 0; i < frameOptionList.length; i ++) {
+ frameOptionList[i].classList.add("visibilityOverride");
+ }
+ }
+}
+
+//inputCardNameNumberTextImport
+var savedImportResponse = ""
+function inputCardNameTextImport(cardName) {
+ var xhttp = new XMLHttpRequest();
+ xhttp.onreadystatechange = function() {
+ if (this.readyState == 4 && this.status == 200) {
+ savedImportResponse = this.responseText.split('{"object":"card"');
+ inputCardNameNumberTextImport(1);
+ document.getElementById("inputCardNameNumberTextImport").max = savedImportResponse.length - 1;
+ document.getElementById("inputCardNameNumberTextImport").value = 1;
+ } else if (this.readyState == 4 && this.status == 404) {
+ savedImportResponse = ""
+ alert("Sorry, but we can't seem to find any card named '" + cardName + "'");
+ }
+ }
+ xhttp.open("GET", "https://api.scryfall.com/cards/search?order=released&q=name%3D" + cardName.replace(/ /g, "+"), true);
+ xhttp.send();
+}
+function inputCardNameNumberTextImport(index) {
+ var importCardTextResponse = savedImportResponse[index]//.split('{"object":"related_card"')[0]
+ importText(beforeAfter(importCardTextResponse, '"name":"', '",'), "Title");
+ importText(beforeAfter(importCardTextResponse, '"type_line":"', '",'), "Type");
+ importText(beforeAfter(importCardTextResponse, '"oracle_text":"', '",').replace(/\\n/g, "\n").replace(/ \\"/g, ' \u201C').replace(/\\"/g, '\u201D').replace(/\(/g, "{i}(").replace(/\)/g, "){/i}"), "Rules Text");
+ if (importCardTextResponse.includes('"power":"')) {
+ importText(beforeAfter(importCardTextResponse, '"power":"', '",') + "/" + beforeAfter(importCardTextResponse, '"toughness":"', '",'), "Power Toughness");
+ } else {
+ importText("", "Power Toughness");
+ }
+ if (importCardTextResponse.includes('"loyalty":"') && version.currentVersion == "planeswalker") {
+ importText(beforeAfter(importCardTextResponse, '"loyalty":"', '",'), "Loyalty");
+ var abilityList = beforeAfter(importCardTextResponse, '"oracle_text":"', '",').replace(/ \\"/g, ' \u201C').replace(/\\"/g, '\u201D').split(/\\n/g);
+ for (var i = 0; i < abilityList.length; i++) {
+ var stringVersion = ""
+ switch(i) {
+ case 3:
+ stringVersion = "Fourth"
+ break;
+ case 2:
+ stringVersion = "Third"
+ break;
+ case 1:
+ stringVersion = "Second"
+ break;
+ default:
+ stringVersion = "First"
+ }
+ if (abilityList[i].slice(0, 4).includes(":")) {
+ importText(abilityList[i].split(/: (.+)?/)[1], stringVersion + " Ability");
+ document.getElementById("inputPlaneswalker" + (i + 1) + "Icon").value = abilityList[i].split(/: (.+)?/)[0];
+ } else {
+ importText("{left24}" + abilityList[i], stringVersion + " Ability");
+ document.getElementById("inputPlaneswalker" + (i + 1) + "Icon").value = "";
+ }
+ if (document.getElementById("inputPlaneswalker" + (i + 1)).value < 1) {
+ document.getElementById("inputPlaneswalker" + (i + 1)).value = 1;
+ }
+ }
+ }
+ document.getElementById("inputManaCost").value = beforeAfter(importCardTextResponse, '"mana_cost":"', '",');
+ document.getElementById("inputCardArtName").value = beforeAfter(importCardTextResponse, '"name":"', '",');
+ document.getElementById("inputSetCode").value = beforeAfter(importCardTextResponse, '"set":"', '",');
+ document.getElementById("inputSetRarity").value = beforeAfter(importCardTextResponse, '"rarity":"', '",')[0];
+ autocrop(setSymbol, "https://cors-anywhere.herokuapp.com/http://gatherer.wizards.com/Handlers/Image.ashx?type=symbol&set=" + document.getElementById("inputSetCode").value + "&size=large&rarity=" + document.getElementById("inputSetRarity").value);
+ inputCardArtName(beforeAfter(importCardTextResponse, '"name":"', '",'));
+}
+function importText(text, target) {
+ for (var i = 0; i < version.textList.length; i++) {
+ if (version.textList[i][0] == target) {
+ if (i == whichTextIndex) {
+ document.getElementById("inputText").value = text;
+ } else {
+ version.textList[i][1] = text;
+ }
+ updateText();
+ }
+ }
+}
+
+
+
+
+var inputsToRemoveAutocorrect = document.querySelectorAll("input");
+
+inputsToRemoveAutocorrect.forEach(input => {
+ input.setAttribute("autocomplete", "off")
+ input.setAttribute("autocorrect", "off")
+ input.setAttribute("autocapitalize", "off")
+ input.setAttribute("spellcheck", false)
+})
+
+
+
+
diff --git a/data/scripts/setCodeList.js b/OLDdata/scripts/setCodeList.js
similarity index 100%
rename from data/scripts/setCodeList.js
rename to OLDdata/scripts/setCodeList.js
diff --git a/OLDdata/scripts/sortable.js b/OLDdata/scripts/sortable.js
new file mode 100644
index 00000000..192a3659
--- /dev/null
+++ b/OLDdata/scripts/sortable.js
@@ -0,0 +1,3695 @@
+/**!
+ * Sortable 1.10.1
+ * @author RubaXa
+ * @author owenm
+ * @license MIT
+ */
+function _typeof(obj) {
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof = function (obj) {
+ return typeof obj;
+ };
+ } else {
+ _typeof = function (obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+ };
+ }
+
+ return _typeof(obj);
+}
+
+function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+}
+
+function _extends() {
+ _extends = Object.assign || function (target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+
+ for (var key in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+ }
+
+ return target;
+ };
+
+ return _extends.apply(this, arguments);
+}
+
+function _objectSpread(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+ var ownKeys = Object.keys(source);
+
+ if (typeof Object.getOwnPropertySymbols === 'function') {
+ ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+ return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+ }));
+ }
+
+ ownKeys.forEach(function (key) {
+ _defineProperty(target, key, source[key]);
+ });
+ }
+
+ return target;
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+ if (source == null) return {};
+ var target = {};
+ var sourceKeys = Object.keys(source);
+ var key, i;
+
+ for (i = 0; i < sourceKeys.length; i++) {
+ key = sourceKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ target[key] = source[key];
+ }
+
+ return target;
+}
+
+function _objectWithoutProperties(source, excluded) {
+ if (source == null) return {};
+
+ var target = _objectWithoutPropertiesLoose(source, excluded);
+
+ var key, i;
+
+ if (Object.getOwnPropertySymbols) {
+ var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+ for (i = 0; i < sourceSymbolKeys.length; i++) {
+ key = sourceSymbolKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+ target[key] = source[key];
+ }
+ }
+
+ return target;
+}
+
+function _toConsumableArray(arr) {
+ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+}
+
+function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr)) {
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+ return arr2;
+ }
+}
+
+function _iterableToArray(iter) {
+ if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
+
+function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
+
+var version = "1.10.1";
+
+function userAgent(pattern) {
+ if (typeof window !== 'undefined' && window.navigator) {
+ return !!
+ /*@__PURE__*/
+ navigator.userAgent.match(pattern);
+ }
+}
+
+var IE11OrLess = userAgent(/(?:Trident.*rv[ :]?11\.|msie|iemobile|Windows Phone)/i);
+var Edge = userAgent(/Edge/i);
+var FireFox = userAgent(/firefox/i);
+var Safari = userAgent(/safari/i) && !userAgent(/chrome/i) && !userAgent(/android/i);
+var IOS = userAgent(/iP(ad|od|hone)/i);
+var ChromeForAndroid = userAgent(/chrome/i) && userAgent(/android/i);
+
+var captureMode = {
+ capture: false,
+ passive: false
+};
+
+function on(el, event, fn) {
+ el.addEventListener(event, fn, !IE11OrLess && captureMode);
+}
+
+function off(el, event, fn) {
+ el.removeEventListener(event, fn, !IE11OrLess && captureMode);
+}
+
+function matches(
+/**HTMLElement*/
+el,
+/**String*/
+selector) {
+ if (!selector) return;
+ selector[0] === '>' && (selector = selector.substring(1));
+
+ if (el) {
+ try {
+ if (el.matches) {
+ return el.matches(selector);
+ } else if (el.msMatchesSelector) {
+ return el.msMatchesSelector(selector);
+ } else if (el.webkitMatchesSelector) {
+ return el.webkitMatchesSelector(selector);
+ }
+ } catch (_) {
+ return false;
+ }
+ }
+
+ return false;
+}
+
+function getParentOrHost(el) {
+ return el.host && el !== document && el.host.nodeType ? el.host : el.parentNode;
+}
+
+function closest(
+/**HTMLElement*/
+el,
+/**String*/
+selector,
+/**HTMLElement*/
+ctx, includeCTX) {
+ if (el) {
+ ctx = ctx || document;
+
+ do {
+ if (selector != null && (selector[0] === '>' ? el.parentNode === ctx && matches(el, selector) : matches(el, selector)) || includeCTX && el === ctx) {
+ return el;
+ }
+
+ if (el === ctx) break;
+ /* jshint boss:true */
+ } while (el = getParentOrHost(el));
+ }
+
+ return null;
+}
+
+var R_SPACE = /\s+/g;
+
+function toggleClass(el, name, state) {
+ if (el && name) {
+ if (el.classList) {
+ el.classList[state ? 'add' : 'remove'](name);
+ } else {
+ var className = (' ' + el.className + ' ').replace(R_SPACE, ' ').replace(' ' + name + ' ', ' ');
+ el.className = (className + (state ? ' ' + name : '')).replace(R_SPACE, ' ');
+ }
+ }
+}
+
+function css(el, prop, val) {
+ var style = el && el.style;
+
+ if (style) {
+ if (val === void 0) {
+ if (document.defaultView && document.defaultView.getComputedStyle) {
+ val = document.defaultView.getComputedStyle(el, '');
+ } else if (el.currentStyle) {
+ val = el.currentStyle;
+ }
+
+ return prop === void 0 ? val : val[prop];
+ } else {
+ if (!(prop in style) && prop.indexOf('webkit') === -1) {
+ prop = '-webkit-' + prop;
+ }
+
+ style[prop] = val + (typeof val === 'string' ? '' : 'px');
+ }
+ }
+}
+
+function matrix(el, selfOnly) {
+ var appliedTransforms = '';
+
+ if (typeof el === 'string') {
+ appliedTransforms = el;
+ } else {
+ do {
+ var transform = css(el, 'transform');
+
+ if (transform && transform !== 'none') {
+ appliedTransforms = transform + ' ' + appliedTransforms;
+ }
+ /* jshint boss:true */
+
+ } while (!selfOnly && (el = el.parentNode));
+ }
+
+ var matrixFn = window.DOMMatrix || window.WebKitCSSMatrix || window.CSSMatrix;
+ /*jshint -W056 */
+
+ return matrixFn && new matrixFn(appliedTransforms);
+}
+
+function find(ctx, tagName, iterator) {
+ if (ctx) {
+ var list = ctx.getElementsByTagName(tagName),
+ i = 0,
+ n = list.length;
+
+ if (iterator) {
+ for (; i < n; i++) {
+ iterator(list[i], i);
+ }
+ }
+
+ return list;
+ }
+
+ return [];
+}
+
+function getWindowScrollingElement() {
+ if (IE11OrLess) {
+ return document.documentElement;
+ } else {
+ return document.scrollingElement;
+ }
+}
+/**
+ * Returns the "bounding client rect" of given element
+ * @param {HTMLElement} el The element whose boundingClientRect is wanted
+ * @param {[Boolean]} relativeToContainingBlock Whether the rect should be relative to the containing block of (including) the container
+ * @param {[Boolean]} relativeToNonStaticParent Whether the rect should be relative to the relative parent of (including) the contaienr
+ * @param {[Boolean]} undoScale Whether the container's scale() should be undone
+ * @param {[HTMLElement]} container The parent the element will be placed in
+ * @return {Object} The boundingClientRect of el, with specified adjustments
+ */
+
+
+function getRect(el, relativeToContainingBlock, relativeToNonStaticParent, undoScale, container) {
+ if (!el.getBoundingClientRect && el !== window) return;
+ var elRect, top, left, bottom, right, height, width;
+
+ if (el !== window && el !== getWindowScrollingElement()) {
+ elRect = el.getBoundingClientRect();
+ top = elRect.top;
+ left = elRect.left;
+ bottom = elRect.bottom;
+ right = elRect.right;
+ height = elRect.height;
+ width = elRect.width;
+ } else {
+ top = 0;
+ left = 0;
+ bottom = window.innerHeight;
+ right = window.innerWidth;
+ height = window.innerHeight;
+ width = window.innerWidth;
+ }
+
+ if ((relativeToContainingBlock || relativeToNonStaticParent) && el !== window) {
+ // Adjust for translate()
+ container = container || el.parentNode; // solves #1123 (see: https://stackoverflow.com/a/37953806/6088312)
+ // Not needed on <= IE11
+
+ if (!IE11OrLess) {
+ do {
+ if (container && container.getBoundingClientRect && (css(container, 'transform') !== 'none' || relativeToNonStaticParent && css(container, 'position') !== 'static')) {
+ var containerRect = container.getBoundingClientRect(); // Set relative to edges of padding box of container
+
+ top -= containerRect.top + parseInt(css(container, 'border-top-width'));
+ left -= containerRect.left + parseInt(css(container, 'border-left-width'));
+ bottom = top + elRect.height;
+ right = left + elRect.width;
+ break;
+ }
+ /* jshint boss:true */
+
+ } while (container = container.parentNode);
+ }
+ }
+
+ if (undoScale && el !== window) {
+ // Adjust for scale()
+ var elMatrix = matrix(container || el),
+ scaleX = elMatrix && elMatrix.a,
+ scaleY = elMatrix && elMatrix.d;
+
+ if (elMatrix) {
+ top /= scaleY;
+ left /= scaleX;
+ width /= scaleX;
+ height /= scaleY;
+ bottom = top + height;
+ right = left + width;
+ }
+ }
+
+ return {
+ top: top,
+ left: left,
+ bottom: bottom,
+ right: right,
+ width: width,
+ height: height
+ };
+}
+/**
+ * Checks if a side of an element is scrolled past a side of its parents
+ * @param {HTMLElement} el The element who's side being scrolled out of view is in question
+ * @param {String} elSide Side of the element in question ('top', 'left', 'right', 'bottom')
+ * @param {String} parentSide Side of the parent in question ('top', 'left', 'right', 'bottom')
+ * @return {HTMLElement} The parent scroll element that the el's side is scrolled past, or null if there is no such element
+ */
+
+
+function isScrolledPast(el, elSide, parentSide) {
+ var parent = getParentAutoScrollElement(el, true),
+ elSideVal = getRect(el)[elSide];
+ /* jshint boss:true */
+
+ while (parent) {
+ var parentSideVal = getRect(parent)[parentSide],
+ visible = void 0;
+
+ if (parentSide === 'top' || parentSide === 'left') {
+ visible = elSideVal >= parentSideVal;
+ } else {
+ visible = elSideVal <= parentSideVal;
+ }
+
+ if (!visible) return parent;
+ if (parent === getWindowScrollingElement()) break;
+ parent = getParentAutoScrollElement(parent, false);
+ }
+
+ return false;
+}
+/**
+ * Gets nth child of el, ignoring hidden children, sortable's elements (does not ignore clone if it's visible)
+ * and non-draggable elements
+ * @param {HTMLElement} el The parent element
+ * @param {Number} childNum The index of the child
+ * @param {Object} options Parent Sortable's options
+ * @return {HTMLElement} The child at index childNum, or null if not found
+ */
+
+
+function getChild(el, childNum, options) {
+ var currentChild = 0,
+ i = 0,
+ children = el.children;
+
+ while (i < children.length) {
+ if (children[i].style.display !== 'none' && children[i] !== Sortable.ghost && children[i] !== Sortable.dragged && closest(children[i], options.draggable, el, false)) {
+ if (currentChild === childNum) {
+ return children[i];
+ }
+
+ currentChild++;
+ }
+
+ i++;
+ }
+
+ return null;
+}
+/**
+ * Gets the last child in the el, ignoring ghostEl or invisible elements (clones)
+ * @param {HTMLElement} el Parent element
+ * @param {selector} selector Any other elements that should be ignored
+ * @return {HTMLElement} The last child, ignoring ghostEl
+ */
+
+
+function lastChild(el, selector) {
+ var last = el.lastElementChild;
+
+ while (last && (last === Sortable.ghost || css(last, 'display') === 'none' || selector && !matches(last, selector))) {
+ last = last.previousElementSibling;
+ }
+
+ return last || null;
+}
+/**
+ * Returns the index of an element within its parent for a selected set of
+ * elements
+ * @param {HTMLElement} el
+ * @param {selector} selector
+ * @return {number}
+ */
+
+
+function index(el, selector) {
+ var index = 0;
+
+ if (!el || !el.parentNode) {
+ return -1;
+ }
+ /* jshint boss:true */
+
+
+ while (el = el.previousElementSibling) {
+ if (el.nodeName.toUpperCase() !== 'TEMPLATE' && el !== Sortable.clone && (!selector || matches(el, selector))) {
+ index++;
+ }
+ }
+
+ return index;
+}
+/**
+ * Returns the scroll offset of the given element, added with all the scroll offsets of parent elements.
+ * The value is returned in real pixels.
+ * @param {HTMLElement} el
+ * @return {Array} Offsets in the format of [left, top]
+ */
+
+
+function getRelativeScrollOffset(el) {
+ var offsetLeft = 0,
+ offsetTop = 0,
+ winScroller = getWindowScrollingElement();
+
+ if (el) {
+ do {
+ var elMatrix = matrix(el),
+ scaleX = elMatrix.a,
+ scaleY = elMatrix.d;
+ offsetLeft += el.scrollLeft * scaleX;
+ offsetTop += el.scrollTop * scaleY;
+ } while (el !== winScroller && (el = el.parentNode));
+ }
+
+ return [offsetLeft, offsetTop];
+}
+/**
+ * Returns the index of the object within the given array
+ * @param {Array} arr Array that may or may not hold the object
+ * @param {Object} obj An object that has a key-value pair unique to and identical to a key-value pair in the object you want to find
+ * @return {Number} The index of the object in the array, or -1
+ */
+
+
+function indexOfObject(arr, obj) {
+ for (var i in arr) {
+ if (!arr.hasOwnProperty(i)) continue;
+
+ for (var key in obj) {
+ if (obj.hasOwnProperty(key) && obj[key] === arr[i][key]) return Number(i);
+ }
+ }
+
+ return -1;
+}
+
+function getParentAutoScrollElement(el, includeSelf) {
+ // skip to window
+ if (!el || !el.getBoundingClientRect) return getWindowScrollingElement();
+ var elem = el;
+ var gotSelf = false;
+
+ do {
+ // we don't need to get elem css if it isn't even overflowing in the first place (performance)
+ if (elem.clientWidth < elem.scrollWidth || elem.clientHeight < elem.scrollHeight) {
+ var elemCSS = css(elem);
+
+ if (elem.clientWidth < elem.scrollWidth && (elemCSS.overflowX == 'auto' || elemCSS.overflowX == 'scroll') || elem.clientHeight < elem.scrollHeight && (elemCSS.overflowY == 'auto' || elemCSS.overflowY == 'scroll')) {
+ if (!elem.getBoundingClientRect || elem === document.body) return getWindowScrollingElement();
+ if (gotSelf || includeSelf) return elem;
+ gotSelf = true;
+ }
+ }
+ /* jshint boss:true */
+
+ } while (elem = elem.parentNode);
+
+ return getWindowScrollingElement();
+}
+
+function extend(dst, src) {
+ if (dst && src) {
+ for (var key in src) {
+ if (src.hasOwnProperty(key)) {
+ dst[key] = src[key];
+ }
+ }
+ }
+
+ return dst;
+}
+
+function isRectEqual(rect1, rect2) {
+ return Math.round(rect1.top) === Math.round(rect2.top) && Math.round(rect1.left) === Math.round(rect2.left) && Math.round(rect1.height) === Math.round(rect2.height) && Math.round(rect1.width) === Math.round(rect2.width);
+}
+
+var _throttleTimeout;
+
+function throttle(callback, ms) {
+ return function () {
+ if (!_throttleTimeout) {
+ var args = arguments,
+ _this = this;
+
+ if (args.length === 1) {
+ callback.call(_this, args[0]);
+ } else {
+ callback.apply(_this, args);
+ }
+
+ _throttleTimeout = setTimeout(function () {
+ _throttleTimeout = void 0;
+ }, ms);
+ }
+ };
+}
+
+function cancelThrottle() {
+ clearTimeout(_throttleTimeout);
+ _throttleTimeout = void 0;
+}
+
+function scrollBy(el, x, y) {
+ el.scrollLeft += x;
+ el.scrollTop += y;
+}
+
+function clone(el) {
+ var Polymer = window.Polymer;
+ var $ = window.jQuery || window.Zepto;
+
+ if (Polymer && Polymer.dom) {
+ return Polymer.dom(el).cloneNode(true);
+ } else if ($) {
+ return $(el).clone(true)[0];
+ } else {
+ return el.cloneNode(true);
+ }
+}
+
+function setRect(el, rect) {
+ css(el, 'position', 'absolute');
+ css(el, 'top', rect.top);
+ css(el, 'left', rect.left);
+ css(el, 'width', rect.width);
+ css(el, 'height', rect.height);
+}
+
+function unsetRect(el) {
+ css(el, 'position', '');
+ css(el, 'top', '');
+ css(el, 'left', '');
+ css(el, 'width', '');
+ css(el, 'height', '');
+}
+
+var expando = 'Sortable' + new Date().getTime();
+
+function AnimationStateManager() {
+ var animationStates = [],
+ animationCallbackId;
+ return {
+ captureAnimationState: function captureAnimationState() {
+ animationStates = [];
+ if (!this.options.animation) return;
+ var children = [].slice.call(this.el.children);
+ children.forEach(function (child) {
+ if (css(child, 'display') === 'none' || child === Sortable.ghost) return;
+ animationStates.push({
+ target: child,
+ rect: getRect(child)
+ });
+
+ var fromRect = _objectSpread({}, animationStates[animationStates.length - 1].rect); // If animating: compensate for current animation
+
+
+ if (child.thisAnimationDuration) {
+ var childMatrix = matrix(child, true);
+
+ if (childMatrix) {
+ fromRect.top -= childMatrix.f;
+ fromRect.left -= childMatrix.e;
+ }
+ }
+
+ child.fromRect = fromRect;
+ });
+ },
+ addAnimationState: function addAnimationState(state) {
+ animationStates.push(state);
+ },
+ removeAnimationState: function removeAnimationState(target) {
+ animationStates.splice(indexOfObject(animationStates, {
+ target: target
+ }), 1);
+ },
+ animateAll: function animateAll(callback) {
+ var _this = this;
+
+ if (!this.options.animation) {
+ clearTimeout(animationCallbackId);
+ if (typeof callback === 'function') callback();
+ return;
+ }
+
+ var animating = false,
+ animationTime = 0;
+ animationStates.forEach(function (state) {
+ var time = 0,
+ target = state.target,
+ fromRect = target.fromRect,
+ toRect = getRect(target),
+ prevFromRect = target.prevFromRect,
+ prevToRect = target.prevToRect,
+ animatingRect = state.rect,
+ targetMatrix = matrix(target, true);
+
+ if (targetMatrix) {
+ // Compensate for current animation
+ toRect.top -= targetMatrix.f;
+ toRect.left -= targetMatrix.e;
+ }
+
+ target.toRect = toRect;
+
+ if (target.thisAnimationDuration) {
+ // Could also check if animatingRect is between fromRect and toRect
+ if (isRectEqual(prevFromRect, toRect) && !isRectEqual(fromRect, toRect) && // Make sure animatingRect is on line between toRect & fromRect
+ (animatingRect.top - toRect.top) / (animatingRect.left - toRect.left) === (fromRect.top - toRect.top) / (fromRect.left - toRect.left)) {
+ // If returning to same place as started from animation and on same axis
+ time = calculateRealTime(animatingRect, prevFromRect, prevToRect, _this.options);
+ }
+ } // if fromRect != toRect: animate
+
+
+ if (!isRectEqual(toRect, fromRect)) {
+ target.prevFromRect = fromRect;
+ target.prevToRect = toRect;
+
+ if (!time) {
+ time = _this.options.animation;
+ }
+
+ _this.animate(target, animatingRect, toRect, time);
+ }
+
+ if (time) {
+ animating = true;
+ animationTime = Math.max(animationTime, time);
+ clearTimeout(target.animationResetTimer);
+ target.animationResetTimer = setTimeout(function () {
+ target.animationTime = 0;
+ target.prevFromRect = null;
+ target.fromRect = null;
+ target.prevToRect = null;
+ target.thisAnimationDuration = null;
+ }, time);
+ target.thisAnimationDuration = time;
+ }
+ });
+ clearTimeout(animationCallbackId);
+
+ if (!animating) {
+ if (typeof callback === 'function') callback();
+ } else {
+ animationCallbackId = setTimeout(function () {
+ if (typeof callback === 'function') callback();
+ }, animationTime);
+ }
+
+ animationStates = [];
+ },
+ animate: function animate(target, currentRect, toRect, duration) {
+ if (duration) {
+ css(target, 'transition', '');
+ css(target, 'transform', '');
+ var elMatrix = matrix(this.el),
+ scaleX = elMatrix && elMatrix.a,
+ scaleY = elMatrix && elMatrix.d,
+ translateX = (currentRect.left - toRect.left) / (scaleX || 1),
+ translateY = (currentRect.top - toRect.top) / (scaleY || 1);
+ target.animatingX = !!translateX;
+ target.animatingY = !!translateY;
+ css(target, 'transform', 'translate3d(' + translateX + 'px,' + translateY + 'px,0)');
+ repaint(target); // repaint
+
+ css(target, 'transition', 'transform ' + duration + 'ms' + (this.options.easing ? ' ' + this.options.easing : ''));
+ css(target, 'transform', 'translate3d(0,0,0)');
+ typeof target.animated === 'number' && clearTimeout(target.animated);
+ target.animated = setTimeout(function () {
+ css(target, 'transition', '');
+ css(target, 'transform', '');
+ target.animated = false;
+ target.animatingX = false;
+ target.animatingY = false;
+ }, duration);
+ }
+ }
+ };
+}
+
+function repaint(target) {
+ return target.offsetWidth;
+}
+
+function calculateRealTime(animatingRect, fromRect, toRect, options) {
+ return Math.sqrt(Math.pow(fromRect.top - animatingRect.top, 2) + Math.pow(fromRect.left - animatingRect.left, 2)) / Math.sqrt(Math.pow(fromRect.top - toRect.top, 2) + Math.pow(fromRect.left - toRect.left, 2)) * options.animation;
+}
+
+var plugins = [];
+var defaults = {
+ initializeByDefault: true
+};
+var PluginManager = {
+ mount: function mount(plugin) {
+ // Set default static properties
+ for (var option in defaults) {
+ if (defaults.hasOwnProperty(option) && !(option in plugin)) {
+ plugin[option] = defaults[option];
+ }
+ }
+
+ plugins.push(plugin);
+ },
+ pluginEvent: function pluginEvent(eventName, sortable, evt) {
+ var _this = this;
+
+ this.eventCanceled = false;
+
+ evt.cancel = function () {
+ _this.eventCanceled = true;
+ };
+
+ var eventNameGlobal = eventName + 'Global';
+ plugins.forEach(function (plugin) {
+ if (!sortable[plugin.pluginName]) return; // Fire global events if it exists in this sortable
+
+ if (sortable[plugin.pluginName][eventNameGlobal]) {
+ sortable[plugin.pluginName][eventNameGlobal](_objectSpread({
+ sortable: sortable
+ }, evt));
+ } // Only fire plugin event if plugin is enabled in this sortable,
+ // and plugin has event defined
+
+
+ if (sortable.options[plugin.pluginName] && sortable[plugin.pluginName][eventName]) {
+ sortable[plugin.pluginName][eventName](_objectSpread({
+ sortable: sortable
+ }, evt));
+ }
+ });
+ },
+ initializePlugins: function initializePlugins(sortable, el, defaults, options) {
+ plugins.forEach(function (plugin) {
+ var pluginName = plugin.pluginName;
+ if (!sortable.options[pluginName] && !plugin.initializeByDefault) return;
+ var initialized = new plugin(sortable, el, sortable.options);
+ initialized.sortable = sortable;
+ initialized.options = sortable.options;
+ sortable[pluginName] = initialized; // Add default options from plugin
+
+ _extends(defaults, initialized.defaults);
+ });
+
+ for (var option in sortable.options) {
+ if (!sortable.options.hasOwnProperty(option)) continue;
+ var modified = this.modifyOption(sortable, option, sortable.options[option]);
+
+ if (typeof modified !== 'undefined') {
+ sortable.options[option] = modified;
+ }
+ }
+ },
+ getEventProperties: function getEventProperties(name, sortable) {
+ var eventProperties = {};
+ plugins.forEach(function (plugin) {
+ if (typeof plugin.eventProperties !== 'function') return;
+
+ _extends(eventProperties, plugin.eventProperties.call(sortable[plugin.pluginName], name));
+ });
+ return eventProperties;
+ },
+ modifyOption: function modifyOption(sortable, name, value) {
+ var modifiedValue;
+ plugins.forEach(function (plugin) {
+ // Plugin must exist on the Sortable
+ if (!sortable[plugin.pluginName]) return; // If static option listener exists for this option, call in the context of the Sortable's instance of this plugin
+
+ if (plugin.optionListeners && typeof plugin.optionListeners[name] === 'function') {
+ modifiedValue = plugin.optionListeners[name].call(sortable[plugin.pluginName], value);
+ }
+ });
+ return modifiedValue;
+ }
+};
+
+function dispatchEvent(_ref) {
+ var sortable = _ref.sortable,
+ rootEl = _ref.rootEl,
+ name = _ref.name,
+ targetEl = _ref.targetEl,
+ cloneEl = _ref.cloneEl,
+ toEl = _ref.toEl,
+ fromEl = _ref.fromEl,
+ oldIndex = _ref.oldIndex,
+ newIndex = _ref.newIndex,
+ oldDraggableIndex = _ref.oldDraggableIndex,
+ newDraggableIndex = _ref.newDraggableIndex,
+ originalEvent = _ref.originalEvent,
+ putSortable = _ref.putSortable,
+ extraEventProperties = _ref.extraEventProperties;
+ sortable = sortable || rootEl && rootEl[expando];
+ if (!sortable) return;
+ var evt,
+ options = sortable.options,
+ onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1); // Support for new CustomEvent feature
+
+ if (window.CustomEvent && !IE11OrLess && !Edge) {
+ evt = new CustomEvent(name, {
+ bubbles: true,
+ cancelable: true
+ });
+ } else {
+ evt = document.createEvent('Event');
+ evt.initEvent(name, true, true);
+ }
+
+ evt.to = toEl || rootEl;
+ evt.from = fromEl || rootEl;
+ evt.item = targetEl || rootEl;
+ evt.clone = cloneEl;
+ evt.oldIndex = oldIndex;
+ evt.newIndex = newIndex;
+ evt.oldDraggableIndex = oldDraggableIndex;
+ evt.newDraggableIndex = newDraggableIndex;
+ evt.originalEvent = originalEvent;
+ evt.pullMode = putSortable ? putSortable.lastPutMode : undefined;
+
+ var allEventProperties = _objectSpread({}, extraEventProperties, PluginManager.getEventProperties(name, sortable));
+
+ for (var option in allEventProperties) {
+ evt[option] = allEventProperties[option];
+ }
+
+ if (rootEl) {
+ rootEl.dispatchEvent(evt);
+ }
+
+ if (options[onName]) {
+ options[onName].call(sortable, evt);
+ }
+}
+
+var pluginEvent = function pluginEvent(eventName, sortable) {
+ var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+ originalEvent = _ref.evt,
+ data = _objectWithoutProperties(_ref, ["evt"]);
+
+ PluginManager.pluginEvent.bind(Sortable)(eventName, sortable, _objectSpread({
+ dragEl: dragEl,
+ parentEl: parentEl,
+ ghostEl: ghostEl,
+ rootEl: rootEl,
+ nextEl: nextEl,
+ lastDownEl: lastDownEl,
+ cloneEl: cloneEl,
+ cloneHidden: cloneHidden,
+ dragStarted: moved,
+ putSortable: putSortable,
+ activeSortable: Sortable.active,
+ originalEvent: originalEvent,
+ oldIndex: oldIndex,
+ oldDraggableIndex: oldDraggableIndex,
+ newIndex: newIndex,
+ newDraggableIndex: newDraggableIndex,
+ hideGhostForTarget: _hideGhostForTarget,
+ unhideGhostForTarget: _unhideGhostForTarget,
+ cloneNowHidden: function cloneNowHidden() {
+ cloneHidden = true;
+ },
+ cloneNowShown: function cloneNowShown() {
+ cloneHidden = false;
+ },
+ dispatchSortableEvent: function dispatchSortableEvent(name) {
+ _dispatchEvent({
+ sortable: sortable,
+ name: name,
+ originalEvent: originalEvent
+ });
+ }
+ }, data));
+};
+
+function _dispatchEvent(info) {
+ dispatchEvent(_objectSpread({
+ putSortable: putSortable,
+ cloneEl: cloneEl,
+ targetEl: dragEl,
+ rootEl: rootEl,
+ oldIndex: oldIndex,
+ oldDraggableIndex: oldDraggableIndex,
+ newIndex: newIndex,
+ newDraggableIndex: newDraggableIndex
+ }, info));
+}
+
+var dragEl,
+ parentEl,
+ ghostEl,
+ rootEl,
+ nextEl,
+ lastDownEl,
+ cloneEl,
+ cloneHidden,
+ oldIndex,
+ newIndex,
+ oldDraggableIndex,
+ newDraggableIndex,
+ activeGroup,
+ putSortable,
+ awaitingDragStarted = false,
+ ignoreNextClick = false,
+ sortables = [],
+ tapEvt,
+ touchEvt,
+ lastDx,
+ lastDy,
+ tapDistanceLeft,
+ tapDistanceTop,
+ moved,
+ lastTarget,
+ lastDirection,
+ pastFirstInvertThresh = false,
+ isCircumstantialInvert = false,
+ targetMoveDistance,
+ // For positioning ghost absolutely
+ghostRelativeParent,
+ ghostRelativeParentInitialScroll = [],
+ // (left, top)
+_silent = false,
+ savedInputChecked = [];
+/** @const */
+
+var documentExists = typeof document !== 'undefined',
+ PositionGhostAbsolutely = IOS,
+ CSSFloatProperty = Edge || IE11OrLess ? 'cssFloat' : 'float',
+ // This will not pass for IE9, because IE9 DnD only works on anchors
+supportDraggable = documentExists && !ChromeForAndroid && !IOS && 'draggable' in document.createElement('div'),
+ supportCssPointerEvents = function () {
+ if (!documentExists) return; // false when <= IE11
+
+ if (IE11OrLess) {
+ return false;
+ }
+
+ var el = document.createElement('x');
+ el.style.cssText = 'pointer-events:auto';
+ return el.style.pointerEvents === 'auto';
+}(),
+ _detectDirection = function _detectDirection(el, options) {
+ var elCSS = css(el),
+ elWidth = parseInt(elCSS.width) - parseInt(elCSS.paddingLeft) - parseInt(elCSS.paddingRight) - parseInt(elCSS.borderLeftWidth) - parseInt(elCSS.borderRightWidth),
+ child1 = getChild(el, 0, options),
+ child2 = getChild(el, 1, options),
+ firstChildCSS = child1 && css(child1),
+ secondChildCSS = child2 && css(child2),
+ firstChildWidth = firstChildCSS && parseInt(firstChildCSS.marginLeft) + parseInt(firstChildCSS.marginRight) + getRect(child1).width,
+ secondChildWidth = secondChildCSS && parseInt(secondChildCSS.marginLeft) + parseInt(secondChildCSS.marginRight) + getRect(child2).width;
+
+ if (elCSS.display === 'flex') {
+ return elCSS.flexDirection === 'column' || elCSS.flexDirection === 'column-reverse' ? 'vertical' : 'horizontal';
+ }
+
+ if (elCSS.display === 'grid') {
+ return elCSS.gridTemplateColumns.split(' ').length <= 1 ? 'vertical' : 'horizontal';
+ }
+
+ if (child1 && firstChildCSS["float"] && firstChildCSS["float"] !== 'none') {
+ var touchingSideChild2 = firstChildCSS["float"] === 'left' ? 'left' : 'right';
+ return child2 && (secondChildCSS.clear === 'both' || secondChildCSS.clear === touchingSideChild2) ? 'vertical' : 'horizontal';
+ }
+
+ return child1 && (firstChildCSS.display === 'block' || firstChildCSS.display === 'flex' || firstChildCSS.display === 'table' || firstChildCSS.display === 'grid' || firstChildWidth >= elWidth && elCSS[CSSFloatProperty] === 'none' || child2 && elCSS[CSSFloatProperty] === 'none' && firstChildWidth + secondChildWidth > elWidth) ? 'vertical' : 'horizontal';
+},
+ _dragElInRowColumn = function _dragElInRowColumn(dragRect, targetRect, vertical) {
+ var dragElS1Opp = vertical ? dragRect.left : dragRect.top,
+ dragElS2Opp = vertical ? dragRect.right : dragRect.bottom,
+ dragElOppLength = vertical ? dragRect.width : dragRect.height,
+ targetS1Opp = vertical ? targetRect.left : targetRect.top,
+ targetS2Opp = vertical ? targetRect.right : targetRect.bottom,
+ targetOppLength = vertical ? targetRect.width : targetRect.height;
+ return dragElS1Opp === targetS1Opp || dragElS2Opp === targetS2Opp || dragElS1Opp + dragElOppLength / 2 === targetS1Opp + targetOppLength / 2;
+},
+
+/**
+ * Detects first nearest empty sortable to X and Y position using emptyInsertThreshold.
+ * @param {Number} x X position
+ * @param {Number} y Y position
+ * @return {HTMLElement} Element of the first found nearest Sortable
+ */
+_detectNearestEmptySortable = function _detectNearestEmptySortable(x, y) {
+ var ret;
+ sortables.some(function (sortable) {
+ if (lastChild(sortable)) return;
+ var rect = getRect(sortable),
+ threshold = sortable[expando].options.emptyInsertThreshold,
+ insideHorizontally = x >= rect.left - threshold && x <= rect.right + threshold,
+ insideVertically = y >= rect.top - threshold && y <= rect.bottom + threshold;
+
+ if (threshold && insideHorizontally && insideVertically) {
+ return ret = sortable;
+ }
+ });
+ return ret;
+},
+ _prepareGroup = function _prepareGroup(options) {
+ function toFn(value, pull) {
+ return function (to, from, dragEl, evt) {
+ var sameGroup = to.options.group.name && from.options.group.name && to.options.group.name === from.options.group.name;
+
+ if (value == null && (pull || sameGroup)) {
+ // Default pull value
+ // Default pull and put value if same group
+ return true;
+ } else if (value == null || value === false) {
+ return false;
+ } else if (pull && value === 'clone') {
+ return value;
+ } else if (typeof value === 'function') {
+ return toFn(value(to, from, dragEl, evt), pull)(to, from, dragEl, evt);
+ } else {
+ var otherGroup = (pull ? to : from).options.group.name;
+ return value === true || typeof value === 'string' && value === otherGroup || value.join && value.indexOf(otherGroup) > -1;
+ }
+ };
+ }
+
+ var group = {};
+ var originalGroup = options.group;
+
+ if (!originalGroup || _typeof(originalGroup) != 'object') {
+ originalGroup = {
+ name: originalGroup
+ };
+ }
+
+ group.name = originalGroup.name;
+ group.checkPull = toFn(originalGroup.pull, true);
+ group.checkPut = toFn(originalGroup.put);
+ group.revertClone = originalGroup.revertClone;
+ options.group = group;
+},
+ _hideGhostForTarget = function _hideGhostForTarget() {
+ if (!supportCssPointerEvents && ghostEl) {
+ css(ghostEl, 'display', 'none');
+ }
+},
+ _unhideGhostForTarget = function _unhideGhostForTarget() {
+ if (!supportCssPointerEvents && ghostEl) {
+ css(ghostEl, 'display', '');
+ }
+}; // #1184 fix - Prevent click event on fallback if dragged but item not changed position
+
+
+if (documentExists) {
+ document.addEventListener('click', function (evt) {
+ if (ignoreNextClick) {
+ evt.preventDefault();
+ evt.stopPropagation && evt.stopPropagation();
+ evt.stopImmediatePropagation && evt.stopImmediatePropagation();
+ ignoreNextClick = false;
+ return false;
+ }
+ }, true);
+}
+
+var nearestEmptyInsertDetectEvent = function nearestEmptyInsertDetectEvent(evt) {
+ if (dragEl) {
+ evt = evt.touches ? evt.touches[0] : evt;
+
+ var nearest = _detectNearestEmptySortable(evt.clientX, evt.clientY);
+
+ if (nearest) {
+ // Create imitation event
+ var event = {};
+
+ for (var i in evt) {
+ if (evt.hasOwnProperty(i)) {
+ event[i] = evt[i];
+ }
+ }
+
+ event.target = event.rootEl = nearest;
+ event.preventDefault = void 0;
+ event.stopPropagation = void 0;
+
+ nearest[expando]._onDragOver(event);
+ }
+ }
+};
+
+var _checkOutsideTargetEl = function _checkOutsideTargetEl(evt) {
+ if (dragEl) {
+ dragEl.parentNode[expando]._isOutsideThisEl(evt.target);
+ }
+};
+/**
+ * @class Sortable
+ * @param {HTMLElement} el
+ * @param {Object} [options]
+ */
+
+
+function Sortable(el, options) {
+ if (!(el && el.nodeType && el.nodeType === 1)) {
+ throw "Sortable: `el` must be an HTMLElement, not ".concat({}.toString.call(el));
+ }
+
+ this.el = el; // root element
+
+ this.options = options = _extends({}, options); // Export instance
+
+ el[expando] = this;
+ var defaults = {
+ group: null,
+ sort: true,
+ disabled: false,
+ store: null,
+ handle: null,
+ draggable: /^[uo]l$/i.test(el.nodeName) ? '>li' : '>*',
+ swapThreshold: 1,
+ // percentage; 0 <= x <= 1
+ invertSwap: false,
+ // invert always
+ invertedSwapThreshold: null,
+ // will be set to same as swapThreshold if default
+ removeCloneOnHide: true,
+ direction: function direction() {
+ return _detectDirection(el, this.options);
+ },
+ ghostClass: 'sortable-ghost',
+ chosenClass: 'sortable-chosen',
+ dragClass: 'sortable-drag',
+ ignore: 'a, img',
+ filter: null,
+ preventOnFilter: true,
+ animation: 0,
+ easing: null,
+ setData: function setData(dataTransfer, dragEl) {
+ dataTransfer.setData('Text', dragEl.textContent);
+ },
+ dropBubble: false,
+ dragoverBubble: false,
+ dataIdAttr: 'data-id',
+ delay: 0,
+ delayOnTouchOnly: false,
+ touchStartThreshold: (Number.parseInt ? Number : window).parseInt(window.devicePixelRatio, 10) || 1,
+ forceFallback: false,
+ fallbackClass: 'sortable-fallback',
+ fallbackOnBody: false,
+ fallbackTolerance: 0,
+ fallbackOffset: {
+ x: 0,
+ y: 0
+ },
+ supportPointer: Sortable.supportPointer !== false && 'PointerEvent' in window,
+ emptyInsertThreshold: 5
+ };
+ PluginManager.initializePlugins(this, el, defaults); // Set default options
+
+ for (var name in defaults) {
+ !(name in options) && (options[name] = defaults[name]);
+ }
+
+ _prepareGroup(options); // Bind all private methods
+
+
+ for (var fn in this) {
+ if (fn.charAt(0) === '_' && typeof this[fn] === 'function') {
+ this[fn] = this[fn].bind(this);
+ }
+ } // Setup drag mode
+
+
+ this.nativeDraggable = options.forceFallback ? false : supportDraggable;
+
+ if (this.nativeDraggable) {
+ // Touch start threshold cannot be greater than the native dragstart threshold
+ this.options.touchStartThreshold = 1;
+ } // Bind events
+
+
+ if (options.supportPointer) {
+ on(el, 'pointerdown', this._onTapStart);
+ } else {
+ on(el, 'mousedown', this._onTapStart);
+ on(el, 'touchstart', this._onTapStart);
+ }
+
+ if (this.nativeDraggable) {
+ on(el, 'dragover', this);
+ on(el, 'dragenter', this);
+ }
+
+ sortables.push(this.el); // Restore sorting
+
+ options.store && options.store.get && this.sort(options.store.get(this) || []); // Add animation state manager
+
+ _extends(this, AnimationStateManager());
+}
+
+Sortable.prototype =
+/** @lends Sortable.prototype */
+{
+ constructor: Sortable,
+ _isOutsideThisEl: function _isOutsideThisEl(target) {
+ if (!this.el.contains(target) && target !== this.el) {
+ lastTarget = null;
+ }
+ },
+ _getDirection: function _getDirection(evt, target) {
+ return typeof this.options.direction === 'function' ? this.options.direction.call(this, evt, target, dragEl) : this.options.direction;
+ },
+ _onTapStart: function _onTapStart(
+ /** Event|TouchEvent */
+ evt) {
+ if (!evt.cancelable) return;
+
+ var _this = this,
+ el = this.el,
+ options = this.options,
+ preventOnFilter = options.preventOnFilter,
+ type = evt.type,
+ touch = evt.touches && evt.touches[0] || evt.pointerType && evt.pointerType === 'touch' && evt,
+ target = (touch || evt).target,
+ originalTarget = evt.target.shadowRoot && (evt.path && evt.path[0] || evt.composedPath && evt.composedPath()[0]) || target,
+ filter = options.filter;
+
+ _saveInputCheckedState(el); // Don't trigger start event when an element is been dragged, otherwise the evt.oldindex always wrong when set option.group.
+
+
+ if (dragEl) {
+ return;
+ }
+
+ if (/mousedown|pointerdown/.test(type) && evt.button !== 0 || options.disabled) {
+ return; // only left button and enabled
+ } // cancel dnd if original target is content editable
+
+
+ if (originalTarget.isContentEditable) {
+ return;
+ }
+
+ target = closest(target, options.draggable, el, false);
+
+ if (target && target.animated) {
+ return;
+ }
+
+ if (lastDownEl === target) {
+ // Ignoring duplicate `down`
+ return;
+ } // Get the index of the dragged element within its parent
+
+
+ oldIndex = index(target);
+ oldDraggableIndex = index(target, options.draggable); // Check filter
+
+ if (typeof filter === 'function') {
+ if (filter.call(this, evt, target, this)) {
+ _dispatchEvent({
+ sortable: _this,
+ rootEl: originalTarget,
+ name: 'filter',
+ targetEl: target,
+ toEl: el,
+ fromEl: el
+ });
+
+ pluginEvent('filter', _this, {
+ evt: evt
+ });
+ preventOnFilter && evt.cancelable && evt.preventDefault();
+ return; // cancel dnd
+ }
+ } else if (filter) {
+ filter = filter.split(',').some(function (criteria) {
+ criteria = closest(originalTarget, criteria.trim(), el, false);
+
+ if (criteria) {
+ _dispatchEvent({
+ sortable: _this,
+ rootEl: criteria,
+ name: 'filter',
+ targetEl: target,
+ fromEl: el,
+ toEl: el
+ });
+
+ pluginEvent('filter', _this, {
+ evt: evt
+ });
+ return true;
+ }
+ });
+
+ if (filter) {
+ preventOnFilter && evt.cancelable && evt.preventDefault();
+ return; // cancel dnd
+ }
+ }
+
+ if (options.handle && !closest(originalTarget, options.handle, el, false)) {
+ return;
+ } // Prepare `dragstart`
+
+
+ this._prepareDragStart(evt, touch, target);
+ },
+ _prepareDragStart: function _prepareDragStart(
+ /** Event */
+ evt,
+ /** Touch */
+ touch,
+ /** HTMLElement */
+ target) {
+ var _this = this,
+ el = _this.el,
+ options = _this.options,
+ ownerDocument = el.ownerDocument,
+ dragStartFn;
+
+ if (target && !dragEl && target.parentNode === el) {
+ var dragRect = getRect(target);
+ rootEl = el;
+ dragEl = target;
+ parentEl = dragEl.parentNode;
+ nextEl = dragEl.nextSibling;
+ lastDownEl = target;
+ activeGroup = options.group;
+ Sortable.dragged = dragEl;
+ tapEvt = {
+ target: dragEl,
+ clientX: (touch || evt).clientX,
+ clientY: (touch || evt).clientY
+ };
+ tapDistanceLeft = tapEvt.clientX - dragRect.left;
+ tapDistanceTop = tapEvt.clientY - dragRect.top;
+ this._lastX = (touch || evt).clientX;
+ this._lastY = (touch || evt).clientY;
+ dragEl.style['will-change'] = 'all';
+
+ dragStartFn = function dragStartFn() {
+ pluginEvent('delayEnded', _this, {
+ evt: evt
+ });
+
+ if (Sortable.eventCanceled) {
+ _this._onDrop();
+
+ return;
+ } // Delayed drag has been triggered
+ // we can re-enable the events: touchmove/mousemove
+
+
+ _this._disableDelayedDragEvents();
+
+ if (!FireFox && _this.nativeDraggable) {
+ dragEl.draggable = true;
+ } // Bind the events: dragstart/dragend
+
+
+ _this._triggerDragStart(evt, touch); // Drag start event
+
+
+ _dispatchEvent({
+ sortable: _this,
+ name: 'choose',
+ originalEvent: evt
+ }); // Chosen item
+
+
+ toggleClass(dragEl, options.chosenClass, true);
+ }; // Disable "draggable"
+
+
+ options.ignore.split(',').forEach(function (criteria) {
+ find(dragEl, criteria.trim(), _disableDraggable);
+ });
+ on(ownerDocument, 'dragover', nearestEmptyInsertDetectEvent);
+ on(ownerDocument, 'mousemove', nearestEmptyInsertDetectEvent);
+ on(ownerDocument, 'touchmove', nearestEmptyInsertDetectEvent);
+ on(ownerDocument, 'mouseup', _this._onDrop);
+ on(ownerDocument, 'touchend', _this._onDrop);
+ on(ownerDocument, 'touchcancel', _this._onDrop); // Make dragEl draggable (must be before delay for FireFox)
+
+ if (FireFox && this.nativeDraggable) {
+ this.options.touchStartThreshold = 4;
+ dragEl.draggable = true;
+ }
+
+ pluginEvent('delayStart', this, {
+ evt: evt
+ }); // Delay is impossible for native DnD in Edge or IE
+
+ if (options.delay && (!options.delayOnTouchOnly || touch) && (!this.nativeDraggable || !(Edge || IE11OrLess))) {
+ if (Sortable.eventCanceled) {
+ this._onDrop();
+
+ return;
+ } // If the user moves the pointer or let go the click or touch
+ // before the delay has been reached:
+ // disable the delayed drag
+
+
+ on(ownerDocument, 'mouseup', _this._disableDelayedDrag);
+ on(ownerDocument, 'touchend', _this._disableDelayedDrag);
+ on(ownerDocument, 'touchcancel', _this._disableDelayedDrag);
+ on(ownerDocument, 'mousemove', _this._delayedDragTouchMoveHandler);
+ on(ownerDocument, 'touchmove', _this._delayedDragTouchMoveHandler);
+ options.supportPointer && on(ownerDocument, 'pointermove', _this._delayedDragTouchMoveHandler);
+ _this._dragStartTimer = setTimeout(dragStartFn, options.delay);
+ } else {
+ dragStartFn();
+ }
+ }
+ },
+ _delayedDragTouchMoveHandler: function _delayedDragTouchMoveHandler(
+ /** TouchEvent|PointerEvent **/
+ e) {
+ var touch = e.touches ? e.touches[0] : e;
+
+ if (Math.max(Math.abs(touch.clientX - this._lastX), Math.abs(touch.clientY - this._lastY)) >= Math.floor(this.options.touchStartThreshold / (this.nativeDraggable && window.devicePixelRatio || 1))) {
+ this._disableDelayedDrag();
+ }
+ },
+ _disableDelayedDrag: function _disableDelayedDrag() {
+ dragEl && _disableDraggable(dragEl);
+ clearTimeout(this._dragStartTimer);
+
+ this._disableDelayedDragEvents();
+ },
+ _disableDelayedDragEvents: function _disableDelayedDragEvents() {
+ var ownerDocument = this.el.ownerDocument;
+ off(ownerDocument, 'mouseup', this._disableDelayedDrag);
+ off(ownerDocument, 'touchend', this._disableDelayedDrag);
+ off(ownerDocument, 'touchcancel', this._disableDelayedDrag);
+ off(ownerDocument, 'mousemove', this._delayedDragTouchMoveHandler);
+ off(ownerDocument, 'touchmove', this._delayedDragTouchMoveHandler);
+ off(ownerDocument, 'pointermove', this._delayedDragTouchMoveHandler);
+ },
+ _triggerDragStart: function _triggerDragStart(
+ /** Event */
+ evt,
+ /** Touch */
+ touch) {
+ touch = touch || evt.pointerType == 'touch' && evt;
+
+ if (!this.nativeDraggable || touch) {
+ if (this.options.supportPointer) {
+ on(document, 'pointermove', this._onTouchMove);
+ } else if (touch) {
+ on(document, 'touchmove', this._onTouchMove);
+ } else {
+ on(document, 'mousemove', this._onTouchMove);
+ }
+ } else {
+ on(dragEl, 'dragend', this);
+ on(rootEl, 'dragstart', this._onDragStart);
+ }
+
+ try {
+ if (document.selection) {
+ // Timeout neccessary for IE9
+ _nextTick(function () {
+ document.selection.empty();
+ });
+ } else {
+ window.getSelection().removeAllRanges();
+ }
+ } catch (err) {}
+ },
+ _dragStarted: function _dragStarted(fallback, evt) {
+
+ awaitingDragStarted = false;
+
+ if (rootEl && dragEl) {
+ pluginEvent('dragStarted', this, {
+ evt: evt
+ });
+
+ if (this.nativeDraggable) {
+ on(document, 'dragover', _checkOutsideTargetEl);
+ }
+
+ var options = this.options; // Apply effect
+
+ !fallback && toggleClass(dragEl, options.dragClass, false);
+ toggleClass(dragEl, options.ghostClass, true);
+ Sortable.active = this;
+ fallback && this._appendGhost(); // Drag start event
+
+ _dispatchEvent({
+ sortable: this,
+ name: 'start',
+ originalEvent: evt
+ });
+ } else {
+ this._nulling();
+ }
+ },
+ _emulateDragOver: function _emulateDragOver() {
+ if (touchEvt) {
+ this._lastX = touchEvt.clientX;
+ this._lastY = touchEvt.clientY;
+
+ _hideGhostForTarget();
+
+ var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
+ var parent = target;
+
+ while (target && target.shadowRoot) {
+ target = target.shadowRoot.elementFromPoint(touchEvt.clientX, touchEvt.clientY);
+ if (target === parent) break;
+ parent = target;
+ }
+
+ dragEl.parentNode[expando]._isOutsideThisEl(target);
+
+ if (parent) {
+ do {
+ if (parent[expando]) {
+ var inserted = void 0;
+ inserted = parent[expando]._onDragOver({
+ clientX: touchEvt.clientX,
+ clientY: touchEvt.clientY,
+ target: target,
+ rootEl: parent
+ });
+
+ if (inserted && !this.options.dragoverBubble) {
+ break;
+ }
+ }
+
+ target = parent; // store last element
+ }
+ /* jshint boss:true */
+ while (parent = parent.parentNode);
+ }
+
+ _unhideGhostForTarget();
+ }
+ },
+ _onTouchMove: function _onTouchMove(
+ /**TouchEvent*/
+ evt) {
+ if (tapEvt) {
+ var options = this.options,
+ fallbackTolerance = options.fallbackTolerance,
+ fallbackOffset = options.fallbackOffset,
+ touch = evt.touches ? evt.touches[0] : evt,
+ ghostMatrix = ghostEl && matrix(ghostEl),
+ scaleX = ghostEl && ghostMatrix && ghostMatrix.a,
+ scaleY = ghostEl && ghostMatrix && ghostMatrix.d,
+ relativeScrollOffset = PositionGhostAbsolutely && ghostRelativeParent && getRelativeScrollOffset(ghostRelativeParent),
+ dx = (touch.clientX - tapEvt.clientX + fallbackOffset.x) / (scaleX || 1) + (relativeScrollOffset ? relativeScrollOffset[0] - ghostRelativeParentInitialScroll[0] : 0) / (scaleX || 1),
+ dy = (touch.clientY - tapEvt.clientY + fallbackOffset.y) / (scaleY || 1) + (relativeScrollOffset ? relativeScrollOffset[1] - ghostRelativeParentInitialScroll[1] : 0) / (scaleY || 1); // only set the status to dragging, when we are actually dragging
+
+ if (!Sortable.active && !awaitingDragStarted) {
+ if (fallbackTolerance && Math.max(Math.abs(touch.clientX - this._lastX), Math.abs(touch.clientY - this._lastY)) < fallbackTolerance) {
+ return;
+ }
+
+ this._onDragStart(evt, true);
+ }
+
+ if (ghostEl) {
+ if (ghostMatrix) {
+ ghostMatrix.e += dx - (lastDx || 0);
+ ghostMatrix.f += dy - (lastDy || 0);
+ } else {
+ ghostMatrix = {
+ a: 1,
+ b: 0,
+ c: 0,
+ d: 1,
+ e: dx,
+ f: dy
+ };
+ }
+
+ var cssMatrix = "matrix(".concat(ghostMatrix.a, ",").concat(ghostMatrix.b, ",").concat(ghostMatrix.c, ",").concat(ghostMatrix.d, ",").concat(ghostMatrix.e, ",").concat(ghostMatrix.f, ")");
+ css(ghostEl, 'webkitTransform', cssMatrix);
+ css(ghostEl, 'mozTransform', cssMatrix);
+ css(ghostEl, 'msTransform', cssMatrix);
+ css(ghostEl, 'transform', cssMatrix);
+ lastDx = dx;
+ lastDy = dy;
+ touchEvt = touch;
+ }
+
+ evt.cancelable && evt.preventDefault();
+ }
+ },
+ _appendGhost: function _appendGhost() {
+ // Bug if using scale(): https://stackoverflow.com/questions/2637058
+ // Not being adjusted for
+ if (!ghostEl) {
+ var container = this.options.fallbackOnBody ? document.body : rootEl,
+ rect = getRect(dragEl, true, PositionGhostAbsolutely, true, container),
+ options = this.options; // Position absolutely
+
+ if (PositionGhostAbsolutely) {
+ // Get relatively positioned parent
+ ghostRelativeParent = container;
+
+ while (css(ghostRelativeParent, 'position') === 'static' && css(ghostRelativeParent, 'transform') === 'none' && ghostRelativeParent !== document) {
+ ghostRelativeParent = ghostRelativeParent.parentNode;
+ }
+
+ if (ghostRelativeParent !== document.body && ghostRelativeParent !== document.documentElement) {
+ if (ghostRelativeParent === document) ghostRelativeParent = getWindowScrollingElement();
+ rect.top += ghostRelativeParent.scrollTop;
+ rect.left += ghostRelativeParent.scrollLeft;
+ } else {
+ ghostRelativeParent = getWindowScrollingElement();
+ }
+
+ ghostRelativeParentInitialScroll = getRelativeScrollOffset(ghostRelativeParent);
+ }
+
+ ghostEl = dragEl.cloneNode(true);
+ toggleClass(ghostEl, options.ghostClass, false);
+ toggleClass(ghostEl, options.fallbackClass, true);
+ toggleClass(ghostEl, options.dragClass, true);
+ css(ghostEl, 'transition', '');
+ css(ghostEl, 'transform', '');
+ css(ghostEl, 'box-sizing', 'border-box');
+ css(ghostEl, 'margin', 0);
+ css(ghostEl, 'top', rect.top);
+ css(ghostEl, 'left', rect.left);
+ css(ghostEl, 'width', rect.width);
+ css(ghostEl, 'height', rect.height);
+ css(ghostEl, 'opacity', '0.8');
+ css(ghostEl, 'position', PositionGhostAbsolutely ? 'absolute' : 'fixed');
+ css(ghostEl, 'zIndex', '100000');
+ css(ghostEl, 'pointerEvents', 'none');
+ Sortable.ghost = ghostEl;
+ container.appendChild(ghostEl); // Set transform-origin
+
+ css(ghostEl, 'transform-origin', tapDistanceLeft / parseInt(ghostEl.style.width) * 100 + '% ' + tapDistanceTop / parseInt(ghostEl.style.height) * 100 + '%');
+ }
+ },
+ _onDragStart: function _onDragStart(
+ /**Event*/
+ evt,
+ /**boolean*/
+ fallback) {
+ var _this = this;
+
+ var dataTransfer = evt.dataTransfer;
+ var options = _this.options;
+ pluginEvent('dragStart', this, {
+ evt: evt
+ });
+
+ if (Sortable.eventCanceled) {
+ this._onDrop();
+
+ return;
+ }
+
+ pluginEvent('setupClone', this);
+
+ if (!Sortable.eventCanceled) {
+ cloneEl = clone(dragEl);
+ cloneEl.draggable = false;
+ cloneEl.style['will-change'] = '';
+
+ this._hideClone();
+
+ toggleClass(cloneEl, this.options.chosenClass, false);
+ Sortable.clone = cloneEl;
+ } // #1143: IFrame support workaround
+
+
+ _this.cloneId = _nextTick(function () {
+ pluginEvent('clone', _this);
+ if (Sortable.eventCanceled) return;
+
+ if (!_this.options.removeCloneOnHide) {
+ rootEl.insertBefore(cloneEl, dragEl);
+ }
+
+ _this._hideClone();
+
+ _dispatchEvent({
+ sortable: _this,
+ name: 'clone'
+ });
+ });
+ !fallback && toggleClass(dragEl, options.dragClass, true); // Set proper drop events
+
+ if (fallback) {
+ ignoreNextClick = true;
+ _this._loopId = setInterval(_this._emulateDragOver, 50);
+ } else {
+ // Undo what was set in _prepareDragStart before drag started
+ off(document, 'mouseup', _this._onDrop);
+ off(document, 'touchend', _this._onDrop);
+ off(document, 'touchcancel', _this._onDrop);
+
+ if (dataTransfer) {
+ dataTransfer.effectAllowed = 'move';
+ options.setData && options.setData.call(_this, dataTransfer, dragEl);
+ }
+
+ on(document, 'drop', _this); // #1276 fix:
+
+ css(dragEl, 'transform', 'translateZ(0)');
+ }
+
+ awaitingDragStarted = true;
+ _this._dragStartId = _nextTick(_this._dragStarted.bind(_this, fallback, evt));
+ on(document, 'selectstart', _this);
+ moved = true;
+
+ if (Safari) {
+ css(document.body, 'user-select', 'none');
+ }
+ },
+ // Returns true - if no further action is needed (either inserted or another condition)
+ _onDragOver: function _onDragOver(
+ /**Event*/
+ evt) {
+ var el = this.el,
+ target = evt.target,
+ dragRect,
+ targetRect,
+ revert,
+ options = this.options,
+ group = options.group,
+ activeSortable = Sortable.active,
+ isOwner = activeGroup === group,
+ canSort = options.sort,
+ fromSortable = putSortable || activeSortable,
+ vertical,
+ _this = this,
+ completedFired = false;
+
+ if (_silent) return;
+
+ function dragOverEvent(name, extra) {
+ pluginEvent(name, _this, _objectSpread({
+ evt: evt,
+ isOwner: isOwner,
+ axis: vertical ? 'vertical' : 'horizontal',
+ revert: revert,
+ dragRect: dragRect,
+ targetRect: targetRect,
+ canSort: canSort,
+ fromSortable: fromSortable,
+ target: target,
+ completed: completed,
+ onMove: function onMove(target, after) {
+ return _onMove(rootEl, el, dragEl, dragRect, target, getRect(target), evt, after);
+ },
+ changed: changed
+ }, extra));
+ } // Capture animation state
+
+
+ function capture() {
+ dragOverEvent('dragOverAnimationCapture');
+
+ _this.captureAnimationState();
+
+ if (_this !== fromSortable) {
+ fromSortable.captureAnimationState();
+ }
+ } // Return invocation when dragEl is inserted (or completed)
+
+
+ function completed(insertion) {
+ dragOverEvent('dragOverCompleted', {
+ insertion: insertion
+ });
+
+ if (insertion) {
+ // Clones must be hidden before folding animation to capture dragRectAbsolute properly
+ if (isOwner) {
+ activeSortable._hideClone();
+ } else {
+ activeSortable._showClone(_this);
+ }
+
+ if (_this !== fromSortable) {
+ // Set ghost class to new sortable's ghost class
+ toggleClass(dragEl, putSortable ? putSortable.options.ghostClass : activeSortable.options.ghostClass, false);
+ toggleClass(dragEl, options.ghostClass, true);
+ }
+
+ if (putSortable !== _this && _this !== Sortable.active) {
+ putSortable = _this;
+ } else if (_this === Sortable.active && putSortable) {
+ putSortable = null;
+ } // Animation
+
+
+ if (fromSortable === _this) {
+ _this._ignoreWhileAnimating = target;
+ }
+
+ _this.animateAll(function () {
+ dragOverEvent('dragOverAnimationComplete');
+ _this._ignoreWhileAnimating = null;
+ });
+
+ if (_this !== fromSortable) {
+ fromSortable.animateAll();
+ fromSortable._ignoreWhileAnimating = null;
+ }
+ } // Null lastTarget if it is not inside a previously swapped element
+
+
+ if (target === dragEl && !dragEl.animated || target === el && !target.animated) {
+ lastTarget = null;
+ } // no bubbling and not fallback
+
+
+ if (!options.dragoverBubble && !evt.rootEl && target !== document) {
+ dragEl.parentNode[expando]._isOutsideThisEl(evt.target); // Do not detect for empty insert if already inserted
+
+
+ !insertion && nearestEmptyInsertDetectEvent(evt);
+ }
+
+ !options.dragoverBubble && evt.stopPropagation && evt.stopPropagation();
+ return completedFired = true;
+ } // Call when dragEl has been inserted
+
+
+ function changed() {
+ newIndex = index(dragEl);
+ newDraggableIndex = index(dragEl, options.draggable);
+
+ _dispatchEvent({
+ sortable: _this,
+ name: 'change',
+ toEl: el,
+ newIndex: newIndex,
+ newDraggableIndex: newDraggableIndex,
+ originalEvent: evt
+ });
+ }
+
+ if (evt.preventDefault !== void 0) {
+ evt.cancelable && evt.preventDefault();
+ }
+
+ target = closest(target, options.draggable, el, true);
+ dragOverEvent('dragOver');
+ if (Sortable.eventCanceled) return completedFired;
+
+ if (dragEl.contains(evt.target) || target.animated && target.animatingX && target.animatingY || _this._ignoreWhileAnimating === target) {
+ return completed(false);
+ }
+
+ ignoreNextClick = false;
+
+ if (activeSortable && !options.disabled && (isOwner ? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original list
+ : putSortable === this || (this.lastPutMode = activeGroup.checkPull(this, activeSortable, dragEl, evt)) && group.checkPut(this, activeSortable, dragEl, evt))) {
+ vertical = this._getDirection(evt, target) === 'vertical';
+ dragRect = getRect(dragEl);
+ dragOverEvent('dragOverValid');
+ if (Sortable.eventCanceled) return completedFired;
+
+ if (revert) {
+ parentEl = rootEl; // actualization
+
+ capture();
+
+ this._hideClone();
+
+ dragOverEvent('revert');
+
+ if (!Sortable.eventCanceled) {
+ if (nextEl) {
+ rootEl.insertBefore(dragEl, nextEl);
+ } else {
+ rootEl.appendChild(dragEl);
+ }
+ }
+
+ return completed(true);
+ }
+
+ var elLastChild = lastChild(el, options.draggable);
+
+ if (!elLastChild || _ghostIsLast(evt, vertical, this) && !elLastChild.animated) {
+ // If already at end of list: Do not insert
+ if (elLastChild === dragEl) {
+ return completed(false);
+ } // assign target only if condition is true
+
+
+ if (elLastChild && el === evt.target) {
+ target = elLastChild;
+ }
+
+ if (target) {
+ targetRect = getRect(target);
+ }
+
+ if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, !!target) !== false) {
+ capture();
+ el.appendChild(dragEl);
+ parentEl = el; // actualization
+
+ changed();
+ return completed(true);
+ }
+ } else if (target.parentNode === el) {
+ targetRect = getRect(target);
+ var direction = 0,
+ targetBeforeFirstSwap,
+ differentLevel = dragEl.parentNode !== el,
+ differentRowCol = !_dragElInRowColumn(dragEl.animated && dragEl.toRect || dragRect, target.animated && target.toRect || targetRect, vertical),
+ side1 = vertical ? 'top' : 'left',
+ scrolledPastTop = isScrolledPast(target, 'top', 'top') || isScrolledPast(dragEl, 'top', 'top'),
+ scrollBefore = scrolledPastTop ? scrolledPastTop.scrollTop : void 0;
+
+ if (lastTarget !== target) {
+ targetBeforeFirstSwap = targetRect[side1];
+ pastFirstInvertThresh = false;
+ isCircumstantialInvert = !differentRowCol && options.invertSwap || differentLevel;
+ }
+
+ direction = _getSwapDirection(evt, target, targetRect, vertical, differentRowCol ? 1 : options.swapThreshold, options.invertedSwapThreshold == null ? options.swapThreshold : options.invertedSwapThreshold, isCircumstantialInvert, lastTarget === target);
+ var sibling;
+
+ if (direction !== 0) {
+ // Check if target is beside dragEl in respective direction (ignoring hidden elements)
+ var dragIndex = index(dragEl);
+
+ do {
+ dragIndex -= direction;
+ sibling = parentEl.children[dragIndex];
+ } while (sibling && (css(sibling, 'display') === 'none' || sibling === ghostEl));
+ } // If dragEl is already beside target: Do not insert
+
+
+ if (direction === 0 || sibling === target) {
+ return completed(false);
+ }
+
+ lastTarget = target;
+ lastDirection = direction;
+ var nextSibling = target.nextElementSibling,
+ after = false;
+ after = direction === 1;
+
+ var moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect, evt, after);
+
+ if (moveVector !== false) {
+ if (moveVector === 1 || moveVector === -1) {
+ after = moveVector === 1;
+ }
+
+ _silent = true;
+ setTimeout(_unsilent, 30);
+ capture();
+
+ if (after && !nextSibling) {
+ el.appendChild(dragEl);
+ } else {
+ target.parentNode.insertBefore(dragEl, after ? nextSibling : target);
+ } // Undo chrome's scroll adjustment (has no effect on other browsers)
+
+
+ if (scrolledPastTop) {
+ scrollBy(scrolledPastTop, 0, scrollBefore - scrolledPastTop.scrollTop);
+ }
+
+ parentEl = dragEl.parentNode; // actualization
+ // must be done before animation
+
+ if (targetBeforeFirstSwap !== undefined && !isCircumstantialInvert) {
+ targetMoveDistance = Math.abs(targetBeforeFirstSwap - getRect(target)[side1]);
+ }
+
+ changed();
+ return completed(true);
+ }
+ }
+
+ if (el.contains(dragEl)) {
+ return completed(false);
+ }
+ }
+
+ return false;
+ },
+ _ignoreWhileAnimating: null,
+ _offMoveEvents: function _offMoveEvents() {
+ off(document, 'mousemove', this._onTouchMove);
+ off(document, 'touchmove', this._onTouchMove);
+ off(document, 'pointermove', this._onTouchMove);
+ off(document, 'dragover', nearestEmptyInsertDetectEvent);
+ off(document, 'mousemove', nearestEmptyInsertDetectEvent);
+ off(document, 'touchmove', nearestEmptyInsertDetectEvent);
+ },
+ _offUpEvents: function _offUpEvents() {
+ var ownerDocument = this.el.ownerDocument;
+ off(ownerDocument, 'mouseup', this._onDrop);
+ off(ownerDocument, 'touchend', this._onDrop);
+ off(ownerDocument, 'pointerup', this._onDrop);
+ off(ownerDocument, 'touchcancel', this._onDrop);
+ off(document, 'selectstart', this);
+ },
+ _onDrop: function _onDrop(
+ /**Event*/
+ evt) {
+ var el = this.el,
+ options = this.options; // Get the index of the dragged element within its parent
+
+ newIndex = index(dragEl);
+ newDraggableIndex = index(dragEl, options.draggable);
+ pluginEvent('drop', this, {
+ evt: evt
+ });
+ parentEl = dragEl && dragEl.parentNode; // Get again after plugin event
+
+ newIndex = index(dragEl);
+ newDraggableIndex = index(dragEl, options.draggable);
+
+ if (Sortable.eventCanceled) {
+ this._nulling();
+
+ return;
+ }
+
+ awaitingDragStarted = false;
+ isCircumstantialInvert = false;
+ pastFirstInvertThresh = false;
+ clearInterval(this._loopId);
+ clearTimeout(this._dragStartTimer);
+
+ _cancelNextTick(this.cloneId);
+
+ _cancelNextTick(this._dragStartId); // Unbind events
+
+
+ if (this.nativeDraggable) {
+ off(document, 'drop', this);
+ off(el, 'dragstart', this._onDragStart);
+ }
+
+ this._offMoveEvents();
+
+ this._offUpEvents();
+
+ if (Safari) {
+ css(document.body, 'user-select', '');
+ }
+
+ if (evt) {
+ if (moved) {
+ evt.cancelable && evt.preventDefault();
+ !options.dropBubble && evt.stopPropagation();
+ }
+
+ ghostEl && ghostEl.parentNode && ghostEl.parentNode.removeChild(ghostEl);
+
+ if (rootEl === parentEl || putSortable && putSortable.lastPutMode !== 'clone') {
+ // Remove clone(s)
+ cloneEl && cloneEl.parentNode && cloneEl.parentNode.removeChild(cloneEl);
+ }
+
+ if (dragEl) {
+ if (this.nativeDraggable) {
+ off(dragEl, 'dragend', this);
+ }
+
+ _disableDraggable(dragEl);
+
+ dragEl.style['will-change'] = ''; // Remove classes
+ // ghostClass is added in dragStarted
+
+ if (moved && !awaitingDragStarted) {
+ toggleClass(dragEl, putSortable ? putSortable.options.ghostClass : this.options.ghostClass, false);
+ //code added by me (Kyle) starts here!
+ cardMasterUpdated()
+ //code added by me (Kyle) ends here!
+ }
+
+ toggleClass(dragEl, this.options.chosenClass, false); // Drag stop event
+
+ _dispatchEvent({
+ sortable: this,
+ name: 'unchoose',
+ toEl: parentEl,
+ newIndex: null,
+ newDraggableIndex: null,
+ originalEvent: evt
+ });
+
+ if (rootEl !== parentEl) {
+ if (newIndex >= 0) {
+ // Add event
+ _dispatchEvent({
+ rootEl: parentEl,
+ name: 'add',
+ toEl: parentEl,
+ fromEl: rootEl,
+ originalEvent: evt
+ }); // Remove event
+
+
+ _dispatchEvent({
+ sortable: this,
+ name: 'remove',
+ toEl: parentEl,
+ originalEvent: evt
+ }); // drag from one list and drop into another
+
+
+ _dispatchEvent({
+ rootEl: parentEl,
+ name: 'sort',
+ toEl: parentEl,
+ fromEl: rootEl,
+ originalEvent: evt
+ });
+
+ _dispatchEvent({
+ sortable: this,
+ name: 'sort',
+ toEl: parentEl,
+ originalEvent: evt
+ });
+ }
+
+ putSortable && putSortable.save();
+ } else {
+ if (newIndex !== oldIndex) {
+ if (newIndex >= 0) {
+ // drag & drop within the same list
+ _dispatchEvent({
+ sortable: this,
+ name: 'update',
+ toEl: parentEl,
+ originalEvent: evt
+ });
+
+ _dispatchEvent({
+ sortable: this,
+ name: 'sort',
+ toEl: parentEl,
+ originalEvent: evt
+ });
+ }
+ }
+ }
+
+ if (Sortable.active) {
+ /* jshint eqnull:true */
+ if (newIndex == null || newIndex === -1) {
+ newIndex = oldIndex;
+ newDraggableIndex = oldDraggableIndex;
+ }
+
+ _dispatchEvent({
+ sortable: this,
+ name: 'end',
+ toEl: parentEl,
+ originalEvent: evt
+ }); // Save sorting
+
+
+ this.save();
+ }
+ }
+ }
+
+ this._nulling();
+ },
+ _nulling: function _nulling() {
+ pluginEvent('nulling', this);
+ rootEl = dragEl = parentEl = ghostEl = nextEl = cloneEl = lastDownEl = cloneHidden = tapEvt = touchEvt = moved = newIndex = newDraggableIndex = oldIndex = oldDraggableIndex = lastTarget = lastDirection = putSortable = activeGroup = Sortable.dragged = Sortable.ghost = Sortable.clone = Sortable.active = null;
+ savedInputChecked.forEach(function (el) {
+ el.checked = true;
+ });
+ savedInputChecked.length = lastDx = lastDy = 0;
+ },
+ handleEvent: function handleEvent(
+ /**Event*/
+ evt) {
+ switch (evt.type) {
+ case 'drop':
+ case 'dragend':
+ this._onDrop(evt);
+
+ break;
+
+ case 'dragenter':
+ case 'dragover':
+ if (dragEl) {
+ this._onDragOver(evt);
+
+ _globalDragOver(evt);
+ }
+
+ break;
+
+ case 'selectstart':
+ evt.preventDefault();
+ break;
+ }
+ },
+
+ /**
+ * Serializes the item into an array of string.
+ * @returns {String[]}
+ */
+ toArray: function toArray() {
+ var order = [],
+ el,
+ children = this.el.children,
+ i = 0,
+ n = children.length,
+ options = this.options;
+
+ for (; i < n; i++) {
+ el = children[i];
+
+ if (closest(el, options.draggable, this.el, false)) {
+ order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
+ }
+ }
+
+ return order;
+ },
+
+ /**
+ * Sorts the elements according to the array.
+ * @param {String[]} order order of the items
+ */
+ sort: function sort(order) {
+ var items = {},
+ rootEl = this.el;
+ this.toArray().forEach(function (id, i) {
+ var el = rootEl.children[i];
+
+ if (closest(el, this.options.draggable, rootEl, false)) {
+ items[id] = el;
+ }
+ }, this);
+ order.forEach(function (id) {
+ if (items[id]) {
+ rootEl.removeChild(items[id]);
+ rootEl.appendChild(items[id]);
+ }
+ });
+ },
+
+ /**
+ * Save the current sorting
+ */
+ save: function save() {
+ var store = this.options.store;
+ store && store.set && store.set(this);
+ },
+
+ /**
+ * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
+ * @param {HTMLElement} el
+ * @param {String} [selector] default: `options.draggable`
+ * @returns {HTMLElement|null}
+ */
+ closest: function closest$1(el, selector) {
+ return closest(el, selector || this.options.draggable, this.el, false);
+ },
+
+ /**
+ * Set/get option
+ * @param {string} name
+ * @param {*} [value]
+ * @returns {*}
+ */
+ option: function option(name, value) {
+ var options = this.options;
+
+ if (value === void 0) {
+ return options[name];
+ } else {
+ var modifiedValue = PluginManager.modifyOption(this, name, value);
+
+ if (typeof modifiedValue !== 'undefined') {
+ options[name] = modifiedValue;
+ } else {
+ options[name] = value;
+ }
+
+ if (name === 'group') {
+ _prepareGroup(options);
+ }
+ }
+ },
+
+ /**
+ * Destroy
+ */
+ destroy: function destroy() {
+ pluginEvent('destroy', this);
+ var el = this.el;
+ el[expando] = null;
+ off(el, 'mousedown', this._onTapStart);
+ off(el, 'touchstart', this._onTapStart);
+ off(el, 'pointerdown', this._onTapStart);
+
+ if (this.nativeDraggable) {
+ off(el, 'dragover', this);
+ off(el, 'dragenter', this);
+ } // Remove draggable attributes
+
+
+ Array.prototype.forEach.call(el.querySelectorAll('[draggable]'), function (el) {
+ el.removeAttribute('draggable');
+ });
+
+ this._onDrop();
+
+ sortables.splice(sortables.indexOf(this.el), 1);
+ this.el = el = null;
+ },
+ _hideClone: function _hideClone() {
+ if (!cloneHidden) {
+ pluginEvent('hideClone', this);
+ if (Sortable.eventCanceled) return;
+ css(cloneEl, 'display', 'none');
+
+ if (this.options.removeCloneOnHide && cloneEl.parentNode) {
+ cloneEl.parentNode.removeChild(cloneEl);
+ }
+
+ cloneHidden = true;
+ }
+ },
+ _showClone: function _showClone(putSortable) {
+ if (putSortable.lastPutMode !== 'clone') {
+ this._hideClone();
+
+ return;
+ }
+
+ if (cloneHidden) {
+ pluginEvent('showClone', this);
+ if (Sortable.eventCanceled) return; // show clone at dragEl or original position
+
+ if (rootEl.contains(dragEl) && !this.options.group.revertClone) {
+ rootEl.insertBefore(cloneEl, dragEl);
+ } else if (nextEl) {
+ rootEl.insertBefore(cloneEl, nextEl);
+ } else {
+ rootEl.appendChild(cloneEl);
+ }
+
+ if (this.options.group.revertClone) {
+ this.animate(dragEl, cloneEl);
+ }
+
+ css(cloneEl, 'display', '');
+ cloneHidden = false;
+ }
+ }
+};
+
+function _globalDragOver(
+/**Event*/
+evt) {
+ if (evt.dataTransfer) {
+ evt.dataTransfer.dropEffect = 'move';
+ }
+
+ evt.cancelable && evt.preventDefault();
+}
+
+function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect, originalEvent, willInsertAfter) {
+ var evt,
+ sortable = fromEl[expando],
+ onMoveFn = sortable.options.onMove,
+ retVal; // Support for new CustomEvent feature
+
+ if (window.CustomEvent && !IE11OrLess && !Edge) {
+ evt = new CustomEvent('move', {
+ bubbles: true,
+ cancelable: true
+ });
+ } else {
+ evt = document.createEvent('Event');
+ evt.initEvent('move', true, true);
+ }
+
+ evt.to = toEl;
+ evt.from = fromEl;
+ evt.dragged = dragEl;
+ evt.draggedRect = dragRect;
+ evt.related = targetEl || toEl;
+ evt.relatedRect = targetRect || getRect(toEl);
+ evt.willInsertAfter = willInsertAfter;
+ evt.originalEvent = originalEvent;
+ fromEl.dispatchEvent(evt);
+
+ if (onMoveFn) {
+ retVal = onMoveFn.call(sortable, evt, originalEvent);
+ }
+
+ return retVal;
+}
+
+function _disableDraggable(el) {
+ el.draggable = false;
+}
+
+function _unsilent() {
+ _silent = false;
+}
+
+function _ghostIsLast(evt, vertical, sortable) {
+ var rect = getRect(lastChild(sortable.el, sortable.options.draggable));
+ var spacer = 10;
+ return vertical ? evt.clientX > rect.right + spacer || evt.clientX <= rect.right && evt.clientY > rect.bottom && evt.clientX >= rect.left : evt.clientX > rect.right && evt.clientY > rect.top || evt.clientX <= rect.right && evt.clientY > rect.bottom + spacer;
+}
+
+function _getSwapDirection(evt, target, targetRect, vertical, swapThreshold, invertedSwapThreshold, invertSwap, isLastTarget) {
+ var mouseOnAxis = vertical ? evt.clientY : evt.clientX,
+ targetLength = vertical ? targetRect.height : targetRect.width,
+ targetS1 = vertical ? targetRect.top : targetRect.left,
+ targetS2 = vertical ? targetRect.bottom : targetRect.right,
+ invert = false;
+
+ if (!invertSwap) {
+ // Never invert or create dragEl shadow when target movemenet causes mouse to move past the end of regular swapThreshold
+ if (isLastTarget && targetMoveDistance < targetLength * swapThreshold) {
+ // multiplied only by swapThreshold because mouse will already be inside target by (1 - threshold) * targetLength / 2
+ // check if past first invert threshold on side opposite of lastDirection
+ if (!pastFirstInvertThresh && (lastDirection === 1 ? mouseOnAxis > targetS1 + targetLength * invertedSwapThreshold / 2 : mouseOnAxis < targetS2 - targetLength * invertedSwapThreshold / 2)) {
+ // past first invert threshold, do not restrict inverted threshold to dragEl shadow
+ pastFirstInvertThresh = true;
+ }
+
+ if (!pastFirstInvertThresh) {
+ // dragEl shadow (target move distance shadow)
+ if (lastDirection === 1 ? mouseOnAxis < targetS1 + targetMoveDistance // over dragEl shadow
+ : mouseOnAxis > targetS2 - targetMoveDistance) {
+ return -lastDirection;
+ }
+ } else {
+ invert = true;
+ }
+ } else {
+ // Regular
+ if (mouseOnAxis > targetS1 + targetLength * (1 - swapThreshold) / 2 && mouseOnAxis < targetS2 - targetLength * (1 - swapThreshold) / 2) {
+ return _getInsertDirection(target);
+ }
+ }
+ }
+
+ invert = invert || invertSwap;
+
+ if (invert) {
+ // Invert of regular
+ if (mouseOnAxis < targetS1 + targetLength * invertedSwapThreshold / 2 || mouseOnAxis > targetS2 - targetLength * invertedSwapThreshold / 2) {
+ return mouseOnAxis > targetS1 + targetLength / 2 ? 1 : -1;
+ }
+ }
+
+ return 0;
+}
+/**
+ * Gets the direction dragEl must be swapped relative to target in order to make it
+ * seem that dragEl has been "inserted" into that element's position
+ * @param {HTMLElement} target The target whose position dragEl is being inserted at
+ * @return {Number} Direction dragEl must be swapped
+ */
+
+
+function _getInsertDirection(target) {
+ if (index(dragEl) < index(target)) {
+ return 1;
+ } else {
+ return -1;
+ }
+}
+/**
+ * Generate id
+ * @param {HTMLElement} el
+ * @returns {String}
+ * @private
+ */
+
+
+function _generateId(el) {
+ var str = el.tagName + el.className + el.src + el.href + el.textContent,
+ i = str.length,
+ sum = 0;
+
+ while (i--) {
+ sum += str.charCodeAt(i);
+ }
+
+ return sum.toString(36);
+}
+
+function _saveInputCheckedState(root) {
+ savedInputChecked.length = 0;
+ var inputs = root.getElementsByTagName('input');
+ var idx = inputs.length;
+
+ while (idx--) {
+ var el = inputs[idx];
+ el.checked && savedInputChecked.push(el);
+ }
+}
+
+function _nextTick(fn) {
+ return setTimeout(fn, 0);
+}
+
+function _cancelNextTick(id) {
+ return clearTimeout(id);
+} // Fixed #973:
+
+
+if (documentExists) {
+ on(document, 'touchmove', function (evt) {
+ if ((Sortable.active || awaitingDragStarted) && evt.cancelable) {
+ evt.preventDefault();
+ }
+ });
+} // Export utils
+
+
+Sortable.utils = {
+ on: on,
+ off: off,
+ css: css,
+ find: find,
+ is: function is(el, selector) {
+ return !!closest(el, selector, el, false);
+ },
+ extend: extend,
+ throttle: throttle,
+ closest: closest,
+ toggleClass: toggleClass,
+ clone: clone,
+ index: index,
+ nextTick: _nextTick,
+ cancelNextTick: _cancelNextTick,
+ detectDirection: _detectDirection,
+ getChild: getChild
+};
+/**
+ * Get the Sortable instance of an element
+ * @param {HTMLElement} element The element
+ * @return {Sortable|undefined} The instance of Sortable
+ */
+
+Sortable.get = function (element) {
+ return element[expando];
+};
+/**
+ * Mount a plugin to Sortable
+ * @param {...SortablePlugin|SortablePlugin[]} plugins Plugins being mounted
+ */
+
+
+Sortable.mount = function () {
+ for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {
+ plugins[_key] = arguments[_key];
+ }
+
+ if (plugins[0].constructor === Array) plugins = plugins[0];
+ plugins.forEach(function (plugin) {
+ if (!plugin.prototype || !plugin.prototype.constructor) {
+ throw "Sortable: Mounted plugin must be a constructor function, not ".concat({}.toString.call(plugin));
+ }
+
+ if (plugin.utils) Sortable.utils = _objectSpread({}, Sortable.utils, plugin.utils);
+ PluginManager.mount(plugin);
+ });
+};
+/**
+ * Create sortable instance
+ * @param {HTMLElement} el
+ * @param {Object} [options]
+ */
+
+
+Sortable.create = function (el, options) {
+ return new Sortable(el, options);
+}; // Export
+
+
+Sortable.version = version;
+
+var autoScrolls = [],
+ scrollEl,
+ scrollRootEl,
+ scrolling = false,
+ lastAutoScrollX,
+ lastAutoScrollY,
+ touchEvt$1,
+ pointerElemChangedInterval;
+
+function AutoScrollPlugin() {
+ function AutoScroll() {
+ this.defaults = {
+ scroll: true,
+ scrollSensitivity: 30,
+ scrollSpeed: 10,
+ bubbleScroll: true
+ }; // Bind all private methods
+
+ for (var fn in this) {
+ if (fn.charAt(0) === '_' && typeof this[fn] === 'function') {
+ this[fn] = this[fn].bind(this);
+ }
+ }
+ }
+
+ AutoScroll.prototype = {
+ dragStarted: function dragStarted(_ref) {
+ var originalEvent = _ref.originalEvent;
+
+ if (this.sortable.nativeDraggable) {
+ on(document, 'dragover', this._handleAutoScroll);
+ } else {
+ if (this.options.supportPointer) {
+ on(document, 'pointermove', this._handleFallbackAutoScroll);
+ } else if (originalEvent.touches) {
+ on(document, 'touchmove', this._handleFallbackAutoScroll);
+ } else {
+ on(document, 'mousemove', this._handleFallbackAutoScroll);
+ }
+ }
+ },
+ dragOverCompleted: function dragOverCompleted(_ref2) {
+ var originalEvent = _ref2.originalEvent;
+
+ // For when bubbling is canceled and using fallback (fallback 'touchmove' always reached)
+ if (!this.options.dragOverBubble && !originalEvent.rootEl) {
+ this._handleAutoScroll(originalEvent);
+ }
+ },
+ drop: function drop() {
+ if (this.sortable.nativeDraggable) {
+ off(document, 'dragover', this._handleAutoScroll);
+ } else {
+ off(document, 'pointermove', this._handleFallbackAutoScroll);
+ off(document, 'touchmove', this._handleFallbackAutoScroll);
+ off(document, 'mousemove', this._handleFallbackAutoScroll);
+ }
+
+ clearPointerElemChangedInterval();
+ clearAutoScrolls();
+ cancelThrottle();
+ },
+ nulling: function nulling() {
+ touchEvt$1 = scrollRootEl = scrollEl = scrolling = pointerElemChangedInterval = lastAutoScrollX = lastAutoScrollY = null;
+ autoScrolls.length = 0;
+ },
+ _handleFallbackAutoScroll: function _handleFallbackAutoScroll(evt) {
+ this._handleAutoScroll(evt, true);
+ },
+ _handleAutoScroll: function _handleAutoScroll(evt, fallback) {
+ var _this = this;
+
+ var x = (evt.touches ? evt.touches[0] : evt).clientX,
+ y = (evt.touches ? evt.touches[0] : evt).clientY,
+ elem = document.elementFromPoint(x, y);
+ touchEvt$1 = evt; // IE does not seem to have native autoscroll,
+ // Edge's autoscroll seems too conditional,
+ // MACOS Safari does not have autoscroll,
+ // Firefox and Chrome are good
+
+ if (fallback || Edge || IE11OrLess || Safari) {
+ autoScroll(evt, this.options, elem, fallback); // Listener for pointer element change
+
+ var ogElemScroller = getParentAutoScrollElement(elem, true);
+
+ if (scrolling && (!pointerElemChangedInterval || x !== lastAutoScrollX || y !== lastAutoScrollY)) {
+ pointerElemChangedInterval && clearPointerElemChangedInterval(); // Detect for pointer elem change, emulating native DnD behaviour
+
+ pointerElemChangedInterval = setInterval(function () {
+ var newElem = getParentAutoScrollElement(document.elementFromPoint(x, y), true);
+
+ if (newElem !== ogElemScroller) {
+ ogElemScroller = newElem;
+ clearAutoScrolls();
+ }
+
+ autoScroll(evt, _this.options, newElem, fallback);
+ }, 10);
+ lastAutoScrollX = x;
+ lastAutoScrollY = y;
+ }
+ } else {
+ // if DnD is enabled (and browser has good autoscrolling), first autoscroll will already scroll, so get parent autoscroll of first autoscroll
+ if (!this.options.bubbleScroll || getParentAutoScrollElement(elem, true) === getWindowScrollingElement()) {
+ clearAutoScrolls();
+ return;
+ }
+
+ autoScroll(evt, this.options, getParentAutoScrollElement(elem, false), false);
+ }
+ }
+ };
+ return _extends(AutoScroll, {
+ pluginName: 'scroll',
+ initializeByDefault: true
+ });
+}
+
+function clearAutoScrolls() {
+ autoScrolls.forEach(function (autoScroll) {
+ clearInterval(autoScroll.pid);
+ });
+ autoScrolls = [];
+}
+
+function clearPointerElemChangedInterval() {
+ clearInterval(pointerElemChangedInterval);
+}
+
+var autoScroll = throttle(function (evt, options, rootEl, isFallback) {
+ // Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521
+ if (!options.scroll) return;
+ var x = (evt.touches ? evt.touches[0] : evt).clientX,
+ y = (evt.touches ? evt.touches[0] : evt).clientY,
+ sens = options.scrollSensitivity,
+ speed = options.scrollSpeed,
+ winScroller = getWindowScrollingElement();
+ var scrollThisInstance = false,
+ scrollCustomFn; // New scroll root, set scrollEl
+
+ if (scrollRootEl !== rootEl) {
+ scrollRootEl = rootEl;
+ clearAutoScrolls();
+ scrollEl = options.scroll;
+ scrollCustomFn = options.scrollFn;
+
+ if (scrollEl === true) {
+ scrollEl = getParentAutoScrollElement(rootEl, true);
+ }
+ }
+
+ var layersOut = 0;
+ var currentParent = scrollEl;
+
+ do {
+ var el = currentParent,
+ rect = getRect(el),
+ top = rect.top,
+ bottom = rect.bottom,
+ left = rect.left,
+ right = rect.right,
+ width = rect.width,
+ height = rect.height,
+ canScrollX = void 0,
+ canScrollY = void 0,
+ scrollWidth = el.scrollWidth,
+ scrollHeight = el.scrollHeight,
+ elCSS = css(el),
+ scrollPosX = el.scrollLeft,
+ scrollPosY = el.scrollTop;
+
+ if (el === winScroller) {
+ canScrollX = width < scrollWidth && (elCSS.overflowX === 'auto' || elCSS.overflowX === 'scroll' || elCSS.overflowX === 'visible');
+ canScrollY = height < scrollHeight && (elCSS.overflowY === 'auto' || elCSS.overflowY === 'scroll' || elCSS.overflowY === 'visible');
+ } else {
+ canScrollX = width < scrollWidth && (elCSS.overflowX === 'auto' || elCSS.overflowX === 'scroll');
+ canScrollY = height < scrollHeight && (elCSS.overflowY === 'auto' || elCSS.overflowY === 'scroll');
+ }
+
+ var vx = canScrollX && (Math.abs(right - x) <= sens && scrollPosX + width < scrollWidth) - (Math.abs(left - x) <= sens && !!scrollPosX);
+ var vy = canScrollY && (Math.abs(bottom - y) <= sens && scrollPosY + height < scrollHeight) - (Math.abs(top - y) <= sens && !!scrollPosY);
+
+ if (!autoScrolls[layersOut]) {
+ for (var i = 0; i <= layersOut; i++) {
+ if (!autoScrolls[i]) {
+ autoScrolls[i] = {};
+ }
+ }
+ }
+
+ if (autoScrolls[layersOut].vx != vx || autoScrolls[layersOut].vy != vy || autoScrolls[layersOut].el !== el) {
+ autoScrolls[layersOut].el = el;
+ autoScrolls[layersOut].vx = vx;
+ autoScrolls[layersOut].vy = vy;
+ clearInterval(autoScrolls[layersOut].pid);
+
+ if (vx != 0 || vy != 0) {
+ scrollThisInstance = true;
+ /* jshint loopfunc:true */
+
+ autoScrolls[layersOut].pid = setInterval(function () {
+ // emulate drag over during autoscroll (fallback), emulating native DnD behaviour
+ if (isFallback && this.layer === 0) {
+ Sortable.active._onTouchMove(touchEvt$1); // To move ghost if it is positioned absolutely
+
+ }
+
+ var scrollOffsetY = autoScrolls[this.layer].vy ? autoScrolls[this.layer].vy * speed : 0;
+ var scrollOffsetX = autoScrolls[this.layer].vx ? autoScrolls[this.layer].vx * speed : 0;
+
+ if (typeof scrollCustomFn === 'function') {
+ if (scrollCustomFn.call(Sortable.dragged.parentNode[expando], scrollOffsetX, scrollOffsetY, evt, touchEvt$1, autoScrolls[this.layer].el) !== 'continue') {
+ return;
+ }
+ }
+
+ scrollBy(autoScrolls[this.layer].el, scrollOffsetX, scrollOffsetY);
+ }.bind({
+ layer: layersOut
+ }), 24);
+ }
+ }
+
+ layersOut++;
+ } while (options.bubbleScroll && currentParent !== winScroller && (currentParent = getParentAutoScrollElement(currentParent, false)));
+
+ scrolling = scrollThisInstance; // in case another function catches scrolling as false in between when it is not
+}, 30);
+
+var drop = function drop(_ref) {
+ var originalEvent = _ref.originalEvent,
+ putSortable = _ref.putSortable,
+ dragEl = _ref.dragEl,
+ activeSortable = _ref.activeSortable,
+ dispatchSortableEvent = _ref.dispatchSortableEvent,
+ hideGhostForTarget = _ref.hideGhostForTarget,
+ unhideGhostForTarget = _ref.unhideGhostForTarget;
+ if (!originalEvent) return;
+ var toSortable = putSortable || activeSortable;
+ hideGhostForTarget();
+ var touch = originalEvent.changedTouches && originalEvent.changedTouches.length ? originalEvent.changedTouches[0] : originalEvent;
+ var target = document.elementFromPoint(touch.clientX, touch.clientY);
+ unhideGhostForTarget();
+
+ if (toSortable && !toSortable.el.contains(target)) {
+ dispatchSortableEvent('spill');
+ this.onSpill({
+ dragEl: dragEl,
+ putSortable: putSortable
+ });
+ }
+};
+
+function Revert() {}
+
+Revert.prototype = {
+ startIndex: null,
+ dragStart: function dragStart(_ref2) {
+ var oldDraggableIndex = _ref2.oldDraggableIndex;
+ this.startIndex = oldDraggableIndex;
+ },
+ onSpill: function onSpill(_ref3) {
+ var dragEl = _ref3.dragEl,
+ putSortable = _ref3.putSortable;
+ this.sortable.captureAnimationState();
+
+ if (putSortable) {
+ putSortable.captureAnimationState();
+ }
+
+ var nextSibling = getChild(this.sortable.el, this.startIndex, this.options);
+
+ if (nextSibling) {
+ this.sortable.el.insertBefore(dragEl, nextSibling);
+ } else {
+ this.sortable.el.appendChild(dragEl);
+ }
+
+ this.sortable.animateAll();
+
+ if (putSortable) {
+ putSortable.animateAll();
+ }
+ },
+ drop: drop
+};
+
+_extends(Revert, {
+ pluginName: 'revertOnSpill'
+});
+
+function Remove() {}
+
+Remove.prototype = {
+ onSpill: function onSpill(_ref4) {
+ var dragEl = _ref4.dragEl,
+ putSortable = _ref4.putSortable;
+ var parentSortable = putSortable || this.sortable;
+ parentSortable.captureAnimationState();
+ dragEl.parentNode && dragEl.parentNode.removeChild(dragEl);
+ parentSortable.animateAll();
+ },
+ drop: drop
+};
+
+_extends(Remove, {
+ pluginName: 'removeOnSpill'
+});
+
+var OnSpill = [Remove, Revert];
+
+var lastSwapEl;
+
+function SwapPlugin() {
+ function Swap() {
+ this.defaults = {
+ swapClass: 'sortable-swap-highlight'
+ };
+ }
+
+ Swap.prototype = {
+ dragStart: function dragStart(_ref) {
+ var dragEl = _ref.dragEl;
+ lastSwapEl = dragEl;
+ },
+ dragOverValid: function dragOverValid(_ref2) {
+ var completed = _ref2.completed,
+ target = _ref2.target,
+ onMove = _ref2.onMove,
+ activeSortable = _ref2.activeSortable,
+ changed = _ref2.changed,
+ cancel = _ref2.cancel;
+ if (!activeSortable.options.swap) return;
+ var el = this.sortable.el,
+ options = this.options;
+
+ if (target && target !== el) {
+ var prevSwapEl = lastSwapEl;
+
+ if (onMove(target) !== false) {
+ toggleClass(target, options.swapClass, true);
+ lastSwapEl = target;
+ } else {
+ lastSwapEl = null;
+ }
+
+ if (prevSwapEl && prevSwapEl !== lastSwapEl) {
+ toggleClass(prevSwapEl, options.swapClass, false);
+ }
+ }
+
+ changed();
+ completed(true);
+ cancel();
+ },
+ drop: function drop(_ref3) {
+ var activeSortable = _ref3.activeSortable,
+ putSortable = _ref3.putSortable,
+ dragEl = _ref3.dragEl;
+ var toSortable = putSortable || this.sortable;
+ var options = this.options;
+ lastSwapEl && toggleClass(lastSwapEl, options.swapClass, false);
+
+ if (lastSwapEl && (options.swap || putSortable && putSortable.options.swap)) {
+ if (dragEl !== lastSwapEl) {
+ toSortable.captureAnimationState();
+ if (toSortable !== activeSortable) activeSortable.captureAnimationState();
+ swapNodes(dragEl, lastSwapEl);
+ toSortable.animateAll();
+ if (toSortable !== activeSortable) activeSortable.animateAll();
+ }
+ }
+ },
+ nulling: function nulling() {
+ lastSwapEl = null;
+ }
+ };
+ return _extends(Swap, {
+ pluginName: 'swap',
+ eventProperties: function eventProperties() {
+ return {
+ swapItem: lastSwapEl
+ };
+ }
+ });
+}
+
+function swapNodes(n1, n2) {
+ var p1 = n1.parentNode,
+ p2 = n2.parentNode,
+ i1,
+ i2;
+ if (!p1 || !p2 || p1.isEqualNode(n2) || p2.isEqualNode(n1)) return;
+ i1 = index(n1);
+ i2 = index(n2);
+
+ if (p1.isEqualNode(p2) && i1 < i2) {
+ i2++;
+ }
+
+ p1.insertBefore(n2, p1.children[i1]);
+ p2.insertBefore(n1, p2.children[i2]);
+}
+
+var multiDragElements = [],
+ multiDragClones = [],
+ lastMultiDragSelect,
+ // for selection with modifier key down (SHIFT)
+multiDragSortable,
+ initialFolding = false,
+ // Initial multi-drag fold when drag started
+folding = false,
+ // Folding any other time
+dragStarted = false,
+ dragEl$1,
+ clonesFromRect,
+ clonesHidden;
+
+function MultiDragPlugin() {
+ function MultiDrag(sortable) {
+ // Bind all private methods
+ for (var fn in this) {
+ if (fn.charAt(0) === '_' && typeof this[fn] === 'function') {
+ this[fn] = this[fn].bind(this);
+ }
+ }
+
+ if (sortable.options.supportPointer) {
+ on(document, 'pointerup', this._deselectMultiDrag);
+ } else {
+ on(document, 'mouseup', this._deselectMultiDrag);
+ on(document, 'touchend', this._deselectMultiDrag);
+ }
+
+ on(document, 'keydown', this._checkKeyDown);
+ on(document, 'keyup', this._checkKeyUp);
+ this.defaults = {
+ selectedClass: 'sortable-selected',
+ multiDragKey: null,
+ setData: function setData(dataTransfer, dragEl) {
+ var data = '';
+
+ if (multiDragElements.length && multiDragSortable === sortable) {
+ multiDragElements.forEach(function (multiDragElement, i) {
+ data += (!i ? '' : ', ') + multiDragElement.textContent;
+ });
+ } else {
+ data = dragEl.textContent;
+ }
+
+ dataTransfer.setData('Text', data);
+ }
+ };
+ }
+
+ MultiDrag.prototype = {
+ multiDragKeyDown: false,
+ isMultiDrag: false,
+ delayStartGlobal: function delayStartGlobal(_ref) {
+ var dragged = _ref.dragEl;
+ dragEl$1 = dragged;
+ },
+ delayEnded: function delayEnded() {
+ this.isMultiDrag = ~multiDragElements.indexOf(dragEl$1);
+ },
+ setupClone: function setupClone(_ref2) {
+ var sortable = _ref2.sortable,
+ cancel = _ref2.cancel;
+ if (!this.isMultiDrag) return;
+
+ for (var i = 0; i < multiDragElements.length; i++) {
+ multiDragClones.push(clone(multiDragElements[i]));
+ multiDragClones[i].sortableIndex = multiDragElements[i].sortableIndex;
+ multiDragClones[i].draggable = false;
+ multiDragClones[i].style['will-change'] = '';
+ toggleClass(multiDragClones[i], this.options.selectedClass, false);
+ multiDragElements[i] === dragEl$1 && toggleClass(multiDragClones[i], this.options.chosenClass, false);
+ }
+
+ sortable._hideClone();
+
+ cancel();
+ },
+ clone: function clone(_ref3) {
+ var sortable = _ref3.sortable,
+ rootEl = _ref3.rootEl,
+ dispatchSortableEvent = _ref3.dispatchSortableEvent,
+ cancel = _ref3.cancel;
+ if (!this.isMultiDrag) return;
+
+ if (!this.options.removeCloneOnHide) {
+ if (multiDragElements.length && multiDragSortable === sortable) {
+ insertMultiDragClones(true, rootEl);
+ dispatchSortableEvent('clone');
+ cancel();
+ }
+ }
+ },
+ showClone: function showClone(_ref4) {
+ var cloneNowShown = _ref4.cloneNowShown,
+ rootEl = _ref4.rootEl,
+ cancel = _ref4.cancel;
+ if (!this.isMultiDrag) return;
+ insertMultiDragClones(false, rootEl);
+ multiDragClones.forEach(function (clone) {
+ css(clone, 'display', '');
+ });
+ cloneNowShown();
+ clonesHidden = false;
+ cancel();
+ },
+ hideClone: function hideClone(_ref5) {
+ var _this = this;
+
+ var sortable = _ref5.sortable,
+ cloneNowHidden = _ref5.cloneNowHidden,
+ cancel = _ref5.cancel;
+ if (!this.isMultiDrag) return;
+ multiDragClones.forEach(function (clone) {
+ css(clone, 'display', 'none');
+
+ if (_this.options.removeCloneOnHide && clone.parentNode) {
+ clone.parentNode.removeChild(clone);
+ }
+ });
+ cloneNowHidden();
+ clonesHidden = true;
+ cancel();
+ },
+ dragStartGlobal: function dragStartGlobal(_ref6) {
+ var sortable = _ref6.sortable;
+
+ if (!this.isMultiDrag && multiDragSortable) {
+ multiDragSortable.multiDrag._deselectMultiDrag();
+ }
+
+ multiDragElements.forEach(function (multiDragElement) {
+ multiDragElement.sortableIndex = index(multiDragElement);
+ }); // Sort multi-drag elements
+
+ multiDragElements = multiDragElements.sort(function (a, b) {
+ return a.sortableIndex - b.sortableIndex;
+ });
+ dragStarted = true;
+ },
+ dragStarted: function dragStarted(_ref7) {
+ var _this2 = this;
+
+ var sortable = _ref7.sortable;
+ if (!this.isMultiDrag) return;
+
+ if (this.options.sort) {
+ // Capture rects,
+ // hide multi drag elements (by positioning them absolute),
+ // set multi drag elements rects to dragRect,
+ // show multi drag elements,
+ // animate to rects,
+ // unset rects & remove from DOM
+ sortable.captureAnimationState();
+
+ if (this.options.animation) {
+ multiDragElements.forEach(function (multiDragElement) {
+ if (multiDragElement === dragEl$1) return;
+ css(multiDragElement, 'position', 'absolute');
+ });
+ var dragRect = getRect(dragEl$1, false, true, true);
+ multiDragElements.forEach(function (multiDragElement) {
+ if (multiDragElement === dragEl$1) return;
+ setRect(multiDragElement, dragRect);
+ });
+ folding = true;
+ initialFolding = true;
+ }
+ }
+
+ sortable.animateAll(function () {
+ folding = false;
+ initialFolding = false;
+
+ if (_this2.options.animation) {
+ multiDragElements.forEach(function (multiDragElement) {
+ unsetRect(multiDragElement);
+ });
+ } // Remove all auxiliary multidrag items from el, if sorting enabled
+
+
+ if (_this2.options.sort) {
+ removeMultiDragElements();
+ }
+ });
+ },
+ dragOver: function dragOver(_ref8) {
+ var target = _ref8.target,
+ completed = _ref8.completed,
+ cancel = _ref8.cancel;
+
+ if (folding && ~multiDragElements.indexOf(target)) {
+ completed(false);
+ cancel();
+ }
+ },
+ revert: function revert(_ref9) {
+ var fromSortable = _ref9.fromSortable,
+ rootEl = _ref9.rootEl,
+ sortable = _ref9.sortable,
+ dragRect = _ref9.dragRect;
+
+ if (multiDragElements.length > 1) {
+ // Setup unfold animation
+ multiDragElements.forEach(function (multiDragElement) {
+ sortable.addAnimationState({
+ target: multiDragElement,
+ rect: folding ? getRect(multiDragElement) : dragRect
+ });
+ unsetRect(multiDragElement);
+ multiDragElement.fromRect = dragRect;
+ fromSortable.removeAnimationState(multiDragElement);
+ });
+ folding = false;
+ insertMultiDragElements(!this.options.removeCloneOnHide, rootEl);
+ }
+ },
+ dragOverCompleted: function dragOverCompleted(_ref10) {
+ var sortable = _ref10.sortable,
+ isOwner = _ref10.isOwner,
+ insertion = _ref10.insertion,
+ activeSortable = _ref10.activeSortable,
+ parentEl = _ref10.parentEl,
+ putSortable = _ref10.putSortable;
+ var options = this.options;
+
+ if (insertion) {
+ // Clones must be hidden before folding animation to capture dragRectAbsolute properly
+ if (isOwner) {
+ activeSortable._hideClone();
+ }
+
+ initialFolding = false; // If leaving sort:false root, or already folding - Fold to new location
+
+ if (options.animation && multiDragElements.length > 1 && (folding || !isOwner && !activeSortable.options.sort && !putSortable)) {
+ // Fold: Set all multi drag elements's rects to dragEl's rect when multi-drag elements are invisible
+ var dragRectAbsolute = getRect(dragEl$1, false, true, true);
+ multiDragElements.forEach(function (multiDragElement) {
+ if (multiDragElement === dragEl$1) return;
+ setRect(multiDragElement, dragRectAbsolute); // Move element(s) to end of parentEl so that it does not interfere with multi-drag clones insertion if they are inserted
+ // while folding, and so that we can capture them again because old sortable will no longer be fromSortable
+
+ parentEl.appendChild(multiDragElement);
+ });
+ folding = true;
+ } // Clones must be shown (and check to remove multi drags) after folding when interfering multiDragElements are moved out
+
+
+ if (!isOwner) {
+ // Only remove if not folding (folding will remove them anyways)
+ if (!folding) {
+ removeMultiDragElements();
+ }
+
+ if (multiDragElements.length > 1) {
+ var clonesHiddenBefore = clonesHidden;
+
+ activeSortable._showClone(sortable); // Unfold animation for clones if showing from hidden
+
+
+ if (activeSortable.options.animation && !clonesHidden && clonesHiddenBefore) {
+ multiDragClones.forEach(function (clone) {
+ activeSortable.addAnimationState({
+ target: clone,
+ rect: clonesFromRect
+ });
+ clone.fromRect = clonesFromRect;
+ clone.thisAnimationDuration = null;
+ });
+ }
+ } else {
+ activeSortable._showClone(sortable);
+ }
+ }
+ }
+ },
+ dragOverAnimationCapture: function dragOverAnimationCapture(_ref11) {
+ var dragRect = _ref11.dragRect,
+ isOwner = _ref11.isOwner,
+ activeSortable = _ref11.activeSortable;
+ multiDragElements.forEach(function (multiDragElement) {
+ multiDragElement.thisAnimationDuration = null;
+ });
+
+ if (activeSortable.options.animation && !isOwner && activeSortable.multiDrag.isMultiDrag) {
+ clonesFromRect = _extends({}, dragRect);
+ var dragMatrix = matrix(dragEl$1, true);
+ clonesFromRect.top -= dragMatrix.f;
+ clonesFromRect.left -= dragMatrix.e;
+ }
+ },
+ dragOverAnimationComplete: function dragOverAnimationComplete() {
+ if (folding) {
+ folding = false;
+ removeMultiDragElements();
+ }
+ },
+ drop: function drop(_ref12) {
+ var evt = _ref12.originalEvent,
+ rootEl = _ref12.rootEl,
+ parentEl = _ref12.parentEl,
+ sortable = _ref12.sortable,
+ dispatchSortableEvent = _ref12.dispatchSortableEvent,
+ oldIndex = _ref12.oldIndex,
+ putSortable = _ref12.putSortable;
+ var toSortable = putSortable || this.sortable;
+ if (!evt) return;
+ var options = this.options,
+ children = parentEl.children; // Multi-drag selection
+
+ if (!dragStarted) {
+ if (options.multiDragKey && !this.multiDragKeyDown) {
+ this._deselectMultiDrag();
+ }
+
+ toggleClass(dragEl$1, options.selectedClass, !~multiDragElements.indexOf(dragEl$1));
+
+ if (!~multiDragElements.indexOf(dragEl$1)) {
+ multiDragElements.push(dragEl$1);
+ dispatchEvent({
+ sortable: sortable,
+ rootEl: rootEl,
+ name: 'select',
+ targetEl: dragEl$1,
+ originalEvt: evt
+ }); // Modifier activated, select from last to dragEl
+
+ if (evt.shiftKey && lastMultiDragSelect && sortable.el.contains(lastMultiDragSelect)) {
+ var lastIndex = index(lastMultiDragSelect),
+ currentIndex = index(dragEl$1);
+
+ if (~lastIndex && ~currentIndex && lastIndex !== currentIndex) {
+ // Must include lastMultiDragSelect (select it), in case modified selection from no selection
+ // (but previous selection existed)
+ var n, i;
+
+ if (currentIndex > lastIndex) {
+ i = lastIndex;
+ n = currentIndex;
+ } else {
+ i = currentIndex;
+ n = lastIndex + 1;
+ }
+
+ for (; i < n; i++) {
+ if (~multiDragElements.indexOf(children[i])) continue;
+ toggleClass(children[i], options.selectedClass, true);
+ multiDragElements.push(children[i]);
+ dispatchEvent({
+ sortable: sortable,
+ rootEl: rootEl,
+ name: 'select',
+ targetEl: children[i],
+ originalEvt: evt
+ });
+ }
+ }
+ } else {
+ lastMultiDragSelect = dragEl$1;
+ }
+
+ multiDragSortable = toSortable;
+ } else {
+ multiDragElements.splice(multiDragElements.indexOf(dragEl$1), 1);
+ lastMultiDragSelect = null;
+ dispatchEvent({
+ sortable: sortable,
+ rootEl: rootEl,
+ name: 'deselect',
+ targetEl: dragEl$1,
+ originalEvt: evt
+ });
+ }
+ } // Multi-drag drop
+
+
+ if (dragStarted && this.isMultiDrag) {
+ // Do not "unfold" after around dragEl if reverted
+ if ((parentEl[expando].options.sort || parentEl !== rootEl) && multiDragElements.length > 1) {
+ var dragRect = getRect(dragEl$1),
+ multiDragIndex = index(dragEl$1, ':not(.' + this.options.selectedClass + ')');
+ if (!initialFolding && options.animation) dragEl$1.thisAnimationDuration = null;
+ toSortable.captureAnimationState();
+
+ if (!initialFolding) {
+ if (options.animation) {
+ dragEl$1.fromRect = dragRect;
+ multiDragElements.forEach(function (multiDragElement) {
+ multiDragElement.thisAnimationDuration = null;
+
+ if (multiDragElement !== dragEl$1) {
+ var rect = folding ? getRect(multiDragElement) : dragRect;
+ multiDragElement.fromRect = rect; // Prepare unfold animation
+
+ toSortable.addAnimationState({
+ target: multiDragElement,
+ rect: rect
+ });
+ }
+ });
+ } // Multi drag elements are not necessarily removed from the DOM on drop, so to reinsert
+ // properly they must all be removed
+
+
+ removeMultiDragElements();
+ multiDragElements.forEach(function (multiDragElement) {
+ if (children[multiDragIndex]) {
+ parentEl.insertBefore(multiDragElement, children[multiDragIndex]);
+ } else {
+ parentEl.appendChild(multiDragElement);
+ }
+
+ multiDragIndex++;
+ }); // If initial folding is done, the elements may have changed position because they are now
+ // unfolding around dragEl, even though dragEl may not have his index changed, so update event
+ // must be fired here as Sortable will not.
+
+ if (oldIndex === index(dragEl$1)) {
+ var update = false;
+ multiDragElements.forEach(function (multiDragElement) {
+ if (multiDragElement.sortableIndex !== index(multiDragElement)) {
+ update = true;
+ return;
+ }
+ });
+
+ if (update) {
+ dispatchSortableEvent('update');
+ }
+ }
+ } // Must be done after capturing individual rects (scroll bar)
+
+
+ multiDragElements.forEach(function (multiDragElement) {
+ unsetRect(multiDragElement);
+ });
+ toSortable.animateAll();
+ }
+
+ multiDragSortable = toSortable;
+ } // Remove clones if necessary
+
+
+ if (rootEl === parentEl || putSortable && putSortable.lastPutMode !== 'clone') {
+ multiDragClones.forEach(function (clone) {
+ clone.parentNode && clone.parentNode.removeChild(clone);
+ });
+ }
+ },
+ nullingGlobal: function nullingGlobal() {
+ this.isMultiDrag = dragStarted = false;
+ multiDragClones.length = 0;
+ },
+ destroyGlobal: function destroyGlobal() {
+ this._deselectMultiDrag();
+
+ off(document, 'pointerup', this._deselectMultiDrag);
+ off(document, 'mouseup', this._deselectMultiDrag);
+ off(document, 'touchend', this._deselectMultiDrag);
+ off(document, 'keydown', this._checkKeyDown);
+ off(document, 'keyup', this._checkKeyUp);
+ },
+ _deselectMultiDrag: function _deselectMultiDrag(evt) {
+ if (dragStarted) return; // Only deselect if selection is in this sortable
+
+ if (multiDragSortable !== this.sortable) return; // Only deselect if target is not item in this sortable
+
+ if (evt && closest(evt.target, this.options.draggable, this.sortable.el, false)) return; // Only deselect if left click
+
+ if (evt && evt.button !== 0) return;
+
+ while (multiDragElements.length) {
+ var el = multiDragElements[0];
+ toggleClass(el, this.options.selectedClass, false);
+ multiDragElements.shift();
+ dispatchEvent({
+ sortable: this.sortable,
+ rootEl: this.sortable.el,
+ name: 'deselect',
+ targetEl: el,
+ originalEvt: evt
+ });
+ }
+ },
+ _checkKeyDown: function _checkKeyDown(evt) {
+ if (evt.key === this.options.multiDragKey) {
+ this.multiDragKeyDown = true;
+ }
+ },
+ _checkKeyUp: function _checkKeyUp(evt) {
+ if (evt.key === this.options.multiDragKey) {
+ this.multiDragKeyDown = false;
+ }
+ }
+ };
+ return _extends(MultiDrag, {
+ // Static methods & properties
+ pluginName: 'multiDrag',
+ utils: {
+ /**
+ * Selects the provided multi-drag item
+ * @param {HTMLElement} el The element to be selected
+ */
+ select: function select(el) {
+ var sortable = el.parentNode[expando];
+ if (!sortable || !sortable.options.multiDrag || ~multiDragElements.indexOf(el)) return;
+
+ if (multiDragSortable && multiDragSortable !== sortable) {
+ multiDragSortable.multiDrag._deselectMultiDrag();
+
+ multiDragSortable = sortable;
+ }
+
+ toggleClass(el, sortable.options.selectedClass, true);
+ multiDragElements.push(el);
+ },
+
+ /**
+ * Deselects the provided multi-drag item
+ * @param {HTMLElement} el The element to be deselected
+ */
+ deselect: function deselect(el) {
+ var sortable = el.parentNode[expando],
+ index = multiDragElements.indexOf(el);
+ if (!sortable || !sortable.options.multiDrag || !~index) return;
+ toggleClass(el, sortable.options.selectedClass, false);
+ multiDragElements.splice(index, 1);
+ }
+ },
+ eventProperties: function eventProperties() {
+ var _this3 = this;
+
+ var oldIndicies = [],
+ newIndicies = [];
+ multiDragElements.forEach(function (multiDragElement) {
+ oldIndicies.push({
+ multiDragElement: multiDragElement,
+ index: multiDragElement.sortableIndex
+ }); // multiDragElements will already be sorted if folding
+
+ var newIndex;
+
+ if (folding && multiDragElement !== dragEl$1) {
+ newIndex = -1;
+ } else if (folding) {
+ newIndex = index(multiDragElement, ':not(.' + _this3.options.selectedClass + ')');
+ } else {
+ newIndex = index(multiDragElement);
+ }
+
+ newIndicies.push({
+ multiDragElement: multiDragElement,
+ index: newIndex
+ });
+ });
+ return {
+ items: _toConsumableArray(multiDragElements),
+ clones: [].concat(multiDragClones),
+ oldIndicies: oldIndicies,
+ newIndicies: newIndicies
+ };
+ },
+ optionListeners: {
+ multiDragKey: function multiDragKey(key) {
+ key = key.toLowerCase();
+
+ if (key === 'ctrl') {
+ key = 'Control';
+ } else if (key.length > 1) {
+ key = key.charAt(0).toUpperCase() + key.substr(1);
+ }
+
+ return key;
+ }
+ }
+ });
+}
+
+function insertMultiDragElements(clonesInserted, rootEl) {
+ multiDragElements.forEach(function (multiDragElement, i) {
+ var target = rootEl.children[multiDragElement.sortableIndex + (clonesInserted ? Number(i) : 0)];
+
+ if (target) {
+ rootEl.insertBefore(multiDragElement, target);
+ } else {
+ rootEl.appendChild(multiDragElement);
+ }
+ });
+}
+/**
+ * Insert multi-drag clones
+ * @param {[Boolean]} elementsInserted Whether the multi-drag elements are inserted
+ * @param {HTMLElement} rootEl
+ */
+
+
+function insertMultiDragClones(elementsInserted, rootEl) {
+ multiDragClones.forEach(function (clone, i) {
+ var target = rootEl.children[clone.sortableIndex + (elementsInserted ? Number(i) : 0)];
+
+ if (target) {
+ rootEl.insertBefore(clone, target);
+ } else {
+ rootEl.appendChild(clone);
+ }
+ });
+}
+
+function removeMultiDragElements() {
+ multiDragElements.forEach(function (multiDragElement) {
+ if (multiDragElement === dragEl$1) return;
+ multiDragElement.parentNode && multiDragElement.parentNode.removeChild(multiDragElement);
+ });
+}
+
+// export default Sortable;
+// export { AutoScrollPlugin as AutoScroll, MultiDragPlugin as MultiDrag, OnSpill, Sortable, SwapPlugin as Swap };
\ No newline at end of file
diff --git a/data/site/icons/discord.png b/OLDdata/site/icons/discord.png
similarity index 100%
rename from data/site/icons/discord.png
rename to OLDdata/site/icons/discord.png
diff --git a/data/site/icons/izzetright.png b/OLDdata/site/icons/izzetright.png
similarity index 100%
rename from data/site/icons/izzetright.png
rename to OLDdata/site/icons/izzetright.png
diff --git a/data/site/icons/massdrop.png b/OLDdata/site/icons/massdrop.png
similarity index 100%
rename from data/site/icons/massdrop.png
rename to OLDdata/site/icons/massdrop.png
diff --git a/data/site/icons/patreon.png b/OLDdata/site/icons/patreon.png
similarity index 100%
rename from data/site/icons/patreon.png
rename to OLDdata/site/icons/patreon.png
diff --git a/data/site/icons/paypal-512.png b/OLDdata/site/icons/paypal-512.png
similarity index 100%
rename from data/site/icons/paypal-512.png
rename to OLDdata/site/icons/paypal-512.png
diff --git a/data/site/icons/paypal.png b/OLDdata/site/icons/paypal.png
similarity index 100%
rename from data/site/icons/paypal.png
rename to OLDdata/site/icons/paypal.png
diff --git a/data/site/icons/pucatrade.png b/OLDdata/site/icons/pucatrade.png
similarity index 100%
rename from data/site/icons/pucatrade.png
rename to OLDdata/site/icons/pucatrade.png
diff --git a/data/site/icons/reddit.png b/OLDdata/site/icons/reddit.png
similarity index 100%
rename from data/site/icons/reddit.png
rename to OLDdata/site/icons/reddit.png
diff --git a/data/site/icons/twitter.png b/OLDdata/site/icons/twitter.png
similarity index 100%
rename from data/site/icons/twitter.png
rename to OLDdata/site/icons/twitter.png
diff --git a/data/site/images/layerBackground.png b/OLDdata/site/images/layerBackground.png
similarity index 100%
rename from data/site/images/layerBackground.png
rename to OLDdata/site/images/layerBackground.png
diff --git a/data/site/images/lowpoly.png b/OLDdata/site/images/lowpoly.png
similarity index 100%
rename from data/site/images/lowpoly.png
rename to OLDdata/site/images/lowpoly.png
diff --git a/data/site/images/lowpoly.xcf b/OLDdata/site/images/lowpoly.xcf
similarity index 100%
rename from data/site/images/lowpoly.xcf
rename to OLDdata/site/images/lowpoly.xcf
diff --git a/data/site/images/samples/1.png b/OLDdata/site/images/samples/1.png
similarity index 100%
rename from data/site/images/samples/1.png
rename to OLDdata/site/images/samples/1.png
diff --git a/data/site/images/samples/10.png b/OLDdata/site/images/samples/10.png
similarity index 100%
rename from data/site/images/samples/10.png
rename to OLDdata/site/images/samples/10.png
diff --git a/data/site/images/samples/11.png b/OLDdata/site/images/samples/11.png
similarity index 100%
rename from data/site/images/samples/11.png
rename to OLDdata/site/images/samples/11.png
diff --git a/data/site/images/samples/12.png b/OLDdata/site/images/samples/12.png
similarity index 100%
rename from data/site/images/samples/12.png
rename to OLDdata/site/images/samples/12.png
diff --git a/data/site/images/samples/2.png b/OLDdata/site/images/samples/2.png
similarity index 100%
rename from data/site/images/samples/2.png
rename to OLDdata/site/images/samples/2.png
diff --git a/data/site/images/samples/3.png b/OLDdata/site/images/samples/3.png
similarity index 100%
rename from data/site/images/samples/3.png
rename to OLDdata/site/images/samples/3.png
diff --git a/data/site/images/samples/4.png b/OLDdata/site/images/samples/4.png
similarity index 100%
rename from data/site/images/samples/4.png
rename to OLDdata/site/images/samples/4.png
diff --git a/data/site/images/samples/5.png b/OLDdata/site/images/samples/5.png
similarity index 100%
rename from data/site/images/samples/5.png
rename to OLDdata/site/images/samples/5.png
diff --git a/data/site/images/samples/6.png b/OLDdata/site/images/samples/6.png
similarity index 100%
rename from data/site/images/samples/6.png
rename to OLDdata/site/images/samples/6.png
diff --git a/data/site/images/samples/7.png b/OLDdata/site/images/samples/7.png
similarity index 100%
rename from data/site/images/samples/7.png
rename to OLDdata/site/images/samples/7.png
diff --git a/data/site/images/samples/8.png b/OLDdata/site/images/samples/8.png
similarity index 100%
rename from data/site/images/samples/8.png
rename to OLDdata/site/images/samples/8.png
diff --git a/data/site/images/samples/9.png b/OLDdata/site/images/samples/9.png
similarity index 100%
rename from data/site/images/samples/9.png
rename to OLDdata/site/images/samples/9.png
diff --git a/data/site/other/askScryfall/askScryfall.js b/OLDdata/site/other/askScryfall/askScryfall.js
similarity index 100%
rename from data/site/other/askScryfall/askScryfall.js
rename to OLDdata/site/other/askScryfall/askScryfall.js
diff --git a/data/site/other/askScryfall/askScryfallAbilityListGenerator.html b/OLDdata/site/other/askScryfall/askScryfallAbilityListGenerator.html
similarity index 100%
rename from data/site/other/askScryfall/askScryfallAbilityListGenerator.html
rename to OLDdata/site/other/askScryfall/askScryfallAbilityListGenerator.html
diff --git a/data/site/other/askScryfall/minus.png b/OLDdata/site/other/askScryfall/minus.png
similarity index 100%
rename from data/site/other/askScryfall/minus.png
rename to OLDdata/site/other/askScryfall/minus.png
diff --git a/data/site/other/askScryfall/planeswalkerAbilities.txt b/OLDdata/site/other/askScryfall/planeswalkerAbilities.txt
similarity index 100%
rename from data/site/other/askScryfall/planeswalkerAbilities.txt
rename to OLDdata/site/other/askScryfall/planeswalkerAbilities.txt
diff --git a/data/site/other/askScryfall/plus.png b/OLDdata/site/other/askScryfall/plus.png
similarity index 100%
rename from data/site/other/askScryfall/plus.png
rename to OLDdata/site/other/askScryfall/plus.png
diff --git a/data/site/other/askScryfall/ultimate.png b/OLDdata/site/other/askScryfall/ultimate.png
similarity index 100%
rename from data/site/other/askScryfall/ultimate.png
rename to OLDdata/site/other/askScryfall/ultimate.png
diff --git a/data/site/other/askScryfall/urzaBlank.png b/OLDdata/site/other/askScryfall/urzaBlank.png
similarity index 100%
rename from data/site/other/askScryfall/urzaBlank.png
rename to OLDdata/site/other/askScryfall/urzaBlank.png
diff --git a/data/site/other/life/NoSleep.js b/OLDdata/site/other/life/NoSleep.js
similarity index 100%
rename from data/site/other/life/NoSleep.js
rename to OLDdata/site/other/life/NoSleep.js
diff --git a/data/site/other/life/life.js b/OLDdata/site/other/life/life.js
similarity index 100%
rename from data/site/other/life/life.js
rename to OLDdata/site/other/life/life.js
diff --git a/data/site/other/life/menuButton.png b/OLDdata/site/other/life/menuButton.png
similarity index 100%
rename from data/site/other/life/menuButton.png
rename to OLDdata/site/other/life/menuButton.png
diff --git a/data/site/other/life/menuExitButton.png b/OLDdata/site/other/life/menuExitButton.png
similarity index 100%
rename from data/site/other/life/menuExitButton.png
rename to OLDdata/site/other/life/menuExitButton.png
diff --git a/data/site/other/setSymbol/setSymbol.js b/OLDdata/site/other/setSymbol/setSymbol.js
similarity index 100%
rename from data/site/other/setSymbol/setSymbol.js
rename to OLDdata/site/other/setSymbol/setSymbol.js
diff --git a/OLDdata/site/styles.css b/OLDdata/site/styles.css
new file mode 100644
index 00000000..f1917f49
--- /dev/null
+++ b/OLDdata/site/styles.css
@@ -0,0 +1,510 @@
+/*fonts*/
+@font-face {
+ font-family: gothammedium;
+ src: url("../fonts/gotham-medium.ttf");
+}
+@font-face {
+ font-family: belerenb;
+ src: url("../fonts/beleren-b.ttf");
+}
+@font-face {
+ font-family: belerenbsc;
+ src: url("../fonts/beleren-bsc.ttf");
+}
+@font-face {
+ font-family: matrix;
+ src: url("../fonts/matrix.ttf");
+}
+@font-face {
+ font-family: matrixb;
+ src: url("../fonts/matrix-b.ttf");
+}
+@font-face {
+ font-family: matrixbsc;
+ src: url("../fonts/matrix-bsc.ttf");
+}
+@font-face {
+ font-family: mplantin;
+ src: url("../fonts/mplantin.ttf");
+}
+@font-face {
+ font-family: mplantini;
+ src: url("../fonts/mplantin-i.ttf");
+}
+@font-face {
+ font-family: goudymedieval;
+ src: url("../fonts/goudy-medieval.ttf");
+}
+:root {
+ --shifting-color-1: #00c300;
+ --shifting-color-1-light: #c8ff64;
+ --light-color: #eee;
+ --dark-color: #333;
+ --clear-light: #fff3;
+ --clear-mid: #fff6;
+ --clear-dark: #fff9;
+ --clear-darker: #aaa3;
+ --clear-darkerer: #aaa6;
+ --background-gradient: linear-gradient(to bottom right, var(--shifting-color-1), var(--shifting-color-1-light));
+}
+
+/*Background & Footer*/
+html {
+ background-image: linear-gradient(to bottom right, var(--shifting-color-1), var(--shifting-color-1-light));
+ background-attachment: fixed;
+ overflow-x: hidden;
+ -webkit-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+ font-size: 16pt;
+}
+body {
+ margin: 0;
+ border: 0;
+ padding: 0;
+ background-image: url(images/lowpoly.png);
+ background-position: left;
+ background-repeat: no-repeat;
+ background-attachment: fixed;
+ background-size: cover;
+}
+footer {
+ background-color: var(--dark-color);
+ padding: 2rem;
+ font: 0.5em gothammedium;
+ color: var(--light-color);
+}
+
+
+/*Canvas*/
+canvas {
+ width: calc(100%);
+ height: auto;
+ max-width: 750px;
+ max-height: 1050px;
+}
+.canvasContainer {
+ text-align: center;
+}
+
+
+/*Grids*/
+.mainGrid {
+ display: grid;
+ grid-gap: 1rem;
+ grid-template-columns: auto;
+ padding-bottom: 1rem;
+}
+.splitGrid {
+ display: grid;
+ grid-template-columns: 50% 50%;
+}
+.frameGrid {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(3rem, 1fr));
+ grid-auto-rows: min-content;
+}
+.footerGrid {
+ display: grid;
+ grid-template-columns: auto;
+ grid-gap: 1rem;
+}
+.autoGrid {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(5rem, 1fr));
+ grid-auto-rows: min-content;
+}
+
+
+/*Misc elements*/
+.download {
+ text-align: center;
+ font: 1.5rem belerenbsc;
+}
+.pageTitle {
+ font: 3rem belerenbsc;
+ text-align: center;
+ padding-top: 0.5rem;
+}
+.bar {
+ background-image: url(../images/manaSymbols/63.png);
+ background-position: center;
+ background-repeat: no-repeat;
+ background-size: 100% 2px;
+ width: 100%;
+ height: 1rem;
+}
+.imgPreview {
+ width: 100%;
+}
+.layer {
+ padding: 2rem 2rem;
+ color: black;
+ text-align: center;
+ margin-bottom: 3rem;
+ background-color: var(--light-color);
+ background-image: url(images/layerBackground.png);
+ background-position: center;
+ background-repeat: no-repeat;
+}
+
+
+/*Donate Grid Stuff!*/
+.donateHalfGrid > img {
+ width: 90%;
+ margin-bottom: 1rem;
+}
+
+
+/*Various text modifications*/
+.title {
+ text-align: center;
+ font: 1.5rem belerenbsc;
+}
+.truncate {
+ word-break: break-word;
+}
+.paragraph {
+ font: mplantin;
+ text-align: left;
+}
+.indent {
+ text-indent: 2rem;
+}
+
+
+/*General modifications*/
+.hidden:not(.visibilityOverride) {
+ display: none;
+}
+.visible {
+ display: inline-block;
+}
+.selectable {
+ user-select: all;
+}
+
+
+/*Hyperlinks*/
+a {
+ color: black;
+}
+a:hover {
+ color: var(--dark-color);
+}
+footer a {
+ color: white;
+}
+footer a:hover {
+ color: var(--shifting-color-1-light);
+}
+
+
+/*Controls the area taken by the canvas*/
+@media screen and (min-width: 905pt) {
+ /*Makes room for the canvas and controls to be side by side*/
+ .mainGrid {
+ padding: 1rem;
+ grid-template-columns: calc(750px + 2px) auto;
+ }
+}
+@media screen and (min-width: calc(750px + 2rem)) {
+ /*The canvas can be full size and doesn't have to scale anymore*/
+ canvas {
+ width: 750px;
+ height: 1050px;
+ }
+}
+/*The screen is big enough (larger than phone, likely) to use a larger font*/
+@media screen and (min-width: 375pt) {
+ html {
+ font-size: 24pt;
+ }
+}
+/*The screen is big enough for the samples to lay side by side. Also, the donate section can be displayed horizontally.*/
+@media screen and (min-width: 750pt) {
+ .samples {
+ grid-template-columns: 33.33% 33.33% 33.33% !important;
+ margin-bottom: 2rem;
+ }
+ .samples #sample1 {
+ width: 90%;
+ transform: rotate(-10deg) translate(10%, 8%);
+ }
+ .samples #sample2 {
+ z-index: 10;
+ }
+ .samples #sample3 {
+ width: 90%;
+ transform: rotate(10deg) translate(-10%, 8%);
+ }
+ .donateHalfGrid {
+ display: grid;
+ grid-template-columns: 16rem auto;
+ margin-top: 0.5rem;
+ }
+ .donateHalfGrid > img {
+ width: 15rem;
+ margin-bottom: 0;
+ }
+}
+/*These control tooltips for mobile devices vs. desktops/laptops*/
+/*@media screen and (min-width: 1024px) {
+ .tooltip:hover .tooltiptext {
+ visibility: visible;
+ opacity: 1;
+ }
+}
+@media screen and (max-width: 1023px) {
+ .tooltip:focus .tooltiptext, div.tooltip > input:focus + .tooltiptext, div.tooltip > textarea:focus + .tooltiptext {
+ visibility: visible;
+ opacity: 1;
+ }
+}*/
+/*Allows the footer to be displayed horizontally on Desktop*/
+@media screen and (min-width: 375pt) {
+ .footerGrid {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(0px, 1fr));
+ grid-gap: 1rem;
+ }
+}
+
+
+/*WIP (or I'm too lazy to sort these)*/
+.tabMenu {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(6rem, 1fr));
+ grid-auto-rows: min-content;
+}
+.tabOption, .textTabButton {
+ font: 1rem belerenbsc;
+ text-align: center;
+ background-color: var(--clear-light);
+ border: 1px solid var(--light-color);
+ transition: 0.5s;
+}
+.tabOption:hover, .textTabButton:hover {
+ background-color: var(--clear-mid);
+ transition: 0s;
+}
+.tabOption.tabOptionSelected, .textTabButton.activeTextTab {
+ background-color: var(--clear-dark);
+}
+.tabContent:not(.tabVisible) {
+ display: none;
+}
+
+.cardMasterElement {
+ font: 0.75rem belerenbsc;
+ background-color: var(--clear-light);
+ border: 1px solid var(--light-color);
+ border-radius: 0.5rem;
+ margin-top: 0.25rem;
+ display: grid;
+ grid-template-columns: 2rem auto 1rem;
+ align-items: center;
+}
+.cardMasterElement > .handle {
+ cursor: all-scroll;
+ padding: 1rem 0.5rem;
+ text-align: center;
+}
+.cardMasterElement img {
+ max-height: 1.3rem;
+ max-width: 1.3rem;
+ position: absolute;
+ transform: translate(0.1rem, 0);
+}
+.cardmasterElement img.cardMasterElementMaskImage {
+ transform: translate(1.5rem, 0);
+}
+.cardMasterElement img.cardMasterElementMaskImage.zoom:hover {
+ transform: translate(1.5rem, 0) scale(3);
+}
+.cardMasterElementMoving {
+ background-color: var(--clear-dark);
+}
+.closeCardMasterElement {
+ cursor: pointer;
+ text-align: center;
+}
+
+.frameOption img, .maskOption img, .cardMasterElement img {
+ -webkit-user-drag: none;
+ -khtml-user-drag: none;
+ -moz-user-drag: none;
+ -o-user-drag: none;
+ user-drag: none;
+}
+
+#framePicker, #maskPicker {
+ max-height: 260pt;
+ overflow-y: auto;
+ overflow-x: hidden;
+ border: 1px solid var(--light-color);
+}
+.frameOption {
+ height: 3rem;
+ text-align: center;
+ width: 100%;
+}
+.frameOption img {
+ max-width: 3rem;
+ max-height: 3rem;
+}
+.maskOption img {
+ max-width: 1.5rem;
+ max-height: 1.5rem;
+}
+.frameOption.frameOptionSelected, .maskOption.maskOptionSelected {
+ background-color: var(--clear-dark);
+}
+.maskOption, .frameOption {
+ background-color: var(--clear-light);
+ border: 1px solid var(--light-color);
+ border-radius: 0.25rem;
+}
+.maskOption {
+ font-size: 0.75rem;
+ margin-left: 0.5rem;
+ padding: 0.25rem;
+ width: calc(100% - 1.3rem);
+}
+
+
+.textarea {
+ width: 100%;
+ min-height: 6rem;
+ max-height: 18rem;
+ resize: vertical;
+}
+.textTabButton {
+ font-size: 0.75rem;
+}
+.textTab {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(6rem, 1fr));
+ grid-auto-rows: min-content;
+}
+
+.input, .textarea, .button, .select {
+ font: 0.75rem mplantin;
+ background-color: var(--light-color);
+ border: 1px solid #aaa;
+ border-radius: 0.2rem;
+ padding: 0px 0.2rem;
+ outline: none;
+ width: 100%;
+}
+.input.inputOpacity {
+ width: 2.4rem;
+}
+
+
+/* Text code tutorial */
+#textCodeTutorial {
+ font-size: 0.75rem;
+ display: grid;
+ grid-template-columns: 4.5rem auto;
+}
+#textCodeTutorial > div {
+ padding: 0.25rem 0;
+ background-color: var(--clear-mid);
+}
+#textCodeTutorial > div:nth-child(4n), #textCodeTutorial > div:nth-child(4n - 1) {
+ background-color: var(--clear-light);
+}
+
+
+input[type="checkbox"], .frameOption, .maskOption, .button {
+ cursor: pointer;
+}
+
+
+/* image links */
+.proxyFactoryLimitedGrid {
+ margin: 0;
+ max-width: calc(100vw - 4rem);
+}
+.donateGrid {
+ margin: 0;
+ max-width: calc(100vw - 4rem);
+}
+.imageLinkGrid {
+ margin-top: 1rem;
+ display: grid;
+ justify-items: center;
+ grid-template-columns: repeat(auto-fit, minmax(11.5rem, 1fr));
+/* border: 1px solid red;*/
+}
+.showBackgroundThrough {
+ display: inline-block;
+ background: url(images/lowpoly.png) left top no-repeat;
+ background-size: cover;
+ background-attachment: fixed;
+}
+.imageLink {
+ width: calc(100% - 1rem);
+ padding: 0.5rem;
+ border-radius: 1rem;
+ display: grid;
+ grid-template-columns: 4rem auto;
+ align-items: center;
+ justify-items: center;
+ border: 1px solid var(--dark-color);
+}
+.imageLink:hover {
+ background-color: var(--clear-darkerer);
+}
+.imageLink > img {
+ max-height: 3rem;
+ max-width: 4rem;
+}
+.imageLink > div {
+ word-break: break-all;
+ font: 1.5rem belerenbsc;
+}
+
+.visitorCount {
+ display: none;
+}
+.visitorCount > a > img {
+ max-height: 0.5rem;
+}
+.visitorCountTrigger:hover + .visitorCount {
+ display:inline-block;
+}
+
+
+
+.samples {
+ display: grid;
+ grid-template-columns: 100%;
+ align-items: center;
+}
+.samples img {
+ width: 90%;
+ margin: 0 auto;
+ height: auto;
+}
+
+.zoom {
+ transition: 0.2s;
+}
+.zoom:hover {
+ transform: scale(3);
+ z-index: 100;
+}
+
+
+
+
+
+
+
+
+
+
+
diff --git a/data/versions/expedition.js b/OLDdata/versions/expedition.js
similarity index 100%
rename from data/versions/expedition.js
rename to OLDdata/versions/expedition.js
diff --git a/data/versions/future.js b/OLDdata/versions/future.js
similarity index 100%
rename from data/versions/future.js
rename to OLDdata/versions/future.js
diff --git a/data/versions/invention.js b/OLDdata/versions/invention.js
similarity index 100%
rename from data/versions/invention.js
rename to OLDdata/versions/invention.js
diff --git a/data/versions/inventionTextless.js b/OLDdata/versions/inventionTextless.js
similarity index 100%
rename from data/versions/inventionTextless.js
rename to OLDdata/versions/inventionTextless.js
diff --git a/data/versions/m15.js b/OLDdata/versions/m15.js
similarity index 100%
rename from data/versions/m15.js
rename to OLDdata/versions/m15.js
diff --git a/data/versions/m15extras.js b/OLDdata/versions/m15extras.js
similarity index 100%
rename from data/versions/m15extras.js
rename to OLDdata/versions/m15extras.js
diff --git a/data/versions/moreMasks.js b/OLDdata/versions/moreMasks.js
similarity index 100%
rename from data/versions/moreMasks.js
rename to OLDdata/versions/moreMasks.js
diff --git a/data/versions/planeswalker.js b/OLDdata/versions/planeswalker.js
similarity index 100%
rename from data/versions/planeswalker.js
rename to OLDdata/versions/planeswalker.js
diff --git a/data/versions/seventh.js b/OLDdata/versions/seventh.js
similarity index 100%
rename from data/versions/seventh.js
rename to OLDdata/versions/seventh.js
diff --git a/data/versions/unhinged.js b/OLDdata/versions/unhinged.js
similarity index 100%
rename from data/versions/unhinged.js
rename to OLDdata/versions/unhinged.js
diff --git a/data/versions/unsanctioned.js b/OLDdata/versions/unsanctioned.js
similarity index 100%
rename from data/versions/unsanctioned.js
rename to OLDdata/versions/unsanctioned.js
diff --git a/OLDindex.html b/OLDindex.html
new file mode 100644
index 00000000..056c8c8a
--- /dev/null
+++ b/OLDindex.html
@@ -0,0 +1,252 @@
+
+
+
+
+
+
+ Card Conjurer
+
+
+
+
+
+
+
+
+ Card Conjurer
+
+
+
+
+
+
+
+
+
+
Frame
+
Text
+
Art
+
Collector
+
Set Symbol
+
Watermark
+
Advanced
+
Import Card
+
+
+
+
+
+
+
+
+
+
+
No frame selected
+
+
|||
Text Placeholder
+
|||
Card Art Placeholder
+
+
+
Upload your own frame images:
+
+
+
+
+
+
+
+
+
+
+
How To Use Text Codes
+
+ Remember to surround each code with curly brackets ("{" and "}"). The codes are not caps sensitive. The following is a list of available text codes and what they do:
+
+
+
+
+
+
+
+
+
+
+
+
+
X, Y, & Zoom:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Click on one of the following buttons to load the described image frame set:
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Hide unrelated frames
+
+
+
+ Type in a card name to import it! (Only works for regular cards)
+
+ Select which card to import:
+
+
Card Conjurer is a free program that helps you create custom Magic: The Gathering cards. There are already plenty of custom card makers out there, but what sets Card Conjurer apart from the rest is its live-edit capabilities. You can immediately see the effects of any change you make, which makes card customization easier and overall a better experience. Additionally, in comparison to alternative websites, Card Conjurer offers more frames such as planeswalker, seventh edition, or even kaladesh inventions, and provides much more customizability.
+
+
+
About Me
+
+ Hi! My name is Kyle Burton and I am currently a high school student. I used to play Pokemon, but when a friend introduced me to Magic in 2013 I sold my pocket monsters and bought an M14 Intro Pack. Ever since that day, Magic has been my all time favorite game. In addition to playing games, I've always loved technology. During the 2017-18 school year I tought myself how to code Javascript, and a little bit of HTML and CSS. The following summer I created Kyle's Card Imager (KCI). It was pretty simple but I soon began to add more card frames. After a few months I decided to share my creation, so I renamed it Card Conjurer and uploaded it to Github, and then in April of 2019 I bought the domain cardconjurer.com.
+
+
+
+
Check Out Some Samples!
+
+
+
+
+
+
+
+
How You Can Help
+
+
+
+
I play Commander, which can be expensive for a student! Right now, one of the cards that I'm saving up for is . If you've enjoyed using Card Conjurer, a small donation, even as low as a single cent, would be incredibly appreciated and put to good use!
+ This version of the website doesn't have the same features that the original Card Conjurer had. If you want to go back to the old version, click here.
+
+
+
+
Have Any Questions?
+
+ If you have any questions please don't hesitate to email me at . Even if you made a cool card and want to share, I'd love to see it!
+
+
+
+
The Proxy Factory
+
If you'd like to delve deeper into making custom Magic: The Gathering cards, check out The Proxy Factory! They're a community full of individuals interested in creating custom cards, and are very welcoming to new members.
- Remember to surround each code with curly brackets ("{" and "}"). The codes are not caps sensitive. The following is a list of available text codes and what they do:
-
-
-
-
-
-
-
-
-
-
-
-
-
X, Y, & Zoom:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Click on one of the following buttons to load the described image frame set:
-
-
-
-
-
-
-
-
-
-
-
-
-
- Hide unrelated frames
-
-
-
- Type in a card name to import it! (Only works for regular cards)
-
- Select which card to import:
-
-
Card Conjurer is a free program that helps you create custom Magic: The Gathering cards. There are already plenty of custom card makers out there, but what sets Card Conjurer apart from the rest is its live-edit capabilities. You can immediately see the effects of any change you make, which makes card customization easier and overall a better experience. Additionally, in comparison to alternative websites, Card Conjurer offers more frames such as planeswalker, seventh edition, or even kaladesh inventions, and provides much more customizability.
-
-
-
About Me
-
- Hi! My name is Kyle Burton and I am currently a high school student. I used to play Pokemon, but when a friend introduced me to Magic in 2013 I sold my pocket monsters and bought an M14 Intro Pack. Ever since that day, Magic has been my all time favorite game. In addition to playing games, I've always loved technology. During the 2017-18 school year I tought myself how to code Javascript, and a little bit of HTML and CSS. The following summer I created Kyle's Card Imager (KCI). It was pretty simple but I soon began to add more card frames. After a few months I decided to share my creation, so I renamed it Card Conjurer and uploaded it to Github, and then in April of 2019 I bought the domain cardconjurer.com.
-
-
-
-
Check Out Some Samples!
-
-
-
-
+
+
+
+
+
+
+
+
-
-
-
How You Can Help
-
-
-
-
I play Commander, which can be expensive for a student! Right now, one of the cards that I'm saving up for is . If you've enjoyed using Card Conjurer, a small donation, even as low as a single cent, would be incredibly appreciated and put to good use!
- This version of the website doesn't have the same features that the original Card Conjurer had. If you want to go back to the old version, click here.
-
-
-
-
Have Any Questions?
-
- If you have any questions please don't hesitate to email me at . Even if you made a cool card and want to share, I'd love to see it!
-
-
-
-
The Proxy Factory
-
If you'd like to delve deeper into making custom Magic: The Gathering cards, check out The Proxy Factory! They're a community full of individuals interested in creating custom cards, and are very welcoming to new members.