mftsccs-node 0.0.57 → 0.0.58

package/dist/types/DataStructures/User/UserNode.d.ts

@@ -1,20 +1,150 @@
+/**
+ * @fileoverview Node implementation for the UserBinaryTree.
+ * This module provides the UserNode class for storing user-specific concepts and connections.
+ * @module DataStructures/User/UserNode
+ */
 import { LConcept } from "../Local/LConcept";
 import { LConnection } from "../Local/LConnection";
+/**
+ * Represents a node in the user binary tree that stores both concepts and connections.
+ *
+ * @remarks
+ * UserNode implements an AVL tree node that can store multiple concepts and connections
+ * for a given composite key (userId + sessionId + randomizer). This allows efficient
+ * storage and retrieval of all user data associated with a specific key combination.
+ *
+ * @example
+ * ```typescript
+ * const concept = new LConcept(123, "example", 5);
+ * const connection = new LConnection(456, 1, 2, 3, 4, 5);
+ * const node = new UserNode("compositeKey", concept, connection, null, null);
+ * ```
+ */
 export declare class UserNode {
+    /**
+     * The composite key used for tree ordering.
+     * Typically a hexadecimal string combining userId, sessionId, and randomizer.
+     */
     key: any;
+    /**
+     * Array of connections stored in this node.
+     * Multiple connections can be associated with the same key.
+     */
     connectionValue: LConnection[];
+    /**
+     * Array of concepts stored in this node.
+     * Multiple concepts can be associated with the same key.
+     */
     value: LConcept[];
+    /**
+     * Reference to the left child node.
+     */
     leftNode: UserNode | null;
+    /**
+     * Reference to the right child node.
+     */
     rightNode: UserNode | null;
+    /**
+     * The height of this node in the tree.
+     * Used for AVL tree balancing calculations.
+     */
     height: number;
+    /**
+     * Creates a new UserNode.
+     *
+     * @param key - The composite key for tree ordering
+     * @param value - The LConcept to store (added if ID > 0)
+     * @param connectionValue - The LConnection to store (added if ID > 0)
+     * @param leftNode - The left child node (or null)
+     * @param rightNode - The right child node (or null)
+     *
+     * @remarks
+     * Only adds concepts and connections with valid (> 0) IDs to their respective arrays.
+     *
+     * @example
+     * ```typescript
+     * const node = new UserNode("compositeKey", concept, connection, null, null);
+     * ```
+     */
     constructor(key: any, value: LConcept, connectionValue: LConnection, leftNode: UserNode | null, rightNode: UserNode | null);
+    /**
+     * Adds a new node to the tree with AVL balancing.
+     *
+     * @param passedNode - The node to be added
+     * @param node - The current node being evaluated
+     * @param height - The height of the current node
+     * @returns The root node after insertion and balancing
+     *
+     * @remarks
+     * Implements AVL tree insertion. When a node with the same key exists,
+     * the new node's concepts and connections are added to the existing node's arrays.
+     */
     addNode(passedNode: UserNode, node: UserNode | null, height: number): UserNode | null;
+    /**
+     * Performs a right rotation on the given node for AVL balancing.
+     *
+     * @param y - The node to rotate right
+     * @returns The new root node after rotation
+     */
     rightRotate(y: UserNode | null): UserNode | null;
+    /**
+     * Performs a left rotation on the given node for AVL balancing.
+     *
+     * @param x - The node to rotate left
+     * @returns The new root node after rotation
+     */
     leftRotate(x: UserNode | null): UserNode | null;
+    /**
+     * Gets the height of a node.
+     *
+     * @param node - The node to get the height from
+     * @returns The height of the node, or 0 if null
+     */
     getHeight(node: UserNode | null): number;
+    /**
+     * Calculates the balance factor of a node.
+     *
+     * @param N - The node to calculate the balance factor for
+     * @returns The balance factor (difference between left and right heights)
+     */
     getBalanceFactor(N: UserNode | null): number;
+    /**
+     * Retrieves a node from the tree by its composite key.
+     *
+     * @param id - The composite key string to search for
+     * @param node - The current node being evaluated
+     * @returns The matching UserNode if found, null otherwise
+     */
     getFromNode(id: string, node: UserNode | null): UserNode | null;
+    /**
+     * Removes a node from the tree by its composite key.
+     *
+     * @param passedNode - The current node being evaluated
+     * @param id - The composite key string to remove
+     * @returns The root node after removal
+     *
+     * @remarks
+     * Implements standard BST deletion with in-order successor replacement.
+     */
     removeNode(passedNode: UserNode | null, id: string): UserNode | null;
+    /**
+     * Counts all nodes below and including the given node.
+     *
+     * @param root - The root node to start counting from
+     * @returns The total number of nodes in the subtree
+     *
+     * @remarks
+     * Recursively traverses the entire subtree to count all nodes.
+     */
     countNodeBelow(root: UserNode | null): number;
+    /**
+     * Finds the in-order successor of a node.
+     *
+     * @param root - The node to find the successor from
+     * @returns The in-order successor node (leftmost node in right subtree)
+     *
+     * @remarks
+     * Used during node deletion to find the replacement node.
+     */
     inOrderSuccessor(root: UserNode): UserNode;
 }

