@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/editor/state-machine/types.d.ts

@@ -0,0 +1,241 @@
+/**
+ * @file state-machine/types.ts
+ * @description Type definitions for State Machine Editor
+ * PRO-1.4: Professional Editor Features
+ */
+import type { SMState, SMTransition, SMDefinition } from '../../ai/StateMachine';
+import type { Vec2 } from '../../core/types';
+export type SMEditorMode = 'select' | 'pan' | 'connect' | 'create-state' | 'comment';
+export interface SMSelection {
+    states: Set<string>;
+    transitions: Set<string>;
+}
+export interface SMBoxSelection {
+    active: boolean;
+    start: Vec2;
+    end: Vec2;
+}
+export interface SMClipboard {
+    states: SMEditorStateData[];
+    transitions: SMEditorTransitionData[];
+}
+export interface SMViewport {
+    offset: Vec2;
+    zoom: number;
+    minZoom: number;
+    maxZoom: number;
+}
+export type SMEditorActionType = 'add-state' | 'remove-state' | 'move-state' | 'update-state' | 'add-transition' | 'remove-transition' | 'update-transition' | 'add-parameter' | 'remove-parameter' | 'update-parameter' | 'batch';
+export interface SMEditorAction {
+    type: SMEditorActionType;
+    data: unknown;
+    timestamp: number;
+}
+export interface SMEditorHistory {
+    actions: SMEditorAction[];
+    currentIndex: number;
+    maxSize: number;
+}
+export interface SMEditorStateData extends SMState {
+    /** Visual state in editor */
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    isActive?: boolean;
+    isHovered?: boolean;
+    /** Expanded in inspector */
+    expanded?: boolean;
+    /** Comment text (for comment type) */
+    commentText?: string;
+}
+export interface SMEditorTransitionData extends SMTransition {
+    isSelected?: boolean;
+    isHighlighted?: boolean;
+    isActive?: boolean;
+    isHovered?: boolean;
+    /** Bezier control points for curved transitions */
+    bezierPoints?: Vec2[];
+}
+export interface SMPendingConnection {
+    fromStateId: string;
+    fromPosition: Vec2;
+    toPosition: Vec2;
+}
+export interface SMEditorConfig {
+    /** Grid settings */
+    grid: {
+        enabled: boolean;
+        size: number;
+        snapToGrid: boolean;
+        color: string;
+        subDivisions: number;
+    };
+    /** State visual settings */
+    state: {
+        width: number;
+        height: number;
+        cornerRadius: number;
+        borderWidth: number;
+        fontSize: number;
+        iconSize: number;
+    };
+    /** Transition visual settings */
+    transition: {
+        lineWidth: number;
+        arrowSize: number;
+        curveStrength: number;
+        labelOffset: number;
+    };
+    /** Minimap settings */
+    minimap: {
+        enabled: boolean;
+        width: number;
+        height: number;
+        position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    };
+    /** Interaction settings */
+    interaction: {
+        zoomSpeed: number;
+        panSpeed: number;
+        doubleClickThreshold: number;
+        dragThreshold: number;
+    };
+    /** Auto-save settings */
+    autoSave: {
+        enabled: boolean;
+        interval: number;
+    };
+    /** Debug settings */
+    debug: {
+        showGrid: boolean;
+        showBounds: boolean;
+        showIds: boolean;
+    };
+}
+export declare const SM_STATE_COLORS: Record<string, string>;
+export declare const SM_STATUS_COLORS: {
+    idle: string;
+    active: string;
+    transitioning: string;
+    error: string;
+};
+export type SMEditorEventType = 'state-created' | 'state-deleted' | 'state-updated' | 'state-moved' | 'state-selected' | 'transition-created' | 'transition-deleted' | 'transition-updated' | 'transition-selected' | 'parameter-created' | 'parameter-deleted' | 'parameter-updated' | 'layer-created' | 'layer-deleted' | 'layer-updated' | 'viewport-changed' | 'mode-changed' | 'playback-started' | 'playback-stopped' | 'playback-state-changed' | 'definition-loaded' | 'definition-saved';
+export interface SMEditorEvent {
+    type: SMEditorEventType;
+    data: unknown;
+    timestamp: number;
+}
+export interface SMPaletteCategory {
+    id: string;
+    name: string;
+    icon?: string;
+    collapsed?: boolean;
+    items: SMPaletteItem[];
+}
+export interface SMPaletteItem {
+    id: string;
+    name: string;
+    type: SMState['type'];
+    description?: string;
+    icon?: string;
+    color?: string;
+}
+export interface SMValidationResult {
+    valid: boolean;
+    errors: SMValidationError[];
+    warnings: SMValidationWarning[];
+}
+export interface SMValidationError {
+    type: 'error';
+    code: string;
+    message: string;
+    stateId?: string;
+    transitionId?: string;
+    layerId?: string;
+}
+export interface SMValidationWarning {
+    type: 'warning';
+    code: string;
+    message: string;
+    stateId?: string;
+    transitionId?: string;
+    layerId?: string;
+}
+export interface SMSearchOptions {
+    query: string;
+    searchStates: boolean;
+    searchTransitions: boolean;
+    searchParameters: boolean;
+    caseSensitive: boolean;
+}
+export interface SMFilterOptions {
+    stateTypes: Set<SMState['type']>;
+    showMutedTransitions: boolean;
+    showComments: boolean;
+    layerIds: Set<string>;
+}
+export type SMLayoutType = 'horizontal' | 'vertical' | 'radial' | 'tree' | 'force-directed';
+export interface SMLayoutOptions {
+    type: SMLayoutType;
+    spacing: number;
+    animate: boolean;
+    preserveSelection: boolean;
+}
+export interface SMLayoutResult {
+    positions: Map<string, Vec2>;
+    bounds: {
+        min: Vec2;
+        max: Vec2;
+    };
+}
+export interface SMDebugState {
+    enabled: boolean;
+    running: boolean;
+    paused: boolean;
+    currentStateIds: Map<string, string>;
+    activeTransitions: Map<string, string>;
+    parameterValues: Map<string, boolean | number>;
+    breakpoints: Set<string>;
+    watchExpressions: string[];
+    history: SMDebugHistoryEntry[];
+    historyLimit: number;
+}
+export interface SMDebugHistoryEntry {
+    timestamp: number;
+    type: 'state-enter' | 'state-exit' | 'transition-start' | 'transition-complete' | 'parameter-change';
+    layerId: string;
+    details: {
+        stateId?: string;
+        stateName?: string;
+        transitionId?: string;
+        transitionName?: string;
+        parameterId?: string;
+        parameterName?: string;
+        oldValue?: unknown;
+        newValue?: unknown;
+    };
+}
+export interface SMTreeData {
+    definition: SMDefinition;
+    editorState: {
+        viewport: SMViewport;
+        selection: {
+            states: string[];
+            transitions: string[];
+        };
+        activeLayerId: string | null;
+    };
+    metadata: {
+        version: string;
+        exportedAt: number;
+        editorVersion: string;
+    };
+}
+export declare const DEFAULT_SM_EDITOR_CONFIG: SMEditorConfig;
+export declare function createEmptySelection(): SMSelection;
+export declare function createEmptyViewport(): SMViewport;
+export declare function createEmptyHistory(): SMEditorHistory;
+export declare function createEmptyClipboard(): SMClipboard;
+export declare function createEmptyDebugState(): SMDebugState;
+export declare function cloneSelection(selection: SMSelection): SMSelection;
+export declare function isSelectionEmpty(selection: SMSelection): boolean;
+export declare function mergeSelections(a: SMSelection, b: SMSelection): SMSelection;

