@tomgiee/tsdp 1.0.0

package/dist/src/validator/media-validator.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * Media validators for SDP (RFC 8866)
+ *
+ * Validates media descriptions and media-level constraints per RFC 8866.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMediaDescription = validateMediaDescription;
+exports.validateAllMediaDescriptions = validateAllMediaDescriptions;
+const errors_1 = require("../types/errors");
+const session_validator_1 = require("./session-validator");
+const attributes_1 = require("../types/attributes");
+// ============================================================================
+// Media Description Validator
+// ============================================================================
+/**
+ * Validate a media description
+ *
+ * Checks RFC 8866 Section 5.14 (m=) and media-level field requirements.
+ *
+ * @param media - Media description to validate
+ * @param index - Index of media description (for error messages)
+ * @param hasSessionConnection - Whether session-level connection exists
+ * @returns ValidationResult with any errors found
+ */
+function validateMediaDescription(media, index, hasSessionConnection) {
+    const errors = [];
+    const prefix = `mediaDescriptions[${index}]`;
+    // 1. Validate media field (RFC 8866 Section 5.14)
+    validateMediaField(media, prefix, errors);
+    // 2. Validate port (RFC 8866 Section 5.14)
+    validatePort(media, prefix, errors);
+    // 3. Validate formats (RFC 8866 Section 5.14)
+    validateFormats(media, prefix, errors);
+    // 4. Validate connection coverage (RFC 8866 Section 5.7)
+    if (!hasSessionConnection) {
+        validateMediaConnection(media, prefix, errors);
+    }
+    // 5. Validate bandwidths (RFC 8866 Section 5.8)
+    validateMediaBandwidths(media, prefix, errors);
+    // 6. Validate attributes (RFC 8866 Section 6)
+    validateMediaAttributes(media, prefix, errors);
+    return errors.length === 0 ? (0, session_validator_1.validResult)() : (0, session_validator_1.invalidResult)(errors);
+}
+/**
+ * Validate media field
+ *
+ * RFC 8866 Section 5.14: Media type and protocol are required
+ */
+function validateMediaField(media, prefix, errors) {
+    // Validate media type
+    if (!media.media.type || media.media.type.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.type`, media.media.type, 'Media type cannot be empty', 'RFC8866:5.14'));
+    }
+    // Validate protocol
+    if (!media.media.proto || media.media.proto.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.proto`, media.media.proto, 'Protocol cannot be empty', 'RFC8866:5.14'));
+    }
+}
+/**
+ * Validate port
+ *
+ * RFC 8866 Section 5.14: Port must be 0-65535
+ */
+function validatePort(media, prefix, errors) {
+    const port = media.media.port;
+    if (port.kind === 'simple') {
+        if (port.value < 0 || port.value > 65535) {
+            errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.port`, port.value, 'Port must be 0-65535', 'RFC8866:5.14'));
+        }
+    }
+    else if (port.kind === 'range') {
+        if (port.base < 0 || port.base > 65535) {
+            errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.port.base`, port.base, 'Port must be 0-65535', 'RFC8866:5.14'));
+        }
+        if (port.count < 1) {
+            errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.port.count`, port.count, 'Port count must be at least 1', 'RFC8866:5.14'));
+        }
+        // Check that port range doesn't exceed 65535
+        if (port.base + port.count - 1 > 65535) {
+            errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: port range ${port.base}/${port.count} exceeds 65535`, 'RFC8866:5.14'));
+        }
+    }
+}
+/**
+ * Validate formats
+ *
+ * RFC 8866 Section 5.14: At least one format is required
+ */
+function validateFormats(media, prefix, errors) {
+    if (!media.media.formats || media.media.formats.length === 0) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: at least one media format is required`, 'RFC8866:5.14'));
+    }
+}
+/**
+ * Validate media-level connection
+ *
+ * RFC 8866 Section 5.7: Connection required if no session-level connection
+ */
+function validateMediaConnection(media, prefix, errors) {
+    if (!media.connections || media.connections.length === 0) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: connection information required when no session-level connection`, 'RFC8866:5.7'));
+    }
+}
+/**
+ * Validate media-level bandwidths
+ *
+ * RFC 8866 Section 5.8: Bandwidth values must be non-negative
+ */
+function validateMediaBandwidths(media, prefix, errors) {
+    for (let i = 0; i < media.bandwidths.length; i++) {
+        const bw = media.bandwidths[i];
+        if (bw.value < 0) {
+            errors.push(errors_1.ValidationError.invalidValue(`${prefix}.bandwidths[${i}].value`, bw.value, 'Bandwidth value must be non-negative', 'RFC8866:5.8'));
+        }
+    }
+}
+/**
+ * Validate media-level attributes
+ *
+ * RFC 8866 Section 6: Various attribute constraints including:
+ * - Only one direction attribute allowed
+ * - Session-only attributes cannot appear at media level
+ * - At most one rtpmap per payload type (RFC 8866 Section 6.6)
+ * - At most one fmtp per format (RFC 8866 Section 6.15)
+ * - ptime, maxptime, quality, framerate value constraints
+ */
+function validateMediaAttributes(media, prefix, errors) {
+    const directionAttrs = ['sendrecv', 'sendonly', 'recvonly', 'inactive'];
+    let directionCount = 0;
+    // Track rtpmap payload types for duplicate detection and format validation
+    const rtpmapPayloadTypes = new Set();
+    const rtpmapPayloadTypeDuplicates = new Set();
+    // Track fmtp formats for duplicate detection and format validation
+    const fmtpFormats = new Set();
+    const fmtpFormatDuplicates = new Set();
+    for (const attr of media.attributes) {
+        // Check for multiple direction attributes (only one allowed)
+        if (attr.kind === 'property' && directionAttrs.includes(attr.name)) {
+            directionCount++;
+        }
+        // Check for session-only attributes at media level (RFC 8866 Section 6)
+        if (attributes_1.SESSION_ONLY_ATTRIBUTES.includes(attr.name)) {
+            errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: attribute '${attr.name}' is only valid at session level, not media level`, 'RFC8866:6'));
+        }
+        // Check rtpmap payload types (should match format list, at most one per payload type)
+        if (attr.kind === 'value' && attr.name === 'rtpmap') {
+            const match = attr.value.match(/^(\d+)\s/);
+            if (match) {
+                const payloadType = match[1];
+                if (rtpmapPayloadTypes.has(payloadType)) {
+                    rtpmapPayloadTypeDuplicates.add(payloadType);
+                }
+                else {
+                    rtpmapPayloadTypes.add(payloadType);
+                }
+            }
+        }
+        // Check fmtp formats (should have corresponding rtpmap or be in format list, at most one per format)
+        if (attr.kind === 'value' && attr.name === 'fmtp') {
+            const match = attr.value.match(/^(\S+)\s/);
+            if (match) {
+                const format = match[1];
+                if (fmtpFormats.has(format)) {
+                    fmtpFormatDuplicates.add(format);
+                }
+                else {
+                    fmtpFormats.add(format);
+                }
+            }
+        }
+        // Validate ptime is positive
+        if (attr.kind === 'value' && attr.name === 'ptime') {
+            const ptime = parseFloat(attr.value);
+            if (isNaN(ptime) || ptime <= 0) {
+                errors.push(errors_1.ValidationError.invalidValue(`${prefix}.attributes.ptime`, attr.value, 'ptime must be a positive number', 'RFC8866:6.4'));
+            }
+        }
+        // Validate maxptime is positive
+        if (attr.kind === 'value' && attr.name === 'maxptime') {
+            const maxptime = parseFloat(attr.value);
+            if (isNaN(maxptime) || maxptime <= 0) {
+                errors.push(errors_1.ValidationError.invalidValue(`${prefix}.attributes.maxptime`, attr.value, 'maxptime must be a positive number', 'RFC8866:6.5'));
+            }
+        }
+        // Validate quality is 0-10
+        if (attr.kind === 'value' && attr.name === 'quality') {
+            const quality = parseInt(attr.value, 10);
+            if (isNaN(quality) || quality < 0 || quality > 10) {
+                errors.push(errors_1.ValidationError.invalidValue(`${prefix}.attributes.quality`, attr.value, 'quality must be 0-10', 'RFC8866:6.14'));
+            }
+        }
+        // Validate framerate is positive
+        if (attr.kind === 'value' && attr.name === 'framerate') {
+            const framerate = parseFloat(attr.value);
+            if (isNaN(framerate) || framerate <= 0) {
+                errors.push(errors_1.ValidationError.invalidValue(`${prefix}.attributes.framerate`, attr.value, 'framerate must be a positive number', 'RFC8866:6.13'));
+            }
+        }
+    }
+    if (directionCount > 1) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: only one direction attribute (sendrecv/sendonly/recvonly/inactive) allowed`, 'RFC8866:6.7'));
+    }
+    // Validate no duplicate rtpmap entries for same payload type (RFC 8866 Section 6.6)
+    for (const pt of rtpmapPayloadTypeDuplicates) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: duplicate rtpmap for payload type ${pt} (at most one rtpmap per format allowed)`, 'RFC8866:6.6'));
+    }
+    // Validate no duplicate fmtp entries for same format (RFC 8866 Section 6.15)
+    for (const fmt of fmtpFormatDuplicates) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: duplicate fmtp for format ${fmt} (at most one fmtp per format allowed)`, 'RFC8866:6.15'));
+    }
+    // Validate rtpmap payload types are in format list
+    // Cast formats to strings for comparison since Format is a branded string
+    const formatStrings = media.media.formats.map((f) => f);
+    for (const pt of rtpmapPayloadTypes) {
+        if (!formatStrings.includes(pt)) {
+            errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: rtpmap payload type ${pt} not in format list`, 'RFC8866:6.6'));
+        }
+    }
+    // Validate fmtp formats are in format list or have rtpmap
+    for (const fmt of fmtpFormats) {
+        if (!formatStrings.includes(fmt) && !rtpmapPayloadTypes.has(fmt)) {
+            errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: fmtp format ${fmt} not in format list`, 'RFC8866:6.15'));
+        }
+    }
+}
+/**
+ * Validate all media descriptions in a session
+ *
+ * @param mediaDescriptions - Array of media descriptions
+ * @param hasSessionConnection - Whether session-level connection exists
+ * @returns ValidationResult with any errors found
+ */
+function validateAllMediaDescriptions(mediaDescriptions, hasSessionConnection) {
+    const allErrors = [];
+    for (let i = 0; i < mediaDescriptions.length; i++) {
+        const result = validateMediaDescription(mediaDescriptions[i], i, hasSessionConnection);
+        allErrors.push(...result.errors);
+    }
+    return allErrors.length === 0 ? (0, session_validator_1.validResult)() : (0, session_validator_1.invalidResult)(allErrors);
+}

package/dist/src/validator/semantic-validator.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Semantic validators for SDP (RFC 8866)
+ *
+ * Cross-field semantic validation that checks relationships between fields.
+ */
+import { SessionDescription } from '../types/session';
+import { ValidationResult } from './session-validator';
+/**
+ * Options for customizing validation behavior
+ */
+export interface ValidationOptions {
+    /**
+     * Whether to skip semantic validation (cross-field checks)
+     */
+    skipSemanticValidation?: boolean;
+    /**
+     * Whether to allow deprecated k= field without warning
+     */
+    allowDeprecatedKeyField?: boolean;
+    /**
+     * Whether to require connection at session level
+     */
+    requireSessionConnection?: boolean;
+}
+/**
+ * Perform complete semantic validation of a session description
+ *
+ * This is the main validation entry point that checks:
+ * 1. Session-level validation
+ * 2. Media-level validation
+ * 3. Cross-field semantic constraints
+ *
+ * @param session - Session description to validate
+ * @param options - Optional validation options
+ * @returns ValidationResult with all errors found
+ */
+export declare function validateSdp(session: SessionDescription, options?: ValidationOptions): ValidationResult;
+/**
+ * Validate cross-field semantic constraints
+ *
+ * Checks relationships between different parts of the SDP.
+ *
+ * @param session - Session description to validate
+ * @returns ValidationResult with any errors found
+ */
+export declare function validateSemanticConstraints(session: SessionDescription): ValidationResult;
+//# sourceMappingURL=semantic-validator.d.ts.map

package/dist/src/validator/semantic-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-validator.d.ts","sourceRoot":"","sources":["../../../src/validator/semantic-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EACL,gBAAgB,EAIjB,MAAM,qBAAqB,CAAC;AAO7B;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;OAEG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAElC;;OAEG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CA0ClB;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,kBAAkB,GAAG,gBAAgB,CAmBzF"}

package/dist/src/validator/semantic-validator.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Semantic validators for SDP (RFC 8866)
+ *
+ * Cross-field semantic validation that checks relationships between fields.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSdp = validateSdp;
+exports.validateSemanticConstraints = validateSemanticConstraints;
+const errors_1 = require("../types/errors");
+const session_validator_1 = require("./session-validator");
+const media_validator_1 = require("./media-validator");
+/**
+ * Perform complete semantic validation of a session description
+ *
+ * This is the main validation entry point that checks:
+ * 1. Session-level validation
+ * 2. Media-level validation
+ * 3. Cross-field semantic constraints
+ *
+ * @param session - Session description to validate
+ * @param options - Optional validation options
+ * @returns ValidationResult with all errors found
+ */
+function validateSdp(session, options = {}) {
+    const allErrors = [];
+    // 1. Session-level validation
+    const sessionResult = (0, session_validator_1.validateSessionDescription)(session);
+    allErrors.push(...sessionResult.errors);
+    // 2. Check for deprecated key field
+    if (!options.allowDeprecatedKeyField && session.key !== undefined) {
+        allErrors.push(errors_1.ValidationError.constraintViolation('The k= field is deprecated per RFC 8866', 'RFC8866:5.12'));
+    }
+    // 3. Require session-level connection if specified
+    if (options.requireSessionConnection && session.connection === undefined) {
+        allErrors.push(errors_1.ValidationError.constraintViolation('Session-level connection information is required', 'RFC8866:5.7'));
+    }
+    // 4. Media-level validation
+    const hasSessionConnection = session.connection !== undefined;
+    const mediaResult = (0, media_validator_1.validateAllMediaDescriptions)(session.mediaDescriptions, hasSessionConnection);
+    allErrors.push(...mediaResult.errors);
+    // 5. Cross-field semantic validation (if not skipped)
+    if (!options.skipSemanticValidation) {
+        const semanticResult = validateSemanticConstraints(session);
+        allErrors.push(...semanticResult.errors);
+    }
+    return allErrors.length === 0 ? (0, session_validator_1.validResult)() : (0, session_validator_1.invalidResult)(allErrors);
+}
+/**
+ * Validate cross-field semantic constraints
+ *
+ * Checks relationships between different parts of the SDP.
+ *
+ * @param session - Session description to validate
+ * @returns ValidationResult with any errors found
+ */
+function validateSemanticConstraints(session) {
+    const errors = [];
+    // 1. Validate session vs media direction consistency
+    validateDirectionConsistency(session, errors);
+    // 2. Validate bandwidth constraints
+    validateBandwidthConsistency(session, errors);
+    // 3. Validate address type consistency
+    validateAddressTypeConsistency(session, errors);
+    // 4. Validate ptime/maxptime relationship
+    validatePtimeConsistency(session, errors);
+    // 5. Validate time description constraints
+    validateTimeConsistency(session, errors);
+    return errors.length === 0 ? (0, session_validator_1.validResult)() : (0, session_validator_1.invalidResult)(errors);
+}
+/**
+ * Validate direction attribute consistency
+ *
+ * If session has a direction attribute, media can override but should be compatible.
+ */
+function validateDirectionConsistency(session, errors) {
+    const directionAttrs = ['sendrecv', 'sendonly', 'recvonly', 'inactive'];
+    // Find session-level direction
+    let sessionDirection;
+    for (const attr of session.attributes) {
+        if (attr.kind === 'property' && directionAttrs.includes(attr.name)) {
+            sessionDirection = attr.name;
+            break;
+        }
+    }
+    // If session is inactive, warn if any media has active direction
+    if (sessionDirection === 'inactive') {
+        for (let i = 0; i < session.mediaDescriptions.length; i++) {
+            const md = session.mediaDescriptions[i];
+            for (const attr of md.attributes) {
+                if (attr.kind === 'property' &&
+                    (attr.name === 'sendrecv' || attr.name === 'sendonly' || attr.name === 'recvonly')) {
+                    // This is a warning, not an error - media can override
+                    // But we'll note it for completeness
+                }
+            }
+        }
+    }
+}
+/**
+ * Validate bandwidth consistency
+ *
+ * CT (Conference Total) should be >= sum of AS (Application Specific) for all media.
+ */
+function validateBandwidthConsistency(session, errors) {
+    // Find session-level CT bandwidth
+    let sessionCT;
+    for (const bw of session.bandwidths) {
+        if (bw.type === 'CT') {
+            sessionCT = bw.value;
+            break;
+        }
+    }
+    if (sessionCT === undefined) {
+        return; // No CT to validate against
+    }
+    // Sum all AS bandwidths from media
+    let totalAS = 0;
+    for (const md of session.mediaDescriptions) {
+        for (const bw of md.bandwidths) {
+            if (bw.type === 'AS') {
+                totalAS += bw.value;
+            }
+        }
+    }
+    // Also add session-level AS
+    for (const bw of session.bandwidths) {
+        if (bw.type === 'AS') {
+            totalAS += bw.value;
+        }
+    }
+    if (totalAS > sessionCT) {
+        errors.push(errors_1.ValidationError.constraintViolation(`Sum of AS bandwidths (${totalAS}) exceeds CT bandwidth (${sessionCT})`, 'RFC8866:5.8'));
+    }
+}
+/**
+ * Validate address type consistency
+ *
+ * Origin address type should be compatible with connection address types.
+ */
+function validateAddressTypeConsistency(session, errors) {
+    const originAddrType = session.origin.addrType;
+    // Check session-level connection
+    if (session.connection) {
+        const connAddrType = session.connection.addrType;
+        // Different address types are allowed, but we could warn
+        // For now, we don't enforce strict consistency
+    }
+    // Check media-level connections
+    for (let i = 0; i < session.mediaDescriptions.length; i++) {
+        const md = session.mediaDescriptions[i];
+        for (let j = 0; j < md.connections.length; j++) {
+            const conn = md.connections[j];
+            // Different address types are allowed per RFC
+        }
+    }
+}
+/**
+ * Validate ptime/maxptime relationship
+ *
+ * If both ptime and maxptime are specified, ptime should be <= maxptime.
+ *
+ * RFC 8866 Sections 6.4-6.5: Both values use non-zero-int-or-real,
+ * meaning they can be decimal values.
+ */
+function validatePtimeConsistency(session, errors) {
+    for (let i = 0; i < session.mediaDescriptions.length; i++) {
+        const md = session.mediaDescriptions[i];
+        let ptime;
+        let maxptime;
+        for (const attr of md.attributes) {
+            if (attr.kind === 'value') {
+                if (attr.name === 'ptime') {
+                    ptime = parseFloat(attr.value);
+                }
+                else if (attr.name === 'maxptime') {
+                    maxptime = parseFloat(attr.value);
+                }
+            }
+        }
+        if (ptime !== undefined && maxptime !== undefined && ptime > maxptime) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Media ${i}: ptime (${ptime}) exceeds maxptime (${maxptime})`, 'RFC8866:6.4-6.5'));
+        }
+    }
+}
+/**
+ * Validate time description constraints
+ *
+ * Check that repeat times and timezone adjustments are consistent.
+ */
+function validateTimeConsistency(session, errors) {
+    for (let i = 0; i < session.timeDescriptions.length; i++) {
+        const td = session.timeDescriptions[i];
+        // Repeat times only make sense for bounded sessions
+        if (td.repeats.length > 0) {
+            const { startTime, stopTime } = td.timing;
+            if (startTime === 0 && stopTime === 0) {
+                // Repeat with unbounded session - technically valid but unusual
+                // Could add a warning here
+            }
+        }
+        // Timezone adjustments only make sense for bounded sessions with repeats
+        if (td.timezone && td.repeats.length === 0) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Time description ${i}: timezone adjustment specified without repeat times`, 'RFC8866:5.11'));
+        }
+    }
+}

package/dist/src/validator/session-validator.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Session validators for SDP (RFC 8866)
+ *
+ * Validates session-level fields and constraints per RFC 8866.
+ */
+import { SessionDescription } from '../types/session';
+import { ValidationError } from '../types/errors';
+/**
+ * Result of validation - either valid or contains errors
+ */
+export interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly ValidationError[];
+}
+/**
+ * Create a valid result
+ */
+export declare function validResult(): ValidationResult;
+/**
+ * Create an invalid result with errors
+ */
+export declare function invalidResult(errors: ValidationError[]): ValidationResult;
+/**
+ * Validate a complete session description
+ *
+ * Checks RFC 8866 Section 5 requirements:
+ * - Required fields are present (v, o, s, t)
+ * - Version is 0
+ * - At least one time description
+ * - Connection coverage (session or all media)
+ *
+ * @param session - Session description to validate
+ * @returns ValidationResult with any errors found
+ */
+export declare function validateSessionDescription(session: SessionDescription): ValidationResult;
+//# sourceMappingURL=session-validator.d.ts.map

package/dist/src/validator/session-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-validator.d.ts","sourceRoot":"","sources":["../../../src/validator/session-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AASlD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;CAC7C;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,gBAAgB,CAE9C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,gBAAgB,CAEzE;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,kBAAkB,GAAG,gBAAgB,CAkCxF"}