@zengrid/shared 1.0.3 → 1.1.0

package/dist/src/data-structures/segment-tree/aggregation-config.d.ts

@@ -0,0 +1,6 @@
+import { AggregationType } from './segment-tree.interface';
+export declare function getAggregationConfig(type: AggregationType): {
+    fn: (a: number, b: number) => number;
+    identity: number;
+};
+//# sourceMappingURL=aggregation-config.d.ts.map

package/dist/src/data-structures/segment-tree/aggregation-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-config.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/aggregation-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEzE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,eAAe,GAAG;IAC3D,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAiBA"}

package/dist/src/data-structures/segment-tree/index.d.ts

@@ -0,0 +1,4 @@
+export { SegmentTree } from './segment-tree';
+export type { ISegmentTree, SegmentTreeOptions, AggregateFunction } from './segment-tree.interface';
+export { Aggregations, SegmentTreeUtils, AggregationType } from './segment-tree.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/data-structures/segment-tree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACpG,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/src/data-structures/segment-tree/lazy-propagation.d.ts

@@ -0,0 +1,5 @@
+import type { AggregateFunction } from './segment-tree.interface';
+import { AggregationType } from './segment-tree.interface';
+export declare function pushDown<T>(tree: T[], lazy: T[], aggregate: AggregateFunction<T>, identityValue: T, type: AggregationType, node: number, start: number, end: number): void;
+export declare function applyUpdate<T>(nodeValue: T, updateValue: T, rangeSize: number, aggregate: AggregateFunction<T>, type: AggregationType): T;
+//# sourceMappingURL=lazy-propagation.d.ts.map

package/dist/src/data-structures/segment-tree/lazy-propagation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-propagation.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/lazy-propagation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAoB,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE7E,wBAAgB,QAAQ,CAAC,CAAC,EACxB,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,aAAa,EAAE,CAAC,EAChB,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,IAAI,CAgBN;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,SAAS,EAAE,CAAC,EACZ,WAAW,EAAE,CAAC,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,IAAI,EAAE,eAAe,GACpB,CAAC,CAMH"}

package/dist/src/data-structures/segment-tree/segment-tree.d.ts

@@ -0,0 +1,30 @@
+import type { ISegmentTree, SegmentTreeOptions, AggregateFunction } from './segment-tree.interface';
+import { AggregationType } from './segment-tree.interface';
+export declare class SegmentTree<T> implements ISegmentTree<T> {
+    private tree;
+    private lazy;
+    private arr;
+    private n;
+    private aggregate;
+    private identityValue;
+    private useLazy;
+    private _type;
+    constructor(options: SegmentTreeOptions<T>);
+    private pushDown;
+    query(left: number, right: number): T;
+    update(index: number, value: T): void;
+    rangeUpdate(left: number, right: number, value: T): void;
+    get(index: number): T;
+    build(arr: T[]): void;
+    toArray(): T[];
+    findFirst(left: number, predicate: (value: T) => boolean): number;
+    get size(): number;
+    get total(): T;
+    get aggregationType(): AggregationType;
+    static from<T>(values: T[], type?: AggregationType): SegmentTree<T>;
+    static custom<T>(values: T[], aggregate: AggregateFunction<T>, identity: T): SegmentTree<T>;
+    findIndexAtSum(target: number): number;
+    toString(): string;
+    validate(): boolean;
+}
+//# sourceMappingURL=segment-tree.d.ts.map

package/dist/src/data-structures/segment-tree/segment-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-tree.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/segment-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACpG,OAAO,EAAoB,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAS7E,qBAAa,WAAW,CAAC,CAAC,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACpD,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,KAAK,CAAkB;gBAEnB,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC;IA6B1C,OAAO,CAAC,QAAQ;IAchB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC;IAwBrC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAoBrC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IA0BxD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC;IAQrB,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,IAAI;IAarB,OAAO,IAAI,CAAC,EAAE;IAQd,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM;IAUjE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,CAAC,CAKb;IAED,IAAI,eAAe,IAAI,eAAe,CAErC;IAED,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,IAAI,GAAE,eAAqC,GAAG,WAAW,CAAC,CAAC,CAAC;IAIxF,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAS3F,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IA0BtC,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,OAAO;CAGpB"}

