kipphi 2.1.3-beta.1 → 2.1.3

package/chart.ts

@@ -10,6 +10,7 @@ import {
     NormalEasing,
     rpeEasingArray,
     SegmentedEasing,
+    TemplateEasing,
     TemplateEasingLib,
 } from "./easing";
 
@@ -149,6 +150,11 @@ export class Chart {
     /** 难度等级显示绑定的判定线 */
     levelAttach:       JudgeLine | null = null;
 
+    /** 仅用于构造时检查 
+     * @internal
+     */
+    segmentedTemplates: Map<(SegmentedEasing & { easing: TemplateEasing}), [string, TimeT]> = new Map();
+
     constructor() {}
     
     /**
@@ -286,6 +292,9 @@ export class Chart {
         for (let i = 0; i < len; i++) {
             const easingData = templateEasings[i];
             const sequence = chart.sequenceMap.get(easingData.content);
+            if (!sequence) {
+                continue; // 后面check的时候会错误处理
+            }
             if (sequence.type !== EventType.easing) {
                 throw err.CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS(easingData.name);
             }
@@ -303,7 +312,10 @@ export class Chart {
             }
         }
 
-        chart.templateEasingLib.check()
+        chart.templateEasingLib.check();
+
+        chart.checkSegmentedTemplates();
+
         for (const lineData of data.orphanLines) {
             const line: JudgeLine = JudgeLine.fromKPAJSON(data.version, chart, lineData.id, lineData, chart.templateEasingLib, chart.timeCalculator)
             chart.orphanLines.push(line)
@@ -727,6 +739,25 @@ export class Chart {
         
     }
     */
+    checkErrors() {
+        KPAError.flush();
+        for (const [_, seq] of this.sequenceMap) {
+            seq.checkErrors();
+        }
+    }
+    /**
+     * 用于构造谱面时检查
+     */
+    protected checkSegmentedTemplates() {
+        for (const [easing, [pos, time]] of this.segmentedTemplates) {
+            const inner = easing.easing;
+            if (inner.getValue(easing.left) === inner.getValue(easing.right)) {
+                err.EASING_DELTA_CANNOT_BE_ZERO(pos, time).warn();
+            }
+        }
+        this.segmentedTemplates.clear();
+        // 查完就清除，不再需要
+    }
 }
 
 /**

package/env.ts

@@ -74,6 +74,7 @@ export enum ERROR_IDS {
     NODES_NOT_BELONG_TO_SAME_SEQUENCE =             EASING     | INVALID_USAGE | 2,
     NODES_HAS_ZERO_DELTA =                          EASING     | INVALID_USAGE | 3,
     TEMPLATE_EASING_CIRCULAR_REFERENCE =            EASING     | INVALID_USAGE | 4,
+    EASING_DELTA_CANNOT_BE_ZERO =                   EASING     | INVALID_USAGE | 5,
 
     CANNOT_DIVIDE_EXPRESSION_EVALUATOR =            EVALUATOR  | INVALID_USAGE | 0,
     MISSING_MACRO_EVALUATOR_KEY =                   EVALUATOR  | INVALID_DATA  | 0,
@@ -184,6 +185,8 @@ export const ERRORS = {
         `Hold should have a duration.`,
     TEMPLATE_EASING_CIRCULAR_REFERENCE: (temEasName: string) =>
         `Template Easing '${temEasName}' has circular reference`,
+    EASING_DELTA_CANNOT_BE_ZERO: (seqName: string, time: TimeT) =>
+        `Easing delta cannot be zero. (at ${seqName}, ${toTimeString(time)}`,
 } satisfies Record<keyof typeof ERROR_IDS, (...args: any[]) => string>
 
 type EnumKeys<E extends Record<string, string | number>> = E[keyof E];

package/event.ts

@@ -391,7 +391,7 @@ export class EventStartNode<VT extends EventValueESType = number> extends EventN
         return super.clone(offset) as EventStartNode<VT>;
     };
     clonePair(offset: TimeT): EventStartNode<VT> {
-        const endNode = this.previous.type !== NodeType.HEAD ? this.previous.clone(offset) : new EventEndNode(this.time, this.value);
+        const endNode = this.previous.type !== NodeType.HEAD ? this.previous.clone(offset) : null;
         const startNode = this.clone(offset);
         EventNode.connect(endNode, startNode);
         return startNode;
@@ -640,6 +640,12 @@ export class EventNodeSequence<VT extends EventValueESType = number> { // 泛型
         for (let index = 0; index < length; index++) {
             const event = data[index];
             const [start, end] = chart.createEventFromData<VT>(event, valueType, `${pos}.events[${index}]`);
+
+            // 收集被截的模板缓动
+            const evaluator = start.evaluator;
+            if (evaluator instanceof EasedEvaluator && evaluator.easing instanceof SegmentedEasing && evaluator.easing.easing instanceof TemplateEasing) {
+                chart.segmentedTemplates.set(evaluator.easing as any, [pos, start.time]);
+            }
             // 从前面复制了，复用性减一
             // KPA2没有更改RPE的按事件存储的机制。
             if (TC.lt(event.startTime, lastEndTime)) { // event.startTime < lastEndTime
@@ -956,15 +962,33 @@ export class EventNodeSequence<VT extends EventValueESType = number> { // 泛型
         }
 
         let lastEnd: EventEndNode<VT> = endNode;
+        currentNode = endNode.next;
         while (true) {
+            const evaluator = currentNode.evaluator;
+            if (this.type === EventType.easing && evaluator instanceof EasedEvaluator && evaluator.easing instanceof TemplateEasing) {
+                if (TemplateEasing.checkCircularReference(this as EventNodeSequence, evaluator.easing)) {
+                    err.TEMPLATE_EASING_CIRCULAR_REFERENCE(this.id).warn();
+                }
+            }
+            if (evaluator instanceof EasedEvaluator && evaluator.easing instanceof SegmentedEasing) {
+                const easing = evaluator.easing;
+                const inner = easing.easing;
+                if (inner.getValue(easing.left) === inner.getValue(easing.right)) {
+                    err.EASING_DELTA_CANNOT_BE_ZERO(this.id, currentNode.time).warn();
+                }
+            }
             const endNode = currentNode.next;
             if (endNode.type === NodeType.TAIL) {
                 break;
             }
+            if (!TC.gt(endNode.time, currentNode.time)) {
+                err.EVENT_NODE_TIME_NOT_INCREMENTAL(`${this.id}, ${currentNode.time}`).warn();
+            }
             if (TC.ne(lastEnd.time, currentNode.time)) {
                 err.EVENT_NODE_NOT_DENSE(`${this.id}, ${currentNode.time}`).warn();
             }
             currentNode = currentNode.next.next;
+            lastEnd = endNode;
         }
     }
     hasReferenceTo(this: EventNodeSequence<number>, seq: EventNodeSequence<number>) {

package/index.d.ts

@@ -1081,133 +1081,6 @@ declare module "judgeline" {
         cachedFloorPositions: Float64Array;
         computeCurrentFloorPosition(beats: number, timeCalculator: TimeCalculator): void;
         getRelativeFloorPositionAt(beats: number, timeCalculator: TimeCalculator): number;
-        /**
-         * 通过速度序列的FloorPosition反解出一个时间范围。
-         *
-         * KPA内核代码中最大的一坨史山，没有之一。
-         *
-         * 谱面渲染时最耗时的函数
-         *
-         * startY and endY must not be negative
-         * @param beats
-         * @param timeCalculator
-         * @param startY
-         * @param endY
-         * @returns
-         * /
-        computeTimeRange(beats: number, timeCalculator: TimeCalculator , startY: number, endY: number): [number, number][] {
-            //return [[0, Infinity]]
-            //*
-            // 提取所有有变化的时间点
-            let times: number[] = [];
-            const result: [number, number][] = [];
-            for (const eventLayer of this.eventLayers) {
-                const sequence = eventLayer?.speed;
-                if (!sequence) {
-                    continue;
-                }
-                let node: EventStartNode = sequence.getNodeAt(beats);
-                let endNode: EventEndNode | EventNodeLike<NodeType.TAIL>
-                while (true) {
-                    times.push(TC.toBeats(node.time))
-                    if ((endNode = node.next).type === NodeType.TAIL) {
-                        break;
-                    }
-    
-                    node = endNode.next
-                }
-            }
-            times = [...new Set(times)].sort((a, b) => a - b)
-            const len = times.length;
-            let nextTime = times[0]
-            let nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
-            let nextSpeed = this.getStackedValue("speed", nextTime, true)
-            let range: [number, number] = [undefined, undefined];
-            // console.log(times)
-            const computeTime = (speed: number, currentPos: number, fore: number) => timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
-            for (let i = 0; i < len - 1;) {
-                const thisTime = nextTime;
-                const thisPosY = nextPosY;
-                let thisSpeed = this.getStackedValue("speed", thisTime);
-                if (Math.abs(thisSpeed) < 1e-8) {
-                    thisSpeed = 0; // 不这样做可能导致下面异号判断为真从而死循环
-                }
-                nextTime = times[i + 1]
-                nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator);
-                nextSpeed = this.getStackedValue("speed", nextTime, true)
-                // console.log(thisSpeed, nextSpeed, thisSpeed * nextSpeed < 0, i, [...result])
-                if (thisSpeed * nextSpeed < 0) { // 有变号零点，再次切断，保证处理的每个区间单调性
-                    //debugger;
-                    nextTime = (nextTime - thisTime) * (0 - thisSpeed) / (nextSpeed - thisSpeed) + thisTime;
-                    nextSpeed = 0
-                    nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
-                    //debugger
-                } else {
-                    // console.log("i++")
-                    i++
-                }
-                if (range[0] === undefined) {
-                    // 变速区间直接全部囊括，匀速要算一下，因为好算
-                    /*
-                    设两个时间点的位置为a,b
-                    开始结束点为s,e
-                    选中小段一部分在区间内：
-                    a < s <= b
-                    或a > e >= b
-                    全部在区间内
-                    s <= a <= b
-                    * /
-                    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) {
-                        range[0] = thisTime;
-                    }
-                }
-                // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
-                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)
-                        result.push(range)
-                        range = [undefined, undefined];
-                    }
-                }
-            }
-            const thisPosY = nextPosY;
-            const thisTime = nextTime;
-            const thisSpeed = this.getStackedValue("speed", thisTime);
-            const inf = thisSpeed > 0 ? Infinity : (thisSpeed < 0 ? -Infinity : thisPosY)
-            if (range[0] === undefined) {
-                // 变速区间直接全部囊括，匀速要算一下，因为好算
-                if (thisPosY < startY && startY <= inf || thisPosY >= endY && endY > inf) {
-                    range[0] = computeTime(
-                        thisSpeed,
-                        (thisPosY < inf ? startY : endY) - thisPosY,
-                        thisTime)
-                } else if (thisSpeed === 0) {
-                    range[0] = 0;
-                }
-            }
-            // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
-            if (range[0] !== undefined) {
-                if (thisPosY < endY && endY <= inf || thisPosY >= startY && startY > inf) {
-                    range[1] = computeTime(
-                        thisSpeed,
-                        (thisPosY > inf ? startY : endY) - thisPosY,
-                        thisTime)
-                    result.push(range)
-                } else if (thisSpeed === 0) {
-                    range[1] = Infinity;
-                    result.push(range)
-                }
-            }
-            return result;
-            //* /
-        }*/
         /**
           * 通过速度序列的FloorPosition反解出一个时间范围。
           *
@@ -1697,7 +1570,7 @@ declare module "easing" {
 }
 declare module "chart" {
     import { TimeCalculator } from "bpm";
-    import { Easing, TemplateEasingLib } from "easing";
+    import { Easing, SegmentedEasing, TemplateEasing, TemplateEasingLib } from "easing";
     import { EventNodeSequence, EventStartNode, EventEndNode, EventNode } from "event";
     import { JudgeLine } from "judgeline";
     import { NNNList, NNNode } from "note";
@@ -1765,6 +1638,12 @@ declare module "chart" {
         nameAttach: JudgeLine | null;
         /** 难度等级显示绑定的判定线 */
         levelAttach: JudgeLine | null;
