@tomgiee/tsdp 1.0.1 → 1.1.0

package/dist/src/parser/core.js

@@ -0,0 +1,802 @@
+"use strict";
+/**
+ * Core parsing infrastructure for SDP (RFC 8866)
+ *
+ * This module consolidates:
+ * - Scanner: Low-level tokenization with position tracking
+ * - Primitive parsers: Basic grammar elements (tokens, integers, addresses, times)
+ * - Attribute parsers: SDP attributes (a= fields)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scanner = void 0;
+exports.parseToken = parseToken;
+exports.parseInteger = parseInteger;
+exports.parseByte = parseByte;
+exports.parseNonWSString = parseNonWSString;
+exports.parseByteString = parseByteString;
+exports.parseIP4Address = parseIP4Address;
+exports.parseIP6Address = parseIP6Address;
+exports.parseFQDN = parseFQDN;
+exports.parseNtpTime = parseNtpTime;
+exports.parseTypedTime = parseTypedTime;
+exports.parseEmail = parseEmail;
+exports.parsePhone = parsePhone;
+exports.parseURI = parseURI;
+exports.parseAttributeField = parseAttributeField;
+exports.parseRtpmapValue = parseRtpmapValue;
+exports.parseFmtpValue = parseFmtpValue;
+exports.parsePtimeValue = parsePtimeValue;
+exports.parseMaxptimeValue = parseMaxptimeValue;
+exports.parseFramerateValue = parseFramerateValue;
+exports.parseQualityValue = parseQualityValue;
+const errors_1 = require("../types/errors");
+const address_parser_1 = require("../utils/address-parser");
+const time_converter_1 = require("../utils/time-converter");
+const attributes_1 = require("../types/attributes");
+// ============================================================================
+// Scanner Class
+// ============================================================================
+/**
+ * Scanner class for parsing SDP text
+ *
+ * Maintains position information and provides character-level operations
+ * for parsing SDP fields according to RFC 8866 grammar.
+ */
+class Scanner {
+    /**
+     * Create a new Scanner
+     *
+     * @param input - SDP text to scan
+     */
+    constructor(input) {
+        this.input = input;
+        this.position = 0;
+        this.line = 1;
+        this.column = 1;
+    }
+    /**
+     * Peek at the current character without consuming it
+     *
+     * @returns Current character or null if at EOF
+     */
+    peek() {
+        if (this.isEOF()) {
+            return null;
+        }
+        return this.input[this.position];
+    }
+    /**
+     * Peek ahead n characters without consuming
+     *
+     * @param n - Number of characters to peek ahead
+     * @returns Character at position+n or null if beyond EOF
+     */
+    peekAhead(n) {
+        const pos = this.position + n;
+        if (pos >= this.input.length) {
+            return null;
+        }
+        return this.input[pos];
+    }
+    /**
+     * Advance to the next character and return the current one
+     *
+     * Updates line and column tracking when encountering newlines.
+     *
+     * @returns Current character or null if at EOF
+     */
+    advance() {
+        if (this.isEOF()) {
+            return null;
+        }
+        const ch = this.input[this.position];
+        this.position++;
+        // Update line and column tracking
+        if (ch === '\n') {
+            this.line++;
+            this.column = 1;
+        }
+        else if (ch === '\r') {
+            // Handle CRLF and CR
+            if (this.peek() === '\n') {
+                // CRLF - consume the LF too
+                this.position++;
+            }
+            this.line++;
+            this.column = 1;
+        }
+        else {
+            this.column++;
+        }
+        return ch;
+    }
+    /**
+     * Read characters until a delimiter is found
+     *
+     * Does NOT consume the delimiter.
+     *
+     * @param delimiter - String or RegExp to match
+     * @returns String of characters read (may be empty)
+     */
+    readUntil(delimiter) {
+        let result = '';
+        while (!this.isEOF()) {
+            const ch = this.peek();
+            if (typeof delimiter === 'string') {
+                // String delimiter - check for exact match
+                if (ch === delimiter) {
+                    break;
+                }
+            }
+            else {
+                // RegExp delimiter - test current character
+                if (delimiter.test(ch)) {
+                    break;
+                }
+            }
+            result += this.advance();
+        }
+        return result;
+    }
+    /**
+     * Read while a condition is true
+     *
+     * @param predicate - Function that returns true to continue reading
+     * @returns String of characters read
+     */
+    readWhile(predicate) {
+        let result = '';
+        while (!this.isEOF()) {
+            const ch = this.peek();
+            if (!predicate(ch)) {
+                break;
+            }
+            result += this.advance();
+        }
+        return result;
+    }
+    /**
+     * Skip whitespace characters (space and tab)
+     *
+     * Does NOT skip newlines (CRLF/LF/CR).
+     */
+    skipWhitespace() {
+        while (!this.isEOF()) {
+            const ch = this.peek();
+            if (ch !== ' ' && ch !== '\t') {
+                break;
+            }
+            this.advance();
+        }
+    }
+    /**
+     * Skip to the next line
+     *
+     * Consumes all characters until and including the next line ending (CRLF/LF/CR).
+     */
+    skipToNextLine() {
+        while (!this.isEOF()) {
+            const ch = this.advance();
+            if (ch === '\n' || ch === '\r') {
+                break;
+            }
+        }
+    }
+    /**
+     * Get current position in the input
+     *
+     * @returns Position object with offset, line, and column
+     */
+    getPosition() {
+        return {
+            offset: this.position,
+            line: this.line,
+            column: this.column,
+        };
+    }
+    /**
+     * Check if at end of file
+     *
+     * @returns true if no more characters to read
+     */
+    isEOF() {
+        return this.position >= this.input.length;
+    }
+    /**
+     * Expect a specific string at the current position
+     *
+     * Consumes the string if it matches, throws otherwise.
+     *
+     * @param expected - String to expect
+     * @throws ParseError if string doesn't match
+     */
+    expect(expected) {
+        const start = this.getPosition();
+        for (let i = 0; i < expected.length; i++) {
+            const ch = this.peek();
+            if (ch === null) {
+                throw new errors_1.ParseError(`Expected "${expected}" but reached end of input`, start.line, start.column, this.getContext(start));
+            }
+            if (ch !== expected[i]) {
+                throw new errors_1.ParseError(`Expected "${expected}" but found "${ch}"`, start.line, start.column, this.getContext(start));
+            }
+            this.advance();
+        }
+    }
+    /**
+     * Expect a character that matches a condition
+     *
+     * Consumes the character if it matches, throws otherwise.
+     *
+     * @param predicate - Function that returns true for valid character
+     * @param description - Description of expected character for error messages
+     * @returns The matched character
+     * @throws ParseError if character doesn't match
+     */
+    expectChar(predicate, description) {
+        const pos = this.getPosition();
+        const ch = this.peek();
+        if (ch === null) {
+            throw new errors_1.ParseError(`Expected ${description} but reached end of input`, pos.line, pos.column, this.getContext(pos));
+        }
+        if (!predicate(ch)) {
+            throw new errors_1.ParseError(`Expected ${description} but found "${ch}"`, pos.line, pos.column, this.getContext(pos));
+        }
+        this.advance();
+        return ch;
+    }
+    /**
+     * Expect end of line (CRLF, LF, or CR)
+     *
+     * @throws ParseError if not at end of line
+     */
+    expectEOL() {
+        const pos = this.getPosition();
+        const ch = this.peek();
+        if (ch === null) {
+            // EOF is acceptable as EOL
+            return;
+        }
+        if (ch !== '\r' && ch !== '\n') {
+            throw new errors_1.ParseError(`Expected end of line but found "${ch}"`, pos.line, pos.column, this.getContext(pos));
+        }
+        this.advance();
+    }
+    /**
+     * Expect space character
+     *
+     * @throws ParseError if not a space
+     */
+    expectSpace() {
+        const pos = this.getPosition();
+        const ch = this.peek();
+        if (ch !== ' ') {
+            throw new errors_1.ParseError(`Expected space but found "${ch}"`, pos.line, pos.column, this.getContext(pos));
+        }
+        this.advance();
+    }
+    /**
+     * Get context around a position for error messages
+     *
+     * Returns a snippet of the input around the position.
+     *
+     * @param pos - Position to get context for
+     * @returns Context string (may be empty)
+     */
+    getContext(pos) {
+        const lines = this.input.split('\n');
+        if (pos.line - 1 < lines.length) {
+            return lines[pos.line - 1];
+        }
+        return '';
+    }
+    /**
+     * Get remaining input from current position
+     *
+     * @returns Remaining input string
+     */
+    getRemainingInput() {
+        return this.input.substring(this.position);
+    }
+    /**
+     * Get a substring of the input
+     *
+     * @param start - Start position
+     * @param end - End position (optional, defaults to current position)
+     * @returns Substring
+     */
+    getSubstring(start, end) {
+        return this.input.substring(start, end !== null && end !== void 0 ? end : this.position);
+    }
+}
+exports.Scanner = Scanner;
+// ============================================================================
+// Character Classification Helpers
+// ============================================================================
+/**
+ * Check if a character is a valid token character (RFC 8866)
+ */
+function isTokenChar(ch) {
+    const code = ch.charCodeAt(0);
+    // token-char per RFC 8866
+    return (code === 0x21 || // !
+        (code >= 0x23 && code <= 0x27) || // # $ % & '
+        (code >= 0x2a && code <= 0x2b) || // * +
+        (code >= 0x2d && code <= 0x2e) || // - .
+        (code >= 0x30 && code <= 0x39) || // 0-9
+        (code >= 0x41 && code <= 0x5a) || // A-Z
+        (code >= 0x5e && code <= 0x7e) // ^ _ ` a-z { | } ~
+    );
+}
+/**
+ * Check if character is a digit
+ */
+function isDigit(ch) {
+    return ch >= '0' && ch <= '9';
+}
+/**
+ * Check if character is non-whitespace
+ */
+function isNonWhitespace(ch) {
+    return ch !== ' ' && ch !== '\t' && ch !== '\r' && ch !== '\n';
+}
+/**
+ * Check if character is valid in byte-string
+ */
+function isByteStringChar(ch) {
+    const code = ch.charCodeAt(0);
+    return ((code >= 0x01 && code <= 0x09) ||
+        (code >= 0x0b && code <= 0x0c) ||
+        (code >= 0x0e && code <= 0xff));
+}
+/**
+ * Check if character is a hexadecimal digit
+ */
+function isHexDigit(ch) {
+    return ((ch >= '0' && ch <= '9') ||
+        (ch >= 'a' && ch <= 'f') ||
+        (ch >= 'A' && ch <= 'F'));
+}
+/**
+ * Check if character is alphanumeric
+ */
+function isAlphanumeric(ch) {
+    return ((ch >= '0' && ch <= '9') ||
+        (ch >= 'a' && ch <= 'z') ||
+        (ch >= 'A' && ch <= 'Z'));
+}
+// ============================================================================
+// Token Parsing
+// ============================================================================
+/**
+ * Parse a token (RFC 8866 Section 9)
+ *
+ * token = 1*token-char
+ * token-char = %x21 / %x23-27 / %x2A-2B / %x2D-2E / %x30-39 / %x41-5A / %x5E-7E
+ *
+ * Essentially: any visible ASCII character except space and separators like ()[]{}:;,<>?=@\"
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed token string
+ * @throws ParseError if no valid token found
+ */
+function parseToken(scanner) {
+    const start = scanner.getPosition();
+    const token = scanner.readWhile(isTokenChar);
+    if (token.length === 0) {
+        throw new errors_1.ParseError('Expected token', start.line, start.column);
+    }
+    return token;
+}
+// ============================================================================
+// Integer Parsing
+// ============================================================================
+/**
+ * Parse an integer
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed integer
+ * @throws ParseError if no valid integer found
+ */
+function parseInteger(scanner) {
+    const start = scanner.getPosition();
+    const digits = scanner.readWhile(isDigit);
+    if (digits.length === 0) {
+        throw new errors_1.ParseError('Expected integer', start.line, start.column);
+    }
+    const value = parseInt(digits, 10);
+    if (isNaN(value)) {
+        throw new errors_1.ParseError(`Invalid integer: ${digits}`, start.line, start.column);
+    }
+    return value;
+}
+/**
+ * Parse a byte (0-255)
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed byte value
+ * @throws ParseError if not a valid byte
+ */
+function parseByte(scanner) {
+    const start = scanner.getPosition();
+    const value = parseInteger(scanner);
+    if (value < 0 || value > 255) {
+        throw new errors_1.ParseError(`Byte value out of range: ${value} (expected 0-255)`, start.line, start.column);
+    }
+    return value;
+}
+// ============================================================================
+// String Parsing
+// ============================================================================
+/**
+ * Parse a non-whitespace string
+ *
+ * Reads characters until whitespace or end of line.
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed string
+ * @throws ParseError if empty
+ */
+function parseNonWSString(scanner) {
+    const start = scanner.getPosition();
+    const str = scanner.readWhile(isNonWhitespace);
+    if (str.length === 0) {
+        throw new errors_1.ParseError('Expected non-whitespace string', start.line, start.column);
+    }
+    return str;
+}
+/**
+ * Parse a byte-string (RFC 8866 Section 9)
+ *
+ * byte-string = 1*(%x01-09 / %x0B-0C / %x0E-FF)
+ * (any byte except NUL, CR, LF)
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed byte-string
+ * @throws ParseError if invalid characters found
+ */
+function parseByteString(scanner) {
+    const start = scanner.getPosition();
+    const str = scanner.readWhile(isByteStringChar);
+    if (str.length === 0) {
+        throw new errors_1.ParseError('Expected byte-string', start.line, start.column);
+    }
+    return str;
+}
+// ============================================================================
+// IP Address Parsing
+// ============================================================================
+/**
+ * Parse an IPv4 address
+ *
+ * Format: a.b.c.d where each octet is 0-255
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed IPv4 address
+ * @throws ParseError if invalid IPv4 address
+ */
+function parseIP4Address(scanner) {
+    const start = scanner.getPosition();
+    // Read until whitespace or special characters
+    const addr = scanner.readWhile(ch => isDigit(ch) || ch === '.');
+    if (!(0, address_parser_1.isIP4Address)(addr)) {
+        throw new errors_1.ParseError(`Invalid IPv4 address: ${addr}`, start.line, start.column);
+    }
+    return addr;
+}
+/**
+ * Parse an IPv6 address
+ *
+ * Supports all IPv6 formats including compression (::) and mixed IPv4
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed IPv6 address
+ * @throws ParseError if invalid IPv6 address
+ */
+function parseIP6Address(scanner) {
+    const start = scanner.getPosition();
+    // Read until whitespace (IPv6 can contain : and . and hex digits)
+    const addr = scanner.readWhile(ch => isHexDigit(ch) || ch === ':' || ch === '.');
+    if (!(0, address_parser_1.isIP6Address)(addr)) {
+        throw new errors_1.ParseError(`Invalid IPv6 address: ${addr}`, start.line, start.column);
+    }
+    return addr;
+}
+/**
+ * Parse an FQDN (Fully Qualified Domain Name)
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed FQDN
+ * @throws ParseError if invalid FQDN
+ */
+function parseFQDN(scanner) {
+    const start = scanner.getPosition();
+    // Read until whitespace (FQDN can contain alphanumeric, -, and .)
+    const fqdn = scanner.readWhile(ch => isAlphanumeric(ch) || ch === '-' || ch === '.');
+    if (!(0, address_parser_1.isFQDN)(fqdn)) {
+        throw new errors_1.ParseError(`Invalid FQDN: ${fqdn}`, start.line, start.column);
+    }
+    return fqdn;
+}
+// ============================================================================
+// Time Parsing
+// ============================================================================
+/**
+ * Parse an NTP timestamp
+ *
+ * NTP time is seconds since January 1, 1900 00:00:00 UTC
+ * 0 means unbounded/permanent
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed NTP time
+ * @throws ParseError if invalid
+ */
+function parseNtpTime(scanner) {
+    const start = scanner.getPosition();
+    const value = parseInteger(scanner);
+    if (value < 0) {
+        throw new errors_1.ParseError(`NTP time cannot be negative: ${value}`, start.line, start.column);
+    }
+    return value;
+}
+/**
+ * Parse a typed time value
+ *
+ * Format: [-]<integer>[d|h|m|s]
+ * - d = days
+ * - h = hours
+ * - m = minutes
+ * - s or no suffix = seconds
+ * - Can be negative (for timezone offsets)
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed typed time
+ * @throws ParseError if invalid
+ */
+function parseTypedTime(scanner) {
+    const start = scanner.getPosition();
+    // Read optional minus sign, digits, and optional unit suffix
+    const timeStr = scanner.readWhile(ch => ch === '-' || isDigit(ch) || ch === 'd' || ch === 'h' || ch === 'm' || ch === 's');
+    try {
+        return (0, time_converter_1.parseTypedTime)(timeStr);
+    }
+    catch (error) {
+        throw new errors_1.ParseError(`Invalid typed time: ${timeStr}`, start.line, start.column);
+    }
+}
+// ============================================================================
+// Email, Phone, and URI Parsing
+// ============================================================================
+/**
+ * Parse an email address or display name with email
+ *
+ * Format: email-address / displayable-name <email-address>
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed email string
+ */
+function parseEmail(scanner) {
+    // Email can contain most characters, read until end of line
+    return scanner.readUntil(/[\r\n]/);
+}
+/**
+ * Parse a phone number or display name with phone
+ *
+ * Format: phone-number / displayable-name <phone-number>
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed phone string
+ */
+function parsePhone(scanner) {
+    // Phone can contain most characters, read until end of line
+    return scanner.readUntil(/[\r\n]/);
+}
+/**
+ * Parse a URI
+ *
+ * @param scanner - Scanner instance
+ * @returns Parsed URI string
+ */
+function parseURI(scanner) {
+    // URI can contain many characters, read until end of line
+    return scanner.readUntil(/[\r\n]/);
+}
+// ============================================================================
+// Attribute Field Parser (a=)
+// ============================================================================
+/**
+ * Parse attribute field
+ *
+ * Format:
+ * - Property attribute: a=<attribute-name>
+ * - Value attribute: a=<attribute-name>:<attribute-value>
+ *
+ * Property attributes have no value (e.g., a=recvonly, a=sendrecv).
+ * Value attributes have a value after colon (e.g., a=rtpmap:0 PCMU/8000).
+ *
+ * @param scanner - Scanner instance
+ * @returns Attribute object
+ * @throws ParseError if invalid format
+ */
+function parseAttributeField(scanner) {
+    // Parse attribute name (token up to : or end of line)
+    const name = parseToken(scanner);
+    // Check for colon indicating value attribute
+    const ch = scanner.peek();
+    if (ch === ':') {
+        // Value attribute
+        scanner.advance(); // consume ':'
+        // Read value until end of line
+        const value = scanner.readUntil(/[\r\n]/);
+        return (0, attributes_1.createValueAttribute)(name, value);
+    }
+    else {
+        // Property attribute (no value)
+        // Return predefined attributes for known types
+        switch (name) {
+            case 'recvonly':
+                return (0, attributes_1.createRecvonly)();
+            case 'sendrecv':
+                return (0, attributes_1.createSendrecv)();
+            case 'sendonly':
+                return (0, attributes_1.createSendonly)();
+            case 'inactive':
+                return (0, attributes_1.createInactive)();
+            default:
+                return (0, attributes_1.createPropertyAttribute)(name);
+        }
+    }
+}
+// ============================================================================
+// Specialized Attribute Value Parsers
+// ============================================================================
+/**
+ * Parse rtpmap attribute value
+ *
+ * Format: <payload-type> <encoding-name>/<clock-rate>[/<encoding-params>]
+ *
+ * Examples:
+ * - "0 PCMU/8000"
+ * - "96 H264/90000"
+ * - "97 L16/8000/2" (2 channels)
+ *
+ * @param value - rtpmap attribute value string
+ * @returns Parsed RtpmapValue
+ * @throws ParseError if invalid format
+ */
+function parseRtpmapValue(value) {
+    // Split into payload type and encoding spec
+    const parts = value.split(/\s+/);
+    if (parts.length !== 2) {
+        throw new errors_1.ParseError(`Invalid rtpmap format: expected "<payload-type> <encoding-spec>", got "${value}"`, 0, 0);
+    }
+    const payloadType = parseInt(parts[0], 10);
+    if (isNaN(payloadType) || payloadType < 0 || payloadType > 127) {
+        throw new errors_1.ParseError(`Invalid payload type: ${parts[0]} (expected 0-127)`, 0, 0);
+    }
+    // Parse encoding spec: <encoding-name>/<clock-rate>[/<encoding-params>]
+    const encodingParts = parts[1].split('/');
+    if (encodingParts.length < 2) {
+        throw new errors_1.ParseError(`Invalid encoding spec: expected "<encoding-name>/<clock-rate>", got "${parts[1]}"`, 0, 0);
+    }
+    const encodingName = encodingParts[0];
+    const clockRate = parseInt(encodingParts[1], 10);
+    if (isNaN(clockRate) || clockRate <= 0) {
+        throw new errors_1.ParseError(`Invalid clock rate: ${encodingParts[1]} (must be positive)`, 0, 0);
+    }
+    // Optional encoding parameters (e.g., number of audio channels)
+    let encodingParams;
+    if (encodingParts.length > 2) {
+        encodingParams = parseInt(encodingParts[2], 10);
+        if (isNaN(encodingParams) || encodingParams <= 0) {
+            throw new errors_1.ParseError(`Invalid encoding parameters: ${encodingParts[2]} (must be positive)`, 0, 0);
+        }
+    }
+    return {
+        payloadType,
+        encodingName,
+        clockRate,
+        encodingParams,
+    };
+}
+/**
+ * Parse fmtp attribute value
+ *
+ * Format: <format> <format-specific-params>
+ *
+ * Examples:
+ * - "96 profile-level-id=42e01f;packetization-mode=1"
+ * - "97 apt=96"
+ *
+ * @param value - fmtp attribute value string
+ * @returns Parsed FmtpValue
+ * @throws ParseError if invalid format
+ */
+function parseFmtpValue(value) {
+    // Split on first whitespace
+    const spaceIndex = value.search(/\s/);
+    if (spaceIndex === -1) {
+        throw new errors_1.ParseError(`Invalid fmtp format: expected "<format> <parameters>", got "${value}"`, 0, 0);
+    }
+    const format = value.substring(0, spaceIndex);
+    const parameters = value.substring(spaceIndex + 1).trim();
+    if (parameters.length === 0) {
+        throw new errors_1.ParseError(`Invalid fmtp format: parameters cannot be empty`, 0, 0);
+    }
+    return {
+        format,
+        parameters,
+    };
+}
+/**
+ * Parse ptime attribute value
+ *
+ * Format: <packet-time-in-milliseconds>
+ *
+ * RFC 8866 Section 6.4: ptime-value = non-zero-int-or-real
+ * Decimal values are allowed (e.g., "20.5")
+ *
+ * @param value - ptime attribute value string
+ * @returns Packet time in milliseconds (can be fractional)
+ * @throws ParseError if invalid
+ */
+function parsePtimeValue(value) {
+    const ptime = parseFloat(value);
+    if (isNaN(ptime) || ptime <= 0) {
+        throw new errors_1.ParseError(`Invalid ptime value: ${value} (must be positive number)`, 0, 0);
+    }
+    return ptime;
+}
+/**
+ * Parse maxptime attribute value
+ *
+ * Format: <max-packet-time-in-milliseconds>
+ *
+ * RFC 8866 Section 6.5: maxptime-value = non-zero-int-or-real
+ * Decimal values are allowed (e.g., "40.0")
+ *
+ * @param value - maxptime attribute value string
+ * @returns Maximum packet time in milliseconds (can be fractional)
+ * @throws ParseError if invalid
+ */
+function parseMaxptimeValue(value) {
+    const maxptime = parseFloat(value);
+    if (isNaN(maxptime) || maxptime <= 0) {
+        throw new errors_1.ParseError(`Invalid maxptime value: ${value} (must be positive number)`, 0, 0);
+    }
+    return maxptime;
+}
+/**
+ * Parse framerate attribute value
+ *
+ * Format: <frames-per-second>
+ *
+ * @param value - framerate attribute value string
+ * @returns Frame rate (frames per second)
+ * @throws ParseError if invalid
+ */
+function parseFramerateValue(value) {
+    const framerate = parseFloat(value);
+    if (isNaN(framerate) || framerate <= 0) {
+        throw new errors_1.ParseError(`Invalid framerate value: ${value} (must be positive number)`, 0, 0);
+    }
+    return framerate;
+}
+/**
+ * Parse quality attribute value
+ *
+ * Format: <quality-value>
+ *
+ * Quality is 0-10, where 10 is best quality.
+ *
+ * @param value - quality attribute value string
+ * @returns Quality value (0-10)
+ * @throws ParseError if invalid
+ */
+function parseQualityValue(value) {
+    const quality = parseInt(value, 10);
+    if (isNaN(quality) || quality < 0 || quality > 10) {
+        throw new errors_1.ParseError(`Invalid quality value: ${value} (must be 0-10)`, 0, 0);
+    }
+    return quality;
+}