sonolus-next-rush-plus-engine 1.5.7 → 1.5.9

package/dist/extended/convert.d.ts

@@ -1,7 +1,13 @@
 import { type LevelData } from '@sonolus/core';
+type ExtendedEntityDataField = {
+    name: string;
+    value?: number;
+    ref?: string;
+};
 export type ExtendedEntityData = {
     archetype: string;
-    data: Record<string, number | string>;
+    name?: string;
+    data: ExtendedEntityDataField[];
 };
 export type ExtendedLevelData = {
     bgmOffset: number;
@@ -9,3 +15,4 @@ export type ExtendedLevelData = {
 };
 /** Convert a PJSekaiExtendedLevelData to a Level Data (Next Sekai) */
 export declare const extendedToLevelData: (data: ExtendedLevelData, offset?: number) => LevelData;
+export {};

package/dist/extended/convert.js

@@ -82,143 +82,220 @@ const guideKindMapping = {
     6: ConnectorKind.GUIDE_CYAN,
     7: ConnectorKind.GUIDE_BLACK,
 };
+/** data 배열 → 평탄한 Record로 변환 (value → number, ref → string) */
+const flattenData = (fields) => {
+    const result = {};
+    for (const field of fields) {
+        if (field.value !== undefined)
+            result[field.name] = field.value;
+        else if (field.ref !== undefined)
+            result[field.name] = field.ref;
+    }
+    return result;
+};
+/** 숫자 값 읽기 */
+const getNum = (data, key, defaultValue = 0) => {
+    const val = data[key];
+    if (typeof val === 'number')
+        return val;
+    if (typeof val === 'string') {
+        const n = Number(val);
+        return isNaN(n) ? defaultValue : n;
+    }
+    return defaultValue;
+};
+/** 참조 값 읽기 (number | string) */
+const getEntityRef = (data, key) => {
+    const val = data[key];
+    if (val === undefined)
+        return undefined;
+    return val;
+};
+/** 참조로 FlatEntity 조회 (number → 인덱스, string → 이름) */
+const resolveEntity = (ref, entities, entitiesByName) => {
+    if (typeof ref === 'number')
+        return entities[ref];
+    return entitiesByName.get(ref);
+};
 /** Convert a PJSekaiExtendedLevelData to a Level Data (Next Sekai) */
 export const extendedToLevelData = (data, offset = 0) => {
+    const flatEntities = data.entities.map((e) => ({
+        archetype: e.archetype,
+        name: e.name,
+        data: flattenData(e.data),
+    }));
+    const entitiesByName = new Map();
+    for (const entity of flatEntities) {
+        if (entity.name)
+            entitiesByName.set(entity.name, entity);
+    }
+    const resolve = (ref) => {
+        if (ref === undefined)
+            return undefined;
+        return resolveEntity(ref, flatEntities, entitiesByName);
+    };
     const allIntermediateEntities = [];
     const createIntermediate = (archetype, entityData) => {
-        const intermediateEntity = { archetype, data: entityData };
-        allIntermediateEntities.push(intermediateEntity);
-        return intermediateEntity;
+        const entity = { archetype, data: entityData };
+        allIntermediateEntities.push(entity);
+        return entity;
     };
     createIntermediate('Initialization', {});
-    for (const entity of data.entities) {
-        if (entity.archetype === '#BPM_CHANGE') {
-            createIntermediate('#BPM_CHANGE', {
-                '#BEAT': entity.data['#BEAT'],
-                '#BPM': entity.data['#BPM'],
-            });
-        }
+    for (const entity of flatEntities) {
+        if (entity.archetype !== '#BPM_CHANGE')
+            continue;
+        createIntermediate('#BPM_CHANGE', {
+            '#BEAT': getNum(entity.data, '#BEAT'),
+            '#BPM': getNum(entity.data, '#BPM'),
+        });
     }
     const timescaleGroupsByIndex = new Map();
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
-        if (entity.archetype === 'TimeScaleGroup') {
-            const groupIntermediate = createIntermediate('TimeScaleGroup', {});
-            timescaleGroupsByIndex.set(i, groupIntermediate);
-            let rawChangeIdx = entity.data['first'];
-            let lastChangeIntermediate = null;
-            while (rawChangeIdx !== undefined && rawChangeIdx > 0) {
-                const rawChange = data.entities[rawChangeIdx];
-                const changeIntermediate = createIntermediate('TimeScaleChange', {
-                    '#BEAT': rawChange.data['#BEAT'],
-                    timeScale: rawChange.data['timeScale'],
-                    timeScaleSkip: 0.0,
-                    timeScaleGroup: groupIntermediate,
-                    timeScaleEase: 0,
-                });
-                if (lastChangeIntermediate) {
-                    lastChangeIntermediate.data['next'] = changeIntermediate;
-                }
-                else {
-                    groupIntermediate.data['first'] = changeIntermediate;
-                }
-                lastChangeIntermediate = changeIntermediate;
-                const nextIdx = rawChange.data['next'];
-                if (nextIdx !== undefined && nextIdx > 0) {
-                    rawChangeIdx = nextIdx;
-                }
-                else {
-                    break;
-                }
+    const timescaleGroupsByName = new Map();
+    for (let i = 0; i < flatEntities.length; i++) {
+        const entity = flatEntities[i];
+        if (entity.archetype !== 'TimeScaleGroup')
+            continue;
+        const groupIntermediate = createIntermediate('TimeScaleGroup', {});
+        timescaleGroupsByIndex.set(i, groupIntermediate);
+        if (entity.name)
+            timescaleGroupsByName.set(entity.name, groupIntermediate);
+        let rawChangeRef = getEntityRef(entity.data, 'first');
+        let lastChangeIntermediate = null;
+        while (rawChangeRef !== undefined) {
+            const rawChange = resolve(rawChangeRef);
+            if (!rawChange)
+                break;
+            const changeIntermediate = createIntermediate('TimeScaleChange', {
+                '#BEAT': getNum(rawChange.data, '#BEAT'),
+                timeScale: getNum(rawChange.data, 'timeScale'),
+                timeScaleSkip: 0.0,
+                timeScaleGroup: groupIntermediate,
+                timeScaleEase: 0,
+            });
+            if (lastChangeIntermediate) {
+                lastChangeIntermediate.data['next'] = changeIntermediate;
+            }
+            else {
+                groupIntermediate.data['first'] = changeIntermediate;
             }
+            lastChangeIntermediate = changeIntermediate;
+            rawChangeRef = getEntityRef(rawChange.data, 'next');
         }
     }
-    const notesByOriginalIndex = new Map();
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
-        if (noteTypeMapping[entity.archetype]) {
-            const mappedArchetype = noteTypeMapping[entity.archetype];
-            const directionData = entity.data['direction'] ?? 0;
-            const noteIntermediate = createIntermediate(mappedArchetype, {
-                '#BEAT': entity.data['#BEAT'],
-                lane: entity.data['lane'] ?? 0.0,
-                size: entity.data['size'] ?? 0.0,
-                direction: flickDirectionMapping[directionData],
-                segmentKind: ConnectorKind.ACTIVE_NORMAL,
-            });
-            notesByOriginalIndex.set(i, noteIntermediate);
-        }
+    const resolveTimescaleGroup = (ref) => {
+        if (ref === undefined)
+            return undefined;
+        if (typeof ref === 'number')
+            return timescaleGroupsByIndex.get(ref);
+        return timescaleGroupsByName.get(ref);
+    };
+    const notesByIndex = new Map();
+    const notesByName = new Map();
+    for (let i = 0; i < flatEntities.length; i++) {
+        const entity = flatEntities[i];
+        const mappedArchetype = noteTypeMapping[entity.archetype];
+        if (!mappedArchetype)
+            continue;
+        const tsg = resolveTimescaleGroup(getEntityRef(entity.data, 'timeScaleGroup'));
+        const noteData = {
+            '#BEAT': getNum(entity.data, '#BEAT'),
+            lane: getNum(entity.data, 'lane', 0),
+            size: getNum(entity.data, 'size', 0),
+            direction: flickDirectionMapping[getNum(entity.data, 'direction', 0)],
+            segmentKind: ConnectorKind.ACTIVE_NORMAL,
+        };
+        if (tsg !== undefined)
+            noteData['#TIMESCALE_GROUP'] = tsg;
+        const noteIntermediate = createIntermediate(mappedArchetype, noteData);
+        notesByIndex.set(i, noteIntermediate);
+        if (entity.name)
+            notesByName.set(entity.name, noteIntermediate);
     }
-    const connectorsByOriginalIndex = new Map();
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
-        if (activeConnectorKindMapping[entity.archetype]) {
-            const connectorKind = activeConnectorKindMapping[entity.archetype];
-            const head = notesByOriginalIndex.get(entity.data['head']);
-            const tail = notesByOriginalIndex.get(entity.data['tail']);
-            const segmentHead = notesByOriginalIndex.get(entity.data['start']);
-            const segmentTail = notesByOriginalIndex.get(entity.data['end']);
-            if (!head || !tail || !segmentHead || !segmentTail)
-                continue;
-            const connectorIntermediate = createIntermediate('Connector', {
-                head,
-                tail,
-                segmentHead,
-                segmentTail,
-                activeHead: segmentHead,
-                activeTail: segmentTail,
-            });
-            head.data['connectorEase'] = easeTypeMapping[entity.data['ease'] ?? 0];
-            head.data['segmentKind'] = connectorKind;
-            tail.data['segmentKind'] = connectorKind;
-            segmentHead.data['segmentKind'] = connectorKind;
-            connectorsByOriginalIndex.set(i, connectorIntermediate);
-        }
+    const resolveNote = (ref) => {
+        if (ref === undefined)
+            return undefined;
+        if (typeof ref === 'number')
+            return notesByIndex.get(ref);
+        return notesByName.get(ref);
+    };
+    const connectorsByIndex = new Map();
+    const connectorsByName = new Map();
+    for (let i = 0; i < flatEntities.length; i++) {
+        const entity = flatEntities[i];
+        const connectorKind = activeConnectorKindMapping[entity.archetype];
+        if (!connectorKind)
+            continue;
+        const headNote = resolveNote(getEntityRef(entity.data, 'head'));
+        const tailNote = resolveNote(getEntityRef(entity.data, 'tail'));
+        const segmentHeadNote = resolveNote(getEntityRef(entity.data, 'start'));
+        const segmentTailNote = resolveNote(getEntityRef(entity.data, 'end'));
+        if (!headNote || !tailNote || !segmentHeadNote || !segmentTailNote)
+            continue;
+        const connectorIntermediate = createIntermediate('Connector', {
+            head: headNote,
+            tail: tailNote,
+            segmentHead: segmentHeadNote,
+            segmentTail: segmentTailNote,
+            activeHead: segmentHeadNote,
+            activeTail: segmentTailNote,
+        });
+        headNote.data['connectorEase'] =
+            easeTypeMapping[getNum(entity.data, 'ease', 0)] ?? EaseType.LINEAR;
+        headNote.data['segmentKind'] = connectorKind;
+        tailNote.data['segmentKind'] = connectorKind;
+        segmentHeadNote.data['segmentKind'] = connectorKind;
+        connectorsByIndex.set(i, connectorIntermediate);
+        if (entity.name)
+            connectorsByName.set(entity.name, connectorIntermediate);
     }
-    for (const [i, note] of notesByOriginalIndex.entries()) {
-        const entity = data.entities[i];
-        const timescaleGroupIndex = entity.data['timeScaleGroup'] ?? -1;
-        if (timescaleGroupIndex >= 0 && timescaleGroupsByIndex.has(timescaleGroupIndex)) {
-            note.data['#TIMESCALE_GROUP'] = timescaleGroupsByIndex.get(timescaleGroupIndex);
-        }
-        const attachIndex = entity.data['attach'] ?? -1;
-        if (attachIndex > 0) {
-            const attachConnector = connectorsByOriginalIndex.get(attachIndex);
+    const resolveConnector = (ref) => {
+        if (ref === undefined)
+            return undefined;
+        if (typeof ref === 'number')
+            return connectorsByIndex.get(ref);
+        return connectorsByName.get(ref);
+    };
+    for (let i = 0; i < flatEntities.length; i++) {
+        const entity = flatEntities[i];
+        const note = notesByIndex.get(i);
+        if (!note)
+            continue;
+        const attachRef = getEntityRef(entity.data, 'attach');
+        if (attachRef !== undefined) {
+            const attachConnector = resolveConnector(attachRef);
             if (attachConnector) {
                 note.data['attachHead'] = attachConnector.data['head'];
                 note.data['attachTail'] = attachConnector.data['tail'];
                 note.data['isAttached'] = 1;
             }
         }
-        const slideIndex = entity.data['slide'] ?? -1;
-        if (slideIndex > 0) {
-            const slideConnector = connectorsByOriginalIndex.get(slideIndex);
+        const slideRef = getEntityRef(entity.data, 'slide');
+        if (slideRef !== undefined) {
+            const slideConnector = resolveConnector(slideRef);
             if (slideConnector) {
                 note.data['activeHead'] = slideConnector.data['activeHead'];
             }
         }
     }
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
-        if (entity.archetype === 'SimLine') {
-            const left = notesByOriginalIndex.get(entity.data['a']);
-            const right = notesByOriginalIndex.get(entity.data['b']);
-            if (left && right) {
-                createIntermediate('SimLine', { left, right });
-            }
-        }
+    for (const entity of flatEntities) {
+        if (entity.archetype !== 'SimLine')
+            continue;
+        const left = resolveNote(getEntityRef(entity.data, 'a'));
+        const right = resolveNote(getEntityRef(entity.data, 'b'));
+        if (left && right)
+            createIntermediate('SimLine', { left, right });
     }
     const anchorsByBeat = new Map();
     const anchorPositions = new Map();
-    const getAnchor = (beat, lane, size, timescaleGroup, pos, segmentKind = -1, segmentAlpha = -1, connectorEase = -1) => {
-        let anchors = anchorsByBeat.get(beat);
+    const getAnchor = (beat, lane, size, tsg, pos, segmentKind = -1, segmentAlpha = -1, connectorEase = -1) => {
+        const anchors = anchorsByBeat.get(beat);
         if (anchors) {
             for (const anchor of anchors) {
                 if (anchorPositions.get(anchor)?.has(pos))
                     continue;
                 if (anchor.data['lane'] === lane &&
                     anchor.data['size'] === size &&
-                    anchor.data['#TIMESCALE_GROUP'] === timescaleGroup &&
+                    anchor.data['#TIMESCALE_GROUP'] === tsg &&
                     (segmentKind === -1 ||
                         anchor.data['segmentKind'] === segmentKind ||
                         anchor.data['segmentKind'] === -1) &&
@@ -228,92 +305,79 @@ export const extendedToLevelData = (data, offset = 0) => {
                     (connectorEase === -1 ||
                         anchor.data['connectorEase'] === connectorEase ||
                         anchor.data['connectorEase'] === -1)) {
-                    if (segmentKind !== -1 && anchor.data['segmentKind'] === -1) {
+                    if (segmentKind !== -1 && anchor.data['segmentKind'] === -1)
                         anchor.data['segmentKind'] = segmentKind;
-                    }
-                    if (segmentAlpha !== -1 && anchor.data['segmentAlpha'] === -1) {
+                    if (segmentAlpha !== -1 && anchor.data['segmentAlpha'] === -1)
                         anchor.data['segmentAlpha'] = segmentAlpha;
-                    }
-                    if (connectorEase !== -1 && anchor.data['connectorEase'] === -1) {
+                    if (connectorEase !== -1 && anchor.data['connectorEase'] === -1)
                         anchor.data['connectorEase'] = connectorEase;
-                    }
                     anchorPositions.get(anchor).add(pos);
                     return anchor;
                 }
             }
         }
-        const anchor = createIntermediate('AnchorNote', {
+        const anchorData = {
             '#BEAT': beat,
             lane,
             size,
-            '#TIMESCALE_GROUP': timescaleGroup,
             segmentKind,
             segmentAlpha,
             connectorEase,
-        });
-        if (!anchorsByBeat.has(beat)) {
+        };
+        if (tsg !== undefined)
+            anchorData['#TIMESCALE_GROUP'] = tsg;
+        const anchor = createIntermediate('AnchorNote', anchorData);
+        if (!anchorsByBeat.has(beat))
             anchorsByBeat.set(beat, []);
-        }
         anchorsByBeat.get(beat).push(anchor);
         anchorPositions.set(anchor, new Set([pos]));
         return anchor;
     };
-    for (let i = 0; i < data.entities.length; i++) {
-        const entity = data.entities[i];
-        if (entity.archetype === 'Guide') {
-            const startBeat = entity.data['startBeat'];
-            const startLane = entity.data['startLane'];
-            const startSize = entity.data['startSize'];
-            const startTimeScaleGroup = timescaleGroupsByIndex.get(entity.data['startTimeScaleGroup']);
-            const headBeat = entity.data['headBeat'];
-            const headLane = entity.data['headLane'];
-            const headSize = entity.data['headSize'];
-            const headTimeScaleGroup = timescaleGroupsByIndex.get(entity.data['headTimeScaleGroup']);
-            const tailBeat = entity.data['tailBeat'];
-            const tailLane = entity.data['tailLane'];
-            const tailSize = entity.data['tailSize'];
-            const tailTimeScaleGroup = timescaleGroupsByIndex.get(entity.data['tailTimeScaleGroup']);
-            const endBeat = entity.data['endBeat'];
-            const endLane = entity.data['endLane'];
-            const endSize = entity.data['endSize'];
-            const endTimeScaleGroup = timescaleGroupsByIndex.get(entity.data['endTimeScaleGroup']);
-            const ease = easeTypeMapping[entity.data['ease'] ?? 0];
-            const fade = entity.data['fade'] ?? 1;
-            const [startAlpha, endAlpha] = fadeAlphaMapping[fade];
-            const kind = guideKindMapping[entity.data['color'] ?? 0];
-            const start = getAnchor(startBeat, startLane, startSize, startTimeScaleGroup, 'segmentHead', kind, startAlpha);
-            const end = getAnchor(endBeat, endLane, endSize, endTimeScaleGroup, 'segmentTail', kind, endAlpha);
-            const head = getAnchor(headBeat, headLane, headSize, headTimeScaleGroup, 'head', kind, -1, ease);
-            const tail = getAnchor(tailBeat, tailLane, tailSize, tailTimeScaleGroup, 'tail', kind);
-            createIntermediate('Connector', {
-                head,
-                tail,
-                segmentHead: start,
-                segmentTail: end,
-            });
-        }
+    for (const entity of flatEntities) {
+        if (entity.archetype !== 'Guide')
+            continue;
+        const startBeat = getNum(entity.data, 'startBeat');
+        const startLane = getNum(entity.data, 'startLane');
+        const startSize = getNum(entity.data, 'startSize');
+        const startTSG = resolveTimescaleGroup(getEntityRef(entity.data, 'startTimeScaleGroup'));
+        const headBeat = getNum(entity.data, 'headBeat');
+        const headLane = getNum(entity.data, 'headLane');
+        const headSize = getNum(entity.data, 'headSize');
+        const headTSG = resolveTimescaleGroup(getEntityRef(entity.data, 'headTimeScaleGroup'));
+        const tailBeat = getNum(entity.data, 'tailBeat');
+        const tailLane = getNum(entity.data, 'tailLane');
+        const tailSize = getNum(entity.data, 'tailSize');
+        const tailTSG = resolveTimescaleGroup(getEntityRef(entity.data, 'tailTimeScaleGroup'));
+        const endBeat = getNum(entity.data, 'endBeat');
+        const endLane = getNum(entity.data, 'endLane');
+        const endSize = getNum(entity.data, 'endSize');
+        const endTSG = resolveTimescaleGroup(getEntityRef(entity.data, 'endTimeScaleGroup'));
+        const ease = easeTypeMapping[getNum(entity.data, 'ease', 0)] ?? EaseType.LINEAR;
+        const [startAlpha, endAlpha] = fadeAlphaMapping[getNum(entity.data, 'fade', 1)];
+        const kind = guideKindMapping[getNum(entity.data, 'color', 0)] ?? ConnectorKind.GUIDE_NEUTRAL;
+        const start = getAnchor(startBeat, startLane, startSize, startTSG, 'segmentHead', kind, startAlpha);
+        const end = getAnchor(endBeat, endLane, endSize, endTSG, 'segmentTail', kind, endAlpha);
+        const head = getAnchor(headBeat, headLane, headSize, headTSG, 'head', kind, -1, ease);
+        const tail = getAnchor(tailBeat, tailLane, tailSize, tailTSG, 'tail', kind);
+        createIntermediate('Connector', { head, tail, segmentHead: start, segmentTail: end });
     }
     for (const anchorList of anchorsByBeat.values()) {
         for (const anchor of anchorList) {
-            if (anchor.data['segmentKind'] === -1) {
+            if (anchor.data['segmentKind'] === -1)
                 anchor.data['segmentKind'] = ConnectorKind.GUIDE_NEUTRAL;
-            }
-            if (anchor.data['segmentAlpha'] === -1) {
+            if (anchor.data['segmentAlpha'] === -1)
                 anchor.data['segmentAlpha'] = 1.0;
-            }
-            if (anchor.data['connectorEase'] === -1) {
+            if (anchor.data['connectorEase'] === -1)
                 anchor.data['connectorEase'] = EaseType.LINEAR;
-            }
         }
     }
     for (const entity of allIntermediateEntities) {
-        if (entity.archetype === 'Connector') {
-            const head = entity.data['head'];
-            const tail = entity.data['tail'];
-            if (head && tail) {
-                head.data['next'] = tail;
-            }
-        }
+        if (entity.archetype !== 'Connector')
+            continue;
+        const head = entity.data['head'];
+        const tail = entity.data['tail'];
+        if (head && tail)
+            head.data['next'] = tail;
     }
     allIntermediateEntities.sort((a, b) => {
         const isInitA = a.archetype === 'Initialization' ? 0 : 1;
@@ -327,9 +391,9 @@ export const extendedToLevelData = (data, offset = 0) => {
     const entities = [];
     const intermediateToRef = new Map();
     let entityRefCounter = 0;
-    const getRef = (intermediateEntity) => {
+    const getOutputRef = (intermediateEntity) => {
         let ref = intermediateToRef.get(intermediateEntity);
-        if (ref)
+        if (ref !== undefined)
             return ref;
         ref = (entityRefCounter++).toString(16);
         intermediateToRef.set(intermediateEntity, ref);
@@ -338,7 +402,7 @@ export const extendedToLevelData = (data, offset = 0) => {
     for (const intermediateEntity of allIntermediateEntities) {
         const entity = {
             archetype: intermediateEntity.archetype,
-            name: getRef(intermediateEntity),
+            name: getOutputRef(intermediateEntity),
             data: [],
         };
         for (const [dataName, dataValue] of Object.entries(intermediateEntity.data)) {
@@ -346,7 +410,10 @@ export const extendedToLevelData = (data, offset = 0) => {
                 entity.data.push({ name: dataName, value: dataValue });
             }
             else if (dataValue !== undefined && dataValue !== null) {
-                entity.data.push({ name: dataName, ref: getRef(dataValue) });
+                entity.data.push({
+                    name: dataName,
+                    ref: getOutputRef(dataValue),
+                });
             }
         }
         entities.push(entity);

package/dist/index.d.ts

@@ -4,11 +4,11 @@ import { ucmmwsToLevelData } from './mmw/convert.js';
 import { susToUSC } from './sus/convert.js';
 import { uscToLevelData } from './usc/convert.js';
 import { USC } from './usc/index.js';
-import { extendedToLevelData } from './extended/convert.js';
-export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData };
+import { extendedToLevelData, type ExtendedEntityData, type ExtendedLevelData } from './extended/convert.js';
+export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData, type ExtendedEntityData, type ExtendedLevelData, };
 export * from './usc/index.js';
 export declare const convertToLevelData: (input: string | Uint8Array | USC | LevelData, offset?: number) => LevelData;
-export declare const version = "1.5.7";
+export declare const version = "1.5.9";
 export declare const databaseEngineItem: {
     readonly name: "next-rush-plus";
     readonly version: 13;

package/dist/index.js

@@ -7,8 +7,8 @@ import { isUSC } from './usc/analyze.js';
 import { isLevelData } from './LevelData/analyze.js';
 import { isPJSK } from './pjsk/analyze.js';
 import { pjskToUSC } from './pjsk/convert.js';
-import { extendedToLevelData } from './extended/convert.js';
-export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData };
+import { extendedToLevelData, } from './extended/convert.js';
+export { susToUSC, mmwsToUSC, uscToLevelData, ucmmwsToLevelData, extendedToLevelData, };
 export * from './usc/index.js';
 export const convertToLevelData = (input, offset = 0) => {
     if (isLevelData(input)) {
@@ -60,7 +60,7 @@ export const convertToLevelData = (input, offset = 0) => {
     }
     return uscToLevelData(usc, offset, true, true);
 };
-export const version = '1.5.7';
+export const version = '1.5.9';
 export const databaseEngineItem = {
     name: 'next-rush-plus',
     version: 13,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonolus-next-rush-plus-engine",
-  "version": "1.5.7",
+  "version": "1.5.9",
   "description": "A new Project Sekai inspired engine for Sonolus",
   "author": "Hyeon2",
   "repository": {