+        /** 仅用于构造时检查
+         * @internal
+         */
+        segmentedTemplates: Map<(SegmentedEasing & {
+            easing: TemplateEasing;
+        }), [string, TimeT]>;
         constructor();
         /**
          * 获取有效节拍数
@@ -1898,6 +1777,11 @@ declare module "chart" {
         bindTimeMacro(node: EventStartNode<any>, macroData: MacroData, pos: string): any;
         bindValueMacro(node: EventNode<any>, macroData: MacroData, pos: string): any;
         linkMacro(node: EventNode<EventValueESType>, linkData: MacroLink, pos: string): any;
+        checkErrors(): void;
+        /**
+         * 用于构造谱面时检查
+         */
+        protected checkSegmentedTemplates(): void;
     }
     /**
      * 表示一组判定线的容器
@@ -2262,6 +2146,7 @@ declare module "env" {
         NODES_NOT_BELONG_TO_SAME_SEQUENCE = 2610,
         NODES_HAS_ZERO_DELTA = 2611,
         TEMPLATE_EASING_CIRCULAR_REFERENCE = 2612,
+        EASING_DELTA_CANNOT_BE_ZERO = 2613,
         CANNOT_DIVIDE_EXPRESSION_EVALUATOR = 2352,
         MISSING_MACRO_EVALUATOR_KEY = 2336,
         MACRO_EVALUATOR_NOT_FOUND = 2337,
@@ -2313,6 +2198,7 @@ declare module "env" {
         EVENT_NODE_NOT_DENSE: (pos: string) => string;
         HOLD_HAS_NO_DURATION: () => string;
         TEMPLATE_EASING_CIRCULAR_REFERENCE: (temEasName: string) => string;
+        EASING_DELTA_CANNOT_BE_ZERO: (seqName: string, time: TimeT) => string;
     };
     interface ErrorMap extends Record<keyof typeof ERROR_IDS, Array<any>> {
         EVENT_NODE_NOT_DENSE: [EventNode];
@@ -2379,6 +2265,7 @@ declare module "env" {
             EVENT_NODE_NOT_DENSE: (pos: string) => KPAError<ERROR_IDS.EVENT_NODE_NOT_DENSE>;
             HOLD_HAS_NO_DURATION: () => KPAError<ERROR_IDS.HOLD_HAS_NO_DURATION>;
             TEMPLATE_EASING_CIRCULAR_REFERENCE: (temEasName: string) => KPAError<ERROR_IDS.TEMPLATE_EASING_CIRCULAR_REFERENCE>;
+            EASING_DELTA_CANNOT_BE_ZERO: (seqName: string, time: TimeT) => KPAError<ERROR_IDS.EASING_DELTA_CANNOT_BE_ZERO>;
         };
         freeze(): void;
     };
@@ -2594,6 +2481,9 @@ declare module "operation/event" {
         overlapping: boolean;
         constructor(node: EventStartNode<VT>, targetPrevious: EventStartNode<VT>, updatesFP?: boolean);
     }
+    export class EventNodePairAutoInsertOperation<VT extends EventValueESType> extends EventNodePairInsertOperation<VT> {
+        constructor(node: EventStartNode<VT>, parentSeq: EventNodeSequence<VT>, updatesFP?: boolean);
+    }
     export class EventNodeValueChangeOperation<VT extends EventValueESType> extends Operation {
         updatesEditor: boolean;
         node: EventNode<VT>;
@@ -3068,7 +2958,7 @@ declare module "rpeChartCompiler" {
     import type { Chart } from "chart";
     import { type TimeT, type ChartDataRPE, type JudgeLineDataRPE, type EventDataRPELike, type NoteDataRPE, type EventValueESType } from "chartTypes";
     import { type EasedEvaluatorOfType } from "evaluator";
-    import { EventEndNode, EventNodeSequence, EventStartNode } from "event";
+    import { EventEndNode, EventNodeSequence, EventStartNode, SpeedENS } from "event";
     import type { JudgeLine } from "judgeline";
     import type { NNList, HNList } from "note";
     /**
@@ -3086,6 +2976,7 @@ declare module "rpeChartCompiler" {
             evaluator: EasedEvaluatorOfType<VT>;
         }, getValue: (node: EventStartNode<VT> | EventEndNode<VT>) => VT): EventDataRPELike<VT>;
         dumpEventNodeSequence<VT extends EventValueESType>(sequence: EventNodeSequence<VT>): EventDataRPELike<VT>[];
+        dumpSpeedENS(seq: SpeedENS): EventDataRPELike<number>[];
         compileNNLists(nnLists: NNList[], hnLists: HNList[]): NoteDataRPE[];
         /**
          * 倒序转换为数组

package/index.js

@@ -24,6 +24,61 @@ var checkType = (value, type) => {
   if (Array.isArray(type)) {
     return Array.isArray(value) && value.length === type.length && type.every((t, i) => checkType(value[i], t));
   } else if (typeof type === "string") {
+    if (type.startsWith("int")) {
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        return false;
+      }
+      const match = type.match(/^int(\(|\[)(\-?\d+),(\-?\d+|\+)(\)|\])$/);
+      if (!match) {
+        return true;
+      }
+      const [, leftBrac, left, right, rightBrac] = match;
+      if (!leftBrac) {
+        return true;
+      }
+      const leftN = left === "-" ? -Infinity : Number(left);
+      const rightN = right === "+" ? Infinity : Number(right);
+      if (value < leftN) {
+        return false;
+      }
+      if (leftBrac === "(" && value === leftN) {
+        return false;
+      }
+      if (value > rightN) {
+        return false;
+      }
+      if (rightBrac === ")" && value === rightN) {
+        return false;
+      }
+      return true;
+    } else if (type.startsWith("number")) {
+      if (typeof value !== "number") {
+        return false;
+      }
+      const match = type.match(/^number(\(|\[)(\-?\d+),(\-?\d+|\+)(\)|\])$/);
+      if (!match) {
+        return true;
+      }
+      const [, leftBrac, left, right, rightBrac] = match;
+      if (!leftBrac) {
+        return true;
+      }
+      const leftN = left === "-" ? -Infinity : Number(left);
+      const rightN = right === "+" ? Infinity : Number(right);
+      if (value < leftN) {
+        return false;
+      }
+      if (leftBrac === "(" && value === leftN) {
+        return false;
+      }
+      if (value > rightN) {
+        return false;
+      }
+      if (rightBrac === ")" && value === rightN) {
+        return false;
+      }
+      return true;
+    }
     return typeof value === type;
   } else {
     return value instanceof type;
@@ -79,6 +134,7 @@ var ERROR_IDS;
   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["EASING_DELTA_CANNOT_BE_ZERO"] = EASING | INVALID_USAGE | 5] = "EASING_DELTA_CANNOT_BE_ZERO";
   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";
@@ -129,7 +185,8 @@ var ERRORS = {
   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.`,
-  TEMPLATE_EASING_CIRCULAR_REFERENCE: (temEasName) => `Template Easing '${temEasName}' has circular reference`
+  TEMPLATE_EASING_CIRCULAR_REFERENCE: (temEasName) => `Template Easing '${temEasName}' has circular reference`,
+  EASING_DELTA_CANNOT_BE_ZERO: (seqName, time) => `Easing delta cannot be zero. (at ${seqName}, ${toTimeString(time)}`
 };
 
 class KPAError extends Error {
@@ -1643,7 +1700,7 @@ class EventStartNode extends EventNode {
     return super.clone(offset);
   }
   clonePair(offset) {
-    const endNode = this.previous.type !== 0 /* HEAD */ ? this.previous.clone(offset) : new EventEndNode(this.time, this.value);
+    const endNode = this.previous.type !== 0 /* HEAD */ ? this.previous.clone(offset) : null;
     const startNode = this.clone(offset);
     EventNode.connect(endNode, startNode);
     return startNode;