package/dist/src/data-structures/segment-tree/segment-tree.interface.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Segment Tree interfaces for ZenGrid
+ * Efficiently handles range queries and updates for aggregation operations
+ */
+/**
+ * Aggregation function type
+ * Combines two values into one
+ */
+export type AggregateFunction<T> = (a: T, b: T) => T;
+/**
+ * Common aggregation operations
+ */
+export declare enum AggregationType {
+    SUM = "sum",
+    MIN = "min",
+    MAX = "max",
+    GCD = "gcd",
+    LCM = "lcm",
+    PRODUCT = "product",
+    CUSTOM = "custom"
+}
+/**
+ * Segment Tree interface
+ *
+ * A tree data structure for storing intervals or segments, allowing for efficient
+ * querying and updating of array elements over ranges.
+ *
+ * Use cases:
+ * - Status bar aggregations (sum, min, max of selected cells)
+ * - Range statistics (average, count, sum over a range)
+ * - Dynamic cumulative calculations
+ * - Range minimum/maximum queries
+ * - Frequent range updates with queries
+ *
+ * Performance:
+ * - Build: O(n)
+ * - Query: O(log n)
+ * - Update (point): O(log n)
+ * - Update (range): O(log n) with lazy propagation
+ * - Space: O(4n) = O(n)
+ */
+export interface ISegmentTree<T> {
+    /**
+     * Query the aggregated value over a range [left, right]
+     * @param left - Start index (inclusive)
+     * @param right - End index (inclusive)
+     * @returns Aggregated value over the range
+     * @complexity O(log n)
+     */
+    query(left: number, right: number): T;
+    /**
+     * Update a single element at index
+     * @param index - Index to update
+     * @param value - New value
+     * @complexity O(log n)
+     */
+    update(index: number, value: T): void;
+    /**
+     * Update a range of elements [left, right]
+     * @param left - Start index (inclusive)
+     * @param right - End index (inclusive)
+     * @param value - Value to apply to the range
+     * @complexity O(log n) with lazy propagation
+     */
+    rangeUpdate(left: number, right: number, value: T): void;
+    /**
+     * Get the value at a specific index
+     * @param index - Index to query
+     * @returns Value at index
+     * @complexity O(log n) or O(1) depending on implementation
+     */
+    get(index: number): T;
+    /**
+     * Build or rebuild the tree from new array
+     * @param arr - New array of values
+     * @complexity O(n)
+     */
+    build(arr: T[]): void;
+    /**
+     * Get the entire array
+     * @returns Current array values
+     * @complexity O(n)
+     */
+    toArray(): T[];
+    /**
+     * Find the first index where the aggregate from start meets a condition
+     * Useful for binary search on aggregates
+     * @param left - Start index
+     * @param predicate - Condition to test
+     * @returns Index or -1 if not found
+     * @complexity O(log^2 n)
+     */
+    findFirst(left: number, predicate: (value: T) => boolean): number;
+    /**
+     * Get the size of the underlying array
+     */
+    readonly size: number;
+    /**
+     * Get the total aggregated value (entire array)
+     */
+    readonly total: T;
+    /**
+     * Get the aggregation type
+     */
+    readonly aggregationType: AggregationType;
+}
+/**
+ * Options for creating a Segment Tree
+ */
+export interface SegmentTreeOptions<T> {
+    /**
+     * Initial array of values
+     */
+    values?: T[];
+    /**
+     * Aggregation type (for common operations)
+     * If CUSTOM is specified, must provide customAggregate function
+     */
+    type?: AggregationType;
+    /**
+     * Custom aggregation function
+     * Required if type is CUSTOM
+     */
+    customAggregate?: AggregateFunction<T>;
+    /**
+     * Identity value for the aggregation
+     * - For SUM: 0
+     * - For MIN: Infinity
+     * - For MAX: -Infinity
+     * - For PRODUCT: 1
+     * Must be provided for CUSTOM type
+     */
+    identity?: T;
+    /**
+     * Whether to use lazy propagation for range updates
+     * @default true
+     */
+    lazy?: boolean;
+}
+/**
+ * Predefined aggregation functions and identities
+ */
+export declare const Aggregations: {
+    sum: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    min: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    max: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    gcd: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    lcm: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+    product: {
+        fn: (a: number, b: number) => number;
+        identity: number;
+    };
+};
+/**
+ * Helper functions for segment tree operations
+ */
+export declare const SegmentTreeUtils: {
+    /**
+     * Calculate the tree size needed for array of size n
+     */
+    getTreeSize(n: number): number;
+    /**
+     * Check if index is valid
+     */
+    isValidIndex(index: number, size: number): boolean;
+    /**
+     * Check if range is valid
+     */
+    isValidRange(left: number, right: number, size: number): boolean;
+    /**
+     * Get parent index in tree
+     */
+    parent(index: number): number;
+    /**
+     * Get left child index in tree
+     */
+    leftChild(index: number): number;
+    /**
+     * Get right child index in tree
+     */
+    rightChild(index: number): number;
+    /**
+     * Get the middle point of a range
+     */
+    mid(left: number, right: number): number;
+};
+//# sourceMappingURL=segment-tree.interface.d.ts.map

