@apiconvert/core 0.2.0 → 1.0.0

package/dist/index.js

@@ -1,144 +1,46 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rulesSchemaPath = exports.ConditionOperator = exports.MergeMode = exports.TransformType = exports.DataFormat = void 0;
-exports.normalizeConversionRules = normalizeConversionRules;
-exports.applyConversion = applyConversion;
-exports.parsePayload = parsePayload;
-exports.formatPayload = formatPayload;
+exports.parsePayload = exports.normalizeConversionRules = exports.formatPayload = exports.applyConversion = void 0;
 exports.runConversionCase = runConversionCase;
-const fast_xml_parser_1 = require("fast-xml-parser");
-var DataFormat;
-(function (DataFormat) {
-    DataFormat["Json"] = "json";
-    DataFormat["Xml"] = "xml";
-    DataFormat["Query"] = "query";
-})(DataFormat || (exports.DataFormat = DataFormat = {}));
-var TransformType;
-(function (TransformType) {
-    TransformType["ToLowerCase"] = "toLowerCase";
-    TransformType["ToUpperCase"] = "toUpperCase";
-    TransformType["Number"] = "number";
-    TransformType["Boolean"] = "boolean";
-    TransformType["Concat"] = "concat";
-    TransformType["Split"] = "split";
-})(TransformType || (exports.TransformType = TransformType = {}));
-var MergeMode;
-(function (MergeMode) {
-    MergeMode["Concat"] = "concat";
-    MergeMode["FirstNonEmpty"] = "firstNonEmpty";
-    MergeMode["Array"] = "array";
-})(MergeMode || (exports.MergeMode = MergeMode = {}));
-var ConditionOperator;
-(function (ConditionOperator) {
-    ConditionOperator["Exists"] = "exists";
-    ConditionOperator["Equals"] = "equals";
-    ConditionOperator["NotEquals"] = "notEquals";
-    ConditionOperator["Includes"] = "includes";
-    ConditionOperator["Gt"] = "gt";
-    ConditionOperator["Lt"] = "lt";
-})(ConditionOperator || (exports.ConditionOperator = ConditionOperator = {}));
-exports.rulesSchemaPath = "/schemas/rules/rules.schema.json";
-function normalizeConversionRules(raw) {
-    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
-        if (isConversionRules(raw)) {
-            return normalizeRules(raw);
-        }
-        if (isLegacyConfig(raw)) {
-            return normalizeLegacyRules(raw);
-        }
-        return emptyRules();
-    }
-    if (typeof raw === "string") {
-        try {
-            const parsed = JSON.parse(raw);
-            return normalizeConversionRules(parsed);
-        }
-        catch {
-            return emptyRules();
-        }
-    }
-    return emptyRules();
-}
-function applyConversion(input, rawRules) {
-    const rules = normalizeConversionRules(rawRules);
-    const fieldMappings = rules.fieldMappings ?? [];
-    const arrayMappings = rules.arrayMappings ?? [];
-    if (fieldMappings.length === 0 && arrayMappings.length === 0) {
-        return { output: input ?? {}, errors: [] };
-    }
-    const output = {};
-    const errors = [];
-    applyFieldMappings(input, null, fieldMappings, output, errors, "Field");
-    arrayMappings.forEach((arrayRule, index) => {
-        const value = resolvePathValue(input, null, arrayRule.inputPath ?? "");
-        let items = Array.isArray(value) ? value : null;
-        if (!items && arrayRule.coerceSingle && value != null) {
-            items = [value];
-        }
-        if (!items) {
-            errors.push(`Array ${index + 1}: input path did not resolve to an array (${arrayRule.inputPath}).`);
-            return;
-        }
-        const mappedItems = [];
-        items.forEach((item) => {
-            const itemOutput = {};
-            applyFieldMappings(input, item, arrayRule.itemMappings ?? [], itemOutput, errors, `Array ${index + 1} item`);
-            mappedItems.push(itemOutput);
-        });
-        if (!arrayRule.outputPath || arrayRule.outputPath.trim().length === 0) {
-            errors.push(`Array ${index + 1}: output path is required.`);
-            return;
-        }
-        const outputPath = normalizeWritePath(arrayRule.outputPath);
-        if (!outputPath || outputPath.trim().length === 0) {
-            errors.push(`Array ${index + 1}: output path is required.`);
-            return;
-        }
-        setValueByPath(output, outputPath, mappedItems);
-    });
-    return { output, errors };
-}
-function parsePayload(text, format) {
-    try {
-        switch (format) {
-            case DataFormat.Xml:
-                return { value: parseXml(text) };
-            case DataFormat.Query:
-                return { value: parseQueryString(text) };
-            default:
-                return { value: parseJson(text) };
-        }
-    }
-    catch (error) {
-        return { value: null, error: error instanceof Error ? error.message : String(error) };
-    }
-}
-function formatPayload(value, format, pretty) {
-    switch (format) {
-        case DataFormat.Xml:
-            return formatXml(value, pretty);
-        case DataFormat.Query:
-            return formatQueryString(value);
-        default:
-            return JSON.stringify(sanitizeForJson(value ?? {}), null, pretty ? 2 : 0);
-    }
-}
+const mapping_engine_1 = require("./mapping-engine");
+Object.defineProperty(exports, "applyConversion", { enumerable: true, get: function () { return mapping_engine_1.applyConversion; } });
+const payload_converter_1 = require("./payload-converter");
+Object.defineProperty(exports, "formatPayload", { enumerable: true, get: function () { return payload_converter_1.formatPayload; } });
+Object.defineProperty(exports, "parsePayload", { enumerable: true, get: function () { return payload_converter_1.parsePayload; } });
+const rules_normalizer_1 = require("./rules-normalizer");
+Object.defineProperty(exports, "normalizeConversionRules", { enumerable: true, get: function () { return rules_normalizer_1.normalizeConversionRules; } });
+const types_1 = require("./types");
+__exportStar(require("./types"), exports);
 async function runConversionCase(args) {
-    const rules = normalizeConversionRules(args.rulesText);
+    const rules = (0, rules_normalizer_1.normalizeConversionRules)(args.rulesText);
     const inputFormat = extensionToFormat(args.inputExtension);
     const outputFormat = extensionToFormat(args.outputExtension);
     const inputValue = inputFormat ? parsePayloadOrThrow(args.inputText, inputFormat) : args.inputText;
-    const result = applyConversion(inputValue, rules);
+    const result = (0, mapping_engine_1.applyConversion)(inputValue, rules);
     if (result.errors.length > 0) {
         throw new Error(`Conversion errors: ${result.errors.join("; ")}`);
     }
     if (!outputFormat) {
         return result.output == null ? "" : String(result.output);
     }
-    return formatPayload(result.output, outputFormat, outputFormat === DataFormat.Xml);
+    return (0, payload_converter_1.formatPayload)(result.output, outputFormat, outputFormat === types_1.DataFormat.Xml);
 }
 function parsePayloadOrThrow(text, format) {
-    const { value, error } = parsePayload(text, format);
+    const { value, error } = (0, payload_converter_1.parsePayload)(text, format);
     if (error) {
         throw new Error(error);
     }
@@ -147,611 +49,11 @@ function parsePayloadOrThrow(text, format) {
 function extensionToFormat(extension) {
     const ext = extension.toLowerCase();
     if (ext === "json")
-        return DataFormat.Json;
+        return types_1.DataFormat.Json;
     if (ext === "xml")
-        return DataFormat.Xml;
+        return types_1.DataFormat.Xml;
     if (ext === "txt")
-        return DataFormat.Query;
+        return types_1.DataFormat.Query;
     return null;
 }
-function normalizeRules(rules) {
-    return {
-        version: rules.version ?? 2,
-        inputFormat: rules.inputFormat ?? DataFormat.Json,
-        outputFormat: rules.outputFormat ?? DataFormat.Json,
-        fieldMappings: (rules.fieldMappings ?? []).map((rule) => ({
-            outputPath: rule.outputPath,
-            outputPaths: rule.outputPaths ?? [],
-            source: rule.source ?? { type: "path" },
-            defaultValue: rule.defaultValue ?? ""
-        })),
-        arrayMappings: (rules.arrayMappings ?? []).map((mapping) => ({
-            inputPath: mapping.inputPath,
-            outputPath: mapping.outputPath,
-            coerceSingle: mapping.coerceSingle ?? false,
-            itemMappings: (mapping.itemMappings ?? []).map((rule) => ({
-                outputPath: rule.outputPath,
-                outputPaths: rule.outputPaths ?? [],
-                source: rule.source ?? { type: "path" },
-                defaultValue: rule.defaultValue ?? ""
-            }))
-        }))
-    };
-}
-function normalizeLegacyRules(legacy) {
-    const rows = legacy.rows ?? [];
-    const fieldMappings = rows.map((row) => {
-        const sourceType = row.sourceType ?? "path";
-        let source;
-        if (sourceType === "constant") {
-            source = { type: "constant", value: row.sourceValue ?? "" };
-        }
-        else if (sourceType === "transform") {
-            source = {
-                type: "transform",
-                path: row.sourceValue ?? "",
-                transform: row.transformType ?? TransformType.ToLowerCase
-            };
-        }
-        else {
-            source = { type: "path", path: row.sourceValue ?? "" };
-        }
-        return {
-            outputPath: row.outputPath,
-            source,
-            defaultValue: row.defaultValue ?? ""
-        };
-    });
-    return {
-        version: 2,
-        inputFormat: DataFormat.Json,
-        outputFormat: DataFormat.Json,
-        fieldMappings,
-        arrayMappings: []
-    };
-}
-function emptyRules() {
-    return {
-        version: 2,
-        inputFormat: DataFormat.Json,
-        outputFormat: DataFormat.Json,
-        fieldMappings: [],
-        arrayMappings: []
-    };
-}
-function isConversionRules(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const record = value;
-    return record.version === 2 || "fieldMappings" in record || "arrayMappings" in record;
-}
-function isLegacyConfig(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const record = value;
-    return Array.isArray(record.rows);
-}
-function applyFieldMappings(root, item, mappings, output, errors, label) {
-    mappings.forEach((rule, index) => {
-        const writePaths = getWritePaths(rule);
-        if (writePaths.length === 0) {
-            errors.push(`${label} ${index + 1}: output path is required.`);
-            return;
-        }
-        let value = resolveSourceValue(root, item, rule.source);
-        if ((value == null || value === "") && rule.defaultValue) {
-            value = parsePrimitive(rule.defaultValue);
-        }
-        writePaths.forEach((writePath) => {
-            setValueByPath(output, writePath, value);
-        });
-    });
-}
-function resolveSourceValue(root, item, source) {
-    switch (source.type) {
-        case "constant":
-            return parsePrimitive(source.value ?? "");
-        case "path":
-            return resolvePathValue(root, item, source.path ?? "");
-        case "merge":
-            return resolveMergeSourceValue(root, item, source);
-        case "transform": {
-            if (source.transform === TransformType.Concat) {
-                const tokens = (source.path ?? "")
-                    .split(",")
-                    .map((token) => token.trim())
-                    .filter((token) => token.length > 0);
-                let result = "";
-                for (const token of tokens) {
-                    if (token.toLowerCase().startsWith("const:")) {
-                        result += token.slice("const:".length);
-                        continue;
-                    }
-                    const resolved = resolvePathValue(root, item, token);
-                    result += resolved == null ? "" : String(resolved);
-                }
-                return result;
-            }
-            if (source.transform === TransformType.Split) {
-                const baseValue = resolvePathValue(root, item, source.path ?? "");
-                if (baseValue == null) {
-                    return null;
-                }
-                const separator = source.separator ?? " ";
-                if (separator.length === 0) {
-                    return null;
-                }
-                let tokenIndex = source.tokenIndex ?? 0;
-                const trimAfterSplit = source.trimAfterSplit ?? true;
-                const rawTokens = String(baseValue).split(separator).filter((token) => token.length > 0);
-                const tokens = trimAfterSplit
-                    ? rawTokens.map((token) => token.trim()).filter((token) => token.length > 0)
-                    : rawTokens;
-                if (tokenIndex < 0) {
-                    tokenIndex = tokens.length + tokenIndex;
-                }
-                if (tokenIndex < 0 || tokenIndex >= tokens.length) {
-                    return null;
-                }
-                return tokens[tokenIndex];
-            }
-            const baseValue = resolvePathValue(root, item, source.path ?? "");
-            return resolveTransform(baseValue, source.transform ?? TransformType.ToLowerCase);
-        }
-        case "condition": {
-            if (!source.condition) {
-                return null;
-            }
-            const matched = evaluateCondition(root, item, source.condition);
-            const resolved = matched ? source.trueValue : source.falseValue;
-            return parsePrimitive(resolved ?? "");
-        }
-        default:
-            return null;
-    }
-}
-function resolveMergeSourceValue(root, item, source) {
-    const values = (source.paths ?? [])
-        .filter((path) => !!path && path.trim().length > 0)
-        .map((path) => resolvePathValue(root, item, path));
-    const mode = source.mergeMode ?? MergeMode.Concat;
-    switch (mode) {
-        case MergeMode.FirstNonEmpty:
-            return values.find((value) => value != null && (typeof value !== "string" || value.length > 0)) ?? null;
-        case MergeMode.Array:
-            return values;
-        default:
-            return values.map((value) => (value == null ? "" : String(value))).join(source.separator ?? "");
-    }
-}
-function resolvePathValue(root, item, path) {
-    if (!path || path.trim().length === 0)
-        return null;
-    if (path === "$")
-        return root;
-    if (path.startsWith("$.", 0)) {
-        return getValueByPath(root, path.slice(2));
-    }
-    if (path.startsWith("$[", 0)) {
-        return getValueByPath(root, path.slice(1));
-    }
-    if (item != null) {
-        return getValueByPath(item, path);
-    }
-    return getValueByPath(root, path);
-}
-function evaluateCondition(root, item, condition) {
-    const value = resolvePathValue(root, item, condition.path);
-    const compareValue = condition.value != null ? parsePrimitive(condition.value) : null;
-    switch (condition.operator) {
-        case ConditionOperator.Exists:
-            return value != null;
-        case ConditionOperator.Equals:
-            return Object.is(value, compareValue);
-        case ConditionOperator.NotEquals:
-            return !Object.is(value, compareValue);
-        case ConditionOperator.Includes:
-            return includesValue(value, compareValue);
-        case ConditionOperator.Gt:
-            return toNumber(value) > toNumber(compareValue);
-        case ConditionOperator.Lt:
-            return toNumber(value) < toNumber(compareValue);
-        default:
-            return false;
-    }
-}
-function includesValue(value, compareValue) {
-    if (typeof value === "string" && typeof compareValue === "string") {
-        return value.includes(compareValue);
-    }
-    if (Array.isArray(value)) {
-        return value.some((item) => Object.is(item, compareValue));
-    }
-    return false;
-}
-function resolveTransform(value, transform) {
-    switch (transform) {
-        case TransformType.ToLowerCase:
-            return typeof value === "string" ? value.toLowerCase() : value;
-        case TransformType.ToUpperCase:
-            return typeof value === "string" ? value.toUpperCase() : value;
-        case TransformType.Number:
-            return value == null || value === "" ? value : toNumber(value);
-        case TransformType.Boolean:
-            if (typeof value === "boolean")
-                return value;
-            if (typeof value === "string") {
-                return ["true", "1", "yes", "y"].includes(value.toLowerCase());
-            }
-            return value != null;
-        default:
-            return value;
-    }
-}
-function getValueByPath(input, path) {
-    if (input == null || !path || path.trim().length === 0)
-        return null;
-    const parts = path.split(".").map((part) => part.trim());
-    let current = input;
-    for (const part of parts) {
-        if (current == null)
-            return null;
-        const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
-        if (arrayMatch) {
-            const key = arrayMatch[1];
-            const index = Number.parseInt(arrayMatch[2], 10);
-            if (!isRecord(current) || !(key in current))
-                return null;
-            const next = current[key];
-            if (!Array.isArray(next) || index >= next.length)
-                return null;
-            current = next[index];
-            continue;
-        }
-        if (/^\d+$/.test(part)) {
-            const index = Number.parseInt(part, 10);
-            if (!Array.isArray(current) || index >= current.length)
-                return null;
-            current = current[index];
-            continue;
-        }
-        if (!isRecord(current) || !(part in current))
-            return null;
-        current = current[part];
-    }
-    return current;
-}
-function setValueByPath(target, path, value) {
-    const parts = path.split(".").map((part) => part.trim());
-    let current = target;
-    for (let index = 0; index < parts.length; index += 1) {
-        const part = parts[index];
-        const isLast = index === parts.length - 1;
-        if (isLast) {
-            current[part] = value;
-            return;
-        }
-        const next = current[part];
-        if (!isRecord(next)) {
-            current[part] = {};
-        }
-        current = current[part];
-    }
-}
-function normalizeWritePath(path) {
-    if (!path || path.trim().length === 0) {
-        return path;
-    }
-    if (path.startsWith("$.", 0)) {
-        return path.slice(2);
-    }
-    if (path === "$") {
-        return "";
-    }
-    return path;
-}
-function getWritePaths(rule) {
-    const paths = [];
-    if (rule.outputPath && rule.outputPath.trim().length > 0) {
-        paths.push(rule.outputPath);
-    }
-    (rule.outputPaths ?? []).forEach((path) => {
-        if (path && path.trim().length > 0) {
-            paths.push(path);
-        }
-    });
-    return Array.from(new Set(paths));
-}
-function parsePrimitive(value) {
-    if (value === "true")
-        return true;
-    if (value === "false")
-        return false;
-    if (value === "null")
-        return null;
-    if (value === "undefined")
-        return null;
-    const parsed = Number.parseFloat(value);
-    if (!Number.isNaN(parsed) && isFinite(parsed))
-        return parsed;
-    return value;
-}
-function toNumber(value) {
-    if (value == null)
-        return Number.NaN;
-    if (typeof value === "number")
-        return value;
-    if (typeof value === "string") {
-        const parsed = Number.parseFloat(value);
-        return Number.isNaN(parsed) ? Number.NaN : parsed;
-    }
-    if (typeof value === "boolean")
-        return value ? 1 : 0;
-    const coerced = Number(value);
-    return Number.isNaN(coerced) ? Number.NaN : coerced;
-}
-function parseJson(text) {
-    return JSON.parse(text);
-}
-function parseXml(text) {
-    const parser = new fast_xml_parser_1.XMLParser({
-        ignoreAttributes: false,
-        attributeNamePrefix: "@_",
-        textNodeName: "#text",
-        trimValues: false,
-        parseTagValue: false,
-        parseAttributeValue: false
-    });
-    const parsed = parser.parse(text);
-    return normalizeXmlValue(parsed);
-}
-function formatXml(value, pretty) {
-    if (!isRecord(value) || Object.keys(value).length === 0) {
-        return new fast_xml_parser_1.XMLBuilder({
-            ignoreAttributes: false,
-            attributeNamePrefix: "@_",
-            textNodeName: "#text",
-            format: pretty,
-            indentBy: "  "
-        }).build({ root: null });
-    }
-    const builder = new fast_xml_parser_1.XMLBuilder({
-        ignoreAttributes: false,
-        attributeNamePrefix: "@_",
-        textNodeName: "#text",
-        format: pretty,
-        indentBy: "  "
-    });
-    if (!isRecord(value) || Object.keys(value).length === 0) {
-        return builder.build({ root: null });
-    }
-    const keys = Object.keys(value);
-    if (keys.length === 1) {
-        const rootKey = keys[0];
-        return builder.build({ [rootKey]: value[rootKey] });
-    }
-    return builder.build({ root: value });
-}
-function normalizeXmlValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => normalizeXmlValue(item));
-    }
-    if (isRecord(value)) {
-        const normalized = {};
-        for (const [key, child] of Object.entries(value)) {
-            if (key === "#text" && typeof child === "string") {
-                normalized[key] = parsePrimitive(child.trim());
-                continue;
-            }
-            if (typeof child === "string") {
-                normalized[key] = parsePrimitive(child.trim());
-                continue;
-            }
-            normalized[key] = normalizeXmlValue(child);
-        }
-        return normalized;
-    }
-    if (typeof value === "string") {
-        return parsePrimitive(value.trim());
-    }
-    return value;
-}
-function parseQueryString(text) {
-    const trimmed = text.trim();
-    if (!trimmed)
-        return {};
-    const query = trimmed.startsWith("?") ? trimmed.slice(1) : trimmed;
-    const result = {};
-    const pairs = query.split("&").filter((pair) => pair.length > 0);
-    for (const pair of pairs) {
-        const splitIndex = pair.indexOf("=");
-        const rawKey = splitIndex >= 0 ? pair.slice(0, splitIndex) : pair;
-        const rawValue = splitIndex >= 0 ? pair.slice(splitIndex + 1) : "";
-        const key = decodeURIComponent(rawKey.replace(/\+/g, " "));
-        const value = decodeURIComponent(rawValue.replace(/\+/g, " "));
-        const path = parseQueryKey(key);
-        setQueryValue(result, path, value);
-    }
-    return result;
-}
-function formatQueryString(value) {
-    if (!isRecord(value)) {
-        throw new Error("Query output must be an object.");
-    }
-    const pairs = [];
-    const keys = Object.keys(value).sort((a, b) => a.localeCompare(b));
-    keys.forEach((key) => {
-        addQueryPair(pairs, key, value[key]);
-    });
-    return pairs
-        .map((pair) => `${encodeURIComponent(pair.key)}=${encodeURIComponent(pair.value)}`)
-        .join("&");
-}
-function parseQueryKey(key) {
-    const parts = [];
-    const matcher = /([^\[.\]]+)|\[(.*?)\]/g;
-    let match;
-    while ((match = matcher.exec(key)) !== null) {
-        const token = match[1] ?? match[2] ?? "";
-        if (!token)
-            continue;
-        const number = Number.parseInt(token, 10);
-        if (!Number.isNaN(number) && number.toString() === token) {
-            parts.push(number);
-        }
-        else {
-            parts.push(token);
-        }
-    }
-    if (parts.length === 0) {
-        parts.push(key);
-    }
-    return parts;
-}
-function setQueryValue(target, path, value) {
-    let current = target;
-    let parent = null;
-    let parentKey = null;
-    const ensureObjectContainer = (valueToCheck) => {
-        if (isRecord(valueToCheck))
-            return valueToCheck;
-        const next = {};
-        if (parent != null && parentKey != null) {
-            if (Array.isArray(parent)) {
-                parent[parentKey] = next;
-            }
-            else if (isRecord(parent)) {
-                parent[parentKey.toString()] = next;
-            }
-        }
-        return next;
-    };
-    const ensureArrayContainer = (valueToCheck) => {
-        if (Array.isArray(valueToCheck))
-            return valueToCheck;
-        const next = [];
-        if (parent != null && parentKey != null) {
-            if (Array.isArray(parent)) {
-                parent[parentKey] = next;
-            }
-            else if (isRecord(parent)) {
-                parent[parentKey.toString()] = next;
-            }
-        }
-        return next;
-    };
-    path.forEach((segment, index) => {
-        const isLast = index === path.length - 1;
-        const nextSegment = index + 1 < path.length ? path[index + 1] : null;
-        if (typeof segment === "number") {
-            const arrayContainer = ensureArrayContainer(current);
-            if (isLast) {
-                const existing = arrayContainer[segment];
-                if (existing == null) {
-                    ensureListSize(arrayContainer, segment + 1);
-                    arrayContainer[segment] = value;
-                }
-                else if (Array.isArray(existing)) {
-                    existing.push(value);
-                }
-                else {
-                    arrayContainer[segment] = [existing, value];
-                }
-                return;
-            }
-            parent = arrayContainer;
-            parentKey = segment;
-            ensureListSize(arrayContainer, segment + 1);
-            const existingValue = arrayContainer[segment];
-            const shouldBeArray = typeof nextSegment === "number";
-            if (existingValue == null ||
-                (shouldBeArray && !Array.isArray(existingValue)) ||
-                (!shouldBeArray && !isRecord(existingValue))) {
-                arrayContainer[segment] = shouldBeArray ? [] : {};
-            }
-            current = arrayContainer[segment];
-            return;
-        }
-        const objectContainer = ensureObjectContainer(current);
-        const key = segment;
-        if (isLast) {
-            const existing = objectContainer[key];
-            if (existing === undefined) {
-                objectContainer[key] = value;
-            }
-            else if (Array.isArray(existing)) {
-                existing.push(value);
-            }
-            else {
-                objectContainer[key] = [existing, value];
-            }
-            return;
-        }
-        parent = objectContainer;
-        parentKey = key;
-        const next = objectContainer[key];
-        const shouldBeArray = typeof nextSegment === "number";
-        if (next == null || (shouldBeArray && !Array.isArray(next)) || (!shouldBeArray && !isRecord(next))) {
-            objectContainer[key] = shouldBeArray ? [] : {};
-        }
-        current = objectContainer[key];
-    });
-}
-function ensureListSize(list, size) {
-    while (list.length < size) {
-        list.push(null);
-    }
-}
-function addQueryPair(pairs, key, value) {
-    if (value == null) {
-        pairs.push({ key, value: "" });
-        return;
-    }
-    if (Array.isArray(value)) {
-        value.forEach((item) => {
-            if (isRecord(item) || Array.isArray(item)) {
-                pairs.push({ key, value: JSON.stringify(sanitizeForJson(item)) });
-            }
-            else if (item == null) {
-                pairs.push({ key, value: "" });
-            }
-            else {
-                pairs.push({ key, value: String(item) });
-            }
-        });
-        return;
-    }
-    if (isRecord(value)) {
-        const keys = Object.keys(value).sort((a, b) => a.localeCompare(b));
-        keys.forEach((childKey) => {
-            const nextKey = key.length === 0 ? childKey : `${key}.${childKey}`;
-            addQueryPair(pairs, nextKey, value[childKey]);
-        });
-        return;
-    }
-    if (!key)
-        return;
-    pairs.push({ key, value: String(value) });
-}
-function isRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function sanitizeForJson(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => sanitizeForJson(item));
-    }
-    if (isRecord(value)) {
-        const result = {};
-        Object.entries(value).forEach(([key, child]) => {
-            if (child === null) {
-                return;
-            }
-            result[key] = sanitizeForJson(child);
-        });
-        return result;
-    }
-    return value;
-}
 //# sourceMappingURL=index.js.map