@@ -1771,6 +1828,10 @@ class EventNodeSequence {
     for (let index = 0;index < length; index++) {
       const event = data[index];
       const [start, end] = chart.createEventFromData(event, valueType, `${pos}.events[${index}]`);
+      const evaluator = start.evaluator;
+      if (evaluator instanceof EasedEvaluator && evaluator.easing instanceof SegmentedEasing && evaluator.easing.easing instanceof TemplateEasing) {
+        chart.segmentedTemplates.set(evaluator.easing, [pos, start.time]);
+      }
       if (TC2.lt(event.startTime, lastEndTime)) {
         err.EVENT_NODE_TIME_NOT_INCREMENTAL(`${pos}.events[${index}] and the previous`).warn();
       }
@@ -2011,15 +2072,33 @@ class EventNodeSequence {
       return;
     }
     let lastEnd = endNode;
+    currentNode = endNode.next;
     while (true) {
+      const evaluator = currentNode.evaluator;
+      if (this.type === 5 /* easing */ && evaluator instanceof EasedEvaluator && evaluator.easing instanceof TemplateEasing) {
+        if (TemplateEasing.checkCircularReference(this, evaluator.easing)) {
+          err.TEMPLATE_EASING_CIRCULAR_REFERENCE(this.id).warn();
+        }
+      }
+      if (evaluator instanceof EasedEvaluator && evaluator.easing instanceof SegmentedEasing) {
+        const easing = evaluator.easing;
+        const inner = easing.easing;
+        if (inner.getValue(easing.left) === inner.getValue(easing.right)) {
+          err.EASING_DELTA_CANNOT_BE_ZERO(this.id, currentNode.time).warn();
+        }
+      }
       const endNode2 = currentNode.next;
       if (endNode2.type === 1 /* TAIL */) {
         break;
       }
+      if (!TC2.gt(endNode2.time, currentNode.time)) {
+        err.EVENT_NODE_TIME_NOT_INCREMENTAL(`${this.id}, ${currentNode.time}`).warn();
+      }
       if (TC2.ne(lastEnd.time, currentNode.time)) {
         err.EVENT_NODE_NOT_DENSE(`${this.id}, ${currentNode.time}`).warn();
       }
       currentNode = currentNode.next.next;
+      lastEnd = endNode2;
     }
   }
   hasReferenceTo(seq) {
@@ -2137,8 +2216,8 @@ class Note {
       visibleTime,
       yOffset: this.yOffset / this.speed,
       speed: this.speed,
-      tint: this.tint !== undefined ? hex2rgb(this.tint) : undefined,
-      tintHitEffects: this.tint !== undefined ? hex2rgb(this.tintHitEffects) : undefined,
+      tint: this.tint !== undefined && this.tint !== 16777215 ? hex2rgb(this.tint) : undefined,
+      tintHitEffects: this.tintHitEffects !== undefined && this.tintHitEffects !== 16777215 ? hex2rgb(this.tintHitEffects) : undefined,
       judgeArea: this.judgeSize
     };
   }
@@ -2156,8 +2235,8 @@ class Note {
       yOffset: this.yOffset / this.speed,
       absoluteYOffset: this.yOffset,
       speed: this.speed,
-      tint: this.tint !== undefined ? hex2rgb(this.tint) : undefined,
-      tintHitEffects: this.tint !== undefined ? hex2rgb(this.tintHitEffects) : undefined,
+      tint: this.tint !== undefined && this.tint !== 16777215 ? hex2rgb(this.tint) : undefined,
+      tintHitEffects: this.tintHitEffects !== undefined && this.tintHitEffects !== 16777215 ? hex2rgb(this.tintHitEffects) : undefined,
       judgeSize: this.judgeSize && this.judgeSize !== 1 ? this.judgeSize : undefined
     };
   }
