@hyperfrontend/versioning 0.1.0

package/changelog/parse/index.esm.js

@@ -0,0 +1,1275 @@
+/**
+ * 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
+ */
+function createChangelogItem(description, options) {
+    return {
+        description,
+        scope: options?.scope,
+        commits: options?.commits ?? [],
+        references: options?.references ?? [],
+        breaking: options?.breaking ?? false,
+    };
+}
+
+/**
+ * Maps section headings to their canonical types.
+ * Used during parsing to normalize different heading styles.
+ */
+const SECTION_TYPE_MAP = {
+    // Breaking changes
+    'breaking changes': 'breaking',
+    breaking: 'breaking',
+    'breaking change': 'breaking',
+    // Features
+    features: 'features',
+    feature: 'features',
+    added: 'features',
+    new: 'features',
+    // Fixes
+    fixes: 'fixes',
+    fix: 'fixes',
+    'bug fixes': 'fixes',
+    bugfixes: 'fixes',
+    fixed: 'fixes',
+    // Performance
+    performance: 'performance',
+    'performance improvements': 'performance',
+    perf: 'performance',
+    // Documentation
+    documentation: 'documentation',
+    docs: 'documentation',
+    // Deprecations
+    deprecations: 'deprecations',
+    deprecated: 'deprecations',
+    // Refactoring
+    refactoring: 'refactoring',
+    refactor: 'refactoring',
+    'code refactoring': 'refactoring',
+    // Tests
+    tests: 'tests',
+    test: 'tests',
+    testing: 'tests',
+    // Build
+    build: 'build',
+    'build system': 'build',
+    dependencies: 'build',
+    // CI
+    ci: 'ci',
+    'continuous integration': 'ci',
+    // Chores
+    chores: 'chores',
+    chore: 'chores',
+    maintenance: 'chores',
+    // Other
+    other: 'other',
+    miscellaneous: 'other',
+    misc: 'other',
+    changed: 'other',
+    changes: 'other',
+    removed: 'other',
+    security: 'other',
+};
+/**
+ * Determines the section type from a heading string.
+ * Returns 'other' if the heading is not recognized.
+ *
+ * @param heading - The heading string to parse
+ * @returns The corresponding ChangelogSectionType
+ */
+function getSectionType(heading) {
+    const normalized = heading.toLowerCase().trim();
+    return SECTION_TYPE_MAP[normalized] ?? 'other';
+}
+
+/**
+ * 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;
+// ============================================================================
+// Parsing
+// ============================================================================
+/**
+ * (Safe copy) Parses a string and returns an integer.
+ */
+const parseInt = _parseInt;
+
+/**
+ * Line Parser
+ *
+ * Utilities for parsing individual changelog lines without regex.
+ */
+/**
+ * Parses a version string from a heading.
+ * Examples: "1.2.3", "v1.2.3", "[1.2.3]", "1.2.3 - 2024-01-01"
+ *
+ * @param heading - The heading string to parse
+ * @returns An object containing the parsed version, date, and optional compareUrl
+ */
+function parseVersionFromHeading(heading) {
+    const trimmed = heading.trim();
+    // Check for unreleased
+    const lowerHeading = trimmed.toLowerCase();
+    if (lowerHeading === 'unreleased' || lowerHeading === '[unreleased]') {
+        return { version: 'Unreleased', date: null };
+    }
+    let pos = 0;
+    let version = '';
+    let date = null;
+    let compareUrl;
+    // Skip leading [ if present
+    if (trimmed[pos] === '[') {
+        pos++;
+    }
+    // Skip leading 'v' if present
+    if (trimmed[pos] === 'v' || trimmed[pos] === 'V') {
+        pos++;
+    }
+    // Parse version number (digits and dots)
+    const versionStart = pos;
+    while (pos < trimmed.length) {
+        const char = trimmed[pos];
+        const code = char.charCodeAt(0);
+        // Allow digits, dots, hyphens (for prerelease), plus signs
+        if ((code >= 48 && code <= 57) || // 0-9
+            char === '.' ||
+            char === '-' ||
+            char === '+' ||
+            (code >= 97 && code <= 122) || // a-z (for prerelease tags like alpha, beta, rc)
+            (code >= 65 && code <= 90) // A-Z
+        ) {
+            pos++;
+        }
+        else {
+            break;
+        }
+    }
+    version = trimmed.slice(versionStart, pos);
+    // Skip trailing ] if present
+    if (trimmed[pos] === ']') {
+        pos++;
+    }
+    // Skip whitespace and separator
+    while (pos < trimmed.length && (trimmed[pos] === ' ' || trimmed[pos] === '-' || trimmed[pos] === '–')) {
+        pos++;
+    }
+    // Try to parse date (YYYY-MM-DD format)
+    if (pos < trimmed.length) {
+        const dateMatch = extractDate(trimmed.slice(pos));
+        if (dateMatch) {
+            date = dateMatch.date;
+            pos += dateMatch.length;
+        }
+    }
+    // Skip to check for compare URL (in parentheses or link)
+    while (pos < trimmed.length && trimmed[pos] === ' ') {
+        pos++;
+    }
+    // Check for link at end: [compare](url)
+    if (pos < trimmed.length) {
+        const linkMatch = extractLink(trimmed.slice(pos));
+        if (linkMatch?.url) {
+            compareUrl = linkMatch.url;
+        }
+    }
+    return { version, date, compareUrl };
+}
+/**
+ * Extracts a date in YYYY-MM-DD format from a string.
+ *
+ * @param str - The string to extract a date from
+ * @returns The extracted date and its length, or null if no date found
+ */
+function extractDate(str) {
+    let pos = 0;
+    // Skip optional parentheses
+    if (str[pos] === '(')
+        pos++;
+    // Parse year (4 digits)
+    const yearStart = pos;
+    while (pos < str.length && pos - yearStart < 4) {
+        const code = str.charCodeAt(pos);
+        if (code >= 48 && code <= 57) {
+            pos++;
+        }
+        else {
+            break;
+        }
+    }
+    if (pos - yearStart !== 4)
+        return null;
+    // Expect - or /
+    if (str[pos] !== '-' && str[pos] !== '/')
+        return null;
+    const separator = str[pos];
+    pos++;
+    // Parse month (2 digits)
+    const monthStart = pos;
+    while (pos < str.length && pos - monthStart < 2) {
+        const code = str.charCodeAt(pos);
+        if (code >= 48 && code <= 57) {
+            pos++;
+        }
+        else {
+            break;
+        }
+    }
+    if (pos - monthStart !== 2)
+        return null;
+    // Expect same separator
+    if (str[pos] !== separator)
+        return null;
+    pos++;
+    // Parse day (2 digits)
+    const dayStart = pos;
+    while (pos < str.length && pos - dayStart < 2) {
+        const code = str.charCodeAt(pos);
+        if (code >= 48 && code <= 57) {
+            pos++;
+        }
+        else {
+            break;
+        }
+    }
+    if (pos - dayStart !== 2)
+        return null;
+    // Skip optional closing parenthesis
+    if (str[pos] === ')')
+        pos++;
+    const dateStr = str.slice(yearStart, dayStart + 2);
+    const date = slashToHyphen(dateStr);
+    return { date, length: pos };
+}
+/**
+ * Replaces forward slashes with hyphens (ReDoS-safe).
+ *
+ * @param input - The input string
+ * @returns String with forward slashes replaced by hyphens
+ */
+function slashToHyphen(input) {
+    const result = [];
+    for (let i = 0; i < input.length; i++) {
+        result.push(input[i] === '/' ? '-' : input[i]);
+    }
+    return result.join('');
+}
+/**
+ * Extracts a markdown link from a string.
+ *
+ * @param str - The string to extract a link from
+ * @returns The extracted link text, url, and length, or null if no link found
+ */
+function extractLink(str) {
+    if (str[0] !== '[')
+        return null;
+    let pos = 1;
+    let depth = 1;
+    // Find closing ]
+    while (pos < str.length && depth > 0) {
+        if (str[pos] === '[')
+            depth++;
+        else if (str[pos] === ']')
+            depth--;
+        pos++;
+    }
+    if (depth !== 0)
+        return null;
+    const text = str.slice(1, pos - 1);
+    // Expect (
+    if (str[pos] !== '(')
+        return null;
+    pos++;
+    const urlStart = pos;
+    depth = 1;
+    while (pos < str.length && depth > 0) {
+        if (str[pos] === '(')
+            depth++;
+        else if (str[pos] === ')')
+            depth--;
+        pos++;
+    }
+    if (depth !== 0)
+        return null;
+    const url = str.slice(urlStart, pos - 1);
+    return { text, url, length: pos };
+}
+/**
+ * Parses commit references from a line.
+ * Examples: (abc1234), [abc1234], commit abc1234
+ *
+ * @param text - The text to parse for commit references
+ * @param baseUrl - Optional base URL for constructing commit links
+ * @returns An array of parsed CommitRef objects
+ */
+function parseCommitRefs(text, baseUrl) {
+    const refs = [];
+    let pos = 0;
+    while (pos < text.length) {
+        // Look for potential hash patterns
+        // Common formats: (abc1234), [abc1234], abc1234fabcdef
+        // Check for parenthetical hash
+        if (text[pos] === '(' || text[pos] === '[') {
+            const closeChar = text[pos] === '(' ? ')' : ']';
+            const start = pos + 1;
+            pos++;
+            // Read potential hash
+            while (pos < text.length && isHexDigit(text[pos])) {
+                pos++;
+            }
+            // Check if valid hash (7-40 hex chars)
+            const hash = text.slice(start, pos);
+            if (hash.length >= 7 && hash.length <= 40 && text[pos] === closeChar) {
+                refs.push({
+                    hash,
+                    shortHash: hash.slice(0, 7),
+                    url: baseUrl ? `${baseUrl}/commit/${hash}` : undefined,
+                });
+                pos++; // skip closing bracket
+                continue;
+            }
+        }
+        pos++;
+    }
+    return refs;
+}
+/**
+ * Parses issue/PR references from a line.
+ * Examples: #123, GH-123, closes #123
+ *
+ * @param text - The text to parse for issue references
+ * @param baseUrl - Optional base URL for constructing issue links
+ * @returns An array of parsed IssueRef objects
+ */
+function parseIssueRefs(text, baseUrl) {
+    const refs = [];
+    let pos = 0;
+    while (pos < text.length) {
+        // Look for # followed by digits
+        if (text[pos] === '#') {
+            pos++;
+            const numStart = pos;
+            while (pos < text.length && isDigitChar(text[pos])) {
+                pos++;
+            }
+            if (pos > numStart) {
+                const number = parseInt(text.slice(numStart, pos), 10);
+                // Check context for PR vs issue
+                const beforeHash = text.slice(max(0, numStart - 10), numStart - 1).toLowerCase();
+                const type = beforeHash.includes('pr') || beforeHash.includes('pull') ? 'pull-request' : 'issue';
+                refs.push({
+                    number,
+                    type,
+                    url: baseUrl ? `${baseUrl}/issues/${number}` : undefined,
+                });
+                continue;
+            }
+        }
+        pos++;
+    }
+    return refs;
+}
+/**
+ * Parses the scope from a changelog item.
+ * Example: "**scope:** description" -> { scope: "scope", description: "description" }
+ *
+ * @param text - The text to parse for scope
+ * @returns An object with optional scope and the description
+ */
+function parseScopeFromItem(text) {
+    const trimmed = text.trim();
+    // Check for **scope:** pattern (colon inside or outside bold)
+    if (trimmed.startsWith('**')) {
+        let pos = 2;
+        const scopeStart = pos;
+        // Read until ** or :
+        while (pos < trimmed.length && trimmed[pos] !== '*' && trimmed[pos] !== ':') {
+            pos++;
+        }
+        // Handle **scope:** pattern (colon before closing **)
+        if (trimmed[pos] === ':' && trimmed[pos + 1] === '*' && trimmed[pos + 2] === '*') {
+            const scope = trimmed.slice(scopeStart, pos);
+            pos += 3; // skip :**
+            // Skip whitespace
+            while (trimmed[pos] === ' ')
+                pos++;
+            return { scope, description: trimmed.slice(pos) };
+        }
+        // Handle **scope**: pattern (colon after closing **)
+        if (trimmed[pos] === '*' && trimmed[pos + 1] === '*') {
+            const scope = trimmed.slice(scopeStart, pos);
+            pos += 2; // skip **
+            // Skip : if present
+            if (trimmed[pos] === ':')
+                pos++;
+            // Skip whitespace
+            while (trimmed[pos] === ' ')
+                pos++;
+            return { scope, description: trimmed.slice(pos) };
+        }
+    }
+    // Check for scope: pattern (without bold)
+    const colonPos = trimmed.indexOf(':');
+    if (colonPos > 0 && colonPos < 30) {
+        // scope shouldn't be too long
+        const potentialScope = trimmed.slice(0, colonPos);
+        // Scope should be a simple identifier (letters, numbers, hyphens)
+        if (isValidScope(potentialScope)) {
+            const description = trimmed.slice(colonPos + 1).trim();
+            return { scope: potentialScope, description };
+        }
+    }
+    return { description: trimmed };
+}
+/**
+ * Checks if a string is a valid scope (alphanumeric with hyphens).
+ *
+ * @param str - The string to check
+ * @returns True if the string is a valid scope identifier
+ */
+function isValidScope(str) {
+    if (!str || str.length === 0)
+        return false;
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        if (!(code >= 48 && code <= 57) && // 0-9
+            !(code >= 65 && code <= 90) && // A-Z
+            !(code >= 97 && code <= 122) && // a-z
+            code !== 45 // -
+        ) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Checks if a character is a hex digit.
+ *
+ * @param char - The character to check
+ * @returns True if the character is a hex digit (0-9, A-F, a-f)
+ */
+function isHexDigit(char) {
+    const code = char.charCodeAt(0);
+    return ((code >= 48 && code <= 57) || // 0-9
+        (code >= 65 && code <= 70) || // A-F
+        (code >= 97 && code <= 102) // a-f
+    );
+}
+/**
+ * Checks if a character is a digit.
+ *
+ * @param char - The character to check
+ * @returns True if the character is a digit (0-9)
+ */
+function isDigitChar(char) {
+    const code = char.charCodeAt(0);
+    return code >= 48 && code <= 57;
+}
+
+/**
+ * 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 = 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.construct(_Error, [message, options]);
+
+/**
+ * Changelog Tokenizer
+ *
+ * A state machine tokenizer that processes markdown character-by-character.
+ * No regex is used to ensure ReDoS safety.
+ */
+/**
+ * Maximum input length to prevent memory exhaustion (1MB)
+ */
+const MAX_INPUT_LENGTH = 1024 * 1024;
+/**
+ * Tokenizes a changelog markdown string into tokens.
+ *
+ * @param input - The markdown content to tokenize
+ * @returns Array of tokens
+ * @throws {Error} If input exceeds maximum length
+ */
+function tokenize(input) {
+    if (input.length > MAX_INPUT_LENGTH) {
+        throw createError(`Input exceeds maximum length of ${MAX_INPUT_LENGTH} characters`);
+    }
+    const state = {
+        pos: 0,
+        line: 1,
+        column: 1,
+        input,
+        tokens: [],
+    };
+    while (state.pos < state.input.length) {
+        const char = state.input[state.pos];
+        // Check for newline
+        if (char === '\n') {
+            consumeNewline(state);
+            continue;
+        }
+        // Check for carriage return (handle \r\n)
+        if (char === '\r') {
+            state.pos++;
+            if (state.input[state.pos] === '\n') {
+                consumeNewline(state);
+            }
+            continue;
+        }
+        // At start of line, check for special markers
+        if (state.column === 1) {
+            // Check for heading
+            if (char === '#') {
+                consumeHeading(state);
+                continue;
+            }
+            // Check for list item
+            if ((char === '-' || char === '*') && isWhitespace(state.input[state.pos + 1])) {
+                consumeListItem(state);
+                continue;
+            }
+        }
+        // Check for inline markdown elements
+        if (char === '[') {
+            consumeLink(state);
+            continue;
+        }
+        if (char === '`') {
+            consumeCode(state);
+            continue;
+        }
+        if (char === '*' && state.input[state.pos + 1] === '*') {
+            consumeBold(state);
+            continue;
+        }
+        // Default: consume as text
+        consumeText(state);
+    }
+    // Add EOF token
+    pushToken(state, 'eof', '');
+    return state.tokens;
+}
+/**
+ * Consumes a newline character.
+ *
+ * @param state - The tokenizer state to update
+ */
+function consumeNewline(state) {
+    // Check if this is a blank line (previous token was also newline or at start)
+    const prevToken = state.tokens[state.tokens.length - 1];
+    const isBlank = prevToken?.type === 'newline' || prevToken?.type === 'blank-line' || state.tokens.length === 0;
+    pushToken(state, isBlank ? 'blank-line' : 'newline', '\n');
+    state.pos++;
+    state.line++;
+    state.column = 1;
+}
+/**
+ * Consumes a heading (# through ####).
+ *
+ * @param state - The tokenizer state to update
+ */
+function consumeHeading(state) {
+    const startColumn = state.column;
+    let level = 0;
+    // Count # characters
+    while (state.input[state.pos] === '#' && level < 4) {
+        state.pos++;
+        state.column++;
+        level++;
+    }
+    // Skip whitespace after #
+    while (isWhitespace(state.input[state.pos]) && state.input[state.pos] !== '\n') {
+        state.pos++;
+        state.column++;
+    }
+    // Consume the rest of the line as heading content
+    const contentStart = state.pos;
+    while (state.pos < state.input.length && state.input[state.pos] !== '\n') {
+        state.pos++;
+        state.column++;
+    }
+    const content = state.input.slice(contentStart, state.pos);
+    const type = `heading-${level}`;
+    state.tokens.push({
+        type,
+        value: content.trim(),
+        line: state.line,
+        column: startColumn,
+    });
+}
+/**
+ * Consumes a list item (- or *).
+ *
+ * @param state - The tokenizer state to update
+ */
+function consumeListItem(state) {
+    const startColumn = state.column;
+    // Skip the marker and whitespace
+    state.pos++; // skip - or *
+    state.column++;
+    while (isWhitespace(state.input[state.pos]) && state.input[state.pos] !== '\n') {
+        state.pos++;
+        state.column++;
+    }
+    // Consume the rest of the line as list item content
+    const contentStart = state.pos;
+    while (state.pos < state.input.length && state.input[state.pos] !== '\n') {
+        state.pos++;
+        state.column++;
+    }
+    const content = state.input.slice(contentStart, state.pos);
+    state.tokens.push({
+        type: 'list-item',
+        value: content,
+        line: state.line,
+        column: startColumn,
+    });
+}
+/**
+ * Consumes a markdown link [text](url).
+ *
+ * @param state - The tokenizer state to update
+ */
+function consumeLink(state) {
+    const startColumn = state.column;
+    const startLine = state.line;
+    // Skip opening [
+    state.pos++;
+    state.column++;
+    // Find closing ]
+    const textStart = state.pos;
+    let depth = 1;
+    while (state.pos < state.input.length && depth > 0) {
+        const char = state.input[state.pos];
+        if (char === '[')
+            depth++;
+        else if (char === ']')
+            depth--;
+        else if (char === '\n') {
+            // Link text shouldn't span lines; emit '[' as text and reset
+            state.tokens.push({
+                type: 'text',
+                value: '[',
+                line: startLine,
+                column: startColumn,
+            });
+            state.pos = textStart;
+            state.column = startColumn + 1;
+            return;
+        }
+        if (depth > 0) {
+            state.pos++;
+            state.column++;
+        }
+    }
+    if (depth !== 0) {
+        // No closing ], emit '[' as text and reset
+        state.tokens.push({
+            type: 'text',
+            value: '[',
+            line: startLine,
+            column: startColumn,
+        });
+        state.pos = textStart;
+        state.column = startColumn + 1;
+        return;
+    }
+    const linkText = state.input.slice(textStart, state.pos);
+    state.pos++; // skip ]
+    state.column++;
+    // Check for (url)
+    if (state.input[state.pos] === '(') {
+        state.pos++; // skip (
+        state.column++;
+        const urlStart = state.pos;
+        depth = 1;
+        while (state.pos < state.input.length && depth > 0) {
+            const char = state.input[state.pos];
+            if (char === '(')
+                depth++;
+            else if (char === ')')
+                depth--;
+            else if (char === '\n') {
+                // URL shouldn't span lines
+                break;
+            }
+            if (depth > 0) {
+                state.pos++;
+                state.column++;
+            }
+        }
+        if (depth === 0) {
+            const linkUrl = state.input.slice(urlStart, state.pos);
+            state.pos++; // skip )
+            state.column++;
+            // Emit link-text token
+            state.tokens.push({
+                type: 'link-text',
+                value: linkText,
+                line: startLine,
+                column: startColumn,
+            });
+            // Emit link-url token
+            state.tokens.push({
+                type: 'link-url',
+                value: linkUrl,
+                line: startLine,
+                column: startColumn + linkText.length + 3,
+            });
+            return;
+        }
+    }
+    // No URL part, emit as text
+    state.tokens.push({
+        type: 'text',
+        value: `[${linkText}]`,
+        line: startLine,
+        column: startColumn,
+    });
+}
+/**
+ * Consumes a code span `code`.
+ *
+ * @param state - The tokenizer state to update
+ */
+function consumeCode(state) {
+    const startColumn = state.column;
+    const startLine = state.line;
+    state.pos++; // skip opening `
+    state.column++;
+    const contentStart = state.pos;
+    while (state.pos < state.input.length && state.input[state.pos] !== '`' && state.input[state.pos] !== '\n') {
+        state.pos++;
+        state.column++;
+    }
+    if (state.input[state.pos] === '`') {
+        const content = state.input.slice(contentStart, state.pos);
+        state.pos++; // skip closing `
+        state.column++;
+        state.tokens.push({
+            type: 'code',
+            value: content,
+            line: startLine,
+            column: startColumn,
+        });
+    }
+    else {
+        // No closing `, emit as text
+        state.tokens.push({
+            type: 'text',
+            value: '`' + state.input.slice(contentStart, state.pos),
+            line: startLine,
+            column: startColumn,
+        });
+    }
+}
+/**
+ * Consumes bold text **text**.
+ *
+ * @param state - The tokenizer state to update
+ */
+function consumeBold(state) {
+    const startColumn = state.column;
+    const startLine = state.line;
+    state.pos += 2; // skip opening **
+    state.column += 2;
+    const contentStart = state.pos;
+    while (state.pos < state.input.length) {
+        // Check for closing **
+        if (state.input[state.pos] === '*' && state.input[state.pos + 1] === '*') {
+            break;
+        }
+        if (state.input[state.pos] === '\n') {
+            state.line++;
+            state.column = 0;
+        }
+        state.pos++;
+        state.column++;
+    }
+    if (state.input[state.pos] === '*' && state.input[state.pos + 1] === '*') {
+        const content = state.input.slice(contentStart, state.pos);
+        state.pos += 2; // skip closing **
+        state.column += 2;
+        state.tokens.push({
+            type: 'bold',
+            value: content,
+            line: startLine,
+            column: startColumn,
+        });
+    }
+    else {
+        // No closing **, emit as text
+        state.tokens.push({
+            type: 'text',
+            value: '**' + state.input.slice(contentStart, state.pos),
+            line: startLine,
+            column: startColumn,
+        });
+    }
+}
+/**
+ * Consumes plain text until a special character or end of line.
+ *
+ * @param state - The tokenizer state to update
+ */
+function consumeText(state) {
+    const startColumn = state.column;
+    const startLine = state.line;
+    const startPos = state.pos;
+    while (state.pos < state.input.length) {
+        const char = state.input[state.pos];
+        // Stop at newline
+        if (char === '\n' || char === '\r') {
+            break;
+        }
+        // Stop at special characters (but only if they start a pattern)
+        if (char === '[')
+            break;
+        if (char === '`')
+            break;
+        if (char === '*' && state.input[state.pos + 1] === '*')
+            break;
+        state.pos++;
+        state.column++;
+    }
+    const content = state.input.slice(startPos, state.pos);
+    if (content.length > 0) {
+        state.tokens.push({
+            type: 'text',
+            value: content,
+            line: startLine,
+            column: startColumn,
+        });
+    }
+}
+/**
+ * Pushes a token to the state.
+ *
+ * @param state - The tokenizer state to update
+ * @param type - Token classification (e.g., 'heading-1', 'text', 'link-url')
+ * @param value - Text content associated with the token
+ */
+function pushToken(state, type, value) {
+    state.tokens.push({
+        type,
+        value,
+        line: state.line,
+        column: state.column,
+    });
+}
+/**
+ * Checks if a character is whitespace (but not newline).
+ *
+ * @param char - The character to check
+ * @returns True if the character is whitespace (space or tab)
+ */
+function isWhitespace(char) {
+    return char === ' ' || char === '\t';
+}
+
+/**
+ * Changelog Parser
+ *
+ * Parses a changelog markdown string into a structured Changelog object.
+ * Uses a state machine tokenizer for ReDoS-safe parsing.
+ */
+/**
+ * Parses a changelog markdown string into a Changelog object.
+ *
+ * @param content - The markdown content to parse
+ * @param source - Optional source file path
+ * @returns Parsed Changelog object
+ */
+function parseChangelog(content, source) {
+    const tokens = tokenize(content);
+    const state = {
+        tokens,
+        pos: 0,
+        warnings: [],
+    };
+    // Parse header
+    const header = parseHeader(state);
+    // Parse entries
+    const entries = parseEntries(state);
+    // Detect format
+    const format = detectFormat(header, entries);
+    // Build metadata
+    const metadata = {
+        format,
+        isConventional: format === 'conventional',
+        repositoryUrl: state.repositoryUrl,
+        warnings: state.warnings,
+    };
+    return {
+        source,
+        header,
+        entries,
+        metadata,
+    };
+}
+/**
+ * Parses the changelog header section.
+ *
+ * @param state - The parser state containing tokens and position
+ * @returns The parsed ChangelogHeader with title, description, and links
+ */
+function parseHeader(state) {
+    let title = '# Changelog';
+    const description = [];
+    const links = [];
+    // Look for h1 title
+    const headingToken = currentToken(state);
+    if (headingToken?.type === 'heading-1') {
+        title = `# ${headingToken.value}`;
+        advance(state);
+    }
+    // Skip newlines
+    skipNewlines(state);
+    // Collect description lines until we hit h2 (version entry)
+    while (!isEOF(state) && currentToken(state)?.type !== 'heading-2') {
+        const token = currentToken(state);
+        if (!token)
+            break;
+        if (token.type === 'text') {
+            description.push(token.value);
+        }
+        else if (token.type === 'link-text') {
+            // Check for link definition
+            const nextToken = peek(state, 1);
+            if (nextToken?.type === 'link-url') {
+                description.push(`[${token.value}](${nextToken.value})`);
+                links.push({ label: token.value, url: nextToken.value });
+                // Try to detect repository URL
+                if (!state.repositoryUrl && nextToken.value.includes('github.com')) {
+                    state.repositoryUrl = extractRepoUrl(nextToken.value);
+                }
+                advance(state); // skip link-text
+                advance(state); // skip link-url
+                continue;
+            }
+        }
+        else if (token.type === 'newline' || token.type === 'blank-line') {
+            if (description.length > 0 && description[description.length - 1] !== '') {
+                description.push('');
+            }
+        }
+        advance(state);
+    }
+    // Trim trailing empty lines
+    while (description.length > 0 && description[description.length - 1] === '') {
+        description.pop();
+    }
+    return { title, description, links };
+}
+/**
+ * Parses all changelog entries.
+ *
+ * @param state - The parser state containing tokens and position
+ * @returns An array of parsed ChangelogEntry objects
+ */
+function parseEntries(state) {
+    const entries = [];
+    while (!isEOF(state)) {
+        // Look for h2 heading (version entry)
+        if (currentToken(state)?.type === 'heading-2') {
+            const entry = parseEntry(state);
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        else {
+            advance(state);
+        }
+    }
+    return entries;
+}
+/**
+ * Parses a single changelog entry.
+ *
+ * @param state - The parser state containing tokens and position
+ * @returns The parsed ChangelogEntry or null if parsing fails
+ */
+function parseEntry(state) {
+    const headingToken = currentToken(state);
+    if (headingToken?.type !== 'heading-2') {
+        return null;
+    }
+    const { version, date, compareUrl } = parseVersionFromHeading(headingToken.value);
+    const unreleased = version.toLowerCase() === 'unreleased';
+    advance(state); // skip h2
+    skipNewlines(state);
+    // Parse sections
+    const sections = parseSections(state);
+    return {
+        version,
+        date,
+        unreleased,
+        compareUrl,
+        sections,
+    };
+}
+/**
+ * Parses sections within an entry.
+ *
+ * @param state - The parser state containing tokens and position
+ * @returns An array of parsed ChangelogSection objects
+ */
+function parseSections(state) {
+    const sections = [];
+    while (!isEOF(state)) {
+        const token = currentToken(state);
+        // Stop at next version entry (h2)
+        if (token?.type === 'heading-2') {
+            break;
+        }
+        // Parse section (h3)
+        if (token?.type === 'heading-3') {
+            const section = parseSection(state);
+            if (section) {
+                sections.push(section);
+            }
+        }
+        else if (token?.type === 'list-item') {
+            // Items without section heading - create "other" section
+            const items = parseItems(state);
+            if (items.length > 0) {
+                sections.push({
+                    type: 'other',
+                    heading: 'Changes',
+                    items,
+                });
+            }
+        }
+        else {
+            advance(state);
+        }
+    }
+    return sections;
+}
+/**
+ * Parses a single section.
+ *
+ * @param state - The parser state containing tokens and position
+ * @returns The parsed ChangelogSection or null if parsing fails
+ */
+function parseSection(state) {
+    const headingToken = currentToken(state);
+    if (headingToken?.type !== 'heading-3') {
+        return null;
+    }
+    const heading = headingToken.value;
+    const type = getSectionType(heading);
+    advance(state); // skip h3
+    skipNewlines(state);
+    // Parse items
+    const items = parseItems(state);
+    return {
+        type,
+        heading,
+        items,
+    };
+}
+/**
+ * Parses list items.
+ *
+ * @param state - The parser state containing tokens and position
+ * @returns An array of parsed ChangelogItem objects
+ */
+function parseItems(state) {
+    const items = [];
+    while (!isEOF(state)) {
+        const token = currentToken(state);
+        // Stop at headings
+        if (token?.type === 'heading-2' || token?.type === 'heading-3') {
+            break;
+        }
+        // Parse list item
+        if (token?.type === 'list-item') {
+            const item = parseItem(state);
+            if (item) {
+                items.push(item);
+            }
+        }
+        else {
+            advance(state);
+        }
+    }
+    return items;
+}
+/**
+ * Parses a single list item.
+ *
+ * @param state - The parser state containing tokens and position
+ * @returns The parsed ChangelogItem or null if parsing fails
+ */
+function parseItem(state) {
+    const token = currentToken(state);
+    if (token?.type !== 'list-item') {
+        return null;
+    }
+    const text = token.value;
+    const { scope, description } = parseScopeFromItem(text);
+    const commits = parseCommitRefs(text, state.repositoryUrl);
+    const references = parseIssueRefs(text, state.repositoryUrl);
+    // Check for breaking change indicators
+    const breaking = isBreakingItem(text);
+    advance(state);
+    return createChangelogItem(description, {
+        scope,
+        commits,
+        references,
+        breaking,
+    });
+}
+/**
+ * Checks if an item indicates a breaking change.
+ *
+ * @param text - The text content of the item
+ * @returns True if the item indicates a breaking change
+ */
+function isBreakingItem(text) {
+    const lower = text.toLowerCase();
+    return lower.includes('breaking change') || lower.includes('breaking:') || lower.startsWith('!') || lower.includes('[breaking]');
+}
+/**
+ * Detects the changelog format.
+ *
+ * @param header - The parsed header of the changelog
+ * @param entries - The parsed changelog entries
+ * @returns The detected ChangelogFormat
+ */
+function detectFormat(header, entries) {
+    const descriptionText = header.description.join(' ').toLowerCase();
+    // Check for Keep a Changelog
+    if (descriptionText.includes('keep a changelog') || descriptionText.includes('keepachangelog')) {
+        return 'keep-a-changelog';
+    }
+    // Check for conventional changelog patterns
+    const hasConventionalSections = entries.some((entry) => entry.sections.some((section) => ['features', 'fixes', 'performance'].includes(section.type)));
+    if (hasConventionalSections) {
+        return 'conventional';
+    }
+    // Check if we have entries with structured sections
+    if (entries.some((entry) => entry.sections.length > 0)) {
+        return 'custom';
+    }
+    return 'unknown';
+}
+/**
+ * Extracts repository URL from a GitHub URL.
+ *
+ * @param url - The URL to extract the repository from
+ * @returns The repository URL or undefined if not found
+ */
+function extractRepoUrl(url) {
+    // Try to extract base repo URL from various GitHub URL patterns
+    const githubIndex = url.indexOf('github.com/');
+    if (githubIndex !== -1) {
+        const afterGithub = url.slice(githubIndex + 11);
+        const parts = afterGithub.split('/');
+        if (parts.length >= 2) {
+            return `https://github.com/${parts[0]}/${parts[1]}`;
+        }
+    }
+    return undefined;
+}
+// ============================================================================
+// Parser utilities
+// ============================================================================
+/**
+ * Gets the current token at the parser position.
+ *
+ * @param state - The parser state
+ * @returns The current token or undefined if at end
+ */
+function currentToken(state) {
+    return state.tokens[state.pos];
+}
+/**
+ * Peeks at a token at an offset from the current position.
+ *
+ * @param state - The parser state
+ * @param offset - The offset from current position
+ * @returns The token at the offset or undefined if out of bounds
+ */
+function peek(state, offset) {
+    return state.tokens[state.pos + offset];
+}
+/**
+ * Advances the parser position by one token.
+ *
+ * @param state - The parser state to advance
+ */
+function advance(state) {
+    state.pos++;
+}
+/**
+ * Checks if the parser has reached the end of the token stream.
+ *
+ * @param state - The parser state
+ * @returns True if at end of file
+ */
+function isEOF(state) {
+    const token = currentToken(state);
+    return !token || token.type === 'eof';
+}
+/**
+ * Skips newline tokens until a non-newline token is found.
+ *
+ * @param state - The parser state
+ */
+function skipNewlines(state) {
+    while (!isEOF(state)) {
+        const token = currentToken(state);
+        if (token?.type !== 'newline' && token?.type !== 'blank-line') {
+            break;
+        }
+        advance(state);
+    }
+}
+
+export { parseChangelog, parseCommitRefs, parseIssueRefs, parseScopeFromItem, parseVersionFromHeading, tokenize };
+//# sourceMappingURL=index.esm.js.map