kipphi 2.1.2 → 2.1.3-beta.1

package/index.js

@@ -35,8 +35,9 @@ var rgb2hex = (rgb) => {
 var hex2rgb = (hex) => {
   return [hex >> 16, hex >> 8 & 255, hex & 255];
 };
+var DENO = 324324000;
 var numberToRatio = (num) => {
-  return [Math.round(num * 1e4), 1e4];
+  return [Math.round(num * DENO), DENO];
 };
 var toTimeString = (beaT) => `${beaT[0]}:${beaT[1]}/${beaT[2]}`;
 
@@ -77,6 +78,7 @@ var ERROR_IDS;
   ERROR_IDS2[ERROR_IDS2["NODES_NOT_CONTINUOUS"] = EASING | INVALID_USAGE | 1] = "NODES_NOT_CONTINUOUS";
   ERROR_IDS2[ERROR_IDS2["NODES_NOT_BELONG_TO_SAME_SEQUENCE"] = EASING | INVALID_USAGE | 2] = "NODES_NOT_BELONG_TO_SAME_SEQUENCE";
   ERROR_IDS2[ERROR_IDS2["NODES_HAS_ZERO_DELTA"] = EASING | INVALID_USAGE | 3] = "NODES_HAS_ZERO_DELTA";
+  ERROR_IDS2[ERROR_IDS2["TEMPLATE_EASING_CIRCULAR_REFERENCE"] = EASING | INVALID_USAGE | 4] = "TEMPLATE_EASING_CIRCULAR_REFERENCE";
   ERROR_IDS2[ERROR_IDS2["CANNOT_DIVIDE_EXPRESSION_EVALUATOR"] = EVALUATOR | INVALID_USAGE | 0] = "CANNOT_DIVIDE_EXPRESSION_EVALUATOR";
   ERROR_IDS2[ERROR_IDS2["MISSING_MACRO_EVALUATOR_KEY"] = EVALUATOR | INVALID_DATA | 0] = "MISSING_MACRO_EVALUATOR_KEY";
   ERROR_IDS2[ERROR_IDS2["MACRO_EVALUATOR_NOT_FOUND"] = EVALUATOR | INVALID_DATA | 1] = "MACRO_EVALUATOR_NOT_FOUND";
@@ -126,7 +128,8 @@ var ERRORS = {
   PARAMETRIC_MACRO_REQUIRES_PROTO_KEY: (pos) => `Parametric Macro requires key. At ${pos}`,
   MACRO_NOT_PARAMETRIC: (macroId, pos) => `Macro '${macroId}' is not parametric. At ${pos}`,
   EVENT_NODE_NOT_DENSE: (pos) => `EventNode is not dense. At ${pos}`,
-  HOLD_HAS_NO_DURATION: () => `Hold should have a duration.`
+  HOLD_HAS_NO_DURATION: () => `Hold should have a duration.`,
+  TEMPLATE_EASING_CIRCULAR_REFERENCE: (temEasName) => `Template Easing '${temEasName}' has circular reference`
 };
 
 class KPAError extends Error {
@@ -548,6 +551,9 @@ class TemplateEasing extends Easing {
     this.name = name;
   }
   getValue(t) {
+    if (t === 1) {
+      return 1;
+    }
     const seq = this.eventNodeSequence;
     const delta = this.valueDelta;
     if (delta === 0) {
@@ -569,6 +575,28 @@ class TemplateEasing extends Easing {
   get headValue() {
     return this.eventNodeSequence.head.next.value;
   }
+  segmentedValueGetter(easingLeft, easingRight) {
+    return (t) => {
+      const leftValue = this.getValue(easingLeft);
+      const rightValue = this.getValue(easingRight);
+      const timeDelta = easingRight - easingLeft;
+      const delta = rightValue - leftValue;
+      if (delta === 0) {
+        return 0;
+      }
+      return (this.getValue(easingLeft + timeDelta * t) - leftValue) / delta;
+    };
+  }
+  static checkCircularReference(seq, template) {
+    const seq2 = template.eventNodeSequence;
+    if (seq === seq2) {
+      return true;
+    }
+    if (seq2.hasReferenceTo(seq)) {
+      return true;
+    }
+    return false;
+  }
 }
 
 class WrapperEasing extends Easing {
@@ -952,16 +980,24 @@ class EasedEvaluator extends Evaluator {
     super();
     this.easing = easing;
   }
-  eval(startNode, beats) {
+  eval(startNode, beatsOrSeconds, timeCalculator) {
     const next = startNode.next;
-    const timeDelta = TC2.getDelta(next.time, startNode.time);
-    const current = beats - TC2.toBeats(startNode.time);
     const nextValue = startNode.next.value;
     const value = startNode.value;
     if (nextValue === value) {
       return value;
     }
-    return this.convert(value, nextValue, this.easing.getValue(current / timeDelta));
+    if (timeCalculator) {
+      const startSecs = timeCalculator.toSeconds(TC2.toBeats(startNode.time));
+      const endSecs = timeCalculator.toSeconds(TC2.toBeats(next.time));
+      const current = beatsOrSeconds - startSecs;
+      const timeDelta = endSecs - startSecs;
+      return this.convert(value, nextValue, this.easing.getValue(current / timeDelta));
+    } else {
+      const timeDelta = TC2.getDelta(next.time, startNode.time);
+      const current = beatsOrSeconds - TC2.toBeats(startNode.time);
+      return this.convert(value, nextValue, this.easing.getValue(current / timeDelta));
+    }
   }
   static getEvaluatorFromEasing(type, easing, interpretedAs) {
     const easingIsNormal = easing instanceof NormalEasing;
@@ -1046,11 +1082,11 @@ class TextEasedEvaluator extends EasedEvaluator {
     if (interpretedAs === 2 /* float */) {
       const start = parseFloat(value);
       const delta = parseFloat(nextValue) - start;
-      return start + progress * delta + "";
+      return (start + progress * delta).toFixed(3) + "";
     } else if (interpretedAs === 1 /* int */) {
       const start = parseInt(value);
       const delta = parseInt(nextValue) - start;
-      return start + Math.round(progress * delta) + "";
+      return start + Math.floor(progress * delta) + "";
     } else if (value.startsWith(nextValue)) {
       const startLen = nextValue.length;
       const deltaLen = value.length - startLen;
@@ -1104,8 +1140,8 @@ class MacroEvaluator extends Evaluator {
     node.evaluator = this;
     this.consumers.set(node, this.compile(node, chart));
   }
-  eval(event, beats) {
-    return this.consumers.get(event).eval(event, beats);
+  eval(event, beats, timeCalculator) {
+    return this.consumers.get(event).eval(event, beats, timeCalculator);
   }
   dumpFor(node) {
     return {
@@ -1130,11 +1166,19 @@ class ExpressionEvaluator extends Evaluator {
     this.jsExpr = jsExpr;
     this.func = new Function("t", "return " + jsExpr);
   }
-  eval(startNode, beats) {
-    const next = startNode.next;
-    const timeDelta = TC2.getDelta(next.time, startNode.time);
-    const current = beats - TC2.toBeats(startNode.time);
-    return this.func(current / timeDelta);
+  eval(startNode, beatsOrSecs, timeCalculator) {
+    if (timeCalculator) {
+      const startSecs = timeCalculator.toSeconds(TC2.toBeats(startNode.time));
+      const endSecs = timeCalculator.toSeconds(TC2.toBeats(startNode.next.time));
+      const current = beatsOrSecs - startSecs;
+      const timeDelta = endSecs - startSecs;
+      return this.func(current / timeDelta);
+    } else {
+      const next = startNode.next;
+      const timeDelta = TC2.getDelta(next.time, startNode.time);
+      const current = beatsOrSecs - TC2.toBeats(startNode.time);
+      return this.func(current / timeDelta);
+    }
   }
   dumpFor() {
     return {
@@ -1352,11 +1396,6 @@ class EventNode extends EventNodeLike {
     return ret;
   }
   static getEasing(data, templates, notSegmented = false) {
-    const left = data.easingLeft;
-    const right = data.easingRight;
-    if (!notSegmented && (left && right) && (left !== 0 || right !== 1)) {
-      return new SegmentedEasing(EventNode.getEasing(data, templates, true), left, right);
-    }
     if (data.bezier) {
       const bp = data.bezierPoints;
       const easing = new BezierEasing([bp[0], bp[1]], [bp[2], bp[3]]);
@@ -1563,11 +1602,11 @@ class EventStartNode extends EventNode {
       linkedMacro: [...this.linkedMacros].map((macro) => macro.dumpLinkForNode(this))
     };
   }
-  getValueAt(beats) {
+  getValueAt(beatsOrSecs, timeCalculator) {
     if (this.next.type === 1 /* TAIL */) {
       return this.value;
     }
-    return this.evaluator.eval(this, beats);
+    return this.evaluator.eval(this, beatsOrSecs, timeCalculator);
   }
   getSpeedValueAt(beats) {
     if (this.next.type === 1 /* TAIL */) {
@@ -1845,6 +1884,9 @@ class EventNodeSequence {
   getValueAt(beats, usePrev = false) {
     return this.getNodeAt(beats, usePrev).getValueAt(beats);
   }
+  getValueAtBySecs(beats, seconds, timeCalculator, usePrev = false) {
+    return this.getNodeAt(beats, usePrev).getValueAt(seconds, timeCalculator);
+  }
   getFloorPositionAt(beats, timeCalculator) {
     const node = this.getNodeAt(beats);
     const value = node.getLocalFloorPos(beats, timeCalculator) + node.floorPosition;
@@ -1861,7 +1903,7 @@ class EventNodeSequence {
       const prevStart = node.previous.previous;
       currentFP = prevStart.floorPosition + prevStart.getFullLocalFloorPos(tc);
     } else {
-      currentFP = 0;
+      node.floorPosition = currentFP = 0;
     }
     while (true) {
       const canBeEnd = node.next;
@@ -1980,24 +2022,40 @@ class EventNodeSequence {
       currentNode = currentNode.next.next;
     }
   }
+  hasReferenceTo(seq) {
+    let node = this.head.next;
+    while (true) {
+      const endNode = node.next;
+      if (endNode.type === 1 /* TAIL */) {
+        break;
+      }
+      const evaluator = node.evaluator;
+      if (evaluator instanceof EasedEvaluator && evaluator.easing instanceof TemplateEasing) {
+        if (TemplateEasing.checkCircularReference(seq, evaluator.easing)) {
+          return true;
+        }
+      }
+      node = endNode.next;
+    }
+  }
 }
 // src/note.ts
 var notePropTypes = {
   above: "boolean",
-  alpha: "number",
+  alpha: "int[0,255]",
   endTime: ["number", "number", "number"],
   isFake: "boolean",
   positionX: "number",
-  size: "number",
+  size: "number(0,+)",
   speed: "number",
   startTime: ["number", "number", "number"],
-  type: "number",
-  visibleTime: "number",
-  visibleBeats: "number",
+  type: "int[1,4]",
+  visibleTime: "number(0,+)",
+  visibleBeats: "number(0,+)",
   yOffset: "number",
-  tint: ["number", "number", "number"],
-  tintHitEffects: ["number", "number", "number"],
-  judgeSize: "number"
+  tint: ["int[0,255]", "int[0,255]", "int[0,255]"],
+  tintHitEffects: ["int[0,255]", "int[0,255]", "int[0,255]"],
+  judgeSize: "number(0,+)"
 };
 
 class Note {
@@ -2030,9 +2088,10 @@ class Note {
     this.visibleTime = data.visibleTime;
     this.yOffset = data.absoluteYOffset ?? data.yOffset * this.speed;
     this.visibleBeats = data.visibleBeats;
-    this.tint = data.tint ? rgb2hex(data.tint) : undefined;
+    const color = data.tint ?? data.color;
+    this.tint = color ? rgb2hex(color) : undefined;
     this.tintHitEffects = data.tintHitEffects ? rgb2hex(data.tintHitEffects) : undefined;
-    this.judgeSize = data.judgeSize ?? this.size;
+    this.judgeSize = data.judgeSize ?? data.judgeArea ?? this.size;
   }
   static fromKPAJSON(data, timeCalculator) {
     const note = new Note(data);
@@ -2079,7 +2138,8 @@ class Note {
       yOffset: this.yOffset / this.speed,
       speed: this.speed,
       tint: this.tint !== undefined ? hex2rgb(this.tint) : undefined,
-      tintHitEffects: this.tint !== undefined ? hex2rgb(this.tintHitEffects) : undefined
+      tintHitEffects: this.tint !== undefined ? hex2rgb(this.tintHitEffects) : undefined,
+      judgeArea: this.judgeSize
     };
   }
   dumpKPA() {
@@ -2636,17 +2696,17 @@ class JudgeLine {
       line.speedSequence = speedSequences[0];
       chart.registerEventNodeSequence(4 /* speed */, `#${id}.speed`, speedSequences[0]);
     }
+    if (data.extended?.scaleXEvents) {
+      line.extendedLayer.scaleX = createExtendedSequence(7 /* scaleX */, data.extended.scaleXEvents);
+    } else {
+      line.extendedLayer.scaleX = chart.createEventNodeSequence(7 /* scaleX */, `#${id}.ex.scaleX`);
+    }
+    if (data.extended?.scaleYEvents) {
+      line.extendedLayer.scaleY = createExtendedSequence(8 /* scaleY */, data.extended.scaleYEvents);
+    } else {
+      line.extendedLayer.scaleY = chart.createEventNodeSequence(8 /* scaleY */, `#${id}.ex.scaleY`);
+    }
     if (data.extended) {
-      if (data.extended.scaleXEvents) {
-        line.extendedLayer.scaleX = createExtendedSequence(7 /* scaleX */, data.extended.scaleXEvents);
-      } else {
-        line.extendedLayer.scaleX = chart.createEventNodeSequence(7 /* scaleX */, `#${id}.ex.scaleX`);
-      }
-      if (data.extended.scaleYEvents) {
-        line.extendedLayer.scaleY = createExtendedSequence(8 /* scaleY */, data.extended.scaleYEvents);
-      } else {
-        line.extendedLayer.scaleY = chart.createEventNodeSequence(8 /* scaleY */, `#${id}.ex.scaleY`);
-      }
       if (data.extended.textEvents) {
         line.extendedLayer.text = createExtendedSequence(9 /* text */, data.extended.textEvents);
       }
@@ -2815,7 +2875,7 @@ class JudgeLine {
     if (lineMonotonicity === 0 /* increasing */ && startY >= 0 && endY > 0) {
       return result;
     }
-    const computeTime = (speed, currentPos, fore) => timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
+    const computeTime = (speed, currentPos, fore) => speed * currentPos <= 0 ? fore : timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
     while (true) {
       const thisTime = TC2.toBeats(startNode.time);
       const endNode = startNode.next;
@@ -2823,17 +2883,21 @@ class JudgeLine {
       if (endNode.type === 1 /* TAIL */) {
         const thisPosY2 = startNode.floorPosition - currentJudgeLineFloorPos;
         const thisSpeed2 = startNode.value;
-        const inf = thisSpeed2 > 0 ? Infinity : thisSpeed2 < 0 ? -Infinity : thisPosY2;
         if (range[0] === undefined) {
-          if (thisPosY2 < startY && startY <= inf || thisPosY2 >= endY && endY > inf) {
-            range[0] = computeTime(thisSpeed2, (thisPosY2 < inf ? startY : endY) - thisPosY2, thisTime);
-          } else if (thisSpeed2 === 0) {
-            range[0] = 0;
+          if (thisSpeed2 > 0 && endY > thisPosY2) {
+            range[0] = computeTime(thisSpeed2, startY - thisPosY2, thisTime);
+          } else if (thisSpeed2 < 0 && startY < thisPosY2) {
+            range[0] = computeTime(thisSpeed2, endY - thisPosY2, thisTime);
+          } else if (thisSpeed2 === 0 && startY <= thisPosY2 && thisPosY2 <= endY) {
+            range[0] = thisTime;
           }
         }
         if (range[0] !== undefined) {
-          if (thisPosY2 < endY && endY <= inf || thisPosY2 >= startY && startY > inf) {
-            range[1] = computeTime(thisSpeed2, (thisPosY2 > inf ? startY : endY) - thisPosY2, thisTime);
+          if (thisSpeed2 > 0 && endY > thisPosY2) {
+            range[1] = computeTime(thisSpeed2, endY - thisPosY2, thisTime);
+            result.push(range);
+          } else if (thisSpeed2 < 0 && startY < thisPosY2) {
+            range[1] = computeTime(thisSpeed2, startY - thisPosY2, thisTime);
             result.push(range);
           } else if (thisSpeed2 === 0) {
             range[1] = Infinity;
@@ -2846,7 +2910,7 @@ class JudgeLine {
       const thisPosY = startNode.floorPosition - currentJudgeLineFloorPos;
       const nextPosY = nextStart.floorPosition - currentJudgeLineFloorPos;
       let thisSpeed = startNode.value;
-      let nextSpeed = nextStart.value;
+      let nextSpeed = endNode.value;
       if (Math.abs(thisSpeed) < 0.00000001) {
         thisSpeed = 0;
       }
@@ -2858,15 +2922,13 @@ class JudgeLine {
         const zeroPosY = speedSequence.getFloorPositionAt(zeroTime, timeCalculator) - currentJudgeLineFloorPos;
         const zeroSpeed = 0;
         if (range[0] === undefined) {
-          if (thisPosY < startY && startY <= zeroPosY || thisPosY > endY && endY >= zeroPosY) {
-            range[0] = thisSpeed !== zeroSpeed ? thisTime : computeTime(thisSpeed, (thisPosY < zeroPosY ? startY : endY) - thisPosY, thisTime);
-          } else if (startY <= thisPosY && thisPosY <= endY) {
+          if (thisSpeed > 0 && endY >= thisPosY || thisSpeed < 0 && startY <= thisPosY) {
             range[0] = thisTime;
           }
         }
         if (range[0] !== undefined) {
-          if (thisPosY < endY && endY <= zeroPosY || thisPosY > startY && startY >= zeroPosY) {
-            range[1] = thisSpeed !== zeroSpeed ? zeroTime : computeTime(thisSpeed, (thisPosY > zeroPosY ? startY : endY) - thisPosY, thisTime);
+          if (thisSpeed > 0 && endY <= zeroPosY || thisSpeed < 0 && startY >= zeroPosY) {
+            range[1] = zeroTime;
             result.push(range);
             if (lineMonotonicity !== 2 /* swinging */) {
               return result;
@@ -2875,15 +2937,13 @@ class JudgeLine {
           }
         }
         if (range[0] === undefined) {
-          if (zeroPosY < startY && startY <= nextPosY || zeroPosY > endY && endY >= nextPosY) {
-            range[0] = zeroSpeed !== nextSpeed ? zeroTime : computeTime(nextSpeed, (zeroPosY < nextPosY ? startY : endY) - zeroPosY, zeroTime);
-          } else if (startY <= zeroPosY && zeroPosY <= endY) {
+          if (nextSpeed > 0 && endY >= zeroPosY || nextSpeed < 0 && startY <= zeroPosY) {
             range[0] = zeroTime;
           }
         }
         if (range[0] !== undefined) {
-          if (zeroPosY < endY && endY <= nextPosY || zeroPosY > startY && startY >= nextPosY) {
-            range[1] = zeroSpeed !== nextSpeed ? nextTime : computeTime(nextSpeed, (zeroPosY > nextPosY ? startY : endY) - zeroPosY, zeroTime);
+          if (nextSpeed > 0 && endY <= nextPosY || nextSpeed < 0 && startY >= nextPosY) {
+            range[1] = nextTime;
             result.push(range);
             if (lineMonotonicity !== 2 /* swinging */) {
               return result;
@@ -2893,15 +2953,24 @@ class JudgeLine {
         }
       } else {
         if (range[0] === undefined) {
-          if (thisPosY < startY && startY <= nextPosY || thisPosY > endY && endY >= nextPosY) {
-            range[0] = thisSpeed !== nextSpeed ? thisTime : computeTime(thisSpeed, (thisPosY < nextPosY ? startY : endY) - thisPosY, thisTime);
-          } else if (startY <= thisPosY && thisPosY <= endY) {
+          if (thisSpeed > 0 && endY >= thisPosY && startY < nextPosY) {
+            range[0] = thisSpeed !== nextSpeed ? thisTime : computeTime(thisSpeed, startY - thisPosY, thisTime);
+          } else if (thisSpeed < 0 && startY <= thisPosY && endY > nextPosY) {
+            range[0] = thisSpeed !== nextSpeed ? thisTime : computeTime(thisSpeed, endY - thisPosY, thisTime);
+          } else if (thisSpeed === 0 && startY <= thisPosY && thisPosY <= endY) {
             range[0] = thisTime;
           }
         }
         if (range[0] !== undefined) {
-          if (thisPosY < endY && endY <= nextPosY || thisPosY > startY && startY >= nextPosY) {
-            range[1] = thisSpeed !== nextSpeed ? nextTime : computeTime(thisSpeed, (thisPosY > nextPosY ? startY : endY) - thisPosY, thisTime);
+          if (thisSpeed > 0 && endY <= nextPosY) {
+            range[1] = thisSpeed !== nextSpeed ? nextTime : computeTime(thisSpeed, endY - thisPosY, thisTime);
+            result.push(range);
+            if (lineMonotonicity !== 2 /* swinging */) {
+              return result;
+            }
+            range = [undefined, undefined];
+          } else if (thisSpeed < 0 && startY >= thisPosY) {
+            range[1] = thisSpeed !== nextSpeed ? nextTime : computeTime(thisSpeed, startY - thisPosY, thisTime);
             result.push(range);
             if (lineMonotonicity !== 2 /* swinging */) {
               return result;
@@ -2934,6 +3003,18 @@ class JudgeLine {
     }
     return current;
   }
+  getStackedValueBySeconds(type, beats, seconds, timeCalculator, usePrev = false) {
+    const length = this.eventLayers.length;
+    let current = 0;
+    for (let index = 0;index < length; index++) {
+      const layer = this.eventLayers[index];
+      if (!layer || !layer[type]) {
+        break;
+      }
+      current += layer[type].getValueAtBySecs(beats, seconds, timeCalculator, usePrev);
+    }
+    return current;
+  }
   getNNList(speed, yOffset, isHold, initsJump) {
     const lists = isHold ? this.hnLists : this.nnLists;
     const medianYOffset = getRangeMedian(yOffset);
@@ -3190,6 +3271,9 @@ class TimeCalculator {
   duration;
   constructor() {}
   initSequence() {
+    if (!this.bpmList || !this.duration) {
+      throw new Error("TimeCalculator: bpmList and duration must be set before initSequence");
+    }
     const bpmList = this.bpmList;
     this.bpmSequence = new BPMSequence(bpmList, this.duration);
   }
@@ -3211,7 +3295,7 @@ class TimeCalculator {
   }
 }
 // src/version.ts
-var VERSION = 212;
+var VERSION = 213;
 var SCHEMA = "https://cdn.jsdelivr.net/npm/kipphi@2.1.0/chartType2.schema.json";
 
 // src/chart.ts
@@ -3251,7 +3335,7 @@ class Chart {
   }
   static fromRPEJSON(data, duration) {
     const chart = new Chart;
-    chart.judgeLineGroups = data.judgeLineGroup.map((group) => new JudgeLineGroup(group));
+    chart.judgeLineGroups = (data.judgeLineGroup || ["Default"]).map((group) => new JudgeLineGroup(group));
     chart.name = data.META.name;
     chart.level = data.META.level;
     chart.offset = data.META.offset;
@@ -3342,6 +3426,13 @@ class Chart {
       }
       chart.templateEasingLib.implement(easingData.name, sequence);
     }
+    for (let i = 0;i < len; i++) {
+      const easingData = templateEasings[i];
+      const sequence = chart.sequenceMap.get(easingData.content);
+      if (sequence.hasReferenceTo(sequence)) {
+        throw err.TEMPLATE_EASING_CIRCULAR_REFERENCE(easingData.name);
+      }
+    }
     chart.templateEasingLib.check();
     for (const lineData of data.orphanLines) {
       const line = JudgeLine.fromKPAJSON(data.version, chart, lineData.id, lineData, chart.templateEasingLib, chart.timeCalculator);
@@ -4156,6 +4247,13 @@ class EventNodeEvaluatorChangeOperation extends Operation {
     this.node = node;
     this.value = value;
     this.originalValue = this.node.evaluator;
+    const seq = node.parentSeq;
+    if (seq.type === 5 /* easing */ && value instanceof EasedEvaluator && value.easing instanceof TemplateEasing) {
+      const circular = TemplateEasing.checkCircularReference(seq, value.easing);
+      if (circular) {
+        throw err.TEMPLATE_EASING_CIRCULAR_REFERENCE(value.easing.name);
+      }
+    }
   }
   do() {
     this.node.evaluator = this.value;
@@ -5194,14 +5292,34 @@ class RPEChartCompiler {
   chart;
   sequenceMap = new Map;
   interpolationStep = [0, 1, 16];
+  deletesEmptyLines = true;
   constructor(chart2) {
     this.chart = chart2;
   }
   compileChart() {
-    console.time("compileChart");
     const chart2 = this.chart;
     const judgeLineGroups = chart2.judgeLineGroups.map((group) => group.name);
-    const judgeLineList = chart2.judgeLines.map((line2) => this.compileJudgeLine(line2));
+    const filter = this.deletesEmptyLines ? (line2) => {
+      return line2.nnLists.size > 0 || line2.hnLists.size > 0 || line2.eventLayers.length > 0 || ["moveX", "moveY", "rotate", "alpha"].some((evType) => {
+        const seq = line2.eventLayers[0][evType];
+        let node = seq.head.next;
+        for (let i = 0;i < 2; i++) {
+          const endNode = node.next;
+          if (node.value !== 0) {
+            return true;
+          }
+          if (endNode.type === 1 /* TAIL */) {
+            return false;
+          }
+          if (endNode.value !== 0) {
+            return true;
+          }
+          node = endNode.next;
+        }
+        return true;
+      });
+    } : () => true;
+    const judgeLineList = chart2.judgeLines.filter(filter).map((line2) => this.compileJudgeLine(line2));
     const BPMList = chart2.timeCalculator.dump();
     const META = {
       RPEVersion: 1,
@@ -5240,7 +5358,6 @@ class RPEChartCompiler {
         lineData.attachUI = uiName;
       }
     }
-    console.timeEnd("compileChart");
     return {
       BPMList,
       META,
@@ -5248,8 +5365,8 @@ class RPEChartCompiler {
       judgeLineGroup: judgeLineGroups,
       multiLineString: "",
       multiScale: 1,
-      chartTime: chart2.rpeChartingTime * 60,
-      kpaChartTime: chart2.chartingTime
+      chartTime: chart2.rpeChartingSeconds,
+      kpaChartTime: chart2.chartingSeconds
     };
   }
   compileJudgeLine(judgeLine) {
@@ -5296,7 +5413,7 @@ class RPEChartCompiler {
       bezierPoints: innerEasing instanceof BezierEasing ? [innerEasing.cp1[0], innerEasing.cp1[1], innerEasing.cp2[0], innerEasing.cp2[1]] : [0, 0, 0, 0],
       easingLeft: isSegmented ? easing.left : 0,
       easingRight: isSegmented ? easing.right : 1,
-      easingType: easing instanceof NormalEasing ? easing.rpeId ?? 1 : null,
+      easingType: isSegmented ? easing.easing instanceof NormalEasing ? easing.easing.rpeId ?? 1 : null : easing instanceof NormalEasing ? easing.rpeId ?? 1 : null,
       end,
       endTime: endNode.time,
       linkgroup: 0,