@@ -2256,7 +2335,12 @@ class NoteNode extends NoteNodeLike {
     }
   }
   remove(note) {
-    this.notes.splice(this.notes.indexOf(note), 1);
+    const index = this.notes.indexOf(note);
+    if (index === -1) {
+      console.warn("Note not found in this node!");
+      return;
+    }
+    this.notes.splice(index, 1);
     note.parentNode = null;
   }
   static disconnect(note1, note2) {
@@ -3327,6 +3411,7 @@ class Chart {
   scoreAttach = null;
   nameAttach = null;
   levelAttach = null;
+  segmentedTemplates = new Map;
   constructor() {}
   getEffectiveBeats() {
     const effectiveBeats = this.timeCalculator.secondsToBeats(this.duration);
@@ -3418,6 +3503,9 @@ class Chart {
     for (let i = 0;i < len; i++) {
       const easingData = templateEasings[i];
       const sequence = chart.sequenceMap.get(easingData.content);
+      if (!sequence) {
+        continue;
+      }
       if (sequence.type !== 5 /* easing */) {
         throw err.CANNOT_IMPLEMENT_TEMEAS_WITH_NON_EASING_ENS(easingData.name);
       }
@@ -3434,6 +3522,7 @@ class Chart {
       }
     }
     chart.templateEasingLib.check();
+    chart.checkSegmentedTemplates();
     for (const lineData of data.orphanLines) {
       const line = JudgeLine.fromKPAJSON(data.version, chart, lineData.id, lineData, chart.templateEasingLib, chart.timeCalculator);
       chart.orphanLines.push(line);
@@ -3729,6 +3818,21 @@ class Chart {
     }
     return null;
   }
+  checkErrors() {
+    KPAError.flush();
+    for (const [_, seq] of this.sequenceMap) {
+      seq.checkErrors();
+    }
+  }
+  checkSegmentedTemplates() {
+    for (const [easing, [pos, time]] of this.segmentedTemplates) {
+      const inner = easing.easing;
+      if (inner.getValue(easing.left) === inner.getValue(easing.right)) {
+        err.EASING_DELTA_CANNOT_BE_ZERO(pos, time).warn();
+      }
+    }
+    this.segmentedTemplates.clear();
+  }
 }
 
 class JudgeLineGroup {
@@ -3813,6 +3917,7 @@ __export(exports_operation, {
   EventNodePairRemoveOperation: () => EventNodePairRemoveOperation,
   EventNodePairInsertOrOverwriteOperation: () => EventNodePairInsertOrOverwriteOperation,
   EventNodePairInsertOperation: () => EventNodePairInsertOperation,
+  EventNodePairAutoInsertOperation: () => EventNodePairAutoInsertOperation,
   EventNodeMacroTimeReevaluateOperation: () => EventNodeMacroTimeReevaluateOperation,
   EventNodeEvaluatorChangeOperation: () => EventNodeEvaluatorChangeOperation,
   EventInterpolationOperation: () => EventInterpolationOperation,
@@ -4148,6 +4253,12 @@ class EventNodePairInsertOrOverwriteOperation extends UnionOperation {
   }
 }
 
+class EventNodePairAutoInsertOperation extends EventNodePairInsertOperation {
+  constructor(node, parentSeq, updatesFP = true) {
+    super(node, parentSeq.getNodeAt(TC2.toBeats(node.time)), updatesFP);
+  }
+}
+
 class EventNodeValueChangeOperation extends Operation {
   updatesEditor = true;
   node;
@@ -4360,6 +4471,9 @@ class EncapsuleOperation extends ComplexOperation {
     const sequence = easing.eventNodeSequence;
     sequence.effectiveBeats = TC2.toBeats(nodeArray[nodeArray.length - 1].time);
     new MultiNodeAddOperation(nodeArray, sequence).do();
+    const first = sequence.head.next;
+    first.evaluator = nodeArray[0].evaluator;
+    first.value = nodeArray[0].value;
     return new EncapsuleOperation(oldArray, easing);
   }
 }
@@ -5299,8 +5413,20 @@ class RPEChartCompiler {
   compileChart() {
     const chart2 = this.chart;
     const judgeLineGroups = chart2.judgeLineGroups.map((group) => group.name);
+    const hasNotes = (nnList) => {
+      let node = nnList.head.next;
+      while (true) {
+        if (node.type === 1 /* TAIL */) {
+          return false;
+        }
+        if (node.notes.length > 0) {
+          return true;
+        }
+        node = node.next;
+      }
+    };
     const filter = this.deletesEmptyLines ? (line2) => {
-      return line2.nnLists.size > 0 || line2.hnLists.size > 0 || line2.eventLayers.length > 0 || ["moveX", "moveY", "rotate", "alpha"].some((evType) => {
+      return [...line2.nnLists].some(([_, l]) => hasNotes(l)) || [...line2.hnLists].some(([_, l]) => hasNotes(l)) || 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++) {
@@ -5383,7 +5509,7 @@ class RPEChartCompiler {
         moveYEvents: layer.moveY ? this.dumpEventNodeSequence(layer.moveY) : undefined,
         rotateEvents: layer.rotate ? this.dumpEventNodeSequence(layer.rotate) : undefined,
         alphaEvents: layer.alpha ? this.dumpEventNodeSequence(layer.alpha) : undefined,
-        speedEvents: index === 0 ? this.dumpEventNodeSequence(judgeLine.speedSequence) : undefined
+        speedEvents: index === 0 ? this.dumpSpeedENS(judgeLine.speedSequence) : undefined
       })),
       extended: {
         scaleXEvents: judgeLine.extendedLayer.scaleX ? this.dumpEventNodeSequence(judgeLine.extendedLayer.scaleX) : undefined,
@@ -5481,6 +5607,32 @@ class RPEChartCompiler {
     nodes.push(this.compileEasedEvent(newStart, getValue));
     return nodes;
   }
+  dumpSpeedENS(seq) {
+    const ret = [];
+    let node = seq.head.next;
+    while (true) {
+      const end = node.next;
+      if (end.type === 1 /* TAIL */) {
+        break;
+      }
+      ret.push({
+        start: node.value,
+        end: end.value,
+        startTime: node.time,
+        endTime: end.time,
+        linkgroup: 0
+      });
+      node = end.next;
+    }
+    ret.push({
+      start: node.value,
+      end: node.value,
+      startTime: node.time,
+      endTime: TC2.vadd(node.time, [1, 0, 1]),
+      linkgroup: 0
+    });
+    return ret;
+  }
   compileNNLists(nnLists, hnLists) {
     const noteLists = nnLists.map((list) => this.nnListToArray(list));
     const holdLists = hnLists.map((list) => this.nnListToArray(list));
@@ -5564,8 +5716,8 @@ class RPEChartCompiler {
           srcStart = srcSeq.head.next.value;
           srcEnd = srcSeq.tail.previous.value;
           leftDividedNodeSrc = srcSeq.head.next;
-          rightDividedNodeSrc = srcSeq.tail.previous;
-          toStopAt = rightDividedNodeSrc;
+          rightDividedNodeSrc = srcSeq.tail.previous.previous.previous;
+          toStopAt = srcSeq.tail.previous;
           srcStartTime = srcSeq.head.next.time;
           srcTimeDelta = TC2.sub(srcSeq.tail.previous.time, srcStartTime);
         }
@@ -5612,13 +5764,13 @@ class RPEChartCompiler {
           if (rightDividedNodeSrc.evaluator instanceof ExpressionEvaluator) {
             throw err.CANNOT_DIVIDE_EXPRESSION_EVALUATOR(seq.id);
           } else {
-            first.evaluator = evaluator.deriveWithEasing(new SegmentedEasing(rightDividedNodeSrc.evaluator.easing, 0, newRight));
+            prev.evaluator = evaluator.deriveWithEasing(new SegmentedEasing(rightDividedNodeSrc.evaluator.easing, 0, newRight));
           }
         } else {
           if (rightDividedNodeSrc.evaluator instanceof ExpressionEvaluator) {
             throw err.CANNOT_DIVIDE_EXPRESSION_EVALUATOR(seq.id);
           } else {
-            first.evaluator = evaluator.deriveWithEasing(rightDividedNodeSrc.evaluator.easing);
+            prev.evaluator = evaluator.deriveWithEasing(rightDividedNodeSrc.evaluator.easing);
           }
         }
         const endNode2 = currentNode.next.clone();

package/judgeline.ts

@@ -405,133 +405,6 @@ export class JudgeLine {
     getRelativeFloorPositionAt(beats: number, timeCalculator: TimeCalculator) {
         return this.speedSequence.getFloorPositionAt(beats, timeCalculator) - this.currentFloorPosition;
     }
-    /**
-     * 通过速度序列的FloorPosition反解出一个时间范围。
-     * 
-     * KPA内核代码中最大的一坨史山，没有之一。
-     * 
-     * 谱面渲染时最耗时的函数
-     * 
-     * startY and endY must not be negative
-     * @param beats 
-     * @param timeCalculator 
-     * @param startY 
-     * @param endY 
-     * @returns 
-     * /
-    computeTimeRange(beats: number, timeCalculator: TimeCalculator , startY: number, endY: number): [number, number][] {
-        //return [[0, Infinity]]
-        //*
-        // 提取所有有变化的时间点
-        let times: number[] = [];
-        const result: [number, number][] = [];
-        for (const eventLayer of this.eventLayers) {
-            const sequence = eventLayer?.speed;
-            if (!sequence) {
-                continue;
-            }
-            let node: EventStartNode = sequence.getNodeAt(beats);
-            let endNode: EventEndNode | EventNodeLike<NodeType.TAIL>
-            while (true) {
-                times.push(TC.toBeats(node.time))
-                if ((endNode = node.next).type === NodeType.TAIL) {
-                    break;
-                }
-
-                node = endNode.next
-            }
-        }
-        times = [...new Set(times)].sort((a, b) => a - b)
-        const len = times.length;
-        let nextTime = times[0]
-        let nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
-        let nextSpeed = this.getStackedValue("speed", nextTime, true)
-        let range: [number, number] = [undefined, undefined];
-        // console.log(times)
-        const computeTime = (speed: number, currentPos: number, fore: number) => timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
-        for (let i = 0; i < len - 1;) {
-            const thisTime = nextTime;
-            const thisPosY = nextPosY;
-            let thisSpeed = this.getStackedValue("speed", thisTime);
-            if (Math.abs(thisSpeed) < 1e-8) {
-                thisSpeed = 0; // 不这样做可能导致下面异号判断为真从而死循环
-            }
-            nextTime = times[i + 1]
-            nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator);
-            nextSpeed = this.getStackedValue("speed", nextTime, true)
-            // console.log(thisSpeed, nextSpeed, thisSpeed * nextSpeed < 0, i, [...result])
-            if (thisSpeed * nextSpeed < 0) { // 有变号零点，再次切断，保证处理的每个区间单调性
-                //debugger;
-                nextTime = (nextTime - thisTime) * (0 - thisSpeed) / (nextSpeed - thisSpeed) + thisTime;
-                nextSpeed = 0
-                nextPosY = this.getStackedFloorPosition(nextTime, timeCalculator)
-                //debugger
-            } else {
-                // console.log("i++")
-                i++
-            }
-            if (range[0] === undefined) {
-                // 变速区间直接全部囊括，匀速要算一下，因为好算
-                /*
-                设两个时间点的位置为a,b
-                开始结束点为s,e
-                选中小段一部分在区间内：
-                a < s <= b
-                或a > e >= b
-                全部在区间内
-                s <= a <= b
-                * /
-                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) {
-                    range[0] = thisTime;
-                }
-            }
-            // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
-            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)
-                    result.push(range)
-                    range = [undefined, undefined];
-                }
-            }
-        }
-        const thisPosY = nextPosY;
-        const thisTime = nextTime;
-        const thisSpeed = this.getStackedValue("speed", thisTime);
-        const inf = thisSpeed > 0 ? Infinity : (thisSpeed < 0 ? -Infinity : thisPosY)
-        if (range[0] === undefined) {
-            // 变速区间直接全部囊括，匀速要算一下，因为好算
-            if (thisPosY < startY && startY <= inf || thisPosY >= endY && endY > inf) {
-                range[0] = computeTime(
-                    thisSpeed,
-                    (thisPosY < inf ? startY : endY) - thisPosY,
-                    thisTime)
-            } else if (thisSpeed === 0) {
-                range[0] = 0;
-            }
-        }
-        // 要注意这里不能合成双分支if因为想要的Y片段可能在一个区间内
-        if (range[0] !== undefined) {
-            if (thisPosY < endY && endY <= inf || thisPosY >= startY && startY > inf) {
-                range[1] = computeTime(
-                    thisSpeed,
-                    (thisPosY > inf ? startY : endY) - thisPosY,
-                    thisTime)
-                result.push(range)
-            } else if (thisSpeed === 0) {
-                range[1] = Infinity;
-                result.push(range)
-            }
-        }
-        return result;
-        //* /
-    }*/
    /**
      * 通过速度序列的FloorPosition反解出一个时间范围。
      * 

package/note.ts

@@ -168,8 +168,8 @@ export class Note {
             visibleTime: visibleTime,
             yOffset: this.yOffset / this.speed,
             speed: this.speed,
-            tint: this.tint !== undefined ? hex2rgb(this.tint) : undefined,
-            tintHitEffects: this.tint !== undefined ? hex2rgb(this.tintHitEffects) : undefined,
+            tint: this.tint !== undefined && this.tint !== 0xffffff ? hex2rgb(this.tint) : undefined,
+            tintHitEffects: this.tintHitEffects !== undefined && this.tintHitEffects !== 0xffffff ? hex2rgb(this.tintHitEffects) : undefined,
             judgeArea: this.judgeSize
         }
     }
@@ -189,8 +189,8 @@ export class Note {
             /** 但是有历史包袱，所以加字段 */
             absoluteYOffset: this.yOffset,
             speed: this.speed,
-            tint: this.tint !== undefined ? hex2rgb(this.tint) : undefined,
-            tintHitEffects: this.tint !== undefined ? hex2rgb(this.tintHitEffects) : undefined,
+            tint: this.tint !== undefined && this.tint !== 0xffffff ? hex2rgb(this.tint) : undefined,
+            tintHitEffects: this.tintHitEffects !== undefined && this.tintHitEffects !== 0xffffff ? hex2rgb(this.tintHitEffects) : undefined,
             judgeSize: this.judgeSize && this.judgeSize !== 1.0 ? this.judgeSize : undefined,
         }
     }
@@ -307,7 +307,12 @@ export class NoteNode extends NoteNodeLike<NodeType.MIDDLE> {
         }
     }
     remove(note: Note) {
-        this.notes.splice(this.notes.indexOf(note), 1)
+        const index = this.notes.indexOf(note);
+        if (index === -1) {
+            console.warn("Note not found in this node!")
+            return;
+        }
+        this.notes.splice(index, 1)
         note.parentNode = null
     }
     static disconnect(note1: NNOrHead, note2: NNOrTail) {

package/operation/easy.ts

@@ -35,20 +35,21 @@ class Operable {
 
 
 class OperableNote extends Operable {
-    private _startTime: TimeT;
-    private _endTime: TimeT;
-    private _type: NoteType;
+    // @ts-expect-error 后面会赋值
+    private _fields: {
+        [x in NotePropName]: Note[x]
+    } = {};
     constructor(public target: Note, buffer: Operation[]) {
         super(buffer);
         if (target.parentNode === null) {
             throw new Error("Note has no parent node")
         }
-        this._startTime = target.startTime;
-        this._endTime = target.endTime;
-        this._type = target.type;
+        this._fields.startTime = target.startTime;
+        this._fields.endTime = target.endTime;
+        this._fields.type = target.type;
     }
     get startTime() {
-        return this._startTime;
+        return this._fields.startTime;
     }
     set startTime(userTime: Time) {
         const timeT = userTimeToTuple(userTime);
@@ -60,28 +61,28 @@ class OperableNote extends Operable {
         if (beats > nnList.effectiveBeats) {
             throw new Error("")
         }
-        this._startTime = timeT;
+        this._fields.startTime = timeT;
         const node = nnList.getNodeOf(timeT);
         this.buffer.push(NoteTimeChangeOperation.lazy(this.target, node));
     }
-    get endTime() { return this._endTime; }
+    get endTime() { return this._fields.endTime; }
     set endTime(userTime: Time) {
-        if (this._type !== NoteType.hold) {
+        if (this._fields.type !== NoteType.hold) {
             throw new Error("Note is not a hold note");
         }
         const timeT = userTimeToTuple(userTime);
-        if (!TC.gt(timeT, this._startTime)) {
+        if (!TC.gt(timeT, this._fields.startTime)) {
             throw new Error("");
         }
-        this._endTime = timeT;
+        this._fields.endTime = timeT;
         this.buffer.push(HoldEndTimeChangeOperation.lazy(this.target, timeT));
     }
-    get type() { return this._type; }
+    get type() { return this._fields.type; }
     set type(type: NoteType) {
-        if (this._type === type) {
+        if (this._fields.type === type) {
             return;
         }
-        this._type = type;
+        this._fields.type = type;
         this.buffer.push(NoteTypeChangeOperation.lazy(this.target, type));
     }
 }
@@ -109,8 +110,12 @@ interface OperableNote {
 
 for (const propName of ["above", "alpha", "positionX", "judgeSize", "isFake", "size", "tint", "tintHitEffects", "visibleBeats"] satisfies NotePropName[]) {
     Object.defineProperty(OperableNote.prototype, propName, {
-        get() { return this.target[propName]},
+        get() { return this._fields[propName] ?? this.target[propName]},
         set(value) {
+            if (this._fields[propName] === value) {
+                return;
+            }
+            this._fields[propName] = value;
             this.buffer.push(NotePropChangeOperation.lazy(this.target, propName, value));
         }
     });

package/operation/event.ts

@@ -117,7 +117,11 @@ extends UnionOperation<LazyOperation<typeof EventNodePairInsertOperation<VT>> |
     }
 }
 
-
+export class EventNodePairAutoInsertOperation<VT extends EventValueESType> extends EventNodePairInsertOperation<VT> {
+    constructor(node: EventStartNode<VT>, parentSeq: EventNodeSequence<VT>, updatesFP = true) {
+        super(node, parentSeq.getNodeAt(TC.toBeats(node.time)), updatesFP);
+    }
+}
 
 export class EventNodeValueChangeOperation <VT extends EventValueESType> extends Operation {
     updatesEditor = true
@@ -362,6 +366,10 @@ export class EncapsuleOperation extends ComplexOperation<[MultiNodeDeleteOperati
         // 直接do，这个不需要做成可撤销的
         // @ts-expect-error 这里序列类型确定，为easing，不需要传入谱面
         new MultiNodeAddOperation(nodeArray, sequence).do();
+        // 上面这个操作不能顶替原来的第一个startnode，所以手动来一遍
+        const first = sequence.head.next;
+        first.evaluator = nodeArray[0].evaluator;
+        first.value = nodeArray[0].value;
 
         return new EncapsuleOperation(oldArray, easing); 
     }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "kipphi",
     "description": "Parse your Phigros Chart(.rpe.json or .kpa.json) into an editor-friendly format.",
-    "version": "2.1.3-beta.1",
+    "version": "2.1.3",
     "author": "Team Zincs (https://github.com/TeamZincs)",
     "license": "MIT",
     "repository": {

package/rpeChartCompiler.ts

@@ -4,7 +4,7 @@ import { type TimeT, type ChartDataRPE, type MetaData, type JudgeLineDataRPE, ty
 import { SegmentedEasing, BezierEasing, NormalEasing, fixedEasing, TemplateEasing, Easing } from "./easing";
 import { err } from "./env";
 import { EasedEvaluator, Evaluator, ExpressionEvaluator, NumericEasedEvaluator, TextEasedEvaluator, type EasedEvaluatorConstructorOfType, type EasedEvaluatorOfType } from "./evaluator";
-import { EventEndNode, EventNode, EventNodeSequence, EventStartNode, type EventNodeLike } from "./event";
+import { EventEndNode, EventNode, EventNodeSequence, EventStartNode, SpeedENS, type EventNodeLike } from "./event";
 import type { JudgeLine } from "./judgeline";
 import type { NNList, HNList, NNOrHead } from "./note";
 import TC from "./time";
@@ -31,11 +31,23 @@ export class RPEChartCompiler {
         // console.time("compileChart")
         const chart = this.chart;
         const judgeLineGroups = chart.judgeLineGroups.map(group => group.name);
+        const hasNotes = (nnList: NNList) => {
+            let node = nnList.head.next;
+            while (true) {
+                if (node.type === NodeType.TAIL) {
+                    return false;
+                }
+                if (node.notes.length > 0) {
+                    return true;
+                }
+                node = node.next;
+            }
+        }
         const filter = this.deletesEmptyLines ? (line: JudgeLine) => {
-            return line.nnLists.size > 0
-                || line.hnLists.size > 0
+            return [...line.nnLists].some(([_, l]) => hasNotes(l))
+                || [...line.hnLists].some(([_, l]) => hasNotes(l))
                 || line.eventLayers.length > 0
-                || (["moveX", "moveY", "rotate", "alpha"] as const).some((evType) => {
+                  && (["moveX", "moveY", "rotate", "alpha"] as const).some((evType) => {
                     const seq = line.eventLayers[0][evType];
                     let node = seq.head.next;
                     for (let i = 0; i < 2; i++) {
@@ -128,7 +140,7 @@ export class RPEChartCompiler {
                 moveYEvents: layer.moveY ? this.dumpEventNodeSequence(layer.moveY) : undefined,
                 rotateEvents: layer.rotate ? this.dumpEventNodeSequence(layer.rotate) : undefined,
                 alphaEvents: layer.alpha ? this.dumpEventNodeSequence(layer.alpha) : undefined,
-                speedEvents: index === 0 ? this.dumpEventNodeSequence(judgeLine.speedSequence) : undefined
+                speedEvents: index === 0 ? this.dumpSpeedENS(judgeLine.speedSequence) : undefined
             })),
             extended: {
                 scaleXEvents: judgeLine.extendedLayer.scaleX ? this.dumpEventNodeSequence(judgeLine.extendedLayer.scaleX) : undefined,
@@ -249,6 +261,32 @@ export class RPEChartCompiler {
 
         return nodes
     }
+    dumpSpeedENS(seq: SpeedENS): EventDataRPELike<number>[] {
+        const ret: EventDataRPELike<number>[] = [];
+        let node = seq.head.next;
+        while (true) {
+            const end = node.next;
+            if (end.type === NodeType.TAIL) {
+                break;
+            }
+            ret.push({
+                start: node.value,
+                end: end.value,
+                startTime: node.time,
+                endTime: end.time,
+                linkgroup: 0
+            } as EventDataRPELike<number>);
+            node = end.next;
+        }
+        ret.push({
+            start: node.value,
+            end: node.value,
+            startTime: node.time,
+            endTime: TC.vadd(node.time, [1, 0, 1]),
+            linkgroup: 0
+        } as EventDataRPELike<number>);
+        return ret;
+    }
 
     compileNNLists(nnLists: NNList[], hnLists: HNList[]): NoteDataRPE[] {
         const noteLists = nnLists.map(list => this.nnListToArray(list));
@@ -367,8 +405,8 @@ export class RPEChartCompiler {
                     srcStart = srcSeq.head.next!.value;
                     srcEnd = srcSeq.tail.previous!.value;
                     leftDividedNodeSrc = srcSeq.head.next!;
-                    rightDividedNodeSrc = srcSeq.tail.previous!;
-                    toStopAt = rightDividedNodeSrc;
+                    rightDividedNodeSrc = srcSeq.tail.previous!.previous.previous!;
+                    toStopAt = srcSeq.tail.previous!;
                     srcStartTime = srcSeq.head.next!.time;
                     srcTimeDelta = TC.sub(srcSeq.tail.previous!.time, srcStartTime);
                 }
@@ -450,7 +488,7 @@ export class RPEChartCompiler {
                         throw err.CANNOT_DIVIDE_EXPRESSION_EVALUATOR(seq.id);
                     } else {
                         // 否则就是带缓动求值器
-                        first.evaluator = evaluator.deriveWithEasing(
+                        prev.evaluator = evaluator.deriveWithEasing(
                             new SegmentedEasing((rightDividedNodeSrc.evaluator as NumericEasedEvaluator).easing, 0.0, newRight)
                         ) as unknown as Evaluator<VT>;
                         // TypeScript Compiler我*你娘啊
@@ -460,7 +498,7 @@ export class RPEChartCompiler {
                     if (rightDividedNodeSrc.evaluator instanceof ExpressionEvaluator) {
                         throw err.CANNOT_DIVIDE_EXPRESSION_EVALUATOR(seq.id);
                     } else {
-                        first.evaluator = evaluator.deriveWithEasing(
+                        prev.evaluator = evaluator.deriveWithEasing(
                             (rightDividedNodeSrc.evaluator as NumericEasedEvaluator).easing
                         ) as unknown as Evaluator<VT>;
                     }

package/util.ts

@@ -20,6 +20,56 @@ export const checkType = (value: unknown, type: string | (string | typeof Functi
         && value.length === type.length
         && type.every((t, i) => checkType(value[i], t))
     } else if (typeof type === "string") {
+        if (type.startsWith("int")) {
+            if (typeof value !== "number" || !Number.isInteger(value)) {
+                return false;
+            }
+            const match = type.match(/^int(\(|\[)(\-?\d+),(\-?\d+|\+)(\)|\])$/);
+            if (!match) { return true; }
+            const [,leftBrac, left, right, rightBrac] = match
+            if (!leftBrac) { return true; }
+            const leftN = left === "-" ? -Infinity : Number(left);
+            const rightN = right === "+" ? +Infinity : Number(right);
+            if (value < leftN) {
+                return false;
+            }
+            if (leftBrac === "(" && value === leftN) {
+                return false;
+            }
+            
+            if (value > rightN) {
+                return false;
+            }
+            if (rightBrac === ")" && value === rightN) {
+                return false;
+            }
+            return true;
+        } else if (type.startsWith("number")) {
+            
+            if (typeof value !== "number") {
+                return false;
+            }
+            const match  = type.match(/^number(\(|\[)(\-?\d+),(\-?\d+|\+)(\)|\])$/)
+            if (!match) { return true; }
+            const [, leftBrac, left, right, rightBrac] = match
+            if (!leftBrac) { return true; }
+            const leftN = left === "-" ? -Infinity : Number(left);
+            const rightN = right === "+" ? +Infinity : Number(right);
+            if (value < leftN) {
+                return false;
+            }
+            if (leftBrac === "(" && value === leftN) {
+                return false;
+            }
+            
+            if (value > rightN) {
+                return false;
+            }
+            if (rightBrac === ")" && value === rightN) {
+                return false;
+            }
+            return true;
+        }
         return typeof value === type
     } else {
         return value instanceof type