package/dist/types/Database/GetConceptFromIndexDb.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Placeholder module for IndexedDB concept retrieval functionality.
+ *
+ * This module is reserved for future implementation of concept retrieval operations
+ * from IndexedDB storage in the Concept Connection System.
+ *
+ * @module Database/GetConceptFromIndexDb
+ * @see https://documentation.freeschema.com for reference
+ */

package/dist/types/Database/NoIndexDb.d.ts

@@ -1,9 +1,178 @@
+/**
+ * No-operation IndexedDB interface module for environments without IndexedDB support.
+ *
+ * This module provides stub implementations of database operations that are used when
+ * IndexedDB is not available or when database functionality needs to be disabled.
+ * All functions are no-ops or return default values, allowing the application to
+ * run without actual database persistence.
+ *
+ * @module Database/NoIndexDb
+ * @see https://documentation.freeschema.com for reference
+ */
 import { SettingData } from "../DataStructures/SettingData";
+/**
+ * Opens or returns a reference to the IndexedDB database.
+ *
+ * In this no-op implementation, it simply returns the static database reference
+ * from IndexDb without performing any actual initialization.
+ *
+ * @param databaseName - The name of the database to open
+ * @returns The static IDBDatabase reference from IndexDb.db
+ *
+ * @example
+ * ```typescript
+ * const db = openDatabase('concepts-db');
+ * // Returns IndexDb.db without initialization
+ * ```
+ *
+ * @remarks
+ * This is a stub implementation used when full database functionality is not needed.
+ *
+ * @see IndexDb for the database singleton
+ */
 export declare function openDatabase(databaseName: string): IDBDatabase;
+/**
+ * Stores an object to the database (no-op implementation).
+ *
+ * This function provides a stub for storing data to IndexedDB. In this no-op
+ * implementation, it does not perform any actual storage operations.
+ *
+ * @param databaseName - The name of the database or object store
+ * @param object - The object to store (can be any type)
+ *
+ * @example
+ * ```typescript
+ * const concept = { id: 1, name: 'Example' };
+ * storeToDatabase('concepts', concept);
+ * // No actual storage occurs
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Use the full database module for actual persistence.
+ */
 export declare function storeToDatabase(databaseName: string, object: any): void;
+/**
+ * Retrieves statistics and settings from the database.
+ *
+ * Returns a new SettingData instance initialized with default values.
+ * This provides a consistent interface for accessing settings even when
+ * database functionality is disabled.
+ *
+ * @returns A new SettingData instance with AI features enabled (true)
+ *
+ * @example
+ * ```typescript
+ * const stats = GetStatsFromDatabase();
+ * // Returns SettingData with default configuration
+ * ```
+ *
+ * @remarks
+ * The returned SettingData is initialized with AI features enabled by default.
+ *
+ * @see SettingData for the settings data structure
+ */
 export declare function GetStatsFromDatabase(): SettingData;