package/dist/types/engine/NiceGameEngine.d.ts

@@ -1,17 +1,17 @@
-import type { GameState, GameSettings } from '../core/types';
+import { AudioManager } from '../audio/AudioManager';
+import { EventBus } from '../core/EventBus';
 import { GameClock } from '../core/GameClock';
 import { GameConfig } from '../core/GameConfig';
-import { EventBus } from '../core/EventBus';
 import { ServiceLocator } from '../core/ServiceLocator';
+import type { GameState, GameSettings } from '../core/types';
 import { World } from '../ecs/World';
 import { InputManager } from '../input/InputManager';
-import { AudioManager } from '../audio/AudioManager';
+import { PlayerManager, SplitScreenManager } from '../multiplayer/LocalMultiplayer';
+import { PhysicsEngine2D } from '../physics/PhysicsEngine2D';
 import { Camera2D } from '../rendering/Camera2D';
 import { Renderer2D } from '../rendering/Renderer2D';
-import { PhysicsEngine2D } from '../physics/PhysicsEngine2D';
 import { SceneManager } from '../scene/SceneManager';
 import { GameUI } from '../ui/GameUI';
-import { PlayerManager, SplitScreenManager } from '../multiplayer/LocalMultiplayer';
 export interface EngineOptions {
     canvas: HTMLCanvasElement;
     settings?: Partial<GameSettings>;

package/dist/types/engine/SaveSystem.d.ts

@@ -0,0 +1,155 @@
+import { EventBus } from '../core/EventBus';
+export type SaveSlotType = 'manual' | 'auto' | 'checkpoint' | 'quick';
+export type SaveConflictStrategy = 'local-wins' | 'remote-wins' | 'newest-wins' | 'merge' | 'prompt-user';
+export type SaveStorageBackend = 'indexeddb' | 'localstorage' | 'filesystem' | 'cloud';
+export type MigrationDirection = 'up' | 'down';
+export interface SaveSlotMeta {
+    slotId: string;
+    type: SaveSlotType;
+    label: string;
+    schemaVersion: number;
+    createdAt: number;
+    updatedAt: number;
+    playtimeMs: number;
+    /** Scene/level the player was in */
+    location: string;
+    /** Preview thumbnail (data URL) */
+    thumbnail?: string;
+    /** Compressed size in bytes */
+    sizeBytes: number;
+    /** CRC32 checksum */
+    checksum: number;
+    /** Cloud sync status */
+    cloudSynced: boolean;
+    cloudTimestamp?: number;
+    /** Custom tags for filtering */
+    tags: string[];
+}
+export interface SaveData {
+    meta: SaveSlotMeta;
+    payload: Record<string, unknown>;
+}
+export interface SaveMigration {
+    fromVersion: number;
+    toVersion: number;
+    description: string;
+    /** Transform the payload from one version to the next */
+    migrate: (payload: Record<string, unknown>) => Record<string, unknown>;
+    /** Optional rollback */
+    rollback?: (payload: Record<string, unknown>) => Record<string, unknown>;
+}
+export interface CloudSyncConfig {
+    enabled: boolean;
+    endpoint?: string;
+    apiKey?: string;
+    conflictStrategy: SaveConflictStrategy;
+    syncIntervalMs: number;
+    maxCloudSlots: number;
+}
+export interface AutoSaveConfig {
+    enabled: boolean;
+    intervalMs: number;
+    maxAutoSaves: number;
+    /** Only auto-save when game state is "safe" (not in combat, etc.) */
+    requireSafeState: boolean;
+}
+export interface SaveSystemConfig {
+    schemaVersion: number;
+    storageBackend: SaveStorageBackend;
+    storageKey: string;
+    maxSlots: number;
+    compressionEnabled: boolean;
+    autoSave: AutoSaveConfig;
+    cloud: CloudSyncConfig;
+}
+export declare const DEFAULT_SAVE_CONFIG: SaveSystemConfig;
+export interface SaveConflict {
+    slotId: string;
+    localMeta: SaveSlotMeta;
+    remoteMeta: SaveSlotMeta;
+    resolvedWith?: SaveConflictStrategy;
+}
+export interface SaveResult {
+    success: boolean;
+    slotId: string;
+    sizeBytes: number;
+    compressed: boolean;
+    error?: string;
+}
+/** Simple compression for JSON save data (dictionary-based) */
+export declare function compressSaveData(json: string): Uint8Array;
+/** Decompress save data */
+export declare function decompressSaveData(data: Uint8Array): string;
+export declare function crc32(data: Uint8Array): number;
+export declare class MigrationEngine {
+    private migrations;
+    register(migration: SaveMigration): void;
+    /** Migrate payload from fromVersion to toVersion */
+    migrate(payload: Record<string, unknown>, fromVersion: number, toVersion: number): {
+        payload: Record<string, unknown>;
+        applied: string[];
+    };
+    getRegistered(): readonly SaveMigration[];
+    canMigrate(from: number, to: number): boolean;
+}
+export declare class SaveSystem {
+    private config;
+    private migrationEngine;
+    private eventBus;
+    private slots;
+    private autoSaveTimer;
+    private autoSaveCounter;
+    private safeToSave;
+    constructor(eventBus: EventBus, config?: Partial<SaveSystemConfig>);
+    private setupEventHandlers;
+    /** Register a schema migration */
+    registerMigration(migration: SaveMigration): void;
+    /** Save game state to a slot */
+    save(slotId: string, payload: Record<string, unknown>, options?: {
+        type?: SaveSlotType;
+        label?: string;
+        location?: string;
+        thumbnail?: string;
+        tags?: string[];
+    }): SaveResult;
+    /** Load game state from a slot */
+    load(slotId: string): {
+        payload: Record<string, unknown>;
+        meta: SaveSlotMeta;
+        migrated: boolean;
+    } | null;
+    /** Delete a save slot */
+    delete(slotId: string): boolean;
+    /** List all save slot metadata (sorted by updatedAt desc) */
+    listSlots(): SaveSlotMeta[];
+    /** Get slot metadata without loading payload */
+    getSlotMeta(slotId: string): SaveSlotMeta | null;
+    /** Check if a slot exists */
+    hasSlot(slotId: string): boolean;
+    /** Start auto-save timer */
+    startAutoSave(getPayload: () => Record<string, unknown>, getLocation: () => string): void;
+    /** Stop auto-save */
+    stopAutoSave(): void;
+    /** Quick save (overwriting the single quick save slot) */
+    quickSave(payload: Record<string, unknown>, location: string): SaveResult;
+    /** Quick load */
+    quickLoad(): ReturnType<SaveSystem['load']>;
+    /** Sync local saves to cloud (stub — needs actual endpoint) */
+    syncToCloud(): Promise<{
+        synced: string[];
+        conflicts: SaveConflict[];
+    }>;
+    /** Resolve a cloud sync conflict */
+    resolveConflict(conflict: SaveConflict, strategy: SaveConflictStrategy): SaveSlotMeta;
+    private persistSlot;
+    private removeFromStorage;
+    /** Load all slots from storage backend */
+    loadFromStorage(): Promise<number>;
+    /** Export all saves as a downloadable blob */
+    exportAll(): Blob;
+    /** Import saves from a blob */
+    importAll(blob: Blob): Promise<number>;
+    getConfig(): Readonly<SaveSystemConfig>;
+    getMigrationEngine(): MigrationEngine;
+    destroy(): void;
+}

package/dist/types/export/BevyExporter.d.ts

@@ -0,0 +1,75 @@
+import type { ExportConfig, GameProject } from './PlatformExporter';
+export interface BevyExportConfig extends ExportConfig {
+    /** Bevy version (0.14, 0.15, etc.) */
+    bevyVersion: '0.14' | '0.15';
+    /** Output format */
+    format: 'crate' | 'plugin' | 'module';
+    /** Enable WASM target */
+    wasmTarget: boolean;
+    /** Use bevy_rapier for physics */
+    useRapier: boolean;
+    /** Use bevy_asset_loader */
+    useAssetLoader: boolean;
+    /** Enable hot reloading */
+    hotReloading: boolean;
+    /** Generate component derive macros */
+    deriveComponent: boolean;
+    /** Generate reflect traits */
+    deriveReflect: boolean;
+    /** Use states for scenes */
+    useStates: boolean;
+    /** Bundle sprites into texture atlas */
+    useTextureAtlas: boolean;
+    /** Optimize for release */
+    releaseOptimizations: boolean;
+    /** Cargo features to enable */
+    cargoFeatures: string[];
+}
+export declare const DEFAULT_BEVY_CONFIG: BevyExportConfig;
+export declare class BevyExporter {
+    private config;
+    private rustFiles;
+    private assets;
+    constructor(config?: Partial<BevyExportConfig>);
+    /** Export game project to Bevy */
+    export(project: GameProject): Promise<{
+        success: boolean;
+        outputPath: string | undefined;
+        files: {
+            path: string;
+            content: string;
+            type: "source";
+        }[];
+        assets: {
+            path: string;
+            type: "asset";
+            originalPath: string;
+        }[];
+        stats: {
+            duration: number;
+            fileCount: number;
+            assetCount: number;
+        };
+        errors?: undefined;
+    } | {
+        success: boolean;
+        errors: string[];
+        outputPath?: undefined;
+        files?: undefined;
+        assets?: undefined;
+        stats?: undefined;
+    }>;
+    private generateCargoToml;
+    private generateMain;
+    private generateComponents;
+    private generateSystems;
+    private generateResources;
+    private generateScenes;
+    private generateEntitySpawn;
+    private generateAssets;
+    private generatePlugin;
+    private collectAssets;
+    private isBuiltinComponent;
+    private toSnakeCase;
+    private toPascalCase;
+}

package/dist/types/export/CocosExporter.d.ts

@@ -0,0 +1,40 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface CocosExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Cocos Creator version (e.g., '3.8', '3.7') */
+        engineVersion?: string;
+        /** Use 2D or 3D mode */
+        mode?: '2d' | '3d';
+        /** Bundle name for generated scripts */
+        bundleName?: string;
+        /** Generate TypeScript (vs JavaScript) */
+        useTypeScript?: boolean;
+        /** Physics engine (builtin, box2d, cannon) */
+        physicsEngine?: 'builtin' | 'box2d' | 'cannon';
+    };
+}
+export declare class CocosExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private uuidMap;
+    private engineVersion;
+    private useTypeScript;
+    private is2D;
+    protected doExport(project: NiceProject, options: CocosExportOptions): Promise<void>;
+    private generateProjectConfig;
+    private generateScripts;
+    private generateGameManager;
+    private generateEntityScript;
+    private exportScene;
+    private buildSceneData;
+    private buildNodeData;
+    private convertPropertyValue;
+    private exportPrefab;
+    private buildPrefabData;
+    private exportAsset;
+    private exportAnimationClip;
+    private generateMetaFile;
+    private getImporterType;
+    private getOrCreateUUID;
+}
+export declare function createCocosExporter(): CocosExporter;