package/dist/src/data-structures/segment-tree/segment-tree.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment-tree.interface.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/segment-tree.interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;AAErD;;GAEG;AACH,oBAAY,eAAe;IACzB,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,MAAM,WAAW;CAClB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAEtC;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAEtC;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAEzD;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAEtB;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC;IAEtB;;;;OAIG;IACH,OAAO,IAAI,CAAC,EAAE,CAAC;IAEf;;;;;;;OAOG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAAC;IAElE;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;IAEb;;;OAGG;IACH,IAAI,CAAC,EAAE,eAAe,CAAC;IAEvB;;;OAGG;IACH,eAAe,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAEvC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEb;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;gBAEb,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAIjB,MAAM,KAAK,MAAM;;;;gBAWjB,MAAM,KAAK,MAAM;;;;gBAOjB,MAAM,KAAK,MAAM;;;CAG5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;mBACY,MAAM,GAAG,MAAM;IAK9B;;OAEG;wBACiB,MAAM,QAAQ,MAAM,GAAG,OAAO;IAIlD;;OAEG;uBACgB,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,OAAO;IAIhE;;OAEG;kBACW,MAAM,GAAG,MAAM;IAI7B;;OAEG;qBACc,MAAM,GAAG,MAAM;IAIhC;;OAEG;sBACe,MAAM,GAAG,MAAM;IAIjC;;OAEG;cACO,MAAM,SAAS,MAAM,GAAG,MAAM;CAGzC,CAAC"}

package/dist/src/data-structures/segment-tree/tree-builder.d.ts

@@ -0,0 +1,3 @@
+import type { AggregateFunction } from './segment-tree.interface';
+export declare function buildTree<T>(tree: T[], arr: T[], aggregate: AggregateFunction<T>, node: number, start: number, end: number): void;
+//# sourceMappingURL=tree-builder.d.ts.map

package/dist/src/data-structures/segment-tree/tree-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-builder.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/tree-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,CAAC,EAAE,EACT,GAAG,EAAE,CAAC,EAAE,EACR,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,IAAI,CAcN"}

package/dist/src/data-structures/segment-tree/tree-query.d.ts

@@ -0,0 +1,3 @@
+import type { AggregateFunction } from './segment-tree.interface';
+export declare function queryTree<T>(tree: T[], lazy: T[], aggregate: AggregateFunction<T>, identityValue: T, useLazy: boolean, pushDownFn: (node: number, start: number, end: number) => void, node: number, start: number, end: number, left: number, right: number): T;
+//# sourceMappingURL=tree-query.d.ts.map

