sonolus-next-rush-engine 0.1.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kyle Chang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# NEXT RUSH Sonolus Engine
+
+Perspective-lane rhythm game for [Sonolus](https://sonolus.com).
+
+## Documentation
+
+### `version`
+
+Package version.
+
+### `databaseEngineItem`
+
+Partial database engine item compatible with [sonolus-express](https://github.com/Sonolus/sonolus-express).
+
+### `susToUSC(sus)`
+
+Converts sus chart to USC.
+
+-   `sus`: sus chart.
+
+### `uscToLevelData(usc, offset?)`
+
+Converts USC to Level Data.
+
+-   `usc`: usc chart.
+-   `offset`: offset (default: `0`).
+
+### Assets
+
+The following assets are exposed as package entry points:
+
+-   `EngineConfiguration`
+-   `EnginePlayData`
+-   `EngineWatchData`
+-   `EnginePreviewData`
+-   `EngineTutorialData`
+-   `EngineRom`
+-   `EngineThumbnail`

package/dist/LevelData/analyze.d.ts

@@ -0,0 +1,3 @@
+import { LevelData } from '@sonolus/core';
+/** Check if it is Level Data */
+export declare function isLevelData(data: unknown): data is LevelData;

package/dist/LevelData/analyze.js

@@ -0,0 +1,7 @@
+/** Check if it is Level Data */
+export function isLevelData(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'entities' in data &&
+        Array.isArray(data.entities));
+}

package/dist/extended/analyze.d.ts

@@ -0,0 +1,3 @@
+import { LevelData } from '@sonolus/core';
+/** Check if it is chcy Level Data */
+export declare function isExtendedLevelData(data: unknown): data is LevelData;

package/dist/extended/analyze.js

@@ -0,0 +1,8 @@
+/** Check if it is chcy Level Data */
+export function isExtendedLevelData(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'entities' in data &&
+        Array.isArray(data.entities) &&
+        !data.entities.some((e) => e.archetype === '#TIMESCALE_GROUP'));
+}

package/dist/extended/convert.d.ts

@@ -0,0 +1,12 @@
+import { type LevelData } from '@sonolus/core';
+export interface ExtendedEntityDataField {
+    name: string;
+    value?: number;
+    ref?: string;
+}
+export interface ExtendedEntityData {
+    archetype: string;
+    name?: string;
+    data: ExtendedEntityDataField[];
+}
+export declare const extendedToLevelData: (data: LevelData, offset?: number) => LevelData | undefined;

package/dist/extended/convert.js