package/dist/types/export/Construct3Exporter.d.ts

@@ -0,0 +1,38 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface Construct3ExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Export as addon/behavior instead of full project */
+        exportAsAddon?: boolean;
+        /** Addon ID (if exportAsAddon) */
+        addonId?: string;
+        /** Use Construct's built-in physics */
+        useBuiltInPhysics?: boolean;
+        /** Target runtime version */
+        runtimeVersion?: string;
+        /** Generate JavaScript behaviors */
+        generateBehaviors?: boolean;
+        /** Generate JavaScript plugins */
+        generatePlugins?: boolean;
+    };
+}
+export declare class Construct3Exporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectId;
+    private uidCounter;
+    protected doExport(project: NiceProject, options: Construct3ExportOptions): Promise<void>;
+    private exportAsProject;
+    private generateProjectFile;
+    private collectObjectTypes;
+    private generateObjectTypes;
+    private generateObjectType;
+    private mapProperties;
+    private exportLayout;
+    private entityToInstance;
+    private generateEventSheet;
+    private generateEntityEvents;
+    private generateScripts;
+    private exportAsAddon;
+    private generateReadme;
+}
+export declare function createConstruct3Exporter(): Construct3Exporter;

package/dist/types/export/DefoldExporter.d.ts

@@ -0,0 +1,35 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface DefoldExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** Target platforms */
+        platforms?: ('windows' | 'macos' | 'linux' | 'ios' | 'android' | 'html5')[];
+        /** Use physics 2D */
+        usePhysics2D?: boolean;
+        /** Use physics 3D */
+        usePhysics3D?: boolean;
+        /** Generate HTML5 manifest */
+        html5Manifest?: boolean;
+        /** Include native extension stubs */
+        nativeExtensions?: boolean;
+    };
+}
+export declare class DefoldExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    protected doExport(project: NiceProject, options: DefoldExportOptions): Promise<void>;
+    private generateProjectFile;
+    private generateMainCollection;
+    private exportScene;
+    private entityToEmbeddedInstance;
+    private generateGameObject;
+    private generateEntityScript;
+    private getComponentProperty;
+    private generateSpriteDefinition;
+    private generateCollisionObject;
+    private exportPrefab;
+    private generateSceneScript;
+    private generateSharedScripts;
+    private generateAppManifest;
+    private generateReadme;
+}
+export declare function createDefoldExporter(): DefoldExporter;

