kipphi 2.1.2 → 2.1.3-beta.2

package/judgeline.ts

@@ -186,17 +186,18 @@ export class JudgeLine {
             line.speedSequence = speedSequences[0]
             chart.registerEventNodeSequence(EventType.speed, `#${id}.speed`, speedSequences[0]);
         }
+        
+        if (data.extended?.scaleXEvents) {
+            line.extendedLayer.scaleX = createExtendedSequence(EventType.scaleX, data.extended.scaleXEvents);
+        } else {
+            line.extendedLayer.scaleX = chart.createEventNodeSequence(EventType.scaleX, `#${id}.ex.scaleX`);
+        }
+        if (data.extended?.scaleYEvents) {
+            line.extendedLayer.scaleY = createExtendedSequence(EventType.scaleY, data.extended.scaleYEvents);
+        } else {
+            line.extendedLayer.scaleY = chart.createEventNodeSequence(EventType.scaleY, `#${id}.ex.scaleY`);
+        }
         if (data.extended) {
-            if (data.extended.scaleXEvents) {
-                line.extendedLayer.scaleX = createExtendedSequence(EventType.scaleX, data.extended.scaleXEvents);
-            } else {
-                line.extendedLayer.scaleX = chart.createEventNodeSequence(EventType.scaleX, `#${id}.ex.scaleX`);
-            }
-            if (data.extended.scaleYEvents) {
-                line.extendedLayer.scaleY = createExtendedSequence(EventType.scaleY, data.extended.scaleYEvents);
-            } else {
-                line.extendedLayer.scaleY = chart.createEventNodeSequence(EventType.scaleY, `#${id}.ex.scaleY`);
-            }
             if (data.extended.textEvents) {
                 line.extendedLayer.text = createExtendedSequence(EventType.text, data.extended.textEvents);
             }
@@ -572,8 +573,9 @@ export class JudgeLine {
 
         
         const computeTime = (speed: number, currentPos: number, fore: number) => 
-            timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
+            speed * currentPos <= 0 ? fore : timeCalculator.secondsToBeats(currentPos / (speed * 120) + timeCalculator.toSeconds(fore));
         
+                        
         // 遍历所有事件节点直到结尾
         while (true) {
             const thisTime = TC.toBeats(startNode.time);
@@ -584,24 +586,62 @@ export class JudgeLine {
                 const thisPosY = startNode.floorPosition - currentJudgeLineFloorPos;
                 const thisSpeed = startNode.value;
                 
-                const inf = thisSpeed > 0 ? Infinity : (thisSpeed < 0 ? -Infinity : thisPosY);
                 
                 if (range[0] === undefined) {
-                    if (thisPosY < startY && startY <= inf || thisPosY >= endY && endY > inf) {
+                    /*
+                    有交集
+                    ******* +INF ******
+
+                    ------ endY -------
+                    |
+                    |
+                    |
+                    ----- thisPosY ----
+
+                    */
+                    if (thisSpeed > 0 && endY > thisPosY) {
                         range[0] = computeTime(
                             thisSpeed,
-                            (thisPosY < inf ? startY : endY) - thisPosY,
+                            startY - thisPosY,
                             thisTime)
-                    } else if (thisSpeed === 0) {
-                        range[0] = 0;
+                    /*
+                    有交集
+                    ----- thisPosY ----
+                    |
+                    |
+                    |
+                    ------ startY -------
+
+                    ******* -INF ******
+                    */
+                    } else if (thisSpeed < 0 && startY < thisPosY) {
+                        range[0] = computeTime(
+                            thisSpeed,
+                            endY - thisPosY,
+                            thisTime)
+                    } else if (thisSpeed === 0 && startY <= thisPosY && thisPosY <= endY) {
+                        range[0] = thisTime;
                     }
                 }
                 
                 if (range[0] !== undefined) {
-                    if (thisPosY < endY && endY <= inf || thisPosY >= startY && startY > inf) {
+                    /*
+                    ********** +INF **********
+
+                    ---------- endY ----------
+
+                    -------- thisPosY --------
+                    */
+                    if (thisSpeed > 0 && endY > thisPosY) {
+                        range[1] = computeTime(
+                            thisSpeed,
+                            endY - thisPosY,
+                            thisTime);
+                        result.push(range);
+                    } else if (thisSpeed < 0 && startY < thisPosY) {
                         range[1] = computeTime(
                             thisSpeed,
-                            (thisPosY > inf ? startY : endY) - thisPosY,
+                            startY - thisPosY,
                             thisTime)
                         result.push(range)
                     } else if (thisSpeed === 0) {
@@ -619,7 +659,7 @@ export class JudgeLine {
             const nextPosY = nextStart.floorPosition - currentJudgeLineFloorPos;
             
             let thisSpeed = startNode.value;
-            let nextSpeed = nextStart.value;
+            let nextSpeed = endNode.value;
             
             if (Math.abs(thisSpeed) < 1e-8) {
                 thisSpeed = 0;
@@ -638,21 +678,14 @@ export class JudgeLine {
                 
                 // 处理第一段(开始到零点)
                 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 !== Monotonicity.swinging) {
                             // 单调的FloorPosition函数只能产生一个符合条件的区间，可以提前返回达到优化目的
@@ -664,20 +697,14 @@ export 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 !== Monotonicity.swinging) {
                             // 单调的FloorPosition函数只能产生一个符合条件的区间，可以提前返回达到优化目的
@@ -689,20 +716,37 @@ export class JudgeLine {
             } else {
                 // 正常情况处理
                 if (range[0] === undefined) {
-                    if (thisPosY < startY && startY <= nextPosY || thisPosY > endY && endY >= nextPosY) {
+                    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,
-                            (thisPosY < nextPosY ? startY : endY) - thisPosY, thisTime)
-                    } else if (startY <= thisPosY && thisPosY <= endY) {
+                            endY - thisPosY, thisTime)
+                    } else if (thisSpeed === 0 && startY <= thisPosY && thisPosY <= endY) {
                         range[0] = thisTime;
                     }
+                    // else if (startY <= thisPosY && thisPosY <= endY) {
+                    //     range[0] = thisTime;
+                    // }
                 }
                 
                 if (range[0] !== undefined) {
-                    if (thisPosY < endY && endY <= nextPosY || thisPosY > startY && startY >= nextPosY) {
+                    if (thisSpeed > 0 && endY <= nextPosY) {
+                        range[1] = thisSpeed !== nextSpeed ? nextTime : computeTime(
+                            thisSpeed,
+                            endY - thisPosY, thisTime)
+                        result.push(range);
+                        if (lineMonotonicity !== Monotonicity.swinging) {
+                            // 单调的FloorPosition函数只能产生一个符合条件的区间，可以提前返回达到优化目的
+                            return result;
+                        }
+                        range = [undefined, undefined];
+                    } else if (thisSpeed < 0 && startY >= thisPosY) {
                         range[1] = thisSpeed !== nextSpeed ? nextTime : computeTime(
                             thisSpeed,
-                            (thisPosY > nextPosY ? startY : endY) - thisPosY, thisTime)
+                            startY - thisPosY, thisTime)
                         result.push(range);
                         if (lineMonotonicity !== Monotonicity.swinging) {
                             // 单调的FloorPosition函数只能产生一个符合条件的区间，可以提前返回达到优化目的
@@ -749,6 +793,19 @@ export class JudgeLine {
         }
         return current
     }
+    getStackedValueBySeconds(type: keyof EventLayer, beats: number, seconds: number, timeCalculator: TimeCalculator, usePrev: boolean = 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
+    }
     /**
      * 获取指定时间点的FloorPosition。
      * 

package/note.ts

@@ -20,20 +20,20 @@ export type HEX = number;
 
 export const 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,+)"
 }
 
 /**
@@ -102,15 +102,12 @@ export class Note {
         // 当然也有可能是KPA数据但是就是没有给
         this.visibleBeats = data.visibleBeats;
 
-        this.tint = data.tint ? rgb2hex(data.tint) : undefined;
+        const color = data.tint ?? (data as NoteDataRPE).color;
+
+        this.tint = color ? rgb2hex(color) : undefined;
         this.tintHitEffects = data.tintHitEffects ? rgb2hex(data.tintHitEffects) : undefined;
-        this.judgeSize = data.judgeSize ?? this.size;
-        /*
-        this.previous = null;
-        this.next = null;
-        this.previousSibling = null;
-        this.nextSibling = null;
-        */
+        // @ts-expect-error KPA用judgeSize，RPE用judgeArea，PZP用judgeSize
+        this.judgeSize = data.judgeSize ?? data.judgeArea ?? this.size;
     }
     static fromKPAJSON(data: NoteDataKPA, timeCalculator: TimeCalculator) {
         const note = new Note(data);
@@ -171,8 +168,9 @@ 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
         }
     }
     dumpKPA(): NoteDataKPA {
@@ -191,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,
         }
     }
@@ -375,7 +373,7 @@ export class NNList {
     }
     /** 此方法永远用于最新KPAJSON */
     static fromKPAJSON<T extends boolean>(isHold: T, effectiveBeats: number, data: NNListDataKPA, nnnList: NNNList, timeCalculator: TimeCalculator): T extends true ? HNList : NNList {
-        const list: T extends true ? HNList : NNList = isHold ? new HNList(data.speed, data.medianYOffset, effectiveBeats) : new NNList(data.speed, data.medianYOffset, effectiveBeats)
+        const list: T extends true ? HNList : NNList = isHold ? new HNList(data.speed, data.medianYOffset, effectiveBeats) : new NNList(data.speed, data.medianYOffset, effectiveBeats) as any;
         const nnlength = data.noteNodes.length
         let cur: NNOrHead = list.head;
         for (let i = 0; i < nnlength; i++) {

package/operation/easy.ts

@@ -0,0 +1,136 @@
+import { NoteType, RGB, TimeT } from "../chartTypes";
+import { EventNode } from "../event";
+import { HEX, Note, NoteNode } from "../note";
+import TC from "../time";
+import { numberToRatio } from "../util";
+import { type Operation } from "./basic";
+import { HoldEndTimeChangeOperation, NotePropChangeOperation, NotePropName, NoteTimeChangeOperation, NoteTypeChangeOperation } from "./note"
+
+type IntoOperable = EventNode | NoteNode | Note;
+
+type Time = TimeT | number | string;
+
+type ToOperable = ((o: EventNode) => EventNode) & { buffer: Operation[] };
+
+const userTimeToTuple = (time: Time) => {
+    if (typeof time === "string") {
+        const match = time.match(/^(\d+):(\d+)\/(\d+)$/);
+        if (!match) {
+            throw new Error(`Invalid time format: ${time}`);
+        }
+        return userTimeToTuple(match.map(s => parseInt(s)) as TimeT);
+    } else if (typeof time === "number") {
+        const integer = Math.floor(time);
+        return TC.validateIp([integer, ...numberToRatio(time - integer)]);
+    } else {
+        time = [...time]; // 防止从别的什么地方找来一个数据
+        TC.validateIp(time); // 原地规范化，如果失败就会抛错误，这里不用捕获
+        return time;
+    }
+}
+
+class Operable {
+    constructor(public buffer: Operation[]) {}
+}
+
+
+class OperableNote extends Operable {
+    // @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._fields.startTime = target.startTime;
+        this._fields.endTime = target.endTime;
+        this._fields.type = target.type;
+    }
+    get startTime() {
+        return this._fields.startTime;
+    }
+    set startTime(userTime: Time) {
+        const timeT = userTimeToTuple(userTime);
+        const beats = TC.toBeats(timeT);
+        if (beats < 0) {
+            throw new Error("")
+        }
+        const nnList = this.target.parentNode.parentSeq
+        if (beats > nnList.effectiveBeats) {
+            throw new Error("")
+        }
+        this._fields.startTime = timeT;
+        const node = nnList.getNodeOf(timeT);
+        this.buffer.push(NoteTimeChangeOperation.lazy(this.target, node));
+    }
+    get endTime() { return this._fields.endTime; }
+    set endTime(userTime: Time) {
+        if (this._fields.type !== NoteType.hold) {
+            throw new Error("Note is not a hold note");
+        }
+        const timeT = userTimeToTuple(userTime);
+        if (!TC.gt(timeT, this._fields.startTime)) {
+            throw new Error("");
+        }
+        this._fields.endTime = timeT;
+        this.buffer.push(HoldEndTimeChangeOperation.lazy(this.target, timeT));
+    }
+    get type() { return this._fields.type; }
+    set type(type: NoteType) {
+        if (this._fields.type === type) {
+            return;
+        }
+        this._fields.type = type;
+        this.buffer.push(NoteTypeChangeOperation.lazy(this.target, type));
+    }
+}
+
+interface OperableNote {
+    get above(): boolean;
+    set above(above: boolean);
+    get alpha(): number;
+    set alpha(alpha: number);
+    get positionX(): number;
+    set positionX(positionX: number);
+    get judgeSize(): number;
+    set judgeSize(judgeSize: number);
+    get isFake(): boolean;
+    set isFake(isFake: boolean);
+    get size(): number;
+    set size(size: number);
+    get tint(): HEX;
+    set tint(tint: string | RGB | HEX);
+    get tintHitEffects(): HEX;
+    set tintHitEffects(tintHitEffects: string | RGB | HEX);
+    get visibleBeats(): number;
+    set visibleBeats(visibleBeats: number);
+}
+
+for (const propName of ["above", "alpha", "positionX", "judgeSize", "isFake", "size", "tint", "tintHitEffects", "visibleBeats"] satisfies NotePropName[]) {
+    Object.defineProperty(OperableNote.prototype, 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));
+        }
+    });
+}
+
+export function useToOperable(): ToOperable {
+    const toOperable = (o: EventNode) => {
+        return 
+    };
+    (toOperable as ToOperable).buffer = [];
+    return toOperable as ToOperable;
+}
+
+export function operate(fn: (o: ToOperable) => void) {
+    const o = useToOperable();
+    fn(o);
+    return o.buffer;
+}

package/operation/event.ts

@@ -224,6 +224,13 @@ export class EventNodeEvaluatorChangeOperation <VT extends EventValueESType> ext
     constructor(public node: EventStartNode<VT>, public value: Evaluator<VT>) {
         super();
         this.originalValue = this.node.evaluator
+        const seq = node.parentSeq;
+        if (seq.type === EventType.easing && value instanceof EasedEvaluator && value.easing instanceof TemplateEasing) {
+            const circular = TemplateEasing.checkCircularReference(seq as EventNodeSequence<number>, value.easing);
+            if (circular) {
+                throw err.TEMPLATE_EASING_CIRCULAR_REFERENCE(value.easing.name);
+            }
+        }
     }
     do() {
         this.node.evaluator = this.value

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.2",
+    "version": "2.1.3-beta.2",
     "author": "Team Zincs (https://github.com/TeamZincs)",
     "license": "MIT",
     "repository": {

package/rpeChartCompiler.ts

@@ -22,13 +22,41 @@ type EasedStartNode<VT extends EventValueESType> = EventStartNode<VT> & { evalua
 export class RPEChartCompiler {
     sequenceMap: Map<EventNodeSequence<any>, EventNodeSequence<any>> = new Map();
     interpolationStep: TimeT = [0, 1, 16];
-    constructor(public chart: Chart) {}
+    deletesEmptyLines: boolean = true;
+    constructor(public chart: Chart) {
+
+    }
 
     compileChart(): ChartDataRPE {
-        console.time("compileChart")
+        // console.time("compileChart")
         const chart = this.chart;
         const judgeLineGroups = chart.judgeLineGroups.map(group => group.name);
-        const judgeLineList = chart.judgeLines.map(line => this.compileJudgeLine(line));
+        const filter = this.deletesEmptyLines ? (line: JudgeLine) => {
+            return line.nnLists.size > 0
+                || line.hnLists.size > 0
+                || line.eventLayers.length > 0
+                || (["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++) {
+                        const endNode = node.next;
+                        if (node.value !== 0) {
+                            return true;
+                        }
+                        if (endNode.type === NodeType.TAIL) {
+                            return false;
+                        }
+                        if (endNode.value !== 0) {
+                            return true;
+                        }
+                        node = endNode.next;
+                    }
+                    return true; // 有超过两个的节点
+                })
+        } : () => true
+        const judgeLineList = chart.judgeLines
+            .filter(filter)
+            .map(line => this.compileJudgeLine(line));
         const BPMList = chart.timeCalculator.dump();
         const META: MetaData = {
             RPEVersion: 1,
@@ -72,7 +100,7 @@ export class RPEChartCompiler {
         }
 
 
-        console.timeEnd("compileChart");
+        // console.timeEnd("compileChart");
         return {
             BPMList,
             META,
@@ -80,15 +108,15 @@ export class RPEChartCompiler {
             judgeLineGroup: judgeLineGroups,
             multiLineString: '',
             multiScale: 1.0,
-            chartTime: chart.rpeChartingTime * 60,
-            kpaChartTime: chart.chartingTime,
+            chartTime: chart.rpeChartingSeconds,
+            kpaChartTime: chart.chartingSeconds,
         };
     }
 
     compileJudgeLine(judgeLine: JudgeLine): JudgeLineDataRPE {
         const chart = this.chart;
         const notes = this.compileNNLists([...judgeLine.nnLists.values()], [...judgeLine.hnLists.values()]);
-        
+
         return {
             notes: notes,
             Group: chart.judgeLineGroups.indexOf(judgeLine.group),
@@ -139,10 +167,11 @@ export class RPEChartCompiler {
                 [0, 0, 0, 0],
             easingLeft: isSegmented ? easing.left : 0.0,
             easingRight: isSegmented ? easing.right : 1.0,
-            // @ts-expect-error 缓动为贝塞尔型时可以为null
-            easingType: easing instanceof NormalEasing ?
+            easingType: isSegmented ? (
+                easing.easing instanceof NormalEasing ? easing.easing.rpeId ?? 1 : null
+            ) : (easing instanceof NormalEasing ?
                     easing.rpeId ?? 1 :
-                    null,
+                    null),
             end,
             endTime: endNode.time,
             linkgroup: 0, // 假设默认值为 0

package/tsconfig.json

@@ -1,12 +1,11 @@
 {
   "compilerOptions": {
     // Environment setup & latest features
-    "lib": ["ES2021"],
+    "lib": ["ES2021", "DOM"],
     "target": "ES2016",
     "module": "es2020",
     "moduleDetection": "force",
     "allowJs": true,
-    "outFile": "../dist/index.d.ts",
 
     "emitDeclarationOnly": true,
     "declaration": true,
@@ -18,6 +17,7 @@
     "noUncheckedIndexedAccess": true,
 
     // Some stricter flags (disabled by default)
+    "strict": false,
     "noUnusedLocals": false,
     "noUnusedParameters": false,
     "noPropertyAccessFromIndexSignature": false

package/util.ts

@@ -34,9 +34,11 @@ export const hex2rgb = (hex: number): RGB => {
     return [hex >> 16, hex >> 8 & 0xFF, hex & 0xFF]
 }
 
-// 四位精度小数变分数
+// 5个2，4个3，3个5，7、11、13各一个
+const DENO = 324324000;
+
 export const numberToRatio = (num: number): [number, number] => {
-    return [Math.round(num * 10000), 10000]
+    return [Math.round(num * DENO), DENO]
 }
 
 

package/version.ts

@@ -2,7 +2,7 @@
 
 /// #declaration:global
 
-export const VERSION = 212;
+export const VERSION = 213;
 export const SCHEMA = "https://cdn.jsdelivr.net/npm/kipphi@2.1.0/chartType2.schema.json"