{"version":3,"sources":["jsdelivr-header.js","/npm/@yogesh0333/yogiway@1.2.2/dist/index.js"],"names":[],"mappings":"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","file":"/npm/@yogesh0333/yogiway@1.2.2/dist/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@yogesh0333/yogiway@1.2.2/dist/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\n/**\n * YOGIWAY Format v2 - Ultra-compact, nested-aware data format for LLM prompts\n * Improved with circular reference detection, path compression, and adaptive flattening\n * FREE AND OPEN SOURCE - No license required\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.smartEncode = exports.fromYogiway = exports.toYogiway = exports.fromPathx = exports.toPathx = exports.pathxToYogiway = exports.yogiwayToPathx = exports.pathxDecode = exports.pathxEncode = void 0;\nexports.encode = encode;\nexports.decode = decode;\n/**\n * Compress path by abbreviating common patterns\n */\nfunction compressPath(path) {\n    // Abbreviate common patterns\n    return path\n        .replace(/level(\\d+)/g, \"l$1\") // level1 -> l1\n        .replace(/data\\./g, \"d.\") // data. -> d.\n        .replace(/profile\\./g, \"p.\") // profile. -> p.\n        .replace(/personal\\./g, \"ps.\") // personal. -> ps.\n        .replace(/address\\./g, \"a.\") // address. -> a.\n        .replace(/config/gi, \"cfg\") // config -> cfg\n        .replace(/metadata/gi, \"meta\") // metadata -> meta\n        .replace(/preferences/gi, \"pref\") // preferences -> pref\n        .replace(/notifications/gi, \"notif\"); // notifications -> notif\n}\n/**\n * Expand compressed path back to full path\n */\nfunction expandPath(path) {\n    // Reverse compression (simplified - full implementation would need mapping)\n    return path\n        .replace(/l(\\d+)/g, \"level$1\")\n        .replace(/^d\\./, \"data.\")\n        .replace(/\\.d\\./g, \".data.\")\n        .replace(/^p\\./, \"profile.\")\n        .replace(/\\.p\\./g, \".profile.\");\n}\n/**\n * Find common path prefixes and create abbreviation map\n */\nfunction createPathAbbreviationMap(paths) {\n    const map = {};\n    const reverse = {};\n    // Find common prefixes\n    const prefixCounts = {};\n    paths.forEach((path) => {\n        const parts = path.split(\".\");\n        for (let i = 1; i < parts.length; i++) {\n            const prefix = parts.slice(0, i).join(\".\");\n            prefixCounts[prefix] = (prefixCounts[prefix] || 0) + 1;\n        }\n    });\n    // Create abbreviations for common prefixes (used 3+ times)\n    let abbrIndex = 0;\n    const usedAbbrs = new Set();\n    Object.entries(prefixCounts)\n        .filter(([_, count]) => count >= 3)\n        .sort(([_, a], [__, b]) => b - a) // Most common first\n        .forEach(([prefix]) => {\n        const abbr = String.fromCharCode(97 + (abbrIndex % 26)); // a-z\n        if (!usedAbbrs.has(abbr)) {\n            map[prefix] = abbr;\n            reverse[abbr] = prefix;\n            usedAbbrs.add(abbr);\n            abbrIndex++;\n        }\n    });\n    return { map, reverse };\n}\n/**\n * Flatten an object with lazy path resolution for better performance\n */\nfunction flattenObjectLazy(obj, prefix = \"\", maxDepth = 100, currentDepth = 0, visited = new WeakSet(), compressPaths = true, pathRefs) {\n    // For deep nesting, use path references if available\n    if (currentDepth > 5 && pathRefs) {\n        const pathKey = prefix || \"root\";\n        if (pathRefs[pathKey]) {\n            // Use cached path reference - defer full flattening\n            const result = {};\n            // Only flatten if it's a simple value, otherwise defer\n            if (typeof obj !== \"object\" || obj === null || Array.isArray(obj)) {\n                return flattenObject(obj, prefix, maxDepth, currentDepth, visited, compressPaths);\n            }\n            result[pathRefs[pathKey]] = obj;\n            return result;\n        }\n    }\n    // Fall back to normal flattening\n    return flattenObject(obj, prefix, maxDepth, currentDepth, visited, compressPaths);\n}\n/**\n * Flatten an object with circular reference detection and path compression\n */\nfunction flattenObject(obj, prefix = \"\", maxDepth = 100, currentDepth = 0, visited = new WeakSet(), compressPaths = true) {\n    if (currentDepth >= maxDepth) {\n        return { [prefix || \"value\"]: JSON.stringify(obj) };\n    }\n    // Circular reference detection\n    if (typeof obj === \"object\" && obj !== null) {\n        if (visited.has(obj)) {\n            throw new Error(`Circular reference detected at path: ${prefix || \"root\"}`);\n        }\n        visited.add(obj);\n    }\n    const result = {};\n    try {\n        if (obj === null || obj === undefined) {\n            return { [prefix || \"value\"]: null };\n        }\n        if (Array.isArray(obj)) {\n            obj.forEach((item, index) => {\n                const newPrefix = prefix ? `${prefix}[${index}]` : `[${index}]`;\n                if (typeof item === \"object\" && item !== null && !Array.isArray(item)) {\n                    Object.assign(result, flattenObject(item, newPrefix, maxDepth, currentDepth + 1, visited, compressPaths));\n                }\n                else {\n                    result[newPrefix] = item;\n                }\n            });\n            return result;\n        }\n        if (typeof obj === \"object\") {\n            for (const [key, value] of Object.entries(obj)) {\n                const newPrefix = prefix ? `${prefix}.${key}` : key;\n                if (value === null || value === undefined) {\n                    result[newPrefix] = null;\n                }\n                else if (Array.isArray(value)) {\n                    if (value.length === 0) {\n                        result[newPrefix] = \"[]\";\n                    }\n                    else if (value.every((item) => typeof item !== \"object\" || item === null)) {\n                        result[newPrefix] = value\n                            .map((v) => typeof v === \"string\" && (v.includes(\"\\t\") || v.includes(\"\\n\"))\n                            ? JSON.stringify(v)\n                            : String(v))\n                            .join(\"|\");\n                    }\n                    else {\n                        value.forEach((item, index) => {\n                            const arrayPrefix = `${newPrefix}[${index}]`;\n                            if (typeof item === \"object\" && item !== null) {\n                                Object.assign(result, flattenObject(item, arrayPrefix, maxDepth, currentDepth + 1, visited, compressPaths));\n                            }\n                            else {\n                                result[arrayPrefix] = item;\n                            }\n                        });\n                    }\n                }\n                else if (typeof value === \"object\") {\n                    Object.assign(result, flattenObject(value, newPrefix, maxDepth, currentDepth + 1, visited, compressPaths));\n                }\n                else {\n                    result[newPrefix] = value;\n                }\n            }\n            return result;\n        }\n        return { [prefix || \"value\"]: obj };\n    }\n    finally {\n        // Remove from visited set when done with this branch\n        if (typeof obj === \"object\" && obj !== null) {\n            visited.delete(obj);\n        }\n    }\n}\n/**\n * Calculate if flattening is beneficial\n */\nfunction shouldFlatten(paths, avgDepth) {\n    // Don't flatten if average depth is too high (path overhead)\n    if (avgDepth > 15)\n        return false;\n    // Don't flatten if too many unique paths (overhead)\n    if (paths.length > 100)\n        return false;\n    // Calculate estimated size\n    const pathOverhead = paths.reduce((sum, p) => sum + p.length, 0);\n    const estimatedFlattenedSize = pathOverhead + paths.length * 10; // rough estimate\n    // If paths are very long, flattening might not help\n    if (pathOverhead > 5000)\n        return false;\n    return true;\n}\n/**\n * Create path reference map for repeated path prefixes\n */\nfunction createPathReferenceMap(paths) {\n    const pathRefs = {};\n    const refDefinitions = [];\n    const prefixCounts = {};\n    const prefixToRef = {};\n    // Count prefix usage\n    paths.forEach((path) => {\n        const parts = path.split(\".\");\n        for (let i = 1; i < parts.length; i++) {\n            const prefix = parts.slice(0, i).join(\".\");\n            prefixCounts[prefix] = (prefixCounts[prefix] || 0) + 1;\n        }\n    });\n    // Create references for prefixes used 3+ times\n    let refIndex = 0;\n    Object.entries(prefixCounts)\n        .filter(([_, count]) => count >= 3)\n        .sort(([_, a], [__, b]) => b - a)\n        .forEach(([prefix]) => {\n        const ref = `@p${refIndex}`;\n        prefixToRef[prefix] = ref;\n        refDefinitions.push(`${ref}=${prefix}`);\n        refIndex++;\n    });\n    // Map paths to use references\n    paths.forEach((path) => {\n        // Find longest matching prefix\n        const parts = path.split(\".\");\n        let bestRef;\n        let bestPrefix;\n        for (let i = parts.length - 1; i > 0; i--) {\n            const prefix = parts.slice(0, i).join(\".\");\n            if (prefixToRef[prefix]) {\n                bestRef = prefixToRef[prefix];\n                bestPrefix = prefix;\n                break;\n            }\n        }\n        if (bestRef && bestPrefix) {\n            const suffix = path.substring(bestPrefix.length + 1);\n            pathRefs[path] = `${bestRef}.${suffix}`;\n        }\n    });\n    return { pathRefs, refDefinitions };\n}\n/**\n * Get all unique paths from an array of objects with adaptive flattening\n */\nfunction getAllPaths(items, maxDepth = 100, adaptiveFlattening = true, compressPaths = true, usePathReferences = true) {\n    const pathSet = new Set();\n    const depths = [];\n    items.forEach((item) => {\n        const visited = new WeakSet();\n        const flattened = flattenObject(item, \"\", maxDepth, 0, visited, compressPaths);\n        Object.keys(flattened).forEach((path) => {\n            pathSet.add(path);\n            depths.push(path.split(\".\").length + path.split(\"[\").length - 1);\n        });\n    });\n    const paths = Array.from(pathSet).sort();\n    const avgDepth = depths.length > 0 ? depths.reduce((a, b) => a + b, 0) / depths.length : 0;\n    let pathMap;\n    let pathRefs;\n    let refDefinitions;\n    let shouldFlattenResult = true;\n    if (adaptiveFlattening) {\n        shouldFlattenResult = shouldFlatten(paths, avgDepth);\n        if (shouldFlattenResult) {\n            if (usePathReferences) {\n                // Create path references for repeated prefixes\n                const refInfo = createPathReferenceMap(paths);\n                pathRefs = refInfo.pathRefs;\n                refDefinitions = refInfo.refDefinitions;\n            }\n            if (compressPaths) {\n                // Create path abbreviation map\n                const { map } = createPathAbbreviationMap(paths);\n                pathMap = map;\n                // Compress paths\n                paths.forEach((path, idx) => {\n                    const compressed = compressPath(path);\n                    if (compressed !== path) {\n                        paths[idx] = compressed;\n                    }\n                });\n            }\n        }\n    }\n    return {\n        paths,\n        shouldFlatten: shouldFlattenResult,\n        pathMap,\n        pathRefs,\n        refDefinitions,\n    };\n}\n/**\n * Encode JavaScript object to YOGIWAY format\n */\nfunction encode(data, options = {}) {\n    // Free and open source - no license required\n    const { useTabs = true, abbreviateNames = true, includeTypes = false, maxDepth = 100, flattenNested = true, compressPaths = true, adaptiveFlattening = true, usePathReferences = true, mode = \"performance\", compress = false, lazyPaths = true, streamingChunkSize = 8192, } = options;\n    const delimiter = useTabs ? \"\\t\" : \",\";\n    const lines = [];\n    // Handle streaming for large arrays\n    if (Array.isArray(data) &&\n        data.length > streamingChunkSize &&\n        mode === \"performance\") {\n        return encodeStreaming(data, options);\n    }\n    try {\n        // Mode-based encoding optimizations\n        if (mode === \"minimal\") {\n            // Minimal mode: maximum compression\n            return encodeMinimal(data, options);\n        }\n        else if (mode === \"compatibility\") {\n            // Compatibility mode: more JSON-like\n            return encodeCompatibility(data, options);\n        }\n        // Performance mode (default)\n        if (Array.isArray(data)) {\n            return encodeArray(data, \"\", delimiter, abbreviateNames, includeTypes, maxDepth, flattenNested, compressPaths, adaptiveFlattening, usePathReferences, lazyPaths);\n        }\n        if (typeof data === \"object\" && data !== null) {\n            for (const [key, value] of Object.entries(data)) {\n                if (Array.isArray(value)) {\n                    lines.push(encodeArray(value, abbreviateNames ? abbreviate(key) : key, delimiter, abbreviateNames, includeTypes, maxDepth, flattenNested, compressPaths, adaptiveFlattening, usePathReferences, lazyPaths));\n                }\n                else if (typeof value === \"object\" && value !== null) {\n                    lines.push(encodeArray([value], abbreviateNames ? abbreviate(key) : key, delimiter, abbreviateNames, includeTypes, maxDepth, flattenNested, compressPaths, adaptiveFlattening, usePathReferences, lazyPaths));\n                }\n            }\n        }\n        let result = lines.join(\"\\n\");\n        // Apply compression if requested\n        if (compress && result.length > 100) {\n            // Note: zlib compression would require a library like pako\n            // For now, return uncompressed but mark for compression\n            // In production, use pako or similar\n        }\n        return result;\n    }\n    catch (error) {\n        if (error instanceof Error &&\n            error.message.includes(\"Circular reference\")) {\n            throw new Error(`YOGIWAY encoding failed: ${error.message}. Consider using JSON.stringify for circular structures.`);\n        }\n        throw error;\n    }\n}\n/**\n * Encode in minimal mode - maximum compression\n */\nfunction encodeMinimal(data, options) {\n    return encode(data, {\n        ...options,\n        mode: \"performance\",\n        compressPaths: true,\n        usePathReferences: true,\n        abbreviateNames: true,\n        lazyPaths: true,\n    });\n}\n/**\n * Encode in compatibility mode - more JSON-like\n */\nfunction encodeCompatibility(data, options) {\n    return encode(data, {\n        ...options,\n        mode: \"performance\",\n        compressPaths: false,\n        usePathReferences: false,\n        abbreviateNames: false,\n        lazyPaths: false,\n    });\n}\n/**\n * Encode large arrays in streaming mode\n */\nfunction encodeStreaming(data, options) {\n    const chunkSize = options.streamingChunkSize || 8192;\n    const chunks = [];\n    for (let i = 0; i < data.length; i += chunkSize) {\n        const chunk = data.slice(i, i + chunkSize);\n        chunks.push(encode(chunk, {\n            ...options,\n            mode: \"performance\",\n            lazyPaths: options.lazyPaths,\n        }));\n    }\n    return chunks.join(\"\\n---\\n\");\n}\nfunction encodeArray(arr, name, delimiter, abbreviateNames, includeTypes, maxDepth, flattenNested, compressPaths, adaptiveFlattening, usePathReferences, lazyPaths = true) {\n    if (arr.length === 0)\n        return \"\";\n    let keys;\n    let items;\n    let pathMap;\n    let pathRefs;\n    let refDefinitions;\n    let shouldFlattenResult = flattenNested;\n    if (flattenNested && adaptiveFlattening) {\n        const pathInfo = getAllPaths(arr, maxDepth, adaptiveFlattening, compressPaths, usePathReferences);\n        keys = pathInfo.paths;\n        shouldFlattenResult = pathInfo.shouldFlatten;\n        pathMap = pathInfo.pathMap;\n        pathRefs = pathInfo.pathRefs;\n        refDefinitions = pathInfo.refDefinitions;\n        if (shouldFlattenResult) {\n            const visited = new WeakSet();\n            // Use lazy path resolution if enabled and path refs available\n            if (lazyPaths && pathRefs) {\n                items = arr.map((item) => flattenObjectLazy(item, \"\", maxDepth, 0, visited, compressPaths, pathRefs));\n            }\n            else {\n                items = arr.map((item) => flattenObject(item, \"\", maxDepth, 0, visited, compressPaths));\n            }\n        }\n        else {\n            // Fall back to simple encoding\n            const allKeys = new Set();\n            arr.forEach((item) => {\n                if (typeof item === \"object\" && item !== null) {\n                    Object.keys(item).forEach((key) => allKeys.add(key));\n                }\n            });\n            keys = Array.from(allKeys);\n            items = arr;\n        }\n    }\n    else if (flattenNested) {\n        const pathInfo = getAllPaths(arr, maxDepth, false, compressPaths, usePathReferences);\n        keys = pathInfo.paths;\n        pathRefs = pathInfo.pathRefs;\n        refDefinitions = pathInfo.refDefinitions;\n        const visited = new WeakSet();\n        items = arr.map((item) => flattenObject(item, \"\", maxDepth, 0, visited, compressPaths));\n    }\n    else {\n        const allKeys = new Set();\n        arr.forEach((item) => {\n            if (typeof item === \"object\" && item !== null) {\n                Object.keys(item).forEach((key) => allKeys.add(key));\n            }\n        });\n        keys = Array.from(allKeys);\n        items = arr;\n    }\n    if (keys.length === 0)\n        return \"\";\n    // Create field mapping (a, b, c, ...)\n    const fieldMap = {};\n    keys.forEach((key, index) => {\n        const letter = String.fromCharCode(97 + (index % 26));\n        if (index >= 26) {\n            const firstLetter = String.fromCharCode(97 + Math.floor((index - 26) / 26));\n            const secondLetter = String.fromCharCode(97 + ((index - 26) % 26));\n            fieldMap[key] = firstLetter + secondLetter;\n        }\n        else {\n            fieldMap[key] = letter;\n        }\n    });\n    // Build header with path notation\n    const fieldLetters = keys.map((key) => fieldMap[key]).join(\"\");\n    const header = name\n        ? `${name}[${arr.length}]${fieldLetters}`\n        : `[${arr.length}]${fieldLetters}`;\n    // Add path mapping comment (for decoding)\n    // Apply path references and compression\n    const pathMappingParts = [];\n    // Add path reference definitions first (if any)\n    if (refDefinitions && refDefinitions.length > 0) {\n        pathMappingParts.push(...refDefinitions);\n    }\n    // Add field mappings with path references\n    keys.forEach((key, idx) => {\n        const letter = fieldMap[key];\n        // Use path reference if available, otherwise use compressed/original path\n        let mappedPath;\n        if (pathRefs && pathRefs[key]) {\n            mappedPath = pathRefs[key];\n        }\n        else {\n            mappedPath = compressPaths ? compressPath(key) : key;\n        }\n        pathMappingParts.push(`${letter}=${mappedPath}`);\n    });\n    const pathMapping = pathMappingParts.join(\";\");\n    // Add type hints if requested\n    if (includeTypes) {\n        const types = keys.map((key) => {\n            const sample = items.find((item) => item?.[key] !== undefined)?.[key];\n            return inferType(sample);\n        });\n        const typeHint = `:${types.join(\"\")}`;\n        const rows = items.map((item) => {\n            return keys\n                .map((key) => {\n                const value = item?.[key];\n                return formatValue(value, delimiter);\n            })\n                .join(delimiter);\n        });\n        return `${header}${typeHint}#${pathMapping}\\n${rows.join(\"\\n\")}`;\n    }\n    // Build rows\n    const rows = items.map((item) => {\n        return keys\n            .map((key) => {\n            const value = item?.[key];\n            return formatValue(value, delimiter);\n        })\n            .join(delimiter);\n    });\n    return `${header}#${pathMapping}\\n${rows.join(\"\\n\")}`;\n}\nfunction formatValue(value, delimiter, visited = new WeakSet()) {\n    if (value === null || value === undefined) {\n        return \"\";\n    }\n    if (typeof value === \"string\") {\n        let escaped = value\n            .replace(/\\\\/g, \"\\\\\\\\\")\n            .replace(/\\t/g, \"\\\\t\")\n            .replace(/\\n/g, \"\\\\n\");\n        if (delimiter === \"\\t\" &&\n            (escaped.includes(\"\\t\") || escaped.includes(\"\\n\"))) {\n            return `\"${escaped}\"`;\n        }\n        if (delimiter === \",\" &&\n            (escaped.includes(\",\") || escaped.includes(\"\\n\"))) {\n            return `\"${escaped}\"`;\n        }\n        return escaped;\n    }\n    if (typeof value === \"number\" || typeof value === \"boolean\") {\n        return String(value);\n    }\n    if (Array.isArray(value)) {\n        return value\n            .map((v) => typeof v === \"string\" && (v.includes(delimiter) || v.includes(\"\\n\"))\n            ? JSON.stringify(v)\n            : String(v))\n            .join(\"|\");\n    }\n    if (typeof value === \"object\") {\n        // Check for circular reference before stringifying\n        if (visited.has(value)) {\n            return \"[Circular]\";\n        }\n        visited.add(value);\n        try {\n            return JSON.stringify(value);\n        }\n        catch (e) {\n            if (e instanceof Error && e.message.includes(\"circular\")) {\n                return \"[Circular]\";\n            }\n            throw e;\n        }\n        finally {\n            visited.delete(value);\n        }\n    }\n    return String(value);\n}\nfunction abbreviate(name) {\n    if (name.length <= 3)\n        return name;\n    const first = name[0];\n    const rest = name.slice(1).replace(/[aeiou]/gi, \"\");\n    return (first + rest.slice(0, 2)).toLowerCase();\n}\nfunction inferType(value) {\n    if (value === null || value === undefined)\n        return \"s\";\n    if (typeof value === \"string\")\n        return \"s\";\n    if (typeof value === \"number\")\n        return \"n\";\n    if (typeof value === \"boolean\")\n        return \"b\";\n    if (Array.isArray(value))\n        return \"a\";\n    if (typeof value === \"object\")\n        return \"o\";\n    return \"s\";\n}\n/**\n * Restore nested structure from flattened paths\n */\nfunction restoreNested(flatObj) {\n    const result = {};\n    for (const [path, value] of Object.entries(flatObj)) {\n        // Expand compressed paths\n        const expandedPath = expandPath(path);\n        const parts = expandedPath.split(\".\");\n        let current = result;\n        for (let i = 0; i < parts.length - 1; i++) {\n            const part = parts[i];\n            const arrayMatch = part.match(/^(.+)\\[(\\d+)\\]$/);\n            if (arrayMatch) {\n                const [, arrayName, indexStr] = arrayMatch;\n                const index = parseInt(indexStr, 10);\n                if (!current[arrayName]) {\n                    current[arrayName] = [];\n                }\n                if (!current[arrayName][index]) {\n                    current[arrayName][index] = {};\n                }\n                current = current[arrayName][index];\n            }\n            else {\n                if (!current[part]) {\n                    current[part] = {};\n                }\n                current = current[part];\n            }\n        }\n        const lastPart = parts[parts.length - 1];\n        const arrayMatch = lastPart.match(/^(.+)\\[(\\d+)\\]$/);\n        if (arrayMatch) {\n            const [, arrayName, indexStr] = arrayMatch;\n            const index = parseInt(indexStr, 10);\n            if (!current[arrayName]) {\n                current[arrayName] = [];\n            }\n            current[arrayName][index] = value;\n        }\n        else {\n            current[lastPart] = value;\n        }\n    }\n    return result;\n}\n/**\n * Decode YOGIWAY format to JavaScript object\n */\nfunction decode(yogiway, options = {}) {\n    // Free and open source - no license required\n    const { restoreNested: shouldRestoreNested = true, maxDepth = 100 } = options;\n    const lines = yogiway.trim().split(\"\\n\");\n    if (lines.length === 0)\n        return {};\n    const result = {};\n    let i = 0;\n    while (i < lines.length) {\n        const line = lines[i];\n        if (!line || line.trim() === \"\") {\n            i++;\n            continue;\n        }\n        const headerMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)?\\[(\\d+)\\]([a-z]+)(?::([a-z]+))?#(.+)$/);\n        const headerMatchSimple = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)?\\[(\\d+)\\]([a-z]+)(?::([a-z]+))?$/);\n        const match = headerMatch || headerMatchSimple;\n        if (!match) {\n            i++;\n            continue;\n        }\n        const [, name, countStr, fieldLetters, typeHints, pathMappingStr] = match;\n        const count = parseInt(countStr, 10);\n        if (count > 10000) {\n            throw new Error(`YOGIWAY decode error: Array count too large (${count}). Maximum allowed: 10000.`);\n        }\n        // Parse path mapping (including path references)\n        const pathMapping = {};\n        const pathRefMap = {}; // @p0 -> full path\n        if (pathMappingStr) {\n            try {\n                pathMappingStr.split(\";\").forEach((mapping) => {\n                    const [key, path] = mapping.split(\"=\");\n                    if (key && path) {\n                        // Check if it's a path reference definition (@p0=path)\n                        if (key.startsWith(\"@p\")) {\n                            pathRefMap[key] = path;\n                        }\n                        else {\n                            // Regular field mapping (a=path or a=@p0.suffix)\n                            let resolvedPath = path;\n                            // Resolve path references\n                            if (path.includes(\"@p\")) {\n                                // Replace @p0.suffix with full path\n                                const refMatch = path.match(/^(@p\\d+)(\\.(.+))?$/);\n                                if (refMatch) {\n                                    const ref = refMatch[1];\n                                    const suffix = refMatch[3] || \"\";\n                                    if (pathRefMap[ref]) {\n                                        resolvedPath = suffix\n                                            ? `${pathRefMap[ref]}.${suffix}`\n                                            : pathRefMap[ref];\n                                    }\n                                }\n                            }\n                            pathMapping[key] = resolvedPath;\n                        }\n                    }\n                });\n            }\n            catch (e) {\n                throw new Error(`YOGIWAY decode error: Invalid path mapping format. ${e instanceof Error ? e.message : String(e)}`);\n            }\n        }\n        let delimiter = \"\\t\";\n        if (i + 1 < lines.length) {\n            const nextLine = lines[i + 1];\n            if (nextLine && !nextLine.includes(\"\\t\") && nextLine.includes(\",\")) {\n                delimiter = \",\";\n            }\n        }\n        const fieldPaths = [];\n        for (let j = 0; j < fieldLetters.length; j++) {\n            const letter = fieldLetters[j];\n            const path = pathMapping[letter] || `field${j}`;\n            fieldPaths.push(path);\n        }\n        const items = [];\n        for (let rowNum = 0; rowNum < count && i + 1 < lines.length; rowNum++) {\n            i++;\n            const rowLine = lines[i];\n            if (!rowLine || rowLine.trim() === \"\")\n                break;\n            let values;\n            if (delimiter === \"\\t\") {\n                values = rowLine.split(\"\\t\").map((v) => v.trim());\n            }\n            else {\n                values = parseRow(rowLine, delimiter, fieldPaths.length);\n            }\n            if (values.length !== fieldPaths.length) {\n                throw new Error(`YOGIWAY decode error: Row ${rowNum + 1} has ${values.length} values but expected ${fieldPaths.length} fields.`);\n            }\n            const flatItem = {};\n            fieldPaths.forEach((path, idx) => {\n                const value = values[idx] || \"\";\n                flatItem[path] = parseValue(value, typeHints?.[idx]);\n            });\n            if (shouldRestoreNested && Object.keys(pathMapping).length > 0) {\n                try {\n                    items.push(restoreNested(flatItem));\n                }\n                catch (e) {\n                    throw new Error(`YOGIWAY decode error: Failed to restore nested structure. ${e instanceof Error ? e.message : String(e)}`);\n                }\n            }\n            else {\n                items.push(flatItem);\n            }\n        }\n        const collectionName = name || \"data\";\n        if (result[collectionName]) {\n            if (Array.isArray(result[collectionName])) {\n                result[collectionName].push(...items);\n            }\n            else {\n                result[collectionName] = [result[collectionName], ...items];\n            }\n        }\n        else {\n            result[collectionName] = items.length === 1 ? items[0] : items;\n        }\n        i++;\n    }\n    return result;\n}\nfunction parseRow(row, delimiter, expectedFields) {\n    const values = [];\n    let current = \"\";\n    let inQuotes = false;\n    let i = 0;\n    while (i < row.length && values.length < expectedFields) {\n        const char = row[i];\n        if (char === '\"' && (i === 0 || row[i - 1] !== \"\\\\\")) {\n            inQuotes = !inQuotes;\n            i++;\n            continue;\n        }\n        if (!inQuotes && char === delimiter) {\n            values.push(current);\n            current = \"\";\n            i++;\n            continue;\n        }\n        if (char === \"\\\\\" && i + 1 < row.length) {\n            const next = row[i + 1];\n            if (next === \"t\") {\n                current += \"\\t\";\n                i += 2;\n                continue;\n            }\n            if (next === \"n\") {\n                current += \"\\n\";\n                i += 2;\n                continue;\n            }\n            if (next === \"\\\\\") {\n                current += \"\\\\\";\n                i += 2;\n                continue;\n            }\n        }\n        current += char;\n        i++;\n    }\n    if (current !== \"\" || values.length < expectedFields) {\n        values.push(current);\n    }\n    return values;\n}\nfunction parseValue(value, typeHint) {\n    if (value === \"\")\n        return null;\n    if (value.includes(\"|\") && !value.startsWith('\"')) {\n        return value.split(\"|\").map((v) => parseValue(v.trim(), typeHint));\n    }\n    if (typeHint === \"n\") {\n        const num = Number(value);\n        return isNaN(num) ? value : num;\n    }\n    if (typeHint === \"b\") {\n        return value === \"true\" || value === \"1\";\n    }\n    if (/^-?\\d+\\.?\\d*$/.test(value)) {\n        const num = Number(value);\n        if (!isNaN(num))\n            return num;\n    }\n    if (value === \"true\" || value === \"false\") {\n        return value === \"true\";\n    }\n    if ((value.startsWith(\"{\") && value.endsWith(\"}\")) ||\n        (value.startsWith(\"[\") && value.endsWith(\"]\"))) {\n        try {\n            return JSON.parse(value);\n        }\n        catch {\n            return value;\n        }\n    }\n    return value;\n}\n// Re-export PATHX and converters\nvar pathx_1 = require(\"./pathx\");\nObject.defineProperty(exports, \"pathxEncode\", { enumerable: true, get: function () { return pathx_1.pathxEncode; } });\nObject.defineProperty(exports, \"pathxDecode\", { enumerable: true, get: function () { return pathx_1.pathxDecode; } });\nvar converter_1 = require(\"./converter\");\nObject.defineProperty(exports, \"yogiwayToPathx\", { enumerable: true, get: function () { return converter_1.yogiwayToPathx; } });\nObject.defineProperty(exports, \"pathxToYogiway\", { enumerable: true, get: function () { return converter_1.pathxToYogiway; } });\nObject.defineProperty(exports, \"toPathx\", { enumerable: true, get: function () { return converter_1.toPathx; } });\nObject.defineProperty(exports, \"fromPathx\", { enumerable: true, get: function () { return converter_1.fromPathx; } });\nObject.defineProperty(exports, \"toYogiway\", { enumerable: true, get: function () { return converter_1.toYogiway; } });\nObject.defineProperty(exports, \"fromYogiway\", { enumerable: true, get: function () { return converter_1.fromYogiway; } });\nObject.defineProperty(exports, \"smartEncode\", { enumerable: true, get: function () { return converter_1.smartEncode; } });\n// Export default\nexports.default = { encode, decode };\n"]}