package/dist/types/export/GDevelopExporter.d.ts

@@ -0,0 +1,35 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface GDevelopExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** GDevelop version target */
+        version?: '5.0' | '5.1' | '5.2' | '5.3';
+        /** Include P2P multiplayer setup */
+        includeMultiplayer?: boolean;
+        /** Generate JavaScript events */
+        useJavaScriptEvents?: boolean;
+        /** Include leaderboard setup */
+        includeLeaderboards?: boolean;
+        /** Generate custom extensions */
+        generateExtensions?: boolean;
+    };
+}
+export declare class GDevelopExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectUUID;
+    private zOrderCounter;
+    protected doExport(project: NiceProject, options: GDevelopExportOptions): Promise<void>;
+    private generateProject;
+    private collectGlobalObjects;
+    private entityToGDObject;
+    private generateLayout;
+    private entityToGDInstance;
+    private generateSceneEvents;
+    private generateEntityEvents;
+    private generateGlobalVariables;
+    private collectResources;
+    private createNice2DevExtension;
+    private generateNice2DevExtension;
+    private generateReadme;
+}
+export declare function createGDevelopExporter(): GDevelopExporter;

package/dist/types/export/GameMakerExporter.d.ts

@@ -0,0 +1,43 @@
+import { PlatformExporter, type PlatformId, type PlatformInfo, type NiceProject, type ExportOptions } from './PlatformExporter';
+export interface GameMakerExportOptions extends ExportOptions {
+    platformOptions?: {
+        /** GameMaker version (e.g., '2024.2', '2023.8') */
+        version?: string;
+        /** Use GML Visual (drag and drop) in addition to GML code */
+        useGmlVisual?: boolean;
+        /** Target runtime (VM or YYC) */
+        targetRuntime?: 'vm' | 'yyc';
+        /** Default sprite origin */
+        spriteOrigin?: 'top-left' | 'center' | 'bottom-center';
+        /** Physics world enabled */
+        enablePhysics?: boolean;
+    };
+}
+export declare class GameMakerExporter extends PlatformExporter {
+    readonly platformId: PlatformId;
+    readonly platformInfo: PlatformInfo;
+    private projectName;
+    private resourceTree;
+    private objectScripts;
+    protected doExport(project: NiceProject, options: GameMakerExportOptions): Promise<void>;
+    private generateProjectFile;
+    private generateFolderStructure;
+    private createFolder;
+    private generateScripts;
+    private generateObjects;
+    private findEntityByType;
+    private generateBaseObject;
+    private generateObjectFromEntity;
+    private generateEventList;
+    private extractEntityProperties;
+    private getGMLVarType;
+    private valueToGML;
+    private generateEventScripts;
+    private generateComponentInit;
+    private colorToGML;
+    private generateRoom;
+    private createTileLayer;
+    private generateSprite;
+    private generateSound;
+}
+export declare function createGameMakerExporter(): GameMakerExporter;