@@ -0,0 +1,453 @@
+const ConnectorKind = {
+    NONE: 0,
+    ACTIVE_NORMAL: 1,
+    ACTIVE_CRITICAL: 2,
+    GUIDE_NEUTRAL: 101,
+    GUIDE_RED: 102,
+    GUIDE_GREEN: 103,
+    GUIDE_BLUE: 104,
+    GUIDE_YELLOW: 105,
+    GUIDE_PURPLE: 106,
+    GUIDE_CYAN: 107,
+    GUIDE_BLACK: 108,
+};
+const FlickDirection = {
+    UP_OMNI: 0,
+    UP_LEFT: 1,
+    UP_RIGHT: 2,
+    DOWN_OMNI: 3,
+    DOWN_LEFT: 4,
+    DOWN_RIGHT: 5,
+};
+const EaseType = {
+    NONE: 0,
+    LINEAR: 1,
+    IN_QUAD: 2,
+    OUT_QUAD: 3,
+    IN_OUT_QUAD: 4,
+    OUT_IN_QUAD: 5,
+};
+const noteTypeMapping = {
+    NormalTapNote: 'NormalTapNote',
+    CriticalTapNote: 'CriticalTapNote',
+    NormalFlickNote: 'NormalFlickNote',
+    CriticalFlickNote: 'CriticalFlickNote',
+    NormalSlideStartNote: 'NormalHeadTapNote',
+    CriticalSlideStartNote: 'CriticalHeadTapNote',
+    NormalSlideEndNote: 'NormalTailReleaseNote',
+    CriticalSlideEndNote: 'CriticalTailReleaseNote',
+    NormalSlideEndFlickNote: 'NormalTailFlickNote',
+    CriticalSlideEndFlickNote: 'CriticalTailFlickNote',
+    IgnoredSlideTickNote: 'TransientHiddenTickNote',
+    NormalSlideTickNote: 'NormalTickNote',
+    CriticalSlideTickNote: 'CriticalTickNote',
+    HiddenSlideTickNote: 'AnchorNote',
+    NormalAttachedSlideTickNote: 'NormalTickNote',
+    CriticalAttachedSlideTickNote: 'CriticalTickNote',
+    NormalTraceNote: 'NormalTraceNote',
+    CriticalTraceNote: 'CriticalTraceNote',
+    DamageNote: 'DamageNote',
+    NormalTraceFlickNote: 'NormalTraceFlickNote',
+    CriticalTraceFlickNote: 'CriticalTraceFlickNote',
+    NonDirectionalTraceFlickNote: 'NormalTraceFlickNote',
+    HiddenSlideStartNote: 'AnchorNote',
+    NormalTraceSlideStartNote: 'NormalHeadTraceNote',
+    CriticalTraceSlideStartNote: 'CriticalHeadTraceNote',
+    NormalTraceSlideEndNote: 'NormalTailTraceNote',
+    CriticalTraceSlideEndNote: 'CriticalTailTraceNote',
+};
+const activeConnectorKindMapping = {
+    NormalSlideConnector: ConnectorKind.ACTIVE_NORMAL,
+    CriticalSlideConnector: ConnectorKind.ACTIVE_CRITICAL,
+};
+const flickDirectionMapping = {
+    [-1]: FlickDirection.UP_LEFT,
+    0: FlickDirection.UP_OMNI,
+    1: FlickDirection.UP_RIGHT,
+};
+const easeTypeMapping = {
+    [-2]: EaseType.OUT_IN_QUAD,
+    [-1]: EaseType.OUT_QUAD,
+    0: EaseType.LINEAR,
+    1: EaseType.IN_QUAD,
+    2: EaseType.IN_OUT_QUAD,
+};
+const fadeAlphaMapping = {
+    0: [1.0, 0.0],
+    1: [1.0, 1.0],
+    2: [0.0, 1.0],
+};
+const guideKindMapping = {
+    0: ConnectorKind.GUIDE_NEUTRAL,
+    1: ConnectorKind.GUIDE_RED,
+    2: ConnectorKind.GUIDE_GREEN,
+    3: ConnectorKind.GUIDE_BLUE,
+    4: ConnectorKind.GUIDE_YELLOW,
+    5: ConnectorKind.GUIDE_PURPLE,
+    6: ConnectorKind.GUIDE_CYAN,
+    7: ConnectorKind.GUIDE_BLACK,
+};
+class ExtData {
+    constructor(entities) {
+        this.byArch = new Map();
+        this.notes = [];
+        this.connectors = [];
+        this.entities = entities;
+        entities.forEach((e, idx) => {
+            const arch = e.archetype;
+            if (!this.byArch.has(arch))
+                this.byArch.set(arch, []);
+            this.byArch.get(arch)?.push({ idx, e });
+            if (arch in noteTypeMapping)
+                this.notes.push({ idx, e });
+            if (arch in activeConnectorKindMapping)
+                this.connectors.push({ idx, e });
+        });
+    }
+    get(idx) {
+        return this.entities[idx];
+    }
+    getByArch(arch) {
+        return this.byArch.get(arch) || [];
+    }
+}
+class EntityBuilder {
+    constructor(archetype) {
+        this.values = {};
+        this.refs = {};
+        this.archetype = archetype;
+    }
+    set(key, val) {
+        if (val instanceof EntityBuilder) {
+            this.refs[key] = val;
+        }
+        else if (typeof val === 'number') {
+            this.values[key] = val;
+        }
+    }
+    getBeat() {
+        return this.values['#BEAT'] ?? -1;
+    }
+}
+function getField(e, name) {
+    const field = e.data.find((x) => x.name === name);
+    if (!field)
+        return undefined;
+    if (field.value !== undefined)
+        return field.value;
+    if (field.ref !== undefined)
+        return field.ref;
+    return undefined;
+}
+function getNum(e, name, def = 0) {
+    const val = getField(e, name);
+    return typeof val === 'number' ? val : def;
+}
+function resolveOriginal(ext, ref) {
+    if (typeof ref === 'number')
+        return ext.get(ref);
+    if (typeof ref === 'string')
+        return ext.entities.find((x) => x.name === ref);
+    return undefined;
+}
+export const extendedToLevelData = (data, offset = 0) => {
+    const ext = new ExtData(data.entities);
+    const finalEntities = [];
+    const defaultTsg = new EntityBuilder('#TIMESCALE_GROUP');
+    finalEntities.push(defaultTsg);
+    const init = new EntityBuilder('Initialization');
+    finalEntities.push(init);
+    for (const { e } of ext.getByArch('#BPM_CHANGE')) {
+        const bpm = new EntityBuilder('#BPM_CHANGE');
+        bpm.set('#BEAT', getNum(e, '#BEAT'));
+        bpm.set('#BPM', getNum(e, '#BPM'));
+        finalEntities.push(bpm);
+    }
+    const timescaleGroupsByIndex = new Map();
+    const timescaleGroupsByName = new Map();
+    for (const { idx, e } of ext.getByArch('TimeScaleGroup')) {
+        const group = new EntityBuilder('#TIMESCALE_GROUP');
+        finalEntities.push(group);
+        timescaleGroupsByIndex.set(idx, group);
+        if (e.name)
+            timescaleGroupsByName.set(e.name, group);
+        let rawRef = getField(e, 'first');
+        const changes = [];
+        while (rawRef !== undefined) {
+            const raw = resolveOriginal(ext, rawRef);
+            if (!raw)
+                break;
+            const change = new EntityBuilder('#TIMESCALE_CHANGE');
+            change.set('#BEAT', getNum(raw, '#BEAT'));
+            change.set('#TIMESCALE', getNum(raw, 'timeScale'));
+            change.set('#TIMESCALE_SKIP', 0.0);
+            change.set('#TIMESCALE_GROUP', group);
+            change.set('#TIMESCALE_EASE', 0);
+            change.set('hideNotes', 0);
+            if (changes.length > 0) {
+                changes[changes.length - 1].set('next', change);
+            }
+            changes.push(change);
+            const nextRef = getField(raw, 'next');
+            if (typeof nextRef === 'number' && nextRef <= 0)
+                break;
+            rawRef = nextRef;
+        }
+        if (changes.length > 0) {
+            group.set('first', changes[0]);
+        }
+        finalEntities.push(...changes);
+    }
+    function getTSG(ref) {
+        if (typeof ref === 'number')
+            return timescaleGroupsByIndex.get(ref);
+        if (typeof ref === 'string')
+            return timescaleGroupsByName.get(ref);
+        return undefined;
+    }
+    const notesByIndex = new Map();
+    const notesByName = new Map();
+    const connectorsByIndex = new Map();
+    const connectorsByName = new Map();
+    for (const { idx, e } of ext.notes) {
+        const arch = noteTypeMapping[e.archetype];
+        if (!arch)
+            continue;
+        const note = new EntityBuilder(arch);
+        note.set('#BEAT', getNum(e, '#BEAT'));
+        note.set('lane', getNum(e, 'lane', 0.0));
+        note.set('size', getNum(e, 'size', 0.0));
+        note.set('direction', flickDirectionMapping[getNum(e, 'direction', 0)] ?? FlickDirection.UP_OMNI);
+        note.set('segmentKind', ConnectorKind.ACTIVE_NORMAL);
+        note.set('isAttached', 0);
+        note.set('connectorEase', 0);
+        note.set('isSeparator', 0);
+        finalEntities.push(note);
+        notesByIndex.set(idx, note);
+        if (e.name)
+            notesByName.set(e.name, note);
+    }
+    function getNote(ref) {
+        if (typeof ref === 'number')
+            return notesByIndex.get(ref);
+        if (typeof ref === 'string')
+            return notesByName.get(ref);
+        return undefined;
+    }
+    for (const { idx, e } of ext.connectors) {
+        const startRef = getField(e, 'start');
+        const headRef = getField(e, 'head');
+        const head = getNote(headRef);
+        const tail = getNote(getField(e, 'tail'));
+        const segmentHead = getNote(startRef);
+        const endRef = getField(e, 'end');
+        let segmentTail = getNote(endRef);
+        if (!segmentTail) {
+            const currentTailRef = getField(e, 'tail');
+            let ultimateTailRef = currentTailRef;
+            const visited = new Set();
+            while (ultimateTailRef !== undefined && !visited.has(ultimateTailRef)) {
+                visited.add(ultimateTailRef);
+                const nextConn = ext.connectors.find((c) => getField(c.e, 'head') === ultimateTailRef &&
+                    getField(c.e, 'start') === startRef);
+                if (nextConn) {
+                    ultimateTailRef = getField(nextConn.e, 'tail');
+                }
+                else {
+                    break;
+                }
+            }
+            segmentTail = getNote(ultimateTailRef);
+        }
+        if (!segmentTail) {
+            segmentTail = tail;
+        }
+        if (!head || !tail || !segmentHead || !segmentTail)
+            continue;
+        const kind = activeConnectorKindMapping[e.archetype];
+        const ease = easeTypeMapping[getNum(e, 'ease')] ?? EaseType.LINEAR;
+        const connector = new EntityBuilder('Connector');
+        connector.set('head', head);
+        connector.set('tail', tail);
+        connector.set('segmentHead', segmentHead);
+        connector.set('segmentTail', segmentTail);
+        connector.set('activeHead', segmentHead);
+        connector.set('activeTail', segmentTail);
+        head.set('connectorEase', ease);
+        head.set('segmentKind', kind);
+        tail.set('segmentKind', kind);
+        segmentHead.set('segmentKind', kind);
+        segmentHead.set('segmentAlpha', 1);
+        segmentTail.set('segmentAlpha', 1);
+        finalEntities.push(connector);
+        connectorsByIndex.set(idx, connector);
+        if (e.name)
+            connectorsByName.set(e.name, connector);
+    }
+    function getConn(ref) {
+        if (typeof ref === 'number')
+            return connectorsByIndex.get(ref);
+        if (typeof ref === 'string')
+            return connectorsByName.get(ref);
+        return undefined;
+    }
+    for (const [idx, note] of notesByIndex.entries()) {
+        const e = ext.get(idx);
+        const tsgRef = getField(e, 'timeScaleGroup');
+        const tsg = getTSG(tsgRef);
+        note.set('#TIMESCALE_GROUP', tsg || defaultTsg);
+        const attachRef = getField(e, 'attach');
+        if (attachRef !== undefined) {
+            const attachConn = getConn(attachRef);
+            if (attachConn?.refs.head && attachConn.refs.tail) {
+                note.set('attachHead', attachConn.refs.head);
+                note.set('attachTail', attachConn.refs.tail);
+                note.set('isAttached', 1);
+            }
+        }
+        const slideRef = getField(e, 'slide');
+        if (slideRef !== undefined) {
+            const slideConn = getConn(slideRef);
+            if (slideConn?.refs.activeHead) {
+                note.set('activeHead', slideConn.refs.activeHead);
+            }
+        }
+    }
+    for (const { e } of ext.getByArch('SimLine')) {
+        const a = getNote(getField(e, 'a'));
+        const b = getNote(getField(e, 'b'));
+        if (a && b) {
+            const sim = new EntityBuilder('SimLine');
+            sim.set('left', a);
+            sim.set('right', b);
+            finalEntities.push(sim);
+        }
+    }
+    const anchorsByBeat = new Map();
+    const anchorPositions = new Map();
+    function getAnchor(beat, lane, size, tsg, pos, segmentKind = -1, segmentAlpha = -1, connectorEase = -1) {
+        const anchors = anchorsByBeat.get(beat) || [];
+        for (const anchor of anchors) {
+            const positions = anchorPositions.get(anchor);
+            if (positions?.has(pos))
+                continue;
+            if (anchor.values.lane === lane &&
+                anchor.values.size === size &&
+                anchor.refs['#TIMESCALE_GROUP'] === tsg &&
+                (segmentKind === -1 ||
+                    anchor.values.segmentKind === segmentKind ||
+                    anchor.values.segmentKind === -1) &&
+                (segmentAlpha === -1 ||
+                    anchor.values.segmentAlpha === segmentAlpha ||
+                    anchor.values.segmentAlpha === -1) &&
+                (connectorEase === -1 ||
+                    anchor.values.connectorEase === connectorEase ||
+                    anchor.values.connectorEase === -1)) {
+                if (segmentKind !== -1 && anchor.values.segmentKind === -1)
+                    anchor.set('segmentKind', segmentKind);
+                if (segmentAlpha !== -1 && anchor.values.segmentAlpha === -1)
+                    anchor.set('segmentAlpha', segmentAlpha);
+                if (connectorEase !== -1 && anchor.values.connectorEase === -1)
+                    anchor.set('connectorEase', connectorEase);
+                positions?.add(pos);
+                return anchor;
+            }
+        }
+        const newAnchor = new EntityBuilder('AnchorNote');
+        newAnchor.set('#BEAT', beat);
+        newAnchor.set('lane', lane);
+        newAnchor.set('size', size);
+        if (tsg)
+            newAnchor.set('#TIMESCALE_GROUP', tsg);
+        newAnchor.set('segmentKind', segmentKind);
+        newAnchor.set('segmentAlpha', segmentAlpha);
+        newAnchor.set('connectorEase', connectorEase);
+        newAnchor.set('isAttached', 0);
+        newAnchor.set('isSeparator', 0);
+        finalEntities.push(newAnchor);
+        if (!anchorsByBeat.has(beat))
+            anchorsByBeat.set(beat, []);
+        anchorsByBeat.get(beat)?.push(newAnchor);
+        anchorPositions.set(newAnchor, new Set([pos]));
+        return newAnchor;
+    }
+    for (const { e } of ext.getByArch('Guide')) {
+        const startBeat = getNum(e, 'startBeat');
+        const startLane = getNum(e, 'startLane');
+        const startSize = getNum(e, 'startSize');
+        const startTsg = getTSG(getField(e, 'startTimeScaleGroup'));
+        const headBeat = getNum(e, 'headBeat');
+        const headLane = getNum(e, 'headLane');
+        const headSize = getNum(e, 'headSize');
+        const headTsg = getTSG(getField(e, 'headTimeScaleGroup'));
+        const tailBeat = getNum(e, 'tailBeat');
+        const tailLane = getNum(e, 'tailLane');
+        const tailSize = getNum(e, 'tailSize');
+        const tailTsg = getTSG(getField(e, 'tailTimeScaleGroup'));
+        const endBeat = getNum(e, 'endBeat');
+        const endLane = getNum(e, 'endLane');
+        const endSize = getNum(e, 'endSize');
+        const endTsg = getTSG(getField(e, 'endTimeScaleGroup'));
+        const ease = easeTypeMapping[getNum(e, 'ease', 0)] ?? EaseType.LINEAR;
+        const [startAlpha, endAlpha] = fadeAlphaMapping[getNum(e, 'fade', 1)] ?? [1.0, 1.0];
+        const kind = guideKindMapping[getNum(e, 'color', 0)] ?? ConnectorKind.GUIDE_NEUTRAL;
+        const start = getAnchor(startBeat, startLane, startSize, startTsg, 'segment_head', kind, startAlpha);
+        const end = getAnchor(endBeat, endLane, endSize, endTsg, 'segment_tail', kind, endAlpha);
+        const head = getAnchor(headBeat, headLane, headSize, headTsg, 'head', kind, -1, ease);
+        const tail = getAnchor(tailBeat, tailLane, tailSize, tailTsg, 'tail', kind);
+        const connector = new EntityBuilder('Connector');
+        connector.set('head', head);
+        connector.set('tail', tail);
+        connector.set('segmentHead', start);
+        connector.set('segmentTail', end);
+        finalEntities.push(connector);
+    }
+    for (const list of anchorsByBeat.values()) {
+        for (const anchor of list) {
+            if (anchor.values.segmentKind === -1)
+                anchor.set('segmentKind', ConnectorKind.GUIDE_NEUTRAL);
+            if (anchor.values.segmentAlpha === -1)
+                anchor.set('segmentAlpha', 1.0);
+            if (anchor.values.connectorEase === -1)
+                anchor.set('connectorEase', EaseType.LINEAR);
+        }
+    }
+    finalEntities.sort((a, b) => {
+        const isAInit = a.archetype === 'Initialization' ? 1 : 0;
+        const isBInit = b.archetype === 'Initialization' ? 1 : 0;
+        if (isAInit !== isBInit)
+            return isBInit - isAInit;
+        return a.getBeat() - b.getBeat();
+    });
+    for (const e of finalEntities) {
+        if (e.archetype === 'Connector') {
+            const head = e.refs.head;
+            const tail = e.refs.tail;
+            if (head && tail) {
+                head.set('next', tail);
+            }
+        }
+    }
+    const entityToName = new Map();
+    finalEntities.forEach((e, i) => {
+        entityToName.set(e, i.toString(16));
+    });
+    const serializedEntities = finalEntities.map((e) => {
+        const data = [];
+        for (const [key, val] of Object.entries(e.values)) {
+            data.push({ name: key, value: val });
+        }
+        for (const [key, refObj] of Object.entries(e.refs)) {
+            data.push({ name: key, ref: entityToName.get(refObj) ?? '' });
+        }
+        return {
+            archetype: e.archetype,
+            name: entityToName.get(e) ?? '',
+            data,
+        };
+    });
+    return {
+        bgmOffset: data.bgmOffset + offset,
+        entities: serializedEntities,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { LevelData } from '@sonolus/core';
+import { type ExtendedEntityData, type ExtendedEntityDataField, extendedToLevelData } from './extended/convert.js';
+import { mmwsToUSC, ucmmwsToLevelData } from './mmw/convert.js';
+import { susToUSC } from './sus/convert.js';
+import { uscToLevelData } from './usc/convert.js';
+import { USC } from './usc/index.js';
+export * from './usc/index.js';
+export { type ExtendedEntityData, type ExtendedEntityDataField, extendedToLevelData, mmwsToUSC, susToUSC, ucmmwsToLevelData, uscToLevelData, };
+export declare const convertToLevelData: (input: string | Uint8Array | USC | LevelData, offset?: number) => LevelData;
+export declare const version = ".1.0";
+export declare const databaseEngineItem: {
+    readonly name: "next-rush";
+    readonly version: 13;
+    readonly title: {
+        readonly en: "Next RUSH";
+    };
+    readonly subtitle: {
+        readonly en: "Next RUSH";
+    };
+    readonly author: {
+        readonly en: "Next RUSH";
+    };
+    readonly description: {
+        readonly en: string;
+    };
+};

package/dist/index.js

@@ -0,0 +1,84 @@
+import { isExtendedLevelData } from './extended/analyze.js';
+import { extendedToLevelData, } from './extended/convert.js';
+import { isLevelData } from './LevelData/analyze.js';
+import { detectMMWSType } from './mmw/analyze.js';
+import { mmwsToUSC, ucmmwsToLevelData } from './mmw/convert.js';
+import { susToUSC } from './sus/convert.js';
+import { isUSC } from './usc/analyze.js';
+import { uscToLevelData } from './usc/convert.js';
+export * from './usc/index.js';
+export { extendedToLevelData, mmwsToUSC, susToUSC, ucmmwsToLevelData, uscToLevelData, };
+export const convertToLevelData = (input, offset = 0) => {
+    if (isExtendedLevelData(input)) {
+        const converted = extendedToLevelData(input, offset);
+        if (converted)
+            return converted;
+    }
+    if (isLevelData(input)) {
+        return input;
+    }
+    let usc;
+    if (isUSC(input)) {
+        usc = input;
+    }
+    else if (input instanceof Uint8Array) {
+        const type = detectMMWSType(input);
+        if (type === 'UCMMWS') {
+            return ucmmwsToLevelData(input);
+        }
+        if (type === 'MMWS' || type === 'CCMMWS') {
+            usc = mmwsToUSC(input);
+            if (type === 'MMWS') {
+                return uscToLevelData(usc, offset, true, true);
+            }
+            else {
+                return uscToLevelData(usc, offset, false, false);
+            }
+        }
+        throw new Error('Unsupported Uint8Array type for MMWS');
+    }
+    else if (typeof input === 'string') {
+        try {
+            const parsed = JSON.parse(input);
+            if (isExtendedLevelData(parsed)) {
+                const converted = extendedToLevelData(parsed, offset);
+                if (converted)
+                    return converted;
+            }
+            if (isLevelData(parsed)) {
+                return parsed;
+            }
+            if (isUSC(parsed)) {
+                usc = parsed;
+                return uscToLevelData(usc, offset, false, false);
+            }
+            else {
+                usc = susToUSC(input);
+            }
+        }
+        catch {
+            usc = susToUSC(input);
+        }
+    }
+    else {
+        throw new Error('Unsupported input type: Input must be string(SUS/USC/LevelData), Uint8Array(MMWS), or USC/LevelData object.');
+    }
+    return uscToLevelData(usc, offset, true, true);
+};
+export const version = '.1.0';
+export const databaseEngineItem = {
+    name: 'next-rush',
+    version: 13,
+    title: {
+        en: 'Next RUSH',
+    },
+    subtitle: {
+        en: 'Next RUSH',
+    },
+    author: {
+        en: 'Next RUSH',
+    },
+    description: {
+        en: [`Version: ${version}`].join('\n'),
+    },
+};