+/**
+ * Updates the AI flag in settings (no-op implementation).
+ *
+ * This function provides a stub for updating AI-related settings in the database.
+ * In this no-op implementation, it does not perform any actual updates.
+ *
+ * @param object - The SettingData object containing the new AI flag value
+ *
+ * @example
+ * ```typescript
+ * const settings = new SettingData(false);
+ * AiUpdateFlag(settings);
+ * // No actual update occurs
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Changes are not persisted.
+ *
+ * @see SettingData for the settings data structure
+ */
 export declare function AiUpdateFlag(object: SettingData): void;
+/**
+ * Retrieves an object from the database by type and ID (no-op implementation).
+ *
+ * This async function provides a stub for fetching data from IndexedDB based on
+ * type and ID. In this no-op implementation, it returns undefined.
+ *
+ * @param databaseName - The name of the database or object store
+ * @param type - The type of object to retrieve (e.g., 'concept', 'setting')
+ * @param id - The numeric ID of the object to retrieve
+ * @returns Promise resolving to undefined
+ *
+ * @example
+ * ```typescript
+ * const concept = await getFromDatabaseWithType('concepts', 'concept', 123);
+ * // Returns undefined
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Use the full database module for actual retrieval.
+ */
 export declare function getFromDatabaseWithType(databaseName: string, type: string, id: number): Promise<void>;
+/**
+ * Retrieves objects from the database using legacy method (no-op implementation).
+ *
+ * This async function provides a stub for the older method of fetching data from
+ * IndexedDB. In this no-op implementation, it returns undefined.
+ *
+ * @param databaseName - The name of the database or object store
+ * @returns Promise resolving to undefined
+ *
+ * @example
+ * ```typescript
+ * const data = await getFromDatabaseWithTypeOld('concepts');
+ * // Returns undefined
+ * ```
+ *
+ * @remarks
+ * This is a legacy method maintained for backward compatibility. Use getFromDatabaseWithType
+ * for new implementations.
+ *
+ * @see getFromDatabaseWithType for the current retrieval method
+ */
 export declare function getFromDatabaseWithTypeOld(databaseName: string): Promise<void>;
+/**
+ * Removes an object from the database by ID (no-op implementation).
+ *
+ * This function provides a stub for deleting data from IndexedDB. In this no-op
+ * implementation, it does not perform any actual deletion.
+ *
+ * @param databaseName - The name of the database or object store
+ * @param id - The numeric ID of the object to remove
+ *
+ * @example
+ * ```typescript
+ * removeFromDatabase('concepts', 123);
+ * // No actual deletion occurs
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Use the full database module for actual deletion.
+ */
 export declare function removeFromDatabase(databaseName: string, id: number): void;
+/**
+ * Retrieves all objects from the local database (no-op implementation).
+ *
+ * This async function provides a stub for fetching all data from a local IndexedDB
+ * object store. In this no-op implementation, it returns undefined.
+ *
+ * @param databaseName - The name of the database or object store
+ * @returns Promise resolving to undefined
+ *
+ * @example
+ * ```typescript
+ * const allConcepts = await getAllFromLocalDb('concepts');
+ * // Returns undefined
+ * ```
+ *
+ * @remarks
+ * This is a placeholder implementation. Use the full database module for actual bulk retrieval.
+ *
+ * @see LocalIndexDb for local database operations
+ */
 export declare function getAllFromLocalDb(databaseName: string): Promise<void>;

package/dist/types/Database/indexdblocal.d.ts

@@ -1,3 +1,45 @@
+/**
+ * Local IndexedDB management module for storing concepts locally in the browser.
+ *
+ * This module provides a singleton class that maintains a static reference to a local
+ * IndexedDB database connection. It serves as the primary interface for local browser
+ * storage of concept data in the Concept Connection System.
+ *
+ * @module Database/indexdblocal
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Singleton class managing the local IndexedDB database connection.
+ *
+ * LocalIndexDb provides a static database reference for local browser storage
+ * of concepts. This allows the application to maintain offline functionality
+ * and cache concept data locally.
+ *
+ * @remarks
+ * The static db property is shared across the application and should be initialized
+ * before any database operations are performed.
+ *
+ * @example
+ * ```typescript
+ * // Access the local database instance
+ * const database = LocalIndexDb.db;
+ * if (database) {
+ *   // Perform database operations
+ * }
+ * ```
+ *
+ * @see IndexDb for remote database operations
+ * @see https://documentation.freeschema.com for concept storage patterns
+ */
 export declare class LocalIndexDb {
+    /**
+     * Static reference to the local IndexedDB database instance.
+     *
+     * This property holds the active IDBDatabase connection for local storage.
+     * It should be initialized during application startup before any database
+     * operations are attempted.
+     *
+     * @type {IDBDatabase}
+     */
     static db: IDBDatabase;
 }

package/dist/types/Database/indexeddb.d.ts

@@ -1,3 +1,46 @@
+/**
+ * IndexedDB management module for the Concept Connection System.
+ *
+ * This module provides a singleton class that maintains a static reference to an
+ * IndexedDB database connection. It serves as the primary interface for browser-based
+ * storage of concepts, settings, and other CCS data structures.
+ *
+ * @module Database/indexeddb
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Singleton class managing the IndexedDB database connection.
+ *
+ * IndexDb provides a static database reference that can be accessed throughout
+ * the application for storing and retrieving concept data, settings, and other
+ * persistent information in the browser's IndexedDB storage.
+ *
+ * @remarks
+ * The static db property is shared across the entire application. It should be
+ * initialized during application startup before performing any database operations.
+ * The current database schema version is 4.
+ *
+ * @example
+ * ```typescript
+ * // Access the database instance
+ * const database = IndexDb.db;
+ * if (database) {
+ *   // Perform database operations
+ *   const transaction = database.transaction(['concepts'], 'readonly');
+ * }
+ * ```
+ *
+ * @see LocalIndexDb for local-only database operations
+ * @see https://documentation.freeschema.com for database schema details
+ */
 export declare class IndexDb {
+    /**
+     * Static reference to the IndexedDB database instance.
+     *
+     * This property holds the active IDBDatabase connection used throughout
+     * the application. Must be initialized before use.
+     *
+     * @type {IDBDatabase}
+     */
     static db: IDBDatabase;
 }

package/dist/types/Drawing/ConceptDraw.d.ts

@@ -1 +1,29 @@
+/**
+ * Concept Draw Module for Concept Connection System (CCS-JS)
+ *
+ * This module handles the visual rendering of concepts on an HTML5 canvas.
+ * It provides a drawing loop that continuously renders concepts as triangles
+ * with automatic positioning and animation capabilities.
+ *
+ * @module Drawing/ConceptDraw
+ * @see https://documentation.freeschema.com for visualization reference
+ */
+/**
+ * Initializes and starts the main drawing loop for rendering concepts.
+ *
+ * @example
+ * ```typescript
+ * // Start the drawing loop
+ * DrawingLoop();
+ * ```
+ *
+ * @remarks
+ * Sets up a continuous drawing loop using setInterval that:
+ * - Targets 60 FPS (though currently draws at 2 FPS with 500ms interval)
+ * - Queries the canvas element with ID 'myCanvas'
+ * - Continuously calls MainDraw() to render concepts
+ *
+ * Note: The FPS and FRAME_RATE variables are declared but not currently used.
+ * The actual draw rate is 500ms (2 times per second), not 60 FPS.
+ */
 export declare function DrawingLoop(): void;

package/dist/types/Drawing/ConceptEvents.d.ts

@@ -1 +1,47 @@
+/**
+ * Concept Events Module for Concept Connection System (CCS-JS)
+ *
+ * This module handles user interaction events with visual concepts on the canvas.
+ * It provides hit detection and selection functionality for concepts rendered as triangles.
+ *
+ * @module Drawing/ConceptEvents
+ * @see https://documentation.freeschema.com for interaction reference
+ */
+/**
+ * Detects and returns a concept at the given mouse coordinates.
+ *
+ * @param mouse_x_coordinate - The x-coordinate of the mouse position
+ * @param mouse_y_coordinate - The y-coordinate of the mouse position
+ * @returns The concept at the mouse position, or null if no concept was clicked
+ *
+ * @example
+ * ```typescript
+ * canvas.addEventListener('click', (event) => {
+ *   const rect = canvas.getBoundingClientRect();
+ *   const x = event.clientX - rect.left;
+ *   const y = event.clientY - rect.top;
+ *   const selected = selectConceptObject(x, y);
+ *   if (selected) {
+ *     console.log('Clicked concept:', selected.id);
+ *   }
+ * });
+ * ```
+ *
+ * @remarks
+ * Hit detection uses a rectangular bounding box approach:
+ * - Width: 100 pixels (50 pixels on each side from center)
+ * - Height: 100 pixels (from y coordinate downward)
+ *
+ * Boundary calculations:
+ * - Left: concept.x - 50
+ * - Right: concept.x + 50
+ * - Top: concept.y
+ * - Bottom: concept.y + 100
+ *
+ * Note: Although concepts are drawn as triangles, the hit detection uses
+ * a rectangular area for simplicity. This means clicks near the corners
+ * of the rectangle but outside the actual triangle will still register.
+ *
+ * @see {@link ConceptsData} for the data store being searched
+ */
 export declare function selectConceptObject(mouse_x_coordinate: number, mouse_y_coordinate: number): import("../app").Concept | null;

package/dist/types/Helpers/CheckIfExists.d.ts

@@ -1,10 +1,169 @@
+/**
+ * Check If Exists Helper Module for Concept Connection System (CCS-JS)
+ *
+ * This module provides utility functions to verify the existence of concepts and connections
+ * within arrays. These functions are essential for avoiding duplicates and finding related
+ * entities in the CCS data structures.
+ *
+ * @module Helpers/CheckIfExists
+ * @see https://documentation.freeschema.com for data structure reference
+ */
 import { Concept } from "../DataStructures/Concept";
 import { Connection } from "../DataStructures/Connection";
 import { LConcept, LConnection } from "../app";
+/**
+ * Checks if a concept exists in an array of concepts by matching IDs.
+ *
+ * @param conceptList - Array of concepts to search through
+ * @param concept - The concept to search for
+ * @returns The found concept if it exists, otherwise returns a default concept
+ *
+ * @example
+ * ```typescript
+ * const concepts = [concept1, concept2, concept3];
+ * const found = CheckIfConceptsExistsInArray(concepts, concept2);
+ * if (found.id !== 0) {
+ *   console.log('Concept exists!');
+ * }
+ * ```
+ *
+ * @remarks
+ * Returns a default concept (created via CreateDefaultConcept) if the concept is not found.
+ * Always check the returned concept's ID to verify if a match was found.
+ */
 export declare function CheckIfConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept;
+/**
+ * Checks if concepts of the same type exist in an array, matching by type ID or character value.
+ *
+ * @param conceptList - Array of concepts to search through
+ * @param concept - The concept whose type to match against
+ * @returns Array of all concepts that match the same type
+ *
+ * @example
+ * ```typescript
+ * const concepts = [concept1, concept2, concept3];
+ * const sameType = CheckIfTypeConceptsExistsInArray(concepts, concept1);
+ * console.log(`Found ${sameType.length} concepts of the same type`);
+ * ```
+ *
+ * @remarks
+ * This function normalizes type character values by ensuring they start with "the_" prefix
+ * before comparison. It matches concepts by either:
+ * - Exact typeId match
+ * - Character value match (with "the_" prefix normalization)
+ */
 export declare function CheckIfTypeConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept[];
+/**
+ * Checks if LConcepts (lightweight concepts) of the same type exist in an array.
+ *
+ * @param conceptList - Array of LConcepts to search through
+ * @param concept - The LConcept whose type to match against
+ * @returns Array of all LConcepts that match the same type
+ *
+ * @example
+ * ```typescript
+ * const lconcepts = [lconcept1, lconcept2, lconcept3];
+ * const sameType = CheckIfTypeLConceptsExistsInArray(lconcepts, lconcept1);
+ * console.log(`Found ${sameType.length} LConcepts of the same type`);
+ * ```
+ *
+ * @remarks
+ * This is the LConcept variant of CheckIfTypeConceptsExistsInArray.
+ * LConcept is a lightweight representation that uses typeCharacter instead of type object.
+ * The function normalizes type character values by ensuring they start with "the_" prefix.
+ *
+ * @see {@link CheckIfTypeConceptsExistsInArray}
+ */
 export declare function CheckIfTypeLConceptsExistsInArray(conceptList: LConcept[] | undefined, concept: LConcept): LConcept[];
+/**
+ * Checks if a connection exists in an array of connections by matching IDs.
+ *
+ * @param connectionList - Array of connections to search through
+ * @param connection - The connection to search for
+ * @returns The found connection if it exists, otherwise returns a default connection with all zeros
+ *
+ * @example
+ * ```typescript
+ * const connections = [conn1, conn2, conn3];
+ * const found = CheckIfConnectionExistsInArray(connections, conn2);
+ * if (found.id !== 0) {
+ *   console.log('Connection exists!');
+ * }
+ * ```
+ *
+ * @remarks
+ * Returns a new Connection instance with all parameters set to 0 if the connection is not found.
+ * Always check the returned connection's ID to verify if a match was found.
+ */
 export declare function CheckIfConnectionExistsInArray(connectionList: Connection[] | undefined, connection: Connection): Connection;
+/**
+ * Checks if a connection exists in an array where a concept is either the source or target.
+ *
+ * @param connectionList - Array of connections to search through
+ * @param conceptId - The ID of the concept to find in connections
+ * @returns The first connection found where the concept appears as either toTheConceptId or ofTheConceptId
+ *
+ * @example
+ * ```typescript
+ * const connections = [conn1, conn2, conn3];
+ * const found = CheckIfToTheConceptExistsInConnectionArray(connections, 123);
+ * if (found.id !== 0) {
+ *   console.log('Concept is connected!');
+ * }
+ * ```
+ *
+ * @remarks
+ * This function searches bidirectionally - it finds connections where the concept is either:
+ * - The target (toTheConceptId)
+ * - The source (ofTheConceptId)
+ * If both exist, the ofTheConceptId match takes precedence as it's checked second.
+ * Returns a default connection (all zeros) if no match is found.
+ */
 export declare function CheckIfToTheConceptExistsInConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection;
+/**
+ * Finds all connections in an array where a concept appears as either source or target.
+ *
+ * @param connectionList - Array of connections to search through
+ * @param conceptId - The ID of the concept to find in connections
+ * @returns Array of all connections where the concept is connected (up to 2: one as target, one as source)
+ *
+ * @example
+ * ```typescript
+ * const connections = [conn1, conn2, conn3];
+ * const found = CheckAllConnectionsConnectedInConnectionArray(connections, 123);
+ * console.log(`Concept has ${found.length} connections`);
+ * ```
+ *
+ * @remarks
+ * This function finds connections where the concept appears as:
+ * - toTheConceptId (target/destination of connection)
+ * - ofTheConceptId (source/origin of connection)
+ * Note: Uses `find()` which only returns the first match for each direction,
+ * so maximum 2 connections will be returned even if more exist.
+ *
+ * @see {@link CheckAllConnectionsConnectedInLConnectionArray} for the LConnection variant
+ */
 export declare function CheckAllConnectionsConnectedInConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection[];
+/**
+ * Finds all LConnections (lightweight connections) in an array where a concept appears as either source or target.
+ *
+ * @param connectionList - Array of LConnections to search through
+ * @param conceptId - The ID of the concept to find in connections
+ * @returns Array of all LConnections where the concept is connected (up to 2: one as target, one as source)
+ *
+ * @example
+ * ```typescript
+ * const lconnections = [lconn1, lconn2, lconn3];
+ * const found = CheckAllConnectionsConnectedInLConnectionArray(lconnections, 123);
+ * console.log(`Concept has ${found.length} lightweight connections`);
+ * ```
+ *
+ * @remarks
+ * This is the LConnection variant of CheckAllConnectionsConnectedInConnectionArray.
+ * LConnection is a lightweight representation of connections used for performance optimization.
+ * Like its standard counterpart, it uses `find()` which only returns the first match per direction,
+ * so maximum 2 connections will be returned.
+ *
+ * @see {@link CheckAllConnectionsConnectedInConnectionArray}
+ */
 export declare function CheckAllConnectionsConnectedInLConnectionArray(connectionList: LConnection[] | undefined, conceptId: number): LConnection[];