cerceis-lib/dist/kmeans/index.mjs.map

Contains list of quality of life functions that is written in TypeScript and es6

{"version":3,"sources":["../../src/generate/generate.ts","../../src/array/index.ts","../../src/kmeans/kMeans.ts"],"sourcesContent":["import { AlphabateOptions } from \"./types\";\n\n/**\n * Generator that generates all kinds of values.\n * alphanum\n * objectId\n * int\n * array\n */\ninterface generateArrayOptions{\n    min?: number,\n    max?: number\n}\nexport const Generate = {\n    /**\n     * Generates a string consist of alphanumeric characters of given length\n     * @param {number}[len=4] Length of the string \n     * @returns Alphanumeric string\n     */\n    alphanum(len: number = 4): string{\n        const chars: string ='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'\n        if(len === 1) return chars[Math.floor(Math.random() * chars.length)];\n        let result = '';\n        for (let i = len; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)];\n        return result;\n    },\n     /**\n     * Generates Object Id.\n     * @returns \n     */\n    objectId (): string{\n        const timestamp: string = (new Date().getTime() / 1000 | 0).toString(16);\n        return timestamp + 'xxxxxxxxxxxxxxxx'.replace(/[x]/g, () => {\n            return (Math.random() * 16 | 0).toString(16);\n        }).toLowerCase();\n    },\n    /**\n     * Generates random integer in a given range of [).\n     * Includes Min, exclude Max.\n     * @param min \n     * @param max \n     * @returns number\n     */\n    int(min: number, max: number): number{\n        let result: number = 0;\n        result = Math.floor(Math.random() * (max - min))+ min\n        return result\n    },\n    /**\n     * Generate random number.\n     * @param min \n     * @param max \n     * @returns \n     */\n    random(min: number, max: number): number{\n        return Math.random() * (max - min) + min;\n    },\n    /**\n     *  Generates an array with random integer as elemnt of desired length.\n     *  @param len @required Length of the array.\n     *  @returns Array of a given length\n     */\n    array(len: number, ops:generateArrayOptions = {}){\n        const defaultOps: generateArrayOptions = {\n            min:0,\n            max: 11,\n        }\n        const mergedOps: generateArrayOptions = {...defaultOps, ...ops};\n        const rs: number[] = [];\n        for(let i = 0; i< len ; i++)\n            rs.push(this.int(mergedOps.min ?? 0, mergedOps.max ?? 11))\n        return rs\n    },\n    /**\n     * Generates random alphabate of specified length.\n     * @param {number} [len=5] Length of the string. default = 5,\n     * @param {AlphabateOptions} [options] Options\n     */\n    alphabate(\n        len: number = 5,\n        options: AlphabateOptions = {}\n    ): string{\n        const op: AlphabateOptions = {\n            lowercase: true,\n            uppercase: true\n        }\n        Object.assign(op, options);\n        let result = '';\n        const lowerCaseCharacters = \"abcdefghijklmnopqrstuvwxyz\";\n        const upperCaseCharacters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n        let characterPool = \"\";\n        if(op.lowercase) characterPool += lowerCaseCharacters;\n        if(op.uppercase) characterPool += upperCaseCharacters;\n        const charactersLength = characterPool.length;\n        for (let i = 0; i<len; i++){\n            result += characterPool.charAt(Math.floor(Math.random() * charactersLength));\n        }\n        return result;\n    },\n    /**\n     * @returns Current Date Time with a format of \"YYYY-MM-DD\"\"\n     */\n    currentDate(): string{\n        const t: Date = new Date();\n        return `${t.getFullYear()}-${t.getMonth()+1}-${t.getDate()}`;\n    },\n    /**\n     * @returns Current Date Time with a format of \"HH:mm:ss\"\"\n     */\n    currentTime(): string{\n        const t: Date = new Date();\n        return `${String(t.getHours()).padStart(2,\"0\")}:${String(t.getMinutes()).padStart(2,\"0\")}:${String(t.getSeconds()).padStart(2,\"0\")}`;\n    },\n    /**\n     * @returns Current Date Time with a format of \"YYYY-MM-DD HH:mm:ss\"\"\n     */\n    currentDateTime(): string{\n        const t: Date = new Date();\n        return `${t.getFullYear()}-${t.getMonth()+1}-${t.getDate()} ${String(t.getHours()).padStart(2,\"0\")}:${String(t.getMinutes()).padStart(2,\"0\")}:${String(t.getSeconds()).padStart(2,\"0\")}`;\n    },\n    /**\n     * Generates and return list of date of specified day.\n     * Ex: All Sunday and Monday of 2022-01-01 to 2022-03-01\n     * @param f  From : YYYY-MM-DD\n     * @param t  To : YYYY-MM-DD\n     * @param days  number[] 0 ~ 6 Sunday ~ Saturday.\n     */\n    listOfDateOfDays(f: string, t: string, days: number[]){\n        let fromDate = new Date(f);\n        const toData = new Date(t);\n        let fromISO = fromDate.toISOString();\n        const toISO = toData.toISOString();\n        const rs: string[] = [];\n        while(true){\n            if(fromISO > toISO) break;\n            if(days.includes(fromDate.getDay()))\n                rs.push(fromISO.slice(0,10))\n            fromDate.setDate(fromDate.getDate()+1);\n            fromISO = fromDate.toISOString();\n        }\n        return rs;\n    },\n    /**\n     * Fast UUID generator, RFC4122 version 4 compliant.\n     * Copied and rewritted from the below. Thanks for such\n     * elegant code.\n     * @author Jeff Ward (jcward.com).\n     * @license MIT license\n     * @link http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136\n     **/\n    uuidv4(){\n        const lut: string[] = []; \n        for (let i=0; i<256; i++) { lut[i] = (i<16?'0':'')+(i).toString(16); }\n        const d0 = Math.random()*0xffffffff|0;\n        const d1 = Math.random()*0xffffffff|0;\n        const d2 = Math.random()*0xffffffff|0;\n        const d3 = Math.random()*0xffffffff|0;\n        return (\n            lut[d0&0xff]+lut[d0>>8&0xff]+lut[d0>>16&0xff]+lut[d0>>24&0xff]+'-'+\n            lut[d1&0xff]+lut[d1>>8&0xff]+'-'+lut[d1>>16&0x0f|0x40]+lut[d1>>24&0xff]+'-'+\n            lut[d2&0x3f|0x80]+lut[d2>>8&0xff]+'-'+lut[d2>>16&0xff]+lut[d2>>24&0xff]+\n            lut[d3&0xff]+lut[d3>>8&0xff]+lut[d3>>16&0xff]+lut[d3>>24&0xff]\n        );\n    }\n}\n","export const FromArray = {\n    /**\n     * Returns one or more random elements from an array.\n     * @param arr Input array.\n     * @param noOfResult Number of results to return (default 1).\n     * @param returnIndex Return index positions instead of values.\n     */\n    getRandom<T>(arr: T[], noOfResult: number = 1, returnIndex: boolean = false): T[] | number[] {\n        if (!Array.isArray(arr)) throw new Error(\"Input must be an array\");\n        if (returnIndex) {\n            const result: number[] = [];\n            for (let i = 0; i < noOfResult; i++)\n                result.push(Math.floor(Math.random() * arr.length));\n            return result;\n        }\n        const result: T[] = [];\n        for (let i = 0; i < noOfResult; i++)\n            result.push(arr[Math.floor(Math.random() * arr.length)]);\n        return result;\n    },\n    /**\n     * Find and return the largest N numbers.\n     * @param numbers Array of numbers.\n     * @param n Number of results to return (default 1).\n     * @param returnIndex Return indices instead of values.\n     */\n    getLargest(numbers: number[], n: number = 1, returnIndex: boolean = false): number[] {\n        const results: number[] = [];\n        if (returnIndex) {\n            const indexed = numbers.map((v, i) => ({ v, i })).sort((a, b) => b.v - a.v);\n            for (let i = 0; i < n && i < indexed.length; i++) results.push(indexed[i].i);\n        } else {\n            const sorted = [...numbers].sort((a, b) => b - a);\n            for (let i = 0; i < n && i < sorted.length; i++) results.push(sorted[i]);\n        }\n        return results;\n    },\n    /**\n     * Find and return the smallest N numbers.\n     * @param numbers Array of numbers.\n     * @param n Number of results to return (default 1).\n     * @param returnIndex Return indices instead of values.\n     */\n    getSmallest(numbers: number[], n: number = 1, returnIndex: boolean = false): number[] {\n        const results: number[] = [];\n        if (returnIndex) {\n            const indexed = numbers.map((v, i) => ({ v, i })).sort((a, b) => a.v - b.v);\n            for (let i = 0; i < n && i < indexed.length; i++) results.push(indexed[i].i);\n        } else {\n            const sorted = [...numbers].sort((a, b) => a - b);\n            for (let i = 0; i < n && i < sorted.length; i++) results.push(sorted[i]);\n        }\n        return results;\n    },\n    /**\n     * Return the intersection of two arrays.\n     * @param arrA Array A.\n     * @param arrB Array B.\n     * @param duplicated Include duplicate matches.\n     */\n    getIntersect<T>(arrA: T[], arrB: T[], duplicated: boolean = false): T[] {\n        const seen = new Map<string, number>();\n        const result: T[] = [];\n        for (const item of arrA) seen.set(String(item), 1);\n        for (const item of arrB) {\n            const key = String(item);\n            if (seen.has(key)) {\n                if (!duplicated && seen.get(key) === 1) {\n                    result.push(item);\n                    seen.set(key, 2);\n                } else if (duplicated) {\n                    result.push(item);\n                }\n            }\n        }\n        return result;\n    },\n    /**\n     * Randomly shuffle an array in-place (Fisher-Yates).\n     * @param arr Array to shuffle.\n     */\n    shuffle<T>(arr: T[]): T[] {\n        let currentIndex = arr.length;\n        while (currentIndex !== 0) {\n            const randomIndex = Math.floor(Math.random() * currentIndex);\n            currentIndex--;\n            [arr[currentIndex], arr[randomIndex]] = [arr[randomIndex], arr[currentIndex]];\n        }\n        return arr;\n    },\n    /**\n     * The Thanos snap — removes roughly half the elements randomly.\n     * Mutates the original array.\n     * @param arr Input array.\n     */\n    thanosSnap<T>(arr: T[]): T[] {\n        const targetLen = arr.length % 2 === 0 ? arr.length / 2 : (arr.length - 1) / 2;\n        while (arr.length !== targetLen)\n            arr.splice(Math.floor(Math.random() * arr.length), 1);\n        return arr;\n    },\n    /**\n     * Convert a 2D array ([[key, value], ...]) into an object.\n     * @param arr Input 2D array.\n     */\n    toObject<V>(arr: [string | number, V][]): Record<string | number, V> {\n        const obj: Record<string | number, V> = {};\n        for (const [k, v] of arr) obj[k] = v;\n        return obj;\n    },\n    /**\n     * Split an array into groups by ratio.\n     * ex) [1,2,3,4] split [1,3] → {1:[1], 2:[2,3,4]}\n     * Remainder goes into \"extra\" if it doesn't fit.\n     * @param arr Array to split.\n     * @param ratio Ratio to split into.\n     */\n    splitInto<T>(arr: T[], ratio: number[]): Record<string, T[]> {\n        if (ratio.length === 0) return { 1: arr };\n        const filtered = ratio.filter((r) => r !== 0 && !isNaN(r));\n        const unitLen = Math.floor((1 / filtered.reduce((a, b) => a + b)) * arr.length);\n        const rs: Record<string, T[]> = {};\n        let group = 1;\n        let offset = 0;\n        for (const r of ratio) {\n            const len = r * unitLen;\n            rs[group] = arr.slice(offset, offset + len);\n            offset += rs[group].length;\n            group++;\n        }\n        if (offset < arr.length) rs[\"extra\"] = arr.slice(offset);\n        return rs;\n    },\n    /**\n     * Log array elements to console, optionally limited to a range.\n     * @param arr Array to log.\n     * @param from Starting index (inclusive), default 0.\n     * @param to Ending index (exclusive), default arr.length.\n     */\n    log<T>(arr: T[], from: number = 0, to: number = arr.length): void {\n        for (let i = from; i < to; i++) console.log(arr[i]);\n    },\n};\n","import { Generate } from '../generate/generate';\nimport { FromArray } from '../array/index';\n\n// ─── 1-D (original, kept for backward compatibility) ────────────────────────\n\ninterface Cluster {\n    id: number;\n    position: number;\n    childs: number[];\n}\n\n/**\n * Simple 1D K-means clustering.\n * Runs multiple attempts and returns the best result (most balanced cluster sizes).\n * @param k Number of clusters (default 2).\n * @param arr Input data points.\n * @param attempts Number of attempts to run (default 1).\n */\nexport const KMeans = (k: number = 2, arr: number[], attempts: number = 1): Cluster[] => {\n    if (arr.length === 0) throw new Error(\"Empty array.\");\n\n    const max = Math.max(...arr);\n    const min = Math.min(...arr);\n    const variations: Cluster[][] = [];\n\n    for (let attempt = 0; attempt < attempts; attempt++) {\n        let clusters: Cluster[] = [];\n        for (let i = 0; i < k; i++)\n            clusters.push({ id: i + 1, position: Generate.int(min, max + 1), childs: [] });\n\n        let previousClusters: Cluster[] = [];\n        while (!samePositions(clusters, previousClusters)) {\n            previousClusters = clusters.map((c) => ({ ...c }));\n            for (const c of clusters) c.childs = [];\n            clusters = assignPoints(clusters, arr);\n            clusters = recalibrate(clusters);\n        }\n        variations.push(clusters);\n    }\n\n    if (variations.length === 1) return variations[0];\n\n    // Pick the variation with the most balanced cluster sizes\n    const scores = variations.map((v) => {\n        let score = 0;\n        for (let i = 0; i < v.length - 1; i++)\n            score += Math.abs(v[i + 1].childs.length - v[i].childs.length);\n        return score;\n    });\n    const bestIndex = FromArray.getSmallest(scores, 1, true)[0];\n    return variations[bestIndex];\n};\n\nfunction samePositions(clusters: Cluster[], prev: Cluster[]): boolean {\n    if (prev.length === 0) return false;\n    return clusters.every((c, i) => c.position === prev[i].position);\n}\n\nfunction assignPoints(clusters: Cluster[], arr: number[]): Cluster[] {\n    for (const point of arr) {\n        const distances = clusters.map((c) => Math.abs(c.position - point));\n        const nearest = FromArray.getSmallest(distances, 1, true)[0];\n        clusters[nearest].childs.push(point);\n    }\n    return clusters;\n}\n\nfunction recalibrate(clusters: Cluster[]): Cluster[] {\n    for (const c of clusters) {\n        if (c.childs.length === 0) continue;\n        const mean = c.childs.reduce((a, b) => a + b, 0) / c.childs.length;\n        c.position = Number(mean.toFixed(2));\n    }\n    return clusters;\n}\n\n// ─── N-dimensional ──────────────────────────────────────────────────────────\n\nexport interface NDCluster<T> {\n    /** 1-based cluster id */\n    id: number;\n    /** Mean position in feature space */\n    centroid: number[];\n    /** Original data items assigned to this cluster */\n    members: T[];\n    /** Number of members */\n    size: number;\n    /**\n     * Within-cluster sum of squares — sum of squared Euclidean distances\n     * from each member to the centroid. Lower means a tighter, more\n     * cohesive cluster.\n     */\n    wcss: number;\n}\n\nexport type FeatureExtractor<T> = (item: T) => number[];\n\nexport interface KMeansNDOptions {\n    /**\n     * Number of independent runs. The run with the lowest total WCSS wins.\n     * More attempts → more reliable result at the cost of compute.\n     * Default: 5.\n     */\n    attempts?: number;\n    /**\n     * Centroid initialisation strategy.\n     * - `'kmeans++'` (default) spreads initial centroids far apart,\n     *   which dramatically reduces the chance of a poor local minimum.\n     * - `'random'` picks k random data points as starting centroids.\n     */\n    init?: 'random' | 'kmeans++';\n    /**\n     * Hard cap on iteration count per attempt.\n     * Default: 300.\n     */\n    maxIter?: number;\n}\n\n/**\n * N-dimensional K-means clustering suitable for production analytics\n * (customer segmentation, product segmentation, etc.).\n *\n * @param k Number of clusters.\n * @param data Array of items to cluster.\n * @param features Function that extracts a numeric feature vector from each item.\n *   All vectors must have the same length.\n * @param options Optional tuning parameters.\n *\n * @example\n * // Customer segmentation by recency, frequency, monetary value (RFM)\n * const segments = KMeansND(3, customers, (c) => [c.recency, c.frequency, c.spend]);\n *\n * @example\n * // Works with plain number arrays too\n * const result = KMeansND(2, [[1,2],[3,4],[100,200]], (x) => x);\n */\nexport const KMeansND = <T>(\n    k: number,\n    data: T[],\n    features: FeatureExtractor<T>,\n    options: KMeansNDOptions = {},\n): NDCluster<T>[] => {\n    if (data.length === 0) throw new Error(\"Empty data array.\");\n    if (k < 1) throw new Error(\"k must be >= 1.\");\n    if (k > data.length) throw new Error(\"k cannot exceed the number of data points.\");\n\n    const { attempts = 5, init = 'kmeans++', maxIter = 300 } = options;\n\n    const points = data.map(features);\n    const dims = points[0].length;\n    if (points.some((p) => p.length !== dims))\n        throw new Error(\"All feature vectors must have the same length.\");\n\n    let bestClusters: NDCluster<T>[] | null = null;\n    let bestTotalWCSS = Infinity;\n\n    for (let attempt = 0; attempt < attempts; attempt++) {\n        const centroids =\n            init === 'kmeans++'\n                ? initKMeansPlusPlus(points, k)\n                : initRandom(points, k);\n\n        const memberIndices: number[][] = Array.from({ length: k }, () => []);\n        let prevCentroids: number[][] = [];\n        let iter = 0;\n\n        while (!centroidsConverged(centroids, prevCentroids) && iter < maxIter) {\n            prevCentroids = centroids.map((c) => [...c]);\n            for (const m of memberIndices) m.length = 0;\n\n            // Assign each point to the nearest centroid\n            for (let p = 0; p < points.length; p++) {\n                const dists = centroids.map((c) => euclidean(c, points[p]));\n                let nearest = 0;\n                for (let c = 1; c < k; c++)\n                    if (dists[c] < dists[nearest]) nearest = c;\n                memberIndices[nearest].push(p);\n            }\n\n            // Re-initialise empty clusters to a random data point\n            for (let c = 0; c < k; c++) {\n                if (memberIndices[c].length === 0) {\n                    const randomIdx = Math.floor(Math.random() * points.length);\n                    memberIndices[c].push(randomIdx);\n                }\n            }\n\n            // Recompute centroids as mean of assigned points\n            for (let c = 0; c < k; c++) {\n                const newCentroid = new Array(dims).fill(0);\n                for (const idx of memberIndices[c])\n                    for (let d = 0; d < dims; d++)\n                        newCentroid[d] += points[idx][d];\n                for (let d = 0; d < dims; d++)\n                    newCentroid[d] /= memberIndices[c].length;\n                centroids[c] = newCentroid;\n            }\n\n            iter++;\n        }\n\n        // Build result clusters and compute WCSS\n        const clusters: NDCluster<T>[] = centroids.map((centroid, c) => {\n            const members = memberIndices[c].map((i) => data[i]);\n            const wcss = memberIndices[c].reduce(\n                (sum, i) => sum + euclideanSq(points[i], centroid),\n                0,\n            );\n            return { id: c + 1, centroid, members, size: members.length, wcss };\n        });\n\n        const totalWCSS = clusters.reduce((s, c) => s + c.wcss, 0);\n        if (totalWCSS < bestTotalWCSS) {\n            bestTotalWCSS = totalWCSS;\n            bestClusters = clusters;\n        }\n    }\n\n    return bestClusters!;\n};\n\n// ─── Helpers ─────────────────────────────────────────────────────────────────\n\nfunction euclidean(a: number[], b: number[]): number {\n    return Math.sqrt(euclideanSq(a, b));\n}\n\nfunction euclideanSq(a: number[], b: number[]): number {\n    let sum = 0;\n    for (let i = 0; i < a.length; i++) sum += (a[i] - b[i]) ** 2;\n    return sum;\n}\n\n/** K-means++ centroid seeding for better convergence. */\nfunction initKMeansPlusPlus(points: number[][], k: number): number[][] {\n    const centroids: number[][] = [];\n    // Pick first centroid at random\n    centroids.push([...points[Math.floor(Math.random() * points.length)]]);\n\n    for (let c = 1; c < k; c++) {\n        // For each point, D² = squared distance to nearest existing centroid\n        const weights = points.map((p) => {\n            let minDist = Infinity;\n            for (const centroid of centroids) {\n                const d = euclideanSq(p, centroid);\n                if (d < minDist) minDist = d;\n            }\n            return minDist;\n        });\n        // Weighted random selection\n        centroids.push([...weightedChoice(points, weights)]);\n    }\n    return centroids;\n}\n\nfunction initRandom(points: number[][], k: number): number[][] {\n    const indices = new Set<number>();\n    while (indices.size < k)\n        indices.add(Math.floor(Math.random() * points.length));\n    return [...indices].map((i) => [...points[i]]);\n}\n\nfunction weightedChoice(points: number[][], weights: number[]): number[] {\n    const total = weights.reduce((a, b) => a + b, 0);\n    let r = Math.random() * total;\n    for (let i = 0; i < weights.length; i++) {\n        r -= weights[i];\n        if (r <= 0) return points[i];\n    }\n    return points[points.length - 1];\n}\n\nconst CONVERGENCE_EPSILON = 1e-10;\n\nfunction centroidsConverged(curr: number[][], prev: number[][]): boolean {\n    if (prev.length === 0) return false;\n    return curr.every((c, i) => euclidean(c, prev[i]) < CONVERGENCE_EPSILON);\n}\n"],"mappings":";AAaO,IAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMpB,SAAS,MAAc,GAAU;AAC7B,UAAM,QAAe;AACrB,QAAG,QAAQ,EAAG,QAAO,MAAM,KAAK,MAAM,KAAK,OAAO,IAAI,MAAM,MAAM,CAAC;AACnE,QAAI,SAAS;AACb,aAAS,IAAI,KAAK,IAAI,GAAG,EAAE,EAAG,WAAU,MAAM,KAAK,MAAM,KAAK,OAAO,IAAI,MAAM,MAAM,CAAC;AACtF,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,WAAmB;AACf,UAAM,cAAqB,oBAAI,KAAK,GAAE,QAAQ,IAAI,MAAO,GAAG,SAAS,EAAE;AACvE,WAAO,YAAY,mBAAmB,QAAQ,QAAQ,MAAM;AACxD,cAAQ,KAAK,OAAO,IAAI,KAAK,GAAG,SAAS,EAAE;AAAA,IAC/C,CAAC,EAAE,YAAY;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAI,KAAa,KAAoB;AACjC,QAAI,SAAiB;AACrB,aAAS,KAAK,MAAM,KAAK,OAAO,KAAK,MAAM,IAAI,IAAG;AAClD,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,KAAa,KAAoB;AACpC,WAAO,KAAK,OAAO,KAAK,MAAM,OAAO;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,KAAa,MAA2B,CAAC,GAAE;AAC7C,UAAM,aAAmC;AAAA,MACrC,KAAI;AAAA,MACJ,KAAK;AAAA,IACT;AACA,UAAM,YAAkC,EAAC,GAAG,YAAY,GAAG,IAAG;AAC9D,UAAM,KAAe,CAAC;AACtB,aAAQ,IAAI,GAAG,IAAG,KAAM;AACpB,SAAG,KAAK,KAAK,IAAI,UAAU,OAAO,GAAG,UAAU,OAAO,EAAE,CAAC;AAC7D,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UACI,MAAc,GACd,UAA4B,CAAC,GACxB;AACL,UAAM,KAAuB;AAAA,MACzB,WAAW;AAAA,MACX,WAAW;AAAA,IACf;AACA,WAAO,OAAO,IAAI,OAAO;AACzB,QAAI,SAAS;AACb,UAAM,sBAAsB;AAC5B,UAAM,sBAAsB;AAC5B,QAAI,gBAAgB;AACpB,QAAG,GAAG,UAAW,kBAAiB;AAClC,QAAG,GAAG,UAAW,kBAAiB;AAClC,UAAM,mBAAmB,cAAc;AACvC,aAAS,IAAI,GAAG,IAAE,KAAK,KAAI;AACvB,gBAAU,cAAc,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,gBAAgB,CAAC;AAAA,IAC/E;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAIA,cAAqB;AACjB,UAAM,IAAU,oBAAI,KAAK;AACzB,WAAO,GAAG,EAAE,YAAY,CAAC,IAAI,EAAE,SAAS,IAAE,CAAC,IAAI,EAAE,QAAQ,CAAC;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA,EAIA,cAAqB;AACjB,UAAM,IAAU,oBAAI,KAAK;AACzB,WAAO,GAAG,OAAO,EAAE,SAAS,CAAC,EAAE,SAAS,GAAE,GAAG,CAAC,IAAI,OAAO,EAAE,WAAW,CAAC,EAAE,SAAS,GAAE,GAAG,CAAC,IAAI,OAAO,EAAE,WAAW,CAAC,EAAE,SAAS,GAAE,GAAG,CAAC;AAAA,EACtI;AAAA;AAAA;AAAA;AAAA,EAIA,kBAAyB;AACrB,UAAM,IAAU,oBAAI,KAAK;AACzB,WAAO,GAAG,EAAE,YAAY,CAAC,IAAI,EAAE,SAAS,IAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,OAAO,EAAE,SAAS,CAAC,EAAE,SAAS,GAAE,GAAG,CAAC,IAAI,OAAO,EAAE,WAAW,CAAC,EAAE,SAAS,GAAE,GAAG,CAAC,IAAI,OAAO,EAAE,WAAW,CAAC,EAAE,SAAS,GAAE,GAAG,CAAC;AAAA,EAC1L;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,iBAAiB,GAAW,GAAW,MAAe;AAClD,QAAI,WAAW,IAAI,KAAK,CAAC;AACzB,UAAM,SAAS,IAAI,KAAK,CAAC;AACzB,QAAI,UAAU,SAAS,YAAY;AACnC,UAAM,QAAQ,OAAO,YAAY;AACjC,UAAM,KAAe,CAAC;AACtB,WAAM,MAAK;AACP,UAAG,UAAU,MAAO;AACpB,UAAG,KAAK,SAAS,SAAS,OAAO,CAAC;AAC9B,WAAG,KAAK,QAAQ,MAAM,GAAE,EAAE,CAAC;AAC/B,eAAS,QAAQ,SAAS,QAAQ,IAAE,CAAC;AACrC,gBAAU,SAAS,YAAY;AAAA,IACnC;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,SAAQ;AACJ,UAAM,MAAgB,CAAC;AACvB,aAAS,IAAE,GAAG,IAAE,KAAK,KAAK;AAAE,UAAI,CAAC,KAAK,IAAE,KAAG,MAAI,MAAK,EAAG,SAAS,EAAE;AAAA,IAAG;AACrE,UAAM,KAAK,KAAK,OAAO,IAAE,aAAW;AACpC,UAAM,KAAK,KAAK,OAAO,IAAE,aAAW;AACpC,UAAM,KAAK,KAAK,OAAO,IAAE,aAAW;AACpC,UAAM,KAAK,KAAK,OAAO,IAAE,aAAW;AACpC,WACI,IAAI,KAAG,GAAI,IAAE,IAAI,MAAI,IAAE,GAAI,IAAE,IAAI,MAAI,KAAG,GAAI,IAAE,IAAI,MAAI,KAAG,GAAI,IAAE,MAC/D,IAAI,KAAG,GAAI,IAAE,IAAI,MAAI,IAAE,GAAI,IAAE,MAAI,IAAI,MAAI,KAAG,KAAK,EAAI,IAAE,IAAI,MAAI,KAAG,GAAI,IAAE,MACxE,IAAI,KAAG,KAAK,GAAI,IAAE,IAAI,MAAI,IAAE,GAAI,IAAE,MAAI,IAAI,MAAI,KAAG,GAAI,IAAE,IAAI,MAAI,KAAG,GAAI,IACtE,IAAI,KAAG,GAAI,IAAE,IAAI,MAAI,IAAE,GAAI,IAAE,IAAI,MAAI,KAAG,GAAI,IAAE,IAAI,MAAI,KAAG,GAAI;AAAA,EAErE;AACJ;;;ACpKO,IAAM,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrB,UAAa,KAAU,aAAqB,GAAG,cAAuB,OAAuB;AACzF,QAAI,CAAC,MAAM,QAAQ,GAAG,EAAG,OAAM,IAAI,MAAM,wBAAwB;AACjE,QAAI,aAAa;AACb,YAAMA,UAAmB,CAAC;AAC1B,eAAS,IAAI,GAAG,IAAI,YAAY;AAC5B,QAAAA,QAAO,KAAK,KAAK,MAAM,KAAK,OAAO,IAAI,IAAI,MAAM,CAAC;AACtD,aAAOA;AAAA,IACX;AACA,UAAM,SAAc,CAAC;AACrB,aAAS,IAAI,GAAG,IAAI,YAAY;AAC5B,aAAO,KAAK,IAAI,KAAK,MAAM,KAAK,OAAO,IAAI,IAAI,MAAM,CAAC,CAAC;AAC3D,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,WAAW,SAAmB,IAAY,GAAG,cAAuB,OAAiB;AACjF,UAAM,UAAoB,CAAC;AAC3B,QAAI,aAAa;AACb,YAAM,UAAU,QAAQ,IAAI,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC;AAC1E,eAAS,IAAI,GAAG,IAAI,KAAK,IAAI,QAAQ,QAAQ,IAAK,SAAQ,KAAK,QAAQ,CAAC,EAAE,CAAC;AAAA,IAC/E,OAAO;AACH,YAAM,SAAS,CAAC,GAAG,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AAChD,eAAS,IAAI,GAAG,IAAI,KAAK,IAAI,OAAO,QAAQ,IAAK,SAAQ,KAAK,OAAO,CAAC,CAAC;AAAA,IAC3E;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,YAAY,SAAmB,IAAY,GAAG,cAAuB,OAAiB;AAClF,UAAM,UAAoB,CAAC;AAC3B,QAAI,aAAa;AACb,YAAM,UAAU,QAAQ,IAAI,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC;AAC1E,eAAS,IAAI,GAAG,IAAI,KAAK,IAAI,QAAQ,QAAQ,IAAK,SAAQ,KAAK,QAAQ,CAAC,EAAE,CAAC;AAAA,IAC/E,OAAO;AACH,YAAM,SAAS,CAAC,GAAG,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AAChD,eAAS,IAAI,GAAG,IAAI,KAAK,IAAI,OAAO,QAAQ,IAAK,SAAQ,KAAK,OAAO,CAAC,CAAC;AAAA,IAC3E;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,aAAgB,MAAW,MAAW,aAAsB,OAAY;AACpE,UAAM,OAAO,oBAAI,IAAoB;AACrC,UAAM,SAAc,CAAC;AACrB,eAAW,QAAQ,KAAM,MAAK,IAAI,OAAO,IAAI,GAAG,CAAC;AACjD,eAAW,QAAQ,MAAM;AACrB,YAAM,MAAM,OAAO,IAAI;AACvB,UAAI,KAAK,IAAI,GAAG,GAAG;AACf,YAAI,CAAC,cAAc,KAAK,IAAI,GAAG,MAAM,GAAG;AACpC,iBAAO,KAAK,IAAI;AAChB,eAAK,IAAI,KAAK,CAAC;AAAA,QACnB,WAAW,YAAY;AACnB,iBAAO,KAAK,IAAI;AAAA,QACpB;AAAA,MACJ;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,QAAW,KAAe;AACtB,QAAI,eAAe,IAAI;AACvB,WAAO,iBAAiB,GAAG;AACvB,YAAM,cAAc,KAAK,MAAM,KAAK,OAAO,IAAI,YAAY;AAC3D;AACA,OAAC,IAAI,YAAY,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,WAAW,GAAG,IAAI,YAAY,CAAC;AAAA,IAChF;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAc,KAAe;AACzB,UAAM,YAAY,IAAI,SAAS,MAAM,IAAI,IAAI,SAAS,KAAK,IAAI,SAAS,KAAK;AAC7E,WAAO,IAAI,WAAW;AAClB,UAAI,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,IAAI,MAAM,GAAG,CAAC;AACxD,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,SAAY,KAAyD;AACjE,UAAM,MAAkC,CAAC;AACzC,eAAW,CAAC,GAAG,CAAC,KAAK,IAAK,KAAI,CAAC,IAAI;AACnC,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,UAAa,KAAU,OAAsC;AACzD,QAAI,MAAM,WAAW,EAAG,QAAO,EAAE,GAAG,IAAI;AACxC,UAAM,WAAW,MAAM,OAAO,CAAC,MAAM,MAAM,KAAK,CAAC,MAAM,CAAC,CAAC;AACzD,UAAM,UAAU,KAAK,MAAO,IAAI,SAAS,OAAO,CAAC,GAAG,MAAM,IAAI,CAAC,IAAK,IAAI,MAAM;AAC9E,UAAM,KAA0B,CAAC;AACjC,QAAI,QAAQ;AACZ,QAAI,SAAS;AACb,eAAW,KAAK,OAAO;AACnB,YAAM,MAAM,IAAI;AAChB,SAAG,KAAK,IAAI,IAAI,MAAM,QAAQ,SAAS,GAAG;AAC1C,gBAAU,GAAG,KAAK,EAAE;AACpB;AAAA,IACJ;AACA,QAAI,SAAS,IAAI,OAAQ,IAAG,OAAO,IAAI,IAAI,MAAM,MAAM;AACvD,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAO,KAAU,OAAe,GAAG,KAAa,IAAI,QAAc;AAC9D,aAAS,IAAI,MAAM,IAAI,IAAI,IAAK,SAAQ,IAAI,IAAI,CAAC,CAAC;AAAA,EACtD;AACJ;;;AC5HO,IAAM,SAAS,CAAC,IAAY,GAAG,KAAe,WAAmB,MAAiB;AACrF,MAAI,IAAI,WAAW,EAAG,OAAM,IAAI,MAAM,cAAc;AAEpD,QAAM,MAAM,KAAK,IAAI,GAAG,GAAG;AAC3B,QAAM,MAAM,KAAK,IAAI,GAAG,GAAG;AAC3B,QAAM,aAA0B,CAAC;AAEjC,WAAS,UAAU,GAAG,UAAU,UAAU,WAAW;AACjD,QAAI,WAAsB,CAAC;AAC3B,aAAS,IAAI,GAAG,IAAI,GAAG;AACnB,eAAS,KAAK,EAAE,IAAI,IAAI,GAAG,UAAU,SAAS,IAAI,KAAK,MAAM,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC;AAEjF,QAAI,mBAA8B,CAAC;AACnC,WAAO,CAAC,cAAc,UAAU,gBAAgB,GAAG;AAC/C,yBAAmB,SAAS,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE;AACjD,iBAAW,KAAK,SAAU,GAAE,SAAS,CAAC;AACtC,iBAAW,aAAa,UAAU,GAAG;AACrC,iBAAW,YAAY,QAAQ;AAAA,IACnC;AACA,eAAW,KAAK,QAAQ;AAAA,EAC5B;AAEA,MAAI,WAAW,WAAW,EAAG,QAAO,WAAW,CAAC;AAGhD,QAAM,SAAS,WAAW,IAAI,CAAC,MAAM;AACjC,QAAI,QAAQ;AACZ,aAAS,IAAI,GAAG,IAAI,EAAE,SAAS,GAAG;AAC9B,eAAS,KAAK,IAAI,EAAE,IAAI,CAAC,EAAE,OAAO,SAAS,EAAE,CAAC,EAAE,OAAO,MAAM;AACjE,WAAO;AAAA,EACX,CAAC;AACD,QAAM,YAAY,UAAU,YAAY,QAAQ,GAAG,IAAI,EAAE,CAAC;AAC1D,SAAO,WAAW,SAAS;AAC/B;AAEA,SAAS,cAAc,UAAqB,MAA0B;AAClE,MAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,SAAO,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,aAAa,KAAK,CAAC,EAAE,QAAQ;AACnE;AAEA,SAAS,aAAa,UAAqB,KAA0B;AACjE,aAAW,SAAS,KAAK;AACrB,UAAM,YAAY,SAAS,IAAI,CAAC,MAAM,KAAK,IAAI,EAAE,WAAW,KAAK,CAAC;AAClE,UAAM,UAAU,UAAU,YAAY,WAAW,GAAG,IAAI,EAAE,CAAC;AAC3D,aAAS,OAAO,EAAE,OAAO,KAAK,KAAK;AAAA,EACvC;AACA,SAAO;AACX;AAEA,SAAS,YAAY,UAAgC;AACjD,aAAW,KAAK,UAAU;AACtB,QAAI,EAAE,OAAO,WAAW,EAAG;AAC3B,UAAM,OAAO,EAAE,OAAO,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI,EAAE,OAAO;AAC5D,MAAE,WAAW,OAAO,KAAK,QAAQ,CAAC,CAAC;AAAA,EACvC;AACA,SAAO;AACX;AA8DO,IAAM,WAAW,CACpB,GACA,MACA,UACA,UAA2B,CAAC,MACX;AACjB,MAAI,KAAK,WAAW,EAAG,OAAM,IAAI,MAAM,mBAAmB;AAC1D,MAAI,IAAI,EAAG,OAAM,IAAI,MAAM,iBAAiB;AAC5C,MAAI,IAAI,KAAK,OAAQ,OAAM,IAAI,MAAM,4CAA4C;AAEjF,QAAM,EAAE,WAAW,GAAG,OAAO,YAAY,UAAU,IAAI,IAAI;AAE3D,QAAM,SAAS,KAAK,IAAI,QAAQ;AAChC,QAAM,OAAO,OAAO,CAAC,EAAE;AACvB,MAAI,OAAO,KAAK,CAAC,MAAM,EAAE,WAAW,IAAI;AACpC,UAAM,IAAI,MAAM,gDAAgD;AAEpE,MAAI,eAAsC;AAC1C,MAAI,gBAAgB;AAEpB,WAAS,UAAU,GAAG,UAAU,UAAU,WAAW;AACjD,UAAM,YACF,SAAS,aACH,mBAAmB,QAAQ,CAAC,IAC5B,WAAW,QAAQ,CAAC;AAE9B,UAAM,gBAA4B,MAAM,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,CAAC;AACpE,QAAI,gBAA4B,CAAC;AACjC,QAAI,OAAO;AAEX,WAAO,CAAC,mBAAmB,WAAW,aAAa,KAAK,OAAO,SAAS;AACpE,sBAAgB,UAAU,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AAC3C,iBAAW,KAAK,cAAe,GAAE,SAAS;AAG1C,eAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACpC,cAAM,QAAQ,UAAU,IAAI,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC;AAC1D,YAAI,UAAU;AACd,iBAAS,IAAI,GAAG,IAAI,GAAG;AACnB,cAAI,MAAM,CAAC,IAAI,MAAM,OAAO,EAAG,WAAU;AAC7C,sBAAc,OAAO,EAAE,KAAK,CAAC;AAAA,MACjC;AAGA,eAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,YAAI,cAAc,CAAC,EAAE,WAAW,GAAG;AAC/B,gBAAM,YAAY,KAAK,MAAM,KAAK,OAAO,IAAI,OAAO,MAAM;AAC1D,wBAAc,CAAC,EAAE,KAAK,SAAS;AAAA,QACnC;AAAA,MACJ;AAGA,eAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,cAAM,cAAc,IAAI,MAAM,IAAI,EAAE,KAAK,CAAC;AAC1C,mBAAW,OAAO,cAAc,CAAC;AAC7B,mBAAS,IAAI,GAAG,IAAI,MAAM;AACtB,wBAAY,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC;AACvC,iBAAS,IAAI,GAAG,IAAI,MAAM;AACtB,sBAAY,CAAC,KAAK,cAAc,CAAC,EAAE;AACvC,kBAAU,CAAC,IAAI;AAAA,MACnB;AAEA;AAAA,IACJ;AAGA,UAAM,WAA2B,UAAU,IAAI,CAAC,UAAU,MAAM;AAC5D,YAAM,UAAU,cAAc,CAAC,EAAE,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC;AACnD,YAAM,OAAO,cAAc,CAAC,EAAE;AAAA,QAC1B,CAAC,KAAK,MAAM,MAAM,YAAY,OAAO,CAAC,GAAG,QAAQ;AAAA,QACjD;AAAA,MACJ;AACA,aAAO,EAAE,IAAI,IAAI,GAAG,UAAU,SAAS,MAAM,QAAQ,QAAQ,KAAK;AAAA,IACtE,CAAC;AAED,UAAM,YAAY,SAAS,OAAO,CAAC,GAAG,MAAM,IAAI,EAAE,MAAM,CAAC;AACzD,QAAI,YAAY,eAAe;AAC3B,sBAAgB;AAChB,qBAAe;AAAA,IACnB;AAAA,EACJ;AAEA,SAAO;AACX;AAIA,SAAS,UAAU,GAAa,GAAqB;AACjD,SAAO,KAAK,KAAK,YAAY,GAAG,CAAC,CAAC;AACtC;AAEA,SAAS,YAAY,GAAa,GAAqB;AACnD,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,IAAK,SAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,MAAM;AAC3D,SAAO;AACX;AAGA,SAAS,mBAAmB,QAAoB,GAAuB;AACnE,QAAM,YAAwB,CAAC;AAE/B,YAAU,KAAK,CAAC,GAAG,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,OAAO,MAAM,CAAC,CAAC,CAAC;AAErE,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAExB,UAAM,UAAU,OAAO,IAAI,CAAC,MAAM;AAC9B,UAAI,UAAU;AACd,iBAAW,YAAY,WAAW;AAC9B,cAAM,IAAI,YAAY,GAAG,QAAQ;AACjC,YAAI,IAAI,QAAS,WAAU;AAAA,MAC/B;AACA,aAAO;AAAA,IACX,CAAC;AAED,cAAU,KAAK,CAAC,GAAG,eAAe,QAAQ,OAAO,CAAC,CAAC;AAAA,EACvD;AACA,SAAO;AACX;AAEA,SAAS,WAAW,QAAoB,GAAuB;AAC3D,QAAM,UAAU,oBAAI,IAAY;AAChC,SAAO,QAAQ,OAAO;AAClB,YAAQ,IAAI,KAAK,MAAM,KAAK,OAAO,IAAI,OAAO,MAAM,CAAC;AACzD,SAAO,CAAC,GAAG,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;AACjD;AAEA,SAAS,eAAe,QAAoB,SAA6B;AACrE,QAAM,QAAQ,QAAQ,OAAO,CAAC,GAAG,MAAM,IAAI,GAAG,CAAC;AAC/C,MAAI,IAAI,KAAK,OAAO,IAAI;AACxB,WAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACrC,SAAK,QAAQ,CAAC;AACd,QAAI,KAAK,EAAG,QAAO,OAAO,CAAC;AAAA,EAC/B;AACA,SAAO,OAAO,OAAO,SAAS,CAAC;AACnC;AAEA,IAAM,sBAAsB;AAE5B,SAAS,mBAAmB,MAAkB,MAA2B;AACrE,MAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,SAAO,KAAK,MAAM,CAAC,GAAG,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,IAAI,mBAAmB;AAC3E;","names":["result"]}