@hyperfrontend/versioning 0.1.0

package/changelog/operations/index.cjs.js

@@ -0,0 +1,2455 @@
+'use strict';
+
+/**
+ * Safe copies of Date built-in via factory function and static methods.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides a factory function that uses Reflect.construct internally.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/date
+ */
+// Capture references at module initialization time
+const _Date = globalThis.Date;
+const _Reflect$3 = globalThis.Reflect;
+function createDate(...args) {
+    return _Reflect$3.construct(_Date, args);
+}
+
+/**
+ * Safe copies of Error built-ins via factory functions.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides factory functions that use Reflect.construct internally.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/error
+ */
+// Capture references at module initialization time
+const _Error = globalThis.Error;
+const _Reflect$2 = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Error using the captured Error constructor.
+ * Use this instead of `new Error()`.
+ *
+ * @param message - Optional error message.
+ * @param options - Optional error options.
+ * @returns A new Error instance.
+ */
+const createError = (message, options) => _Reflect$2.construct(_Error, [message, options]);
+
+/**
+ * Creates a new changelog item.
+ *
+ * @param description - The description text of the change
+ * @param options - Optional configuration for scope, commits, references, and breaking flag
+ * @returns A new ChangelogItem object
+ */
+/**
+ * Creates a new changelog entry.
+ *
+ * @param version - The version string (e.g., '1.0.0')
+ * @param options - Optional configuration for date, sections, and other properties
+ * @returns A new ChangelogEntry object
+ */
+function createChangelogEntry(version, options) {
+    return {
+        version,
+        date: options?.date ?? null,
+        unreleased: options?.unreleased,
+        compareUrl: options?.compareUrl,
+        sections: options?.sections ?? [],
+        rawContent: options?.rawContent,
+    };
+}
+/**
+ * Creates an unreleased changelog entry.
+ *
+ * @param sections - Optional array of changelog sections
+ * @returns A new ChangelogEntry object marked as unreleased
+ */
+function createUnreleasedEntry(sections = []) {
+    return {
+        version: 'Unreleased',
+        date: null,
+        unreleased: true,
+        sections,
+    };
+}
+
+/**
+ * Changelog Entry Addition
+ *
+ * Functions for adding new entries to a changelog.
+ */
+/**
+ * Adds a new entry to a changelog.
+ *
+ * @param changelog - The changelog to add to
+ * @param entry - The entry to add
+ * @param options - Optional add options
+ * @returns A new changelog with the entry added
+ *
+ * @example
+ * ```ts
+ * const newChangelog = addEntry(changelog, {
+ *   version: '1.2.0',
+ *   date: '2024-01-15',
+ *   unreleased: false,
+ *   sections: [...]
+ * })
+ * ```
+ */
+function addEntry(changelog, entry, options) {
+    const position = options?.position ?? 'start';
+    const replaceExisting = options?.replaceExisting ?? false;
+    const updateMetadata = options?.updateMetadata ?? false;
+    // Check for existing entry
+    const existingIndex = changelog.entries.findIndex((e) => e.version === entry.version);
+    if (existingIndex !== -1 && !replaceExisting) {
+        throw createError(`Entry with version "${entry.version}" already exists. Use replaceExisting: true to replace.`);
+    }
+    let newEntries;
+    if (existingIndex !== -1 && replaceExisting) {
+        // Replace existing entry
+        newEntries = [...changelog.entries];
+        newEntries[existingIndex] = entry;
+    }
+    else {
+        // Add new entry
+        const insertIndex = position === 'start' ? 0 : position === 'end' ? changelog.entries.length : position;
+        newEntries = [...changelog.entries];
+        newEntries.splice(insertIndex, 0, entry);
+    }
+    // Build new metadata if requested
+    const metadata = updateMetadata ? { ...changelog.metadata, warnings: [] } : changelog.metadata;
+    return {
+        ...changelog,
+        entries: newEntries,
+        metadata,
+    };
+}
+/**
+ * Adds or updates an unreleased entry.
+ *
+ * @param changelog - The changelog to add the unreleased entry to
+ * @param sections - Sections to include in the unreleased entry
+ * @returns A new changelog with unreleased entry added/updated
+ */
+function addUnreleasedEntry(changelog, sections) {
+    const unreleasedEntry = createUnreleasedEntry(sections);
+    return addEntry(changelog, unreleasedEntry, { position: 'start', replaceExisting: true });
+}
+/**
+ * Creates a new release entry from the current unreleased entry.
+ *
+ * @param changelog - The changelog containing the unreleased entry
+ * @param version - The version number for the release
+ * @param date - The release date (defaults to today)
+ * @param compareUrl - Optional comparison URL
+ * @returns A new changelog with the unreleased entry converted to a release
+ */
+function releaseUnreleased(changelog, version, date, compareUrl) {
+    const unreleasedIndex = changelog.entries.findIndex((e) => e.unreleased);
+    if (unreleasedIndex === -1) {
+        throw createError('No unreleased entry found');
+    }
+    const unreleased = changelog.entries[unreleasedIndex];
+    const releaseDate = date ?? createDate().toISOString().split('T')[0];
+    const releaseEntry = createChangelogEntry(version, {
+        date: releaseDate,
+        unreleased: false,
+        compareUrl,
+        sections: unreleased.sections,
+    });
+    const newEntries = [...changelog.entries];
+    newEntries[unreleasedIndex] = releaseEntry;
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+
+/**
+ * Changelog Item Addition
+ *
+ * Functions for adding items to changelog entries.
+ */
+/**
+ * Adds an item to a specific section within an entry.
+ *
+ * @param changelog - The changelog containing the entry to modify
+ * @param version - The version identifier of the entry to update
+ * @param sectionType - Category identifier for grouping changes (e.g., 'features', 'fixes')
+ * @param item - Description of the change with optional scope and metadata
+ * @returns A new changelog with the item added
+ */
+function addItemToEntry(changelog, version, sectionType, item) {
+    const entryIndex = changelog.entries.findIndex((e) => e.version === version);
+    if (entryIndex === -1) {
+        throw createError(`Entry with version "${version}" not found`);
+    }
+    const entry = changelog.entries[entryIndex];
+    const sectionIndex = entry.sections.findIndex((s) => s.type === sectionType);
+    let newSections;
+    if (sectionIndex === -1) {
+        // Create new section
+        newSections = [
+            ...entry.sections,
+            {
+                type: sectionType,
+                heading: sectionType.charAt(0).toUpperCase() + sectionType.slice(1),
+                items: [item],
+            },
+        ];
+    }
+    else {
+        // Add to existing section
+        newSections = [...entry.sections];
+        newSections[sectionIndex] = {
+            ...newSections[sectionIndex],
+            items: [...newSections[sectionIndex].items, item],
+        };
+    }
+    const newEntry = {
+        ...entry,
+        sections: newSections,
+    };
+    const newEntries = [...changelog.entries];
+    newEntries[entryIndex] = newEntry;
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+
+/**
+ * Safe copies of Set built-in via factory function.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides a factory function that uses Reflect.construct internally.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/set
+ */
+// Capture references at module initialization time
+const _Set = globalThis.Set;
+const _Reflect$1 = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Set using the captured Set constructor.
+ * Use this instead of `new Set()`.
+ *
+ * @param iterable - Optional iterable of values.
+ * @returns A new Set instance.
+ */
+const createSet = (iterable) => _Reflect$1.construct(_Set, iterable ? [iterable] : []);
+
+/**
+ * Changelog Entry Removal
+ *
+ * Functions for removing entries from a changelog.
+ */
+/**
+ * Removes an entry from a changelog by version.
+ *
+ * @param changelog - The changelog to remove from
+ * @param version - The version to remove
+ * @param options - Optional removal options
+ * @returns A new changelog without the specified entry
+ *
+ * @example
+ * ```ts
+ * const newChangelog = removeEntry(changelog, '1.0.0')
+ * ```
+ */
+function removeEntry(changelog, version, options) {
+    const throwIfNotFound = options?.throwIfNotFound ?? true;
+    const entryIndex = changelog.entries.findIndex((e) => e.version === version);
+    if (entryIndex === -1) {
+        if (throwIfNotFound) {
+            throw createError(`Entry with version "${version}" not found`);
+        }
+        return changelog;
+    }
+    const newEntries = [...changelog.entries];
+    newEntries.splice(entryIndex, 1);
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Removes multiple entries from a changelog.
+ *
+ * @param changelog - The changelog to remove from
+ * @param versions - The versions to remove
+ * @param options - Optional removal options
+ * @returns A new changelog without the specified entries
+ */
+function removeEntries(changelog, versions, options) {
+    const versionsSet = createSet(versions);
+    const newEntries = changelog.entries.filter((e) => !versionsSet.has(e.version));
+    if (options?.throwIfNotFound !== false) {
+        const removedVersions = changelog.entries.filter((e) => versionsSet.has(e.version)).map((e) => e.version);
+        const notFoundVersions = versions.filter((v) => !removedVersions.includes(v));
+        if (notFoundVersions.length > 0) {
+            throw createError(`Entries not found for versions: ${notFoundVersions.join(', ')}`);
+        }
+    }
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Removes the unreleased entry if it exists.
+ *
+ * @param changelog - The changelog to remove the unreleased entry from
+ * @param options - Optional removal options
+ * @returns A new changelog without the unreleased entry
+ */
+function removeUnreleased(changelog, options) {
+    const unreleasedIndex = changelog.entries.findIndex((e) => e.unreleased);
+    if (unreleasedIndex === -1) {
+        if (options?.throwIfNotFound ?? true) {
+            throw createError('No unreleased entry found');
+        }
+        return changelog;
+    }
+    const newEntries = [...changelog.entries];
+    newEntries.splice(unreleasedIndex, 1);
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+
+/**
+ * Changelog Section/Item Removal
+ *
+ * Functions for removing sections and items from changelog entries.
+ */
+/**
+ * Removes a section from an entry.
+ *
+ * @param changelog - The changelog containing the entry to modify
+ * @param version - The version of the entry to modify
+ * @param sectionType - The section type to remove
+ * @param options - Optional removal options
+ * @returns A new changelog without the specified section
+ */
+function removeSection(changelog, version, sectionType, options) {
+    const throwIfNotFound = options?.throwIfNotFound ?? true;
+    const entryIndex = changelog.entries.findIndex((e) => e.version === version);
+    if (entryIndex === -1) {
+        if (throwIfNotFound) {
+            throw createError(`Entry with version "${version}" not found`);
+        }
+        return changelog;
+    }
+    const entry = changelog.entries[entryIndex];
+    const sectionIndex = entry.sections.findIndex((s) => s.type === sectionType);
+    if (sectionIndex === -1) {
+        if (throwIfNotFound) {
+            throw createError(`Section with type "${sectionType}" not found in version "${version}"`);
+        }
+        return changelog;
+    }
+    const newSections = [...entry.sections];
+    newSections.splice(sectionIndex, 1);
+    const newEntry = {
+        ...entry,
+        sections: newSections,
+    };
+    const newEntries = [...changelog.entries];
+    newEntries[entryIndex] = newEntry;
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Removes an item from an entry by description.
+ *
+ * @param changelog - The changelog containing the entry to modify
+ * @param version - The version of the entry to modify
+ * @param sectionType - The section type containing the item
+ * @param itemDescription - The description of the item to remove
+ * @param options - Optional removal options
+ * @returns A new changelog without the specified item
+ */
+function removeItem(changelog, version, sectionType, itemDescription, options) {
+    const throwIfNotFound = options?.throwIfNotFound ?? true;
+    const entryIndex = changelog.entries.findIndex((e) => e.version === version);
+    if (entryIndex === -1) {
+        if (throwIfNotFound) {
+            throw createError(`Entry with version "${version}" not found`);
+        }
+        return changelog;
+    }
+    const entry = changelog.entries[entryIndex];
+    const sectionIndex = entry.sections.findIndex((s) => s.type === sectionType);
+    if (sectionIndex === -1) {
+        if (throwIfNotFound) {
+            throw createError(`Section with type "${sectionType}" not found in version "${version}"`);
+        }
+        return changelog;
+    }
+    const section = entry.sections[sectionIndex];
+    const itemIndex = section.items.findIndex((i) => i.description === itemDescription);
+    if (itemIndex === -1) {
+        if (throwIfNotFound) {
+            throw createError(`Item with description "${itemDescription}" not found in section "${sectionType}"`);
+        }
+        return changelog;
+    }
+    const newItems = [...section.items];
+    newItems.splice(itemIndex, 1);
+    const newSection = {
+        ...section,
+        items: newItems,
+    };
+    const newSections = [...entry.sections];
+    newSections[sectionIndex] = newSection;
+    const newEntry = {
+        ...entry,
+        sections: newSections,
+    };
+    const newEntries = [...changelog.entries];
+    newEntries[entryIndex] = newEntry;
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Removes empty sections from all entries.
+ *
+ * @param changelog - The changelog to remove empty sections from
+ * @returns A new changelog with empty sections removed
+ */
+function removeEmptySections(changelog) {
+    const newEntries = changelog.entries.map((entry) => {
+        const nonEmptySections = entry.sections.filter((s) => s.items.length > 0);
+        if (nonEmptySections.length === entry.sections.length) {
+            return entry; // No change
+        }
+        return {
+            ...entry,
+            sections: nonEmptySections,
+        };
+    });
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Removes empty entries (entries with no sections or only empty sections).
+ *
+ * @param changelog - The changelog to remove empty entries from
+ * @param keepUnreleased - Whether to keep an empty unreleased entry (default: true)
+ * @returns A new changelog with empty entries removed
+ */
+function removeEmptyEntries(changelog, keepUnreleased = true) {
+    const newEntries = changelog.entries.filter((entry) => {
+        // Check if entry has any items
+        const hasItems = entry.sections.some((s) => s.items.length > 0);
+        if (hasItems)
+            return true;
+        if (keepUnreleased && entry.unreleased)
+            return true;
+        if (entry.rawContent)
+            return true;
+        return false;
+    });
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+
+/**
+ * Changelog Predicate-Based Filtering
+ *
+ * Functions for filtering changelog entries, sections, and items using predicates.
+ */
+/**
+ * Filters entries using a predicate function.
+ *
+ * @param changelog - The changelog to filter
+ * @param predicate - Function that returns true for entries to keep
+ * @returns A new changelog with filtered entries
+ *
+ * @example
+ * ```ts
+ * const filtered = filterEntries(changelog, (entry) => !entry.unreleased)
+ * ```
+ */
+function filterEntries(changelog, predicate) {
+    const newEntries = changelog.entries.filter(predicate);
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Filters entries that have breaking changes.
+ *
+ * @param changelog - The changelog to filter
+ * @returns A new changelog with only entries containing breaking changes
+ */
+function filterBreakingChanges(changelog) {
+    return filterEntries(changelog, (entry) => {
+        // Check for breaking section
+        const hasBreakingSection = entry.sections.some((s) => s.type === 'breaking');
+        if (hasBreakingSection)
+            return true;
+        // Check for breaking items in other sections
+        return entry.sections.some((section) => section.items.some((item) => item.breaking));
+    });
+}
+/**
+ * Filters sections within each entry.
+ *
+ * @param changelog - The changelog to filter
+ * @param predicate - Function that returns true for sections to keep
+ * @returns A new changelog with filtered sections
+ */
+function filterSections(changelog, predicate) {
+    const newEntries = changelog.entries.map((entry) => ({
+        ...entry,
+        sections: entry.sections.filter((section) => predicate(section, entry)),
+    }));
+    return { ...changelog, entries: newEntries };
+}
+/**
+ * Keeps only specified section types.
+ *
+ * @param changelog - The changelog to filter
+ * @param types - Section types to keep
+ * @returns A new changelog with only specified section types
+ */
+function filterSectionTypes(changelog, types) {
+    const typeSet = createSet(types);
+    return filterSections(changelog, (section) => typeSet.has(section.type));
+}
+/**
+ * Filters items within sections.
+ *
+ * @param changelog - The changelog to filter
+ * @param predicate - Function that returns true for items to keep
+ * @returns A new changelog with filtered items
+ */
+function filterItems(changelog, predicate) {
+    const newEntries = changelog.entries.map((entry) => ({
+        ...entry,
+        sections: entry.sections.map((section) => ({
+            ...section,
+            items: section.items.filter((item) => predicate(item, section, entry)),
+        })),
+    }));
+    return { ...changelog, entries: newEntries };
+}
+/**
+ * Filters items by scope.
+ *
+ * @param changelog - The changelog to filter
+ * @param scopes - Scopes to include
+ * @returns A new changelog with only items matching the scopes
+ */
+function filterByScope(changelog, scopes) {
+    const scopeSet = createSet(scopes);
+    return filterItems(changelog, (item) => {
+        if (!item.scope)
+            return false;
+        return scopeSet.has(item.scope);
+    });
+}
+/**
+ * Excludes items by scope.
+ *
+ * @param changelog - The changelog to filter
+ * @param scopes - Scopes to exclude
+ * @returns A new changelog without items matching the scopes
+ */
+function excludeByScope(changelog, scopes) {
+    const scopeSet = createSet(scopes);
+    return filterItems(changelog, (item) => {
+        if (!item.scope)
+            return true;
+        return !scopeSet.has(item.scope);
+    });
+}
+
+/**
+ * Safe copies of Math built-in methods.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
+ */
+// Capture references at module initialization time
+const _Math = globalThis.Math;
+// ============================================================================
+// Min/Max
+// ============================================================================
+/**
+ * (Safe copy) Returns the larger of zero or more numbers.
+ */
+const max = _Math.max;
+
+/**
+ * Safe copies of Number built-in methods and constants.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/number
+ */
+// Capture references at module initialization time
+const _parseInt = globalThis.parseInt;
+const _isNaN = globalThis.isNaN;
+// ============================================================================
+// Parsing
+// ============================================================================
+/**
+ * (Safe copy) Parses a string and returns an integer.
+ */
+const parseInt = _parseInt;
+// ============================================================================
+// Global Type Checking (legacy, less strict)
+// ============================================================================
+/**
+ * (Safe copy) Global isNaN function (coerces to number first, less strict than Number.isNaN).
+ */
+const globalIsNaN = _isNaN;
+
+/**
+ * Compares two semantic versions.
+ *
+ * @param a - First version
+ * @param b - Second version
+ * @returns -1 if a < b, 0 if a == b, 1 if a > b
+ *
+ * @example
+ * compare(parseVersion('1.0.0'), parseVersion('2.0.0')) // -1
+ * compare(parseVersion('1.0.0'), parseVersion('1.0.0')) // 0
+ * compare(parseVersion('2.0.0'), parseVersion('1.0.0')) // 1
+ */
+function compare(a, b) {
+    // Compare major, minor, patch
+    if (a.major !== b.major) {
+        return a.major < b.major ? -1 : 1;
+    }
+    if (a.minor !== b.minor) {
+        return a.minor < b.minor ? -1 : 1;
+    }
+    if (a.patch !== b.patch) {
+        return a.patch < b.patch ? -1 : 1;
+    }
+    // Compare prerelease
+    // Version with prerelease has lower precedence than release
+    if (a.prerelease.length === 0 && b.prerelease.length > 0) {
+        return 1; // a is release, b is prerelease -> a > b
+    }
+    if (a.prerelease.length > 0 && b.prerelease.length === 0) {
+        return -1; // a is prerelease, b is release -> a < b
+    }
+    // Both have prerelease - compare identifiers
+    const maxLen = max(a.prerelease.length, b.prerelease.length);
+    for (let i = 0; i < maxLen; i++) {
+        const aId = a.prerelease[i];
+        const bId = b.prerelease[i];
+        // Shorter prerelease array has lower precedence
+        if (aId === undefined && bId !== undefined) {
+            return -1;
+        }
+        if (aId !== undefined && bId === undefined) {
+            return 1;
+        }
+        if (aId === undefined || bId === undefined) {
+            continue;
+        }
+        // Compare identifiers
+        const cmp = compareIdentifiers(aId, bId);
+        if (cmp !== 0) {
+            return cmp;
+        }
+    }
+    return 0;
+}
+/**
+ * Checks if a version satisfies a comparator.
+ *
+ * @param version - Version to check
+ * @param comparator - Comparator to test against
+ * @returns True if version satisfies the comparator
+ */
+function satisfiesComparator(version, comparator) {
+    const cmp = compare(version, comparator.version);
+    switch (comparator.operator) {
+        case '=':
+            return cmp === 0;
+        case '>':
+            return cmp === 1;
+        case '>=':
+            return cmp >= 0;
+        case '<':
+            return cmp === -1;
+        case '<=':
+            return cmp <= 0;
+        case '^':
+        case '~':
+            // These should have been expanded during parsing
+            // If we encounter them here, treat as >=
+            return cmp >= 0;
+        default:
+            return false;
+    }
+}
+/**
+ * Checks if a version satisfies a range.
+ *
+ * @param version - Version to check
+ * @param range - Range to test against
+ * @returns True if version satisfies the range
+ *
+ * @example
+ * satisfies(parseVersion('1.2.3'), parseRange('^1.0.0')) // true
+ * satisfies(parseVersion('2.0.0'), parseRange('^1.0.0')) // false
+ */
+function satisfies(version, range) {
+    // Empty range matches any
+    if (range.sets.length === 0) {
+        return true;
+    }
+    // OR logic: at least one set must be satisfied
+    for (const set of range.sets) {
+        // AND logic: all comparators in set must be satisfied
+        let allSatisfied = true;
+        // Empty comparator set matches any
+        if (set.comparators.length === 0) {
+            return true;
+        }
+        for (const comp of set.comparators) {
+            if (!satisfiesComparator(version, comp)) {
+                allSatisfied = false;
+                break;
+            }
+        }
+        if (allSatisfied) {
+            return true;
+        }
+    }
+    return false;
+}
+// ============================================================================
+// Internal helpers
+// ============================================================================
+/**
+ * Compares two prerelease identifiers.
+ * Numeric identifiers have lower precedence than alphanumeric.
+ * Numeric identifiers are compared numerically.
+ * Alphanumeric identifiers are compared lexically.
+ *
+ * @param a - First prerelease identifier
+ * @param b - Second prerelease identifier
+ * @returns -1 if a < b, 0 if equal, 1 if a > b
+ */
+function compareIdentifiers(a, b) {
+    const aIsNumeric = isNumeric(a);
+    const bIsNumeric = isNumeric(b);
+    // Numeric identifiers have lower precedence
+    if (aIsNumeric && !bIsNumeric) {
+        return -1;
+    }
+    if (!aIsNumeric && bIsNumeric) {
+        return 1;
+    }
+    // Both numeric - compare as numbers
+    if (aIsNumeric && bIsNumeric) {
+        const aNum = parseInt(a, 10);
+        const bNum = parseInt(b, 10);
+        if (aNum < bNum)
+            return -1;
+        if (aNum > bNum)
+            return 1;
+        return 0;
+    }
+    // Both alphanumeric - compare lexically
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+/**
+ * Checks if a string consists only of digits.
+ *
+ * @param str - String to check for numeric content
+ * @returns True if string contains only digits
+ */
+function isNumeric(str) {
+    if (str.length === 0)
+        return false;
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        if (code < 48 || code > 57) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Creates a new Comparator.
+ *
+ * @param operator - The comparison operator
+ * @param version - The version to compare against
+ * @returns A new Comparator
+ */
+function createComparator(operator, version) {
+    return { operator, version };
+}
+/**
+ * Creates a new ComparatorSet.
+ *
+ * @param comparators - Array of comparators (AND logic)
+ * @returns A new ComparatorSet
+ */
+function createComparatorSet(comparators) {
+    return { comparators };
+}
+/**
+ * Creates a new Range.
+ *
+ * @param sets - Array of comparator sets (OR logic)
+ * @param raw - Original raw string
+ * @returns A new Range
+ */
+function createRange(sets, raw) {
+    return { sets, raw };
+}
+
+/**
+ * Creates a new SemVer object.
+ *
+ * @param options - Version components
+ * @returns A new SemVer object
+ */
+function createSemVer(options) {
+    return {
+        major: options.major,
+        minor: options.minor,
+        patch: options.patch,
+        prerelease: options.prerelease ?? [],
+        build: options.build ?? [],
+        raw: options.raw,
+    };
+}
+
+/**
+ * Maximum range string length.
+ */
+const MAX_RANGE_LENGTH = 1024;
+/**
+ * Parses a semver range string.
+ *
+ * Supports:
+ * - Exact: 1.2.3, =1.2.3
+ * - Comparators: >1.0.0, >=1.0.0, <2.0.0, <=2.0.0
+ * - Caret: ^1.2.3 (compatible with version)
+ * - Tilde: ~1.2.3 (approximately equivalent)
+ * - X-ranges: 1.x, 1.2.x, *
+ * - Hyphen ranges: 1.0.0 - 2.0.0
+ * - OR: 1.0.0 || 2.0.0
+ * - AND: >=1.0.0 <2.0.0
+ *
+ * @param input - The range string to parse
+ * @returns A ParseRangeResult with the parsed range or error
+ */
+function parseRange(input) {
+    if (!input || typeof input !== 'string') {
+        return { success: false, error: 'Range string is required' };
+    }
+    if (input.length > MAX_RANGE_LENGTH) {
+        return { success: false, error: `Range string exceeds maximum length of ${MAX_RANGE_LENGTH}` };
+    }
+    // Trim whitespace
+    const trimmed = input.trim();
+    // Handle wildcard/any
+    if (trimmed === '' || trimmed === '*' || trimmed.toLowerCase() === 'x') {
+        return { success: true, range: createRange([], input) };
+    }
+    // Split by || for OR logic
+    const orParts = splitByOr(trimmed);
+    const sets = [];
+    for (const part of orParts) {
+        const setResult = parseComparatorSet(part.trim());
+        if (!setResult.success) {
+            return { success: false, error: setResult.error };
+        }
+        if (setResult.set) {
+            sets.push(setResult.set);
+        }
+    }
+    return { success: true, range: createRange(sets, input) };
+}
+/**
+ * Splits a string by || delimiter, respecting nesting.
+ *
+ * @param input - Range string containing OR groups
+ * @returns Array of OR-separated parts
+ */
+function splitByOr(input) {
+    const parts = [];
+    let current = '';
+    let pos = 0;
+    while (pos < input.length) {
+        if (input[pos] === '|' && pos + 1 < input.length && input[pos + 1] === '|') {
+            parts.push(current);
+            current = '';
+            pos += 2;
+        }
+        else {
+            current += input[pos];
+            pos++;
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+/**
+ * Parses a single comparator set (space-separated comparators = AND logic).
+ *
+ * @param input - Comparator set string
+ * @returns Parsed set result
+ */
+function parseComparatorSet(input) {
+    if (!input || input.trim() === '') {
+        return { success: true }; // Empty set matches any
+    }
+    const trimmed = input.trim();
+    // Check for hyphen range: "1.0.0 - 2.0.0"
+    const hyphenMatch = parseHyphenRange(trimmed);
+    if (hyphenMatch.isHyphenRange) {
+        if (!hyphenMatch.success) {
+            return { success: false, error: hyphenMatch.error };
+        }
+        return { success: true, set: hyphenMatch.set };
+    }
+    // Split by whitespace for AND logic
+    const tokens = splitByWhitespace(trimmed);
+    const comparators = [];
+    for (const token of tokens) {
+        const compResult = parseSingleComparator(token);
+        if (!compResult.success) {
+            return { success: false, error: compResult.error };
+        }
+        if (compResult.comparators) {
+            comparators.push(...compResult.comparators);
+        }
+    }
+    if (comparators.length === 0) {
+        return { success: true }; // Empty matches any
+    }
+    return { success: true, set: createComparatorSet(comparators) };
+}
+/**
+ * Checks for and parses hyphen ranges like "1.0.0 - 2.0.0".
+ *
+ * @param input - Potential hyphen range string
+ * @returns Hyphen range parsing result
+ */
+function parseHyphenRange(input) {
+    // Look for " - " (space-hyphen-space)
+    let hyphenPos = -1;
+    for (let i = 0; i < input.length - 2; i++) {
+        if (input[i] === ' ' && input[i + 1] === '-' && input[i + 2] === ' ') {
+            hyphenPos = i;
+            break;
+        }
+    }
+    if (hyphenPos === -1) {
+        return { isHyphenRange: false, success: true };
+    }
+    const leftPart = input.slice(0, hyphenPos).trim();
+    const rightPart = input.slice(hyphenPos + 3).trim();
+    const leftVersion = parseSimpleVersion(leftPart);
+    if (!leftVersion) {
+        return { isHyphenRange: true, success: false, error: `Invalid left side of hyphen range: "${leftPart}"` };
+    }
+    const rightVersion = parseSimpleVersion(rightPart);
+    if (!rightVersion) {
+        return { isHyphenRange: true, success: false, error: `Invalid right side of hyphen range: "${rightPart}"` };
+    }
+    // Hyphen range: >=left <=right
+    const comparators = [createComparator('>=', leftVersion), createComparator('<=', rightVersion)];
+    return {
+        isHyphenRange: true,
+        success: true,
+        set: createComparatorSet(comparators),
+    };
+}
+/**
+ * Splits by whitespace.
+ *
+ * @param input - String to split
+ * @returns Array of whitespace-separated tokens
+ */
+function splitByWhitespace(input) {
+    const tokens = [];
+    let current = '';
+    for (const char of input) {
+        if (char === ' ' || char === '\t') {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+/**
+ * Parses a single comparator token (e.g., ">=1.0.0", "^1.2.3", "~1.0").
+ *
+ * @param token - Comparator token to parse
+ * @returns Parsed comparator result
+ */
+function parseSingleComparator(token) {
+    let pos = 0;
+    let operator = '=';
+    // Parse operator
+    if (token[pos] === '^') {
+        operator = '^';
+        pos++;
+    }
+    else if (token[pos] === '~') {
+        operator = '~';
+        pos++;
+    }
+    else if (token[pos] === '>') {
+        if (token[pos + 1] === '=') {
+            operator = '>=';
+            pos += 2;
+        }
+        else {
+            operator = '>';
+            pos++;
+        }
+    }
+    else if (token[pos] === '<') {
+        if (token[pos + 1] === '=') {
+            operator = '<=';
+            pos += 2;
+        }
+        else {
+            operator = '<';
+            pos++;
+        }
+    }
+    else if (token[pos] === '=') {
+        operator = '=';
+        pos++;
+    }
+    const versionPart = token.slice(pos);
+    // Handle wildcards: *, x, X
+    if (versionPart === '*' || versionPart.toLowerCase() === 'x') {
+        // Wildcard matches any - return empty (will be handled as match-all)
+        return { success: true, comparators: [] };
+    }
+    // Handle x-ranges: 1.x, 1.2.x
+    if (versionPart.includes('x') || versionPart.includes('X') || versionPart.includes('*')) {
+        return parseXRange(versionPart);
+    }
+    // Parse version
+    const version = parseSimpleVersion(versionPart);
+    if (!version) {
+        return { success: false, error: `Invalid version in comparator: "${versionPart}"` };
+    }
+    // For caret and tilde, expand to range
+    if (operator === '^') {
+        return expandCaretRange(version);
+    }
+    if (operator === '~') {
+        return expandTildeRange(version);
+    }
+    return { success: true, comparators: [createComparator(operator, version)] };
+}
+/**
+ * Parses x-ranges like 1.x, 1.2.x, etc.
+ *
+ * @param input - X-range string to parse
+ * @param _operator - Range operator (unused but kept for interface consistency)
+ * @returns Comparator result
+ */
+function parseXRange(input, _operator) {
+    const parts = input.split('.');
+    const nums = [];
+    for (const part of parts) {
+        const lower = part.toLowerCase();
+        if (lower === 'x' || lower === '*' || lower === '') {
+            break;
+        }
+        const num = parseInt(part, 10);
+        if (globalIsNaN(num) || num < 0) {
+            return { success: false, error: `Invalid x-range: "${input}"` };
+        }
+        nums.push(num);
+    }
+    if (nums.length === 0) {
+        // * or X alone - match any
+        return { success: true, comparators: [] };
+    }
+    if (nums.length === 1) {
+        // 1.x or 1.* -> >=1.0.0 <2.0.0
+        const lower = createSemVer({ major: nums[0], minor: 0, patch: 0 });
+        const upper = createSemVer({ major: nums[0] + 1, minor: 0, patch: 0 });
+        return { success: true, comparators: [createComparator('>=', lower), createComparator('<', upper)] };
+    }
+    // 1.2.x -> >=1.2.0 <1.3.0
+    const lower = createSemVer({ major: nums[0], minor: nums[1], patch: 0 });
+    const upper = createSemVer({ major: nums[0], minor: nums[1] + 1, patch: 0 });
+    return { success: true, comparators: [createComparator('>=', lower), createComparator('<', upper)] };
+}
+/**
+ * Expands caret range: ^1.2.3 -> >=1.2.3 <2.0.0
+ *
+ * @param version - Base version for caret range
+ * @returns Expanded comparator result
+ */
+function expandCaretRange(version) {
+    let upperMajor = version.major;
+    let upperMinor = 0;
+    let upperPatch = 0;
+    if (version.major === 0) {
+        if (version.minor === 0) {
+            // ^0.0.x -> >=0.0.x <0.0.(x+1)
+            upperPatch = version.patch + 1;
+            upperMinor = version.minor;
+        }
+        else {
+            // ^0.x.y -> >=0.x.y <0.(x+1).0
+            upperMinor = version.minor + 1;
+        }
+    }
+    else {
+        // ^x.y.z -> >=x.y.z <(x+1).0.0
+        upperMajor = version.major + 1;
+    }
+    const upper = createSemVer({ major: upperMajor, minor: upperMinor, patch: upperPatch });
+    return { success: true, comparators: [createComparator('>=', version), createComparator('<', upper)] };
+}
+/**
+ * Expands tilde range: ~1.2.3 -> >=1.2.3 <1.3.0
+ *
+ * @param version - Base version for tilde range
+ * @returns Expanded comparator result
+ */
+function expandTildeRange(version) {
+    const upper = createSemVer({
+        major: version.major,
+        minor: version.minor + 1,
+        patch: 0,
+    });
+    return { success: true, comparators: [createComparator('>=', version), createComparator('<', upper)] };
+}
+/**
+ * Parses a simple version string (no range operators).
+ * More lenient - accepts partial versions.
+ *
+ * @param input - Version string to parse
+ * @returns Parsed SemVer or null if invalid
+ */
+function parseSimpleVersion(input) {
+    if (!input)
+        return null;
+    let pos = 0;
+    // Skip leading v
+    if (input[pos] === 'v' || input[pos] === 'V') {
+        pos++;
+    }
+    const parts = input.slice(pos).split('.');
+    if (parts.length === 0)
+        return null;
+    const nums = [];
+    for (const part of parts) {
+        // Stop at prerelease or build
+        const dashIdx = part.indexOf('-');
+        const plusIdx = part.indexOf('+');
+        let numPart = part;
+        if (dashIdx !== -1) {
+            numPart = part.slice(0, dashIdx);
+        }
+        else if (plusIdx !== -1) {
+            numPart = part.slice(0, plusIdx);
+        }
+        if (numPart === '' || numPart.toLowerCase() === 'x' || numPart === '*') {
+            break;
+        }
+        const num = parseInt(numPart, 10);
+        if (globalIsNaN(num) || num < 0)
+            return null;
+        nums.push(num);
+    }
+    if (nums.length === 0)
+        return null;
+    return createSemVer({
+        major: nums[0],
+        minor: nums[1] ?? 0,
+        patch: nums[2] ?? 0,
+        prerelease: [],
+        build: [],
+        raw: input,
+    });
+}
+
+/**
+ * Maximum version string length to prevent memory exhaustion.
+ */
+const MAX_VERSION_LENGTH = 256;
+/**
+ * Parses a semantic version string.
+ *
+ * Accepts versions in the format: MAJOR.MINOR.PATCH[-prerelease][+build]
+ * Optional leading 'v' or '=' prefixes are stripped.
+ *
+ * @param input - The version string to parse
+ * @returns A ParseVersionResult with the parsed version or error
+ *
+ * @example
+ * parseVersion('1.2.3') // { success: true, version: { major: 1, minor: 2, patch: 3, ... } }
+ * parseVersion('v1.0.0-alpha.1+build.123') // { success: true, ... }
+ * parseVersion('invalid') // { success: false, error: '...' }
+ */
+function parseVersion(input) {
+    // Input validation
+    if (!input || typeof input !== 'string') {
+        return { success: false, error: 'Version string is required' };
+    }
+    if (input.length > MAX_VERSION_LENGTH) {
+        return { success: false, error: `Version string exceeds maximum length of ${MAX_VERSION_LENGTH}` };
+    }
+    // Strip leading whitespace
+    let pos = 0;
+    while (pos < input.length && isWhitespace(input.charCodeAt(pos))) {
+        pos++;
+    }
+    // Strip trailing whitespace
+    let end = input.length;
+    while (end > pos && isWhitespace(input.charCodeAt(end - 1))) {
+        end--;
+    }
+    // Strip optional leading 'v' or '='
+    if (pos < end) {
+        const code = input.charCodeAt(pos);
+        if (code === 118 || code === 86) {
+            // 'v' or 'V'
+            pos++;
+        }
+        else if (code === 61) {
+            // '='
+            pos++;
+        }
+    }
+    // Parse major version
+    const majorResult = parseNumericIdentifier(input, pos, end);
+    if (!majorResult.success) {
+        return { success: false, error: majorResult.error ?? 'Invalid major version' };
+    }
+    pos = majorResult.endPos;
+    // Expect dot
+    if (pos >= end || input.charCodeAt(pos) !== 46) {
+        // '.'
+        return { success: false, error: 'Expected "." after major version' };
+    }
+    pos++;
+    // Parse minor version
+    const minorResult = parseNumericIdentifier(input, pos, end);
+    if (!minorResult.success) {
+        return { success: false, error: minorResult.error ?? 'Invalid minor version' };
+    }
+    pos = minorResult.endPos;
+    // Expect dot
+    if (pos >= end || input.charCodeAt(pos) !== 46) {
+        // '.'
+        return { success: false, error: 'Expected "." after minor version' };
+    }
+    pos++;
+    // Parse patch version
+    const patchResult = parseNumericIdentifier(input, pos, end);
+    if (!patchResult.success) {
+        return { success: false, error: patchResult.error ?? 'Invalid patch version' };
+    }
+    pos = patchResult.endPos;
+    // Parse optional prerelease
+    const prerelease = [];
+    if (pos < end && input.charCodeAt(pos) === 45) {
+        // '-'
+        pos++;
+        const prereleaseResult = parseIdentifiers(input, pos, end, [43]); // Stop at '+'
+        if (!prereleaseResult.success) {
+            return { success: false, error: prereleaseResult.error ?? 'Invalid prerelease' };
+        }
+        prerelease.push(...prereleaseResult.identifiers);
+        pos = prereleaseResult.endPos;
+    }
+    // Parse optional build metadata
+    const build = [];
+    if (pos < end && input.charCodeAt(pos) === 43) {
+        // '+'
+        pos++;
+        const buildResult = parseIdentifiers(input, pos, end, []);
+        if (!buildResult.success) {
+            return { success: false, error: buildResult.error ?? 'Invalid build metadata' };
+        }
+        build.push(...buildResult.identifiers);
+        pos = buildResult.endPos;
+    }
+    // Check for trailing characters
+    if (pos < end) {
+        return { success: false, error: `Unexpected character at position ${pos}: "${input[pos]}"` };
+    }
+    return {
+        success: true,
+        version: createSemVer({
+            major: majorResult.value,
+            minor: minorResult.value,
+            patch: patchResult.value,
+            prerelease,
+            build,
+            raw: input,
+        }),
+    };
+}
+/**
+ * Parses a numeric identifier (non-negative integer, no leading zeros except for "0").
+ *
+ * @param input - Input string to parse
+ * @param start - Start position in the input
+ * @param end - End position in the input
+ * @returns Numeric parsing result
+ */
+function parseNumericIdentifier(input, start, end) {
+    if (start >= end) {
+        return { success: false, value: 0, endPos: start, error: 'Expected numeric identifier' };
+    }
+    let pos = start;
+    const firstCode = input.charCodeAt(pos);
+    // Must start with a digit
+    if (!isDigit(firstCode)) {
+        return { success: false, value: 0, endPos: pos, error: 'Expected digit' };
+    }
+    // Check for leading zero (only "0" is valid, not "01", "007", etc.)
+    if (firstCode === 48 && pos + 1 < end && isDigit(input.charCodeAt(pos + 1))) {
+        return { success: false, value: 0, endPos: pos, error: 'Numeric identifier cannot have leading zeros' };
+    }
+    // Consume digits
+    let value = 0;
+    while (pos < end && isDigit(input.charCodeAt(pos))) {
+        value = value * 10 + (input.charCodeAt(pos) - 48);
+        pos++;
+        // Prevent overflow
+        if (value > Number.MAX_SAFE_INTEGER) {
+            return { success: false, value: 0, endPos: pos, error: 'Numeric identifier is too large' };
+        }
+    }
+    return { success: true, value, endPos: pos };
+}
+/**
+ * Parses dot-separated identifiers (for prerelease/build).
+ *
+ * @param input - Input string to parse
+ * @param start - Start position in the input
+ * @param end - End position in the input
+ * @param stopCodes - Character codes that signal end of identifiers
+ * @returns Identifiers parsing result
+ */
+function parseIdentifiers(input, start, end, stopCodes) {
+    const identifiers = [];
+    let pos = start;
+    while (pos < end) {
+        // Check for stop characters
+        if (stopCodes.includes(input.charCodeAt(pos))) {
+            break;
+        }
+        // Parse one identifier
+        const identStart = pos;
+        while (pos < end) {
+            const code = input.charCodeAt(pos);
+            // Stop at dot or stop characters
+            if (code === 46 || stopCodes.includes(code)) {
+                break;
+            }
+            // Must be alphanumeric or hyphen
+            if (!isAlphanumeric(code) && code !== 45) {
+                return { success: false, identifiers: [], endPos: pos, error: `Invalid character in identifier: "${input[pos]}"` };
+            }
+            pos++;
+        }
+        // Empty identifier is not allowed
+        if (pos === identStart) {
+            return { success: false, identifiers: [], endPos: pos, error: 'Empty identifier' };
+        }
+        identifiers.push(input.slice(identStart, pos));
+        // Consume dot separator
+        if (pos < end && input.charCodeAt(pos) === 46) {
+            pos++;
+            // Dot at end is invalid
+            if (pos >= end || stopCodes.includes(input.charCodeAt(pos))) {
+                return { success: false, identifiers: [], endPos: pos, error: 'Identifier expected after dot' };
+            }
+        }
+    }
+    return { success: true, identifiers, endPos: pos };
+}
+/**
+ * Checks if a character code is a digit (0-9).
+ *
+ * @param code - Character code to check
+ * @returns True if the code represents a digit
+ */
+function isDigit(code) {
+    return code >= 48 && code <= 57;
+}
+/**
+ * Checks if a character code is alphanumeric or hyphen.
+ *
+ * @param code - Character code to check
+ * @returns True if the code represents an alphanumeric character
+ */
+function isAlphanumeric(code) {
+    return ((code >= 48 && code <= 57) || // 0-9
+        (code >= 65 && code <= 90) || // A-Z
+        (code >= 97 && code <= 122) // a-z
+    );
+}
+/**
+ * Checks if a character code is whitespace.
+ *
+ * @param code - Character code to check
+ * @returns True if the code represents whitespace
+ */
+function isWhitespace(code) {
+    return code === 32 || code === 9 || code === 10 || code === 13;
+}
+
+/**
+ * Changelog Range-Based Filtering
+ *
+ * Functions for filtering changelog entries by version range, date range, and count.
+ */
+/**
+ * Filters entries by version range using semver.
+ *
+ * @param changelog - The changelog to filter
+ * @param range - Semver range string (e.g., '>=1.0.0 <2.0.0')
+ * @returns A new changelog with entries matching the range
+ *
+ * @example
+ * ```ts
+ * const majors = filterByVersionRange(changelog, '>=1.0.0 <2.0.0')
+ * ```
+ */
+function filterByVersionRange(changelog, range) {
+    const rangeResult = parseRange(range);
+    if (!rangeResult.success) {
+        throw createError(`Invalid version range: ${range}`);
+    }
+    return filterEntries(changelog, (entry) => {
+        // Skip unreleased
+        if (entry.unreleased)
+            return false;
+        const versionResult = parseVersion(entry.version);
+        if (!versionResult.success)
+            return false;
+        return satisfies(versionResult.version, rangeResult.range);
+    });
+}
+/**
+ * Filters entries from a start version.
+ *
+ * @param changelog - The changelog to filter
+ * @param startVersion - The minimum version (inclusive)
+ * @returns A new changelog with entries >= startVersion
+ */
+function filterFromVersion(changelog, startVersion) {
+    const startResult = parseVersion(startVersion);
+    if (!startResult.success) {
+        throw createError(`Invalid start version: ${startVersion}`);
+    }
+    return filterEntries(changelog, (entry) => {
+        if (entry.unreleased)
+            return true;
+        const versionResult = parseVersion(entry.version);
+        if (!versionResult.success)
+            return false;
+        return compare(versionResult.version, startResult.version) >= 0;
+    });
+}
+/**
+ * Filters entries up to an end version.
+ *
+ * @param changelog - The changelog to apply the version filter to
+ * @param endVersion - The maximum version (inclusive)
+ * @returns A new changelog with entries <= endVersion
+ */
+function filterToVersion(changelog, endVersion) {
+    const endResult = parseVersion(endVersion);
+    if (!endResult.success) {
+        throw createError(`Invalid end version: ${endVersion}`);
+    }
+    return filterEntries(changelog, (entry) => {
+        if (entry.unreleased)
+            return false;
+        const versionResult = parseVersion(entry.version);
+        if (!versionResult.success)
+            return false;
+        return compare(versionResult.version, endResult.version) <= 0;
+    });
+}
+/**
+ * Gets entries within a version range (inclusive).
+ *
+ * @param changelog - The changelog to filter
+ * @param startVersion - The minimum version (inclusive)
+ * @param endVersion - The maximum version (inclusive)
+ * @returns A new changelog with entries in the range
+ */
+function filterVersionRange(changelog, startVersion, endVersion) {
+    const startResult = parseVersion(startVersion);
+    const endResult = parseVersion(endVersion);
+    if (!startResult.success) {
+        throw createError(`Invalid start version: ${startVersion}`);
+    }
+    if (!endResult.success) {
+        throw createError(`Invalid end version: ${endVersion}`);
+    }
+    return filterEntries(changelog, (entry) => {
+        if (entry.unreleased)
+            return false;
+        const versionResult = parseVersion(entry.version);
+        if (!versionResult.success)
+            return false;
+        const cmpStart = compare(versionResult.version, startResult.version);
+        const cmpEnd = compare(versionResult.version, endResult.version);
+        return cmpStart >= 0 && cmpEnd <= 0;
+    });
+}
+/**
+ * Gets the N most recent entries.
+ *
+ * @param changelog - The changelog to filter
+ * @param count - Number of entries to keep
+ * @param includeUnreleased - Whether to include unreleased in count (default: false)
+ * @returns A new changelog with only the most recent entries
+ */
+function filterRecentEntries(changelog, count, includeUnreleased = false) {
+    if (count <= 0) {
+        return { ...changelog, entries: [] };
+    }
+    const entries = includeUnreleased
+        ? changelog.entries.slice(0, count)
+        : (() => {
+            const result = [];
+            let remaining = count;
+            for (const entry of changelog.entries) {
+                if (entry.unreleased) {
+                    result.push(entry);
+                }
+                else if (remaining > 0) {
+                    result.push(entry);
+                    remaining--;
+                }
+                if (remaining <= 0 && !entry.unreleased)
+                    break;
+            }
+            return result;
+        })();
+    return { ...changelog, entries };
+}
+/**
+ * Filters entries by release date.
+ *
+ * @param changelog - The changelog to filter
+ * @param startDate - Start date (inclusive, ISO format)
+ * @param endDate - End date (inclusive, ISO format)
+ * @returns A new changelog with entries in the date range
+ */
+function filterByDateRange(changelog, startDate, endDate) {
+    return filterEntries(changelog, (entry) => {
+        if (!entry.date)
+            return false;
+        if (startDate && entry.date < startDate)
+            return false;
+        if (endDate && entry.date > endDate)
+            return false;
+        return true;
+    });
+}
+
+/**
+ * Safe copies of Map built-in via factory function.
+ *
+ * Since constructors cannot be safely captured via Object.assign, this module
+ * provides a factory function that uses Reflect.construct internally.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/map
+ */
+// Capture references at module initialization time
+const _Map = globalThis.Map;
+const _Reflect = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Map using the captured Map constructor.
+ * Use this instead of `new Map()`.
+ *
+ * @param iterable - Optional iterable of key-value pairs.
+ * @returns A new Map instance.
+ */
+const createMap = (iterable) => _Reflect.construct(_Map, iterable ? [iterable] : []);
+
+/**
+ * Changelog Equality Comparison
+ *
+ * Functions for comparing changelogs for structural equality.
+ * Uses deep comparison without relying on JSON serialization.
+ */
+/**
+ * Checks if two changelog entries are equal.
+ *
+ * @param a - First entry
+ * @param b - Second entry
+ * @returns True if entries are equal
+ */
+function isEntryEqual(a, b) {
+    if (a.version !== b.version)
+        return false;
+    if (a.date !== b.date)
+        return false;
+    if (a.unreleased !== b.unreleased)
+        return false;
+    if (a.compareUrl !== b.compareUrl)
+        return false;
+    if (a.rawContent !== b.rawContent)
+        return false;
+    // Check sections
+    if (a.sections.length !== b.sections.length)
+        return false;
+    for (let i = 0; i < a.sections.length; i++) {
+        if (!isSectionEqual(a.sections[i], b.sections[i]))
+            return false;
+    }
+    return true;
+}
+/**
+ * Checks if two changelog sections are equal.
+ *
+ * @param a - First section
+ * @param b - Second section
+ * @returns True if sections are equal
+ */
+function isSectionEqual(a, b) {
+    if (a.type !== b.type)
+        return false;
+    if (a.heading !== b.heading)
+        return false;
+    // Check items
+    if (a.items.length !== b.items.length)
+        return false;
+    for (let i = 0; i < a.items.length; i++) {
+        if (!isItemEqual(a.items[i], b.items[i]))
+            return false;
+    }
+    return true;
+}
+/**
+ * Checks if two changelog items are equal.
+ *
+ * @param a - First item
+ * @param b - Second item
+ * @returns True if items are equal
+ */
+function isItemEqual(a, b) {
+    if (a.scope !== b.scope)
+        return false;
+    if (a.description !== b.description)
+        return false;
+    if (a.breaking !== b.breaking)
+        return false;
+    // Check commits
+    if (a.commits.length !== b.commits.length)
+        return false;
+    for (let i = 0; i < a.commits.length; i++) {
+        if (!isCommitRefEqual(a.commits[i], b.commits[i]))
+            return false;
+    }
+    // Check references
+    if (a.references.length !== b.references.length)
+        return false;
+    for (let i = 0; i < a.references.length; i++) {
+        if (!isIssueRefEqual(a.references[i], b.references[i]))
+            return false;
+    }
+    return true;
+}
+/**
+ * Checks if two commit references are equal.
+ *
+ * @param a - First commit ref
+ * @param b - Second commit ref
+ * @returns True if commit refs are equal
+ */
+function isCommitRefEqual(a, b) {
+    return a.hash === b.hash && a.shortHash === b.shortHash && a.url === b.url;
+}
+/**
+ * Checks if two issue references are equal.
+ *
+ * @param a - First issue ref
+ * @param b - Second issue ref
+ * @returns True if issue refs are equal
+ */
+function isIssueRefEqual(a, b) {
+    return a.number === b.number && a.type === b.type && a.url === b.url;
+}
+
+/**
+ * Changelog Merging
+ *
+ * Functions for merging multiple changelogs or changelog entries.
+ */
+/**
+ * Default merge options.
+ */
+const DEFAULT_MERGE_OPTIONS = {
+    entryStrategy: 'union',
+    sectionStrategy: 'union',
+    itemStrategy: 'union',
+    useSourceHeader: true,
+    sortByVersion: true,
+    removeDuplicates: true,
+};
+/**
+ * Merges two changelogs together.
+ *
+ * @param source - The source changelog
+ * @param target - The target changelog
+ * @param options - Optional merge options
+ * @returns The merge result with merged changelog and stats
+ *
+ * @example
+ * ```ts
+ * const result = mergeChangelogs(mainChangelog, branchChangelog)
+ * console.log(`Merged ${result.stats.merged} entries`)
+ * ```
+ */
+function mergeChangelogs(source, target, options) {
+    const opts = resolveOptions(options);
+    // Build version maps
+    const sourceByVersion = createMap();
+    const targetByVersion = createMap();
+    for (const entry of source.entries) {
+        sourceByVersion.set(entry.version, entry);
+    }
+    for (const entry of target.entries) {
+        targetByVersion.set(entry.version, entry);
+    }
+    const mergedEntries = [];
+    const allVersions = createSet([...sourceByVersion.keys(), ...targetByVersion.keys()]);
+    let sourceOnly = 0;
+    let targetOnly = 0;
+    let merged = 0;
+    let conflictsResolved = 0;
+    for (const version of allVersions) {
+        const sourceEntry = sourceByVersion.get(version);
+        const targetEntry = targetByVersion.get(version);
+        if (sourceEntry && !targetEntry) {
+            // Only in source
+            mergedEntries.push(sourceEntry);
+            sourceOnly++;
+        }
+        else if (!sourceEntry && targetEntry) {
+            // Only in target
+            mergedEntries.push(targetEntry);
+            targetOnly++;
+        }
+        else if (sourceEntry && targetEntry) {
+            // In both - merge
+            if (isEntryEqual(sourceEntry, targetEntry)) {
+                mergedEntries.push(sourceEntry);
+            }
+            else {
+                const mergedEntry = mergeEntries(sourceEntry, targetEntry, opts);
+                mergedEntries.push(mergedEntry);
+                conflictsResolved++;
+            }
+            merged++;
+        }
+    }
+    // Sort by version if requested
+    let finalEntries = mergedEntries;
+    if (opts.sortByVersion) {
+        finalEntries = sortEntriesByVersion(mergedEntries);
+    }
+    // Build header
+    const header = opts.useSourceHeader ? source.header : target.header;
+    // Build metadata
+    const metadata = {
+        format: source.metadata.format,
+        isConventional: source.metadata.isConventional || target.metadata.isConventional,
+        repositoryUrl: source.metadata.repositoryUrl ?? target.metadata.repositoryUrl,
+        packageName: source.metadata.packageName ?? target.metadata.packageName,
+        warnings: [...source.metadata.warnings, ...target.metadata.warnings],
+    };
+    const changelog = {
+        header,
+        entries: finalEntries,
+        metadata,
+    };
+    return {
+        changelog,
+        stats: {
+            totalEntries: finalEntries.length,
+            sourceOnly,
+            targetOnly,
+            merged,
+            conflictsResolved,
+        },
+    };
+}
+/**
+ * Merges two changelog entries.
+ *
+ * @param source - Source entry
+ * @param target - Target entry
+ * @param opts - Resolved merge options
+ * @returns Merged entry
+ */
+function mergeEntries(source, target, opts) {
+    // Use strategy for scalar values
+    const date = opts.entryStrategy === 'target' ? target.date : source.date;
+    const compareUrl = opts.entryStrategy === 'target' ? target.compareUrl : source.compareUrl;
+    const unreleased = source.unreleased || target.unreleased;
+    // Merge sections
+    const sections = mergeSections(source.sections, target.sections, opts);
+    return {
+        version: source.version,
+        date,
+        unreleased,
+        compareUrl,
+        sections,
+    };
+}
+/**
+ * Merges section arrays.
+ *
+ * @param sourceSections - Array of sections from the source changelog
+ * @param targetSections - Array of sections from the target changelog
+ * @param opts - Resolved merge options
+ * @returns Merged sections
+ */
+function mergeSections(sourceSections, targetSections, opts) {
+    const sourceByType = createMap();
+    const targetByType = createMap();
+    for (const section of sourceSections) {
+        sourceByType.set(section.type, section);
+    }
+    for (const section of targetSections) {
+        targetByType.set(section.type, section);
+    }
+    const result = [];
+    const allTypes = createSet([...sourceByType.keys(), ...targetByType.keys()]);
+    for (const type of allTypes) {
+        const sourceSection = sourceByType.get(type);
+        const targetSection = targetByType.get(type);
+        if (sourceSection && !targetSection) {
+            result.push(sourceSection);
+        }
+        else if (!sourceSection && targetSection) {
+            result.push(targetSection);
+        }
+        else if (sourceSection && targetSection) {
+            if (isSectionEqual(sourceSection, targetSection)) {
+                result.push(sourceSection);
+            }
+            else {
+                const mergedSection = mergeSection(sourceSection, targetSection, opts);
+                result.push(mergedSection);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Merges two sections.
+ *
+ * @param source - Section from the source changelog
+ * @param target - Section from the target changelog
+ * @param opts - Resolved merge options
+ * @returns Merged section
+ */
+function mergeSection(source, target, opts) {
+    const heading = opts.sectionStrategy === 'target' ? target.heading : source.heading;
+    const items = mergeItems(source.items, target.items, opts);
+    return {
+        type: source.type,
+        heading,
+        items,
+    };
+}
+/**
+ * Merges item arrays.
+ *
+ * @param sourceItems - Array of items from the source section
+ * @param targetItems - Array of items from the target section
+ * @param opts - Resolved merge options
+ * @returns Merged items
+ */
+function mergeItems(sourceItems, targetItems, opts) {
+    if (opts.itemStrategy === 'source') {
+        return [...sourceItems];
+    }
+    if (opts.itemStrategy === 'target') {
+        return [...targetItems];
+    }
+    // Union strategy - combine all items
+    const result = [...sourceItems];
+    for (const targetItem of targetItems) {
+        // Check if item already exists in source
+        const exists = sourceItems.some((sourceItem) => isItemEqual(sourceItem, targetItem));
+        if (!exists) {
+            // Check by description only (for 'latest' strategy)
+            if (opts.itemStrategy === 'latest') {
+                const existingIndex = result.findIndex((item) => item.description === targetItem.description);
+                if (existingIndex !== -1) {
+                    // Replace with target (newer)
+                    result[existingIndex] = targetItem;
+                    continue;
+                }
+            }
+            result.push(targetItem);
+        }
+    }
+    return result;
+}
+/**
+ * Resolves merge options with defaults.
+ *
+ * @param options - Optional merge options to resolve with defaults
+ * @returns Fully resolved merge options with all required fields
+ */
+function resolveOptions(options) {
+    if (!options) {
+        return DEFAULT_MERGE_OPTIONS;
+    }
+    return {
+        entryStrategy: options.entryStrategy ?? DEFAULT_MERGE_OPTIONS.entryStrategy,
+        sectionStrategy: options.sectionStrategy ?? DEFAULT_MERGE_OPTIONS.sectionStrategy,
+        itemStrategy: options.itemStrategy ?? DEFAULT_MERGE_OPTIONS.itemStrategy,
+        useSourceHeader: options.useSourceHeader ?? DEFAULT_MERGE_OPTIONS.useSourceHeader,
+        sortByVersion: options.sortByVersion ?? DEFAULT_MERGE_OPTIONS.sortByVersion,
+        removeDuplicates: options.removeDuplicates ?? DEFAULT_MERGE_OPTIONS.removeDuplicates,
+    };
+}
+/**
+ * Sorts entries by version (descending - newest first).
+ *
+ * @param entries - Entries to sort
+ * @returns Sorted entries
+ */
+function sortEntriesByVersion(entries) {
+    return [...entries].sort((a, b) => {
+        // Unreleased always comes first
+        if (a.unreleased && !b.unreleased)
+            return -1;
+        if (!a.unreleased && b.unreleased)
+            return 1;
+        if (a.unreleased && b.unreleased)
+            return 0;
+        // Parse versions for comparison
+        const aResult = parseVersion(a.version);
+        const bResult = parseVersion(b.version);
+        if (!aResult.success || !bResult.success) {
+            // Fall back to string comparison
+            return b.version.localeCompare(a.version);
+        }
+        // Sort descending (newest first)
+        return compare(bResult.version, aResult.version);
+    });
+}
+/**
+ * Appends entries from target to source (no conflict resolution).
+ *
+ * @param source - The base changelog to append to
+ * @param target - The changelog whose entries will be appended
+ * @param position - Where to insert ('start' or 'end')
+ * @returns A new changelog with combined entries
+ */
+function appendChangelog(source, target, position = 'end') {
+    const entries = position === 'start' ? [...target.entries, ...source.entries] : [...source.entries, ...target.entries];
+    return {
+        ...source,
+        entries,
+    };
+}
+/**
+ * Combines multiple changelogs into one.
+ *
+ * @param changelogs - Array of changelogs to combine
+ * @param options - Optional merge options
+ * @returns The combined changelog
+ */
+function combineChangelogs(changelogs, options) {
+    if (changelogs.length === 0) {
+        throw createError('At least one changelog is required');
+    }
+    if (changelogs.length === 1) {
+        return changelogs[0];
+    }
+    let result = changelogs[0];
+    for (let i = 1; i < changelogs.length; i++) {
+        const mergeResult = mergeChangelogs(result, changelogs[i], options);
+        result = mergeResult.changelog;
+    }
+    return result;
+}
+
+/**
+ * Maps section headings to their canonical types.
+ * Used during parsing to normalize different heading styles.
+ */
+/**
+ * Standard section headings for serialization.
+ * Maps section types to their preferred heading text.
+ */
+const SECTION_HEADINGS = {
+    breaking: 'Breaking Changes',
+    features: 'Features',
+    fixes: 'Bug Fixes',
+    performance: 'Performance',
+    documentation: 'Documentation',
+    deprecations: 'Deprecations',
+    refactoring: 'Refactoring',
+    tests: 'Tests',
+    build: 'Build',
+    ci: 'CI',
+    chores: 'Chores',
+    other: 'Other',
+};
+
+/**
+ * Changelog Transformation Helpers
+ *
+ * Generic transformation functions for modifying changelogs.
+ */
+/**
+ * Transforms all entries in a changelog.
+ *
+ * @param changelog - The changelog to transform
+ * @param transformer - Function to transform each entry
+ * @returns A new changelog with transformed entries
+ *
+ * @example
+ * ```ts
+ * const transformed = transformEntries(changelog, (entry) => ({
+ *   ...entry,
+ *   date: entry.date?.toUpperCase()
+ * }))
+ * ```
+ */
+function transformEntries(changelog, transformer) {
+    const newEntries = changelog.entries.map(transformer);
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Transforms all sections in all entries.
+ *
+ * @param changelog - The changelog to transform
+ * @param transformer - Function to transform each section
+ * @returns A new changelog with transformed sections
+ */
+function transformSections(changelog, transformer) {
+    const newEntries = changelog.entries.map((entry) => ({
+        ...entry,
+        sections: entry.sections.map((section) => transformer(section, entry)),
+    }));
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Transforms all items in all sections.
+ *
+ * @param changelog - The changelog to transform
+ * @param transformer - Function to transform each item
+ * @returns A new changelog with transformed items
+ */
+function transformItems(changelog, transformer) {
+    const newEntries = changelog.entries.map((entry) => ({
+        ...entry,
+        sections: entry.sections.map((section) => ({
+            ...section,
+            items: section.items.map((item) => transformer(item, section, entry)),
+        })),
+    }));
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Updates the header of a changelog.
+ *
+ * @param changelog - The changelog to update
+ * @param updates - Partial header updates
+ * @returns A new changelog with updated header
+ */
+function updateHeader(changelog, updates) {
+    return {
+        ...changelog,
+        header: {
+            ...changelog.header,
+            ...updates,
+        },
+    };
+}
+/**
+ * Updates the metadata of a changelog.
+ *
+ * @param changelog - The changelog to update
+ * @param updates - Partial metadata updates
+ * @returns A new changelog with updated metadata
+ */
+function updateMetadata(changelog, updates) {
+    return {
+        ...changelog,
+        metadata: {
+            ...changelog.metadata,
+            ...updates,
+        },
+    };
+}
+/**
+ * Updates a specific entry by version.
+ *
+ * @param changelog - The changelog to update
+ * @param version - Version of entry to update
+ * @param updates - Partial entry updates or transformer function
+ * @returns A new changelog with updated entry
+ */
+function updateEntry(changelog, version, updates) {
+    const entryIndex = changelog.entries.findIndex((e) => e.version === version);
+    if (entryIndex === -1) {
+        throw createError(`Entry with version "${version}" not found`);
+    }
+    const entry = changelog.entries[entryIndex];
+    const updatedEntry = typeof updates === 'function' ? updates(entry) : { ...entry, ...updates };
+    const newEntries = [...changelog.entries];
+    newEntries[entryIndex] = updatedEntry;
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Sorts entries by version (descending - newest first).
+ *
+ * @param changelog - The changelog to sort
+ * @returns A new changelog with sorted entries
+ */
+function sortEntries(changelog) {
+    const sorted = [...changelog.entries].sort((a, b) => {
+        // Unreleased always comes first
+        if (a.unreleased && !b.unreleased)
+            return -1;
+        if (!a.unreleased && b.unreleased)
+            return 1;
+        if (a.unreleased && b.unreleased)
+            return 0;
+        const aResult = parseVersion(a.version);
+        const bResult = parseVersion(b.version);
+        if (!aResult.success || !bResult.success) {
+            return b.version.localeCompare(a.version);
+        }
+        return compare(bResult.version, aResult.version);
+    });
+    return {
+        ...changelog,
+        entries: sorted,
+    };
+}
+/**
+ * Sorts entries by date (newest first).
+ *
+ * @param changelog - The changelog to sort
+ * @returns A new changelog with sorted entries
+ */
+function sortEntriesByDate(changelog) {
+    const sorted = [...changelog.entries].sort((a, b) => {
+        // Unreleased always comes first
+        if (a.unreleased && !b.unreleased)
+            return -1;
+        if (!a.unreleased && b.unreleased)
+            return 1;
+        if (a.unreleased && b.unreleased)
+            return 0;
+        // Entries without dates go to the end
+        if (!a.date && b.date)
+            return 1;
+        if (a.date && !b.date)
+            return -1;
+        if (!a.date && !b.date)
+            return 0;
+        // Compare dates (descending)
+        return b.date.localeCompare(a.date);
+    });
+    return {
+        ...changelog,
+        entries: sorted,
+    };
+}
+/**
+ * Reverses the order of entries.
+ *
+ * @param changelog - The changelog to reverse
+ * @returns A new changelog with reversed entries
+ */
+function reverseEntries(changelog) {
+    return {
+        ...changelog,
+        entries: [...changelog.entries].reverse(),
+    };
+}
+/**
+ * Sorts sections within each entry by a specified order.
+ *
+ * @param changelog - The changelog to sort
+ * @param order - Optional custom section order (defaults to standard order)
+ * @returns A new changelog with sorted sections
+ */
+function sortSections(changelog, order) {
+    const defaultOrder = [
+        'breaking',
+        'features',
+        'fixes',
+        'performance',
+        'documentation',
+        'deprecations',
+        'refactoring',
+        'tests',
+        'build',
+        'ci',
+        'chores',
+        'other',
+    ];
+    const sectionOrder = order ?? defaultOrder;
+    const orderMap = createMap();
+    sectionOrder.forEach((type, index) => orderMap.set(type, index));
+    const newEntries = changelog.entries.map((entry) => ({
+        ...entry,
+        sections: [...entry.sections].sort((a, b) => {
+            const orderA = orderMap.get(a.type) ?? Number.MAX_SAFE_INTEGER;
+            const orderB = orderMap.get(b.type) ?? Number.MAX_SAFE_INTEGER;
+            return orderA - orderB;
+        }),
+    }));
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Normalizes section headings to standard format.
+ *
+ * @param changelog - The changelog to normalize
+ * @returns A new changelog with normalized section headings
+ */
+function normalizeSectionHeadings(changelog) {
+    return transformSections(changelog, (section) => ({
+        ...section,
+        heading: SECTION_HEADINGS[section.type] ?? section.heading,
+    }));
+}
+/**
+ * Removes duplicate items across all sections.
+ *
+ * @param changelog - The changelog to deduplicate
+ * @returns A new changelog without duplicate items
+ */
+function deduplicateItems(changelog) {
+    const newEntries = changelog.entries.map((entry) => {
+        const seenDescriptions = createSet();
+        const newSections = entry.sections.map((section) => {
+            const uniqueItems = [];
+            for (const item of section.items) {
+                const key = `${item.scope ?? ''}:${item.description}`;
+                if (!seenDescriptions.has(key)) {
+                    seenDescriptions.add(key);
+                    uniqueItems.push(item);
+                }
+            }
+            return {
+                ...section,
+                items: uniqueItems,
+            };
+        });
+        return {
+            ...entry,
+            sections: newSections,
+        };
+    });
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Compacts a changelog by removing empty sections and entries.
+ *
+ * @param changelog - The changelog to compact
+ * @param keepUnreleased - Whether to keep empty unreleased entry (default: true)
+ * @returns A new compacted changelog
+ */
+function compact(changelog, keepUnreleased = true) {
+    const newEntries = changelog.entries
+        .map((entry) => ({
+        ...entry,
+        sections: entry.sections.filter((s) => s.items.length > 0),
+    }))
+        .filter((entry) => {
+        const hasContent = entry.sections.length > 0 || entry.rawContent;
+        if (hasContent)
+            return true;
+        if (keepUnreleased && entry.unreleased)
+            return true;
+        return false;
+    });
+    return {
+        ...changelog,
+        entries: newEntries,
+    };
+}
+/**
+ * Strips metadata from a changelog.
+ *
+ * @param changelog - The changelog to strip
+ * @returns A new changelog with minimal metadata
+ */
+function stripMetadata(changelog) {
+    return {
+        ...changelog,
+        source: undefined,
+        metadata: {
+            format: changelog.metadata.format,
+            isConventional: changelog.metadata.isConventional,
+            warnings: [],
+        },
+    };
+}
+/**
+ * Clones a changelog deeply (for modification without affecting original).
+ *
+ * @param changelog - The changelog to clone
+ * @returns A deep copy of the changelog
+ */
+function cloneChangelog(changelog) {
+    return {
+        source: changelog.source,
+        header: {
+            title: changelog.header.title,
+            description: [...changelog.header.description],
+            links: changelog.header.links.map((link) => ({ ...link })),
+        },
+        entries: changelog.entries.map((entry) => ({
+            version: entry.version,
+            date: entry.date,
+            unreleased: entry.unreleased,
+            compareUrl: entry.compareUrl,
+            rawContent: entry.rawContent,
+            sections: entry.sections.map((section) => ({
+                type: section.type,
+                heading: section.heading,
+                items: section.items.map((item) => ({
+                    scope: item.scope,
+                    description: item.description,
+                    breaking: item.breaking,
+                    commits: item.commits.map((commit) => ({ ...commit })),
+                    references: item.references.map((ref) => ({ ...ref })),
+                })),
+            })),
+        })),
+        metadata: {
+            format: changelog.metadata.format,
+            isConventional: changelog.metadata.isConventional,
+            repositoryUrl: changelog.metadata.repositoryUrl,
+            packageName: changelog.metadata.packageName,
+            warnings: [...changelog.metadata.warnings],
+        },
+    };
+}
+
+exports.DEFAULT_MERGE_OPTIONS = DEFAULT_MERGE_OPTIONS;
+exports.addEntry = addEntry;
+exports.addItemToEntry = addItemToEntry;
+exports.addUnreleasedEntry = addUnreleasedEntry;
+exports.appendChangelog = appendChangelog;
+exports.cloneChangelog = cloneChangelog;
+exports.combineChangelogs = combineChangelogs;
+exports.compact = compact;
+exports.deduplicateItems = deduplicateItems;
+exports.excludeByScope = excludeByScope;
+exports.filterBreakingChanges = filterBreakingChanges;
+exports.filterByDateRange = filterByDateRange;
+exports.filterByScope = filterByScope;
+exports.filterByVersionRange = filterByVersionRange;
+exports.filterEntries = filterEntries;
+exports.filterFromVersion = filterFromVersion;
+exports.filterItems = filterItems;
+exports.filterRecentEntries = filterRecentEntries;
+exports.filterSectionTypes = filterSectionTypes;
+exports.filterSections = filterSections;
+exports.filterToVersion = filterToVersion;
+exports.filterVersionRange = filterVersionRange;
+exports.mergeChangelogs = mergeChangelogs;
+exports.normalizeSectionHeadings = normalizeSectionHeadings;
+exports.releaseUnreleased = releaseUnreleased;
+exports.removeEmptyEntries = removeEmptyEntries;
+exports.removeEmptySections = removeEmptySections;
+exports.removeEntries = removeEntries;
+exports.removeEntry = removeEntry;
+exports.removeItem = removeItem;
+exports.removeSection = removeSection;
+exports.removeUnreleased = removeUnreleased;
+exports.reverseEntries = reverseEntries;
+exports.sortEntries = sortEntries;
+exports.sortEntriesByDate = sortEntriesByDate;
+exports.sortSections = sortSections;
+exports.stripMetadata = stripMetadata;
+exports.transformEntries = transformEntries;
+exports.transformItems = transformItems;
+exports.transformSections = transformSections;
+exports.updateEntry = updateEntry;
+exports.updateHeader = updateHeader;
+exports.updateMetadata = updateMetadata;
+//# sourceMappingURL=index.cjs.js.map