package/dist/src/data-structures/segment-tree/tree-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-query.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/tree-query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,wBAAgB,SAAS,CAAC,CAAC,EACzB,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,aAAa,EAAE,CAAC,EAChB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,EAC9D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,CAAC,CA6CH"}

package/dist/src/data-structures/segment-tree/tree-search.d.ts

@@ -0,0 +1,2 @@
+export declare function findIndexAtSumRecursive<T>(tree: T[], lazy: T[], useLazy: boolean, pushDownFn: (node: number, start: number, end: number) => void, node: number, start: number, end: number, targetSum: number): number;
+//# sourceMappingURL=tree-search.d.ts.map

package/dist/src/data-structures/segment-tree/tree-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-search.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/tree-search.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,CAAC,EAAE,EACT,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,EAC9D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,GAChB,MAAM,CA2CR"}

package/dist/src/data-structures/segment-tree/tree-update.d.ts

@@ -0,0 +1,4 @@
+import type { AggregateFunction } from './segment-tree.interface';
+export declare function updateTree<T>(tree: T[], lazy: T[], aggregate: AggregateFunction<T>, useLazy: boolean, pushDownFn: (node: number, start: number, end: number) => void, node: number, start: number, end: number, index: number, value: T): void;
+export declare function rangeUpdateLazy<T>(tree: T[], lazy: T[], aggregate: AggregateFunction<T>, pushDownFn: (node: number, start: number, end: number) => void, node: number, start: number, end: number, left: number, right: number, value: T): void;
+//# sourceMappingURL=tree-update.d.ts.map

package/dist/src/data-structures/segment-tree/tree-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-update.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/tree-update.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,wBAAgB,UAAU,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,EAC9D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,GACP,IAAI,CAqBN;AAED,wBAAgB,eAAe,CAAC,CAAC,EAC/B,IAAI,EAAE,CAAC,EAAE,EACT,IAAI,EAAE,CAAC,EAAE,EACT,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,EAC9D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,GACP,IAAI,CAuBN"}

package/dist/src/data-structures/segment-tree/tree-validation.d.ts

@@ -0,0 +1,3 @@
+import type { AggregateFunction } from './segment-tree.interface';
+export declare function validateNode<T>(tree: T[], arr: T[], aggregate: AggregateFunction<T>, n: number, node: number, start: number, end: number): boolean;
+//# sourceMappingURL=tree-validation.d.ts.map

package/dist/src/data-structures/segment-tree/tree-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-validation.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/segment-tree/tree-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,EAAE,CAAC,EAAE,EACT,GAAG,EAAE,CAAC,EAAE,EACR,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC/B,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,OAAO,CAqBT"}

package/dist/src/data-structures/skip-list/index.d.ts

@@ -0,0 +1,4 @@
+export { SkipList } from './skip-list';
+export type { ISkipList, SkipListNode, SkipListOptions, RangeResult, SkipListStats, } from './skip-list.interface';
+export { defaultComparator, SkipListUtils } from './skip-list.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/data-structures/skip-list/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/skip-list/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,YAAY,EACV,SAAS,EACT,YAAY,EACZ,eAAe,EACf,WAAW,EACX,aAAa,GACd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/src/data-structures/skip-list/skip-list.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Skip List implementation
+ * Probabilistic sorted data structure
+ */
+import type { ISkipList, SkipListOptions, RangeResult, SkipListStats } from './skip-list.interface';
+/**
+ * Skip List - Probabilistic sorted data structure
+ *
+ * Implementation:
+ * - Multiple levels of linked lists
+ * - Each level is a subset of the level below
+ * - Levels are determined probabilistically
+ * - Search starts at highest level and descends
+ *
+ * @example
+ * ```typescript
+ * const skipList = new SkipList<number, string>();
+ * skipList.set(10, 'ten');
+ * skipList.set(5, 'five');
+ * skipList.set(20, 'twenty');
+ *
+ * skipList.get(10); // 'ten'
+ * skipList.range(5, 15); // [{key: 5, value: 'five'}, {key: 10, value: 'ten'}]
+ * skipList.keys(); // [5, 10, 20]
+ * ```
+ */
+export declare class SkipList<K, V> implements ISkipList<K, V> {
+    private head;
+    private maxLevel;
+    private probability;
+    private compare;
+    private currentLevel;
+    private count;
+    constructor(options?: SkipListOptions<K>);
+    /**
+     * Create a new node with random level
+     */
+    private createNode;
+    /**
+     * Generate random level for new node
+     */
+    private randomLevel;
+    /**
+     * Find the position where key should be or is located
+     * Returns update array with predecessors at each level
+     */
+    private findUpdatePath;
+    /**
+     * Insert or update a key-value pair
+     */
+    set(key: K, value: V): V | undefined;
+    /**
+     * Get value by key
+     */
+    get(key: K): V | undefined;
+    /**
+     * Check if key exists
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a key
+     */
+    delete(key: K): boolean;
+    /**
+     * Get all entries in sorted order
+     */
+    entries(): Array<[K, V]>;
+    /**
+     * Get all keys in sorted order
+     */
+    keys(): K[];
+    /**
+     * Get all values in sorted order by key
+     */
+    values(): V[];
+    /**
+     * Get range of entries
+     */
+    range(startKey: K, endKey: K): RangeResult<K, V>[];
+    /**
+     * Get minimum entry
+     */
+    min(): RangeResult<K, V> | undefined;
+    /**
+     * Get maximum entry
+     */
+    max(): RangeResult<K, V> | undefined;
+    /**
+     * Get kth smallest entry (0-indexed)
+     */
+    getKth(k: number): RangeResult<K, V> | undefined;
+    /**
+     * Count entries in range
+     */
+    countRange(startKey: K, endKey: K): number;
+    /**
+     * Find floor (largest key <= given key)
+     */
+    floor(key: K): RangeResult<K, V> | undefined;
+    /**
+     * Find ceiling (smallest key >= given key)
+     */
+    ceiling(key: K): RangeResult<K, V> | undefined;
+    /**
+     * Iterate over all entries
+     */
+    forEach(callback: (value: V, key: K) => void): void;
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Get statistics
+     */
+    getStats(): SkipListStats;
+    /**
+     * Get size
+     */
+    get size(): number;
+    /**
+     * Check if empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Create skip list from entries
+     */
+    static from<K, V>(entries: Array<[K, V]>, options?: SkipListOptions<K>): SkipList<K, V>;
+    /**
+     * Debug: Print structure
+     */
+    toString(): string;
+    /**
+     * Debug: Validate structure
+     */
+    validate(): boolean;
+}
+//# sourceMappingURL=skip-list.d.ts.map

package/dist/src/data-structures/skip-list/skip-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-list.d.ts","sourceRoot":"","sources":["../../../../src/data-structures/skip-list/skip-list.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,SAAS,EAET,eAAe,EACf,WAAW,EACX,aAAa,EACd,MAAM,uBAAuB,CAAC;AAI/B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IACpD,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,KAAK,CAAS;gBAEV,OAAO,GAAE,eAAe,CAAC,CAAC,CAAM;IAW5C;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAetB;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAmCpC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAoB1B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IA0BvB;;OAEG;IACH,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAYxB;;OAEG;IACH,IAAI,IAAI,CAAC,EAAE;IAYX;;OAEG;IACH,MAAM,IAAI,CAAC,EAAE;IAYb;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;IAuBlD;;OAEG;IACH,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAQpC;;OAEG;IACH,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAsBpC;;OAEG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAoBhD;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM;IAI1C;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAkB5C;;OAEG;IACH,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS;IAkB9C;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IASnD;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,QAAQ,IAAI,aAAa;IAyBzB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;IAQvF;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,QAAQ,IAAI,OAAO;CAyBpB"}