@amazon/vinyl-hls-parser 1.0.0

package/dist/test/styles.css

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2024. Amazon.com, Inc. or its affiliates. All rights reserved.
+ */
+
+html,
+body {
+    height: 100%;
+    font-family: sans-serif;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    background-color: #dcdee5;
+    display: flex;
+    flex-direction: column;
+}
+
+.callout {
+    background-color: #bfcbdb;
+    box-sizing: border-box;
+    padding: 10px;
+    font-family: Helvetica, Arial, 'sans-serif';
+    cursor: pointer;
+    transition: background-color 0.3s;
+}
+
+.callout:hover {
+    background-color: #7d9fcc;
+}
+
+.instructions {
+    display: inline-block;
+    font-style: italic;
+    padding: 5px;
+    font-family: inherit;
+}
+
+.jasmine_html-reporter {
+    margin: 0 !important;
+    padding: 0 !important;
+}

package/dist/types/current/index.d.ts

@@ -0,0 +1,13 @@
+/** Auto-generated from build scripts */
+export * from './types/VariantStream';
+export * from './types/SessionData';
+export * from './types/MediaPlaylist';
+export * from './types/MainPlaylist';
+export * from './types/HlsSegment';
+export * from './types/EncryptionKey';
+export * from './types/AlternativeRendition';
+export * from './parse/parseUtil';
+export * from './parse/parseMediaPlaylist';
+export * from './parse/parseMainPlaylist';
+export * from './parse/parseAttributes';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/current/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,mBAAmB,CAAA;AACjC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,2BAA2B,CAAA;AACzC,cAAc,yBAAyB,CAAA"}

package/dist/types/current/index.js

@@ -0,0 +1,12 @@
+/** Auto-generated from build scripts */
+export * from './types/VariantStream';
+export * from './types/SessionData';
+export * from './types/MediaPlaylist';
+export * from './types/MainPlaylist';
+export * from './types/HlsSegment';
+export * from './types/EncryptionKey';
+export * from './types/AlternativeRendition';
+export * from './parse/parseUtil';
+export * from './parse/parseMediaPlaylist';
+export * from './parse/parseMainPlaylist';
+export * from './parse/parseAttributes';

package/dist/types/current/parse/parseAttributes.d.ts

@@ -0,0 +1,7 @@
+import type { StringReader } from '@amazon/vinyl-util';
+/**
+ * Parses an HLS attribute list (e.g. `KEY=VALUE,KEY="quoted,value"`) using
+ * StringReader cursor-based parsing. Handles quoted values with embedded commas.
+ */
+export declare function parseAttributes(reader: StringReader): Record<string, string>;
+//# sourceMappingURL=parseAttributes.d.ts.map

package/dist/types/current/parse/parseAttributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseAttributes.d.ts","sourceRoot":"","sources":["../../../../src/parse/parseAttributes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAOtD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA+B5E"}

package/dist/types/current/parse/parseAttributes.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { char } from '@amazon/vinyl-util';
+const EQUALS = char('=');
+const COMMA = char(',');
+const QUOTE = char('"');
+/**
+ * Parses an HLS attribute list (e.g. `KEY=VALUE,KEY="quoted,value"`) using
+ * StringReader cursor-based parsing. Handles quoted values with embedded commas.
+ */
+export function parseAttributes(reader) {
+    const attrs = {};
+    while (reader.hasNext() &&
+        reader.peek !== char('\n') &&
+        reader.peek !== char('\r')) {
+        const key = reader.substringUntilChar(EQUALS);
+        if (!key || !reader.hasNext())
+            break;
+        reader.next(); // skip '='
+        let value;
+        if (reader.peek === QUOTE) {
+            reader.next(); // skip opening quote
+            value = reader.substringUntilChar(QUOTE);
+            if (reader.hasNext())
+                reader.next(); // skip closing quote
+        }
+        else {
+            value = reader.substringUntil((cc) => cc === COMMA || cc === char('\n') || cc === char('\r'));
+        }
+        attrs[key] = value;
+        if (reader.hasNext() && reader.peek === COMMA) {
+            reader.next(); // skip ','
+        }
+    }
+    return attrs;
+}

package/dist/types/current/parse/parseMainPlaylist.d.ts

@@ -0,0 +1,10 @@
+import type { MainPlaylist } from '../types/MainPlaylist';
+/**
+ * Parses an HLS master playlist from M3U8 text.
+ *
+ * @param text The raw M3U8 manifest string.
+ * @returns A readonly MainPlaylist structure.
+ * @throws StringParseError if the manifest is malformed.
+ */
+export declare function parseMainPlaylist(text: string): MainPlaylist;
+//# sourceMappingURL=parseMainPlaylist.d.ts.map

package/dist/types/current/parse/parseMainPlaylist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseMainPlaylist.d.ts","sourceRoot":"","sources":["../../../../src/parse/parseMainPlaylist.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAYxD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAkH5D"}

package/dist/types/current/parse/parseMainPlaylist.js

@@ -0,0 +1,131 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { StringReader, ValidationError } from '@amazon/vinyl-util';
+import { renditionTypeValidator } from '../types/AlternativeRendition';
+import { parseAttributes } from './parseAttributes';
+import { readLine, skipWhitespaceLine, addIfPresent } from './parseUtil';
+const EXTM3U = '#EXTM3U';
+const EXT_X_STREAM_INF = '#EXT-X-STREAM-INF:';
+const EXT_X_MEDIA = '#EXT-X-MEDIA:';
+const EXT_X_SESSION_DATA = '#EXT-X-SESSION-DATA:';
+const EXT_X_DEFINE = '#EXT-X-DEFINE:';
+/**
+ * Parses an HLS master playlist from M3U8 text.
+ *
+ * @param text The raw M3U8 manifest string.
+ * @returns A readonly MainPlaylist structure.
+ * @throws StringParseError if the manifest is malformed.
+ */
+export function parseMainPlaylist(text) {
+    const reader = new StringReader(text);
+    reader.white();
+    if (!reader.stringIf(EXTM3U)) {
+        reader.err('Expected #EXTM3U');
+    }
+    // Advance past the rest of the #EXTM3U line
+    readLine(reader);
+    const variants = [];
+    const alternativeRenditions = [];
+    const sessionData = [];
+    const defines = {};
+    while (reader.hasNext()) {
+        if (skipWhitespaceLine(reader))
+            continue;
+        const line = readLine(reader);
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith(EXT_X_STREAM_INF)) {
+            const attrStr = trimmed.substring(EXT_X_STREAM_INF.length);
+            const attrReader = new StringReader(attrStr);
+            const attrs = parseAttributes(attrReader);
+            // Next non-empty line is the URI
+            let uri = '';
+            while (reader.hasNext()) {
+                if (skipWhitespaceLine(reader))
+                    continue;
+                uri = readLine(reader).trim();
+                break;
+            }
+            variants.push(addIfPresent({
+                bandwidth: Number(attrs['BANDWIDTH']),
+                uri,
+                ...(attrs['FRAME-RATE'] && {
+                    frameRate: Number(attrs['FRAME-RATE']),
+                }),
+                ...(attrs.RESOLUTION &&
+                    parseResolution(attrs.RESOLUTION)),
+            }, attrs, {
+                CODECS: 'codecs',
+                AUDIO: 'audioGroup',
+                VIDEO: 'videoGroup',
+                SUBTITLES: 'subtitlesGroup',
+                'CLOSED-CAPTIONS': 'closedCaptionsGroup',
+            }));
+        }
+        else if (trimmed.startsWith(EXT_X_MEDIA)) {
+            const attrStr = trimmed.substring(EXT_X_MEDIA.length);
+            const attrReader = new StringReader(attrStr);
+            const attrs = parseAttributes(attrReader);
+            const type = attrs['TYPE'];
+            renditionTypeValidator.assert(type);
+            alternativeRenditions.push(addIfPresent({
+                type,
+                groupId: attrs['GROUP-ID'],
+                name: attrs['NAME'],
+                ...(attrs['DEFAULT'] && {
+                    default: attrs['DEFAULT'] === 'YES',
+                }),
+                ...(attrs['AUTOSELECT'] && {
+                    autoSelect: attrs['AUTOSELECT'] === 'YES',
+                }),
+            }, attrs, {
+                URI: 'uri',
+                LANGUAGE: 'language',
+            }));
+        }
+        else if (trimmed.startsWith(EXT_X_SESSION_DATA)) {
+            const attrStr = trimmed.substring(EXT_X_SESSION_DATA.length);
+            const attrReader = new StringReader(attrStr);
+            const attrs = parseAttributes(attrReader);
+            sessionData.push(addIfPresent({
+                dataId: attrs['DATA-ID'],
+            }, attrs, {
+                VALUE: 'value',
+                URI: 'uri',
+                LANGUAGE: 'language',
+            }));
+        }
+        else if (trimmed.startsWith(EXT_X_DEFINE)) {
+            const attrStr = trimmed.substring(EXT_X_DEFINE.length);
+            const attrReader = new StringReader(attrStr);
+            const attrs = parseAttributes(attrReader);
+            if (attrs['NAME'] && attrs['VALUE']) {
+                defines[attrs['NAME']] = attrs['VALUE'];
+            }
+        }
+        // Unrecognized tags and comments are silently skipped
+    }
+    return { variants, alternativeRenditions, sessionData, defines };
+}
+/**
+ * Parses a resolution string (e.g., "1920x1080") into width and height numbers.
+ * Throws ValidationError for invalid formats per HLS spec.
+ */
+function parseResolution(resolution) {
+    const parts = resolution.split('x');
+    if (parts.length !== 2) {
+        throw new ValidationError('Invalid resolution format, expected WIDTHxHEIGHT');
+    }
+    const width = Number(parts[0]);
+    const height = Number(parts[1]);
+    if (!Number.isInteger(width) ||
+        !Number.isInteger(height) ||
+        width <= 0 ||
+        height <= 0) {
+        throw new ValidationError('Invalid resolution values, width and height must be positive integers');
+    }
+    return { width, height };
+}

package/dist/types/current/parse/parseMediaPlaylist.d.ts

@@ -0,0 +1,12 @@
+import type { MediaPlaylist } from '../types/MediaPlaylist';
+export declare const HLS_VARIABLE_PATTERN: RegExp;
+/**
+ * Parses an HLS media playlist from M3U8 text.
+ *
+ * @param text The raw M3U8 manifest string.
+ * @param variables Optional variable definitions from the master playlist's #EXT-X-DEFINE tags.
+ * @returns A readonly MediaPlaylist structure.
+ * @throws StringParseError if the manifest is malformed.
+ */
+export declare function parseMediaPlaylist(text: string, variables?: Readonly<Record<string, string>>): MediaPlaylist;
+//# sourceMappingURL=parseMediaPlaylist.d.ts.map

package/dist/types/current/parse/parseMediaPlaylist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseMediaPlaylist.d.ts","sourceRoot":"","sources":["../../../../src/parse/parseMediaPlaylist.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAI1D,eAAO,MAAM,oBAAoB,QAAkB,CAAA;AAenD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAC9B,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC7C,aAAa,CA+Jf"}

package/dist/types/current/parse/parseMediaPlaylist.js

@@ -0,0 +1,191 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { StringReader, substitute } from '@amazon/vinyl-util';
+import { encryptionMethodValidator } from '../types/EncryptionKey';
+import { parseAttributes } from './parseAttributes';
+import { readLine, skipWhitespaceLine, addIfPresent } from './parseUtil';
+export const HLS_VARIABLE_PATTERN = /\{\$([^}]+)}/g;
+const EXTM3U = '#EXTM3U';
+const EXTINF = '#EXTINF:';
+const EXT_X_TARGETDURATION = '#EXT-X-TARGETDURATION:';
+const EXT_X_MEDIA_SEQUENCE = '#EXT-X-MEDIA-SEQUENCE:';
+const EXT_X_ENDLIST = '#EXT-X-ENDLIST';
+const EXT_X_PLAYLIST_TYPE = '#EXT-X-PLAYLIST-TYPE:';
+const EXT_X_VERSION = '#EXT-X-VERSION:';
+const EXT_X_KEY = '#EXT-X-KEY:';
+const EXT_X_BYTERANGE = '#EXT-X-BYTERANGE:';
+const EXT_X_DISCONTINUITY = '#EXT-X-DISCONTINUITY';
+const EXT_X_PROGRAM_DATE_TIME = '#EXT-X-PROGRAM-DATE-TIME:';
+const EXT_X_MAP = '#EXT-X-MAP:';
+/**
+ * Parses an HLS media playlist from M3U8 text.
+ *
+ * @param text The raw M3U8 manifest string.
+ * @param variables Optional variable definitions from the master playlist's #EXT-X-DEFINE tags.
+ * @returns A readonly MediaPlaylist structure.
+ * @throws StringParseError if the manifest is malformed.
+ */
+export function parseMediaPlaylist(text, variables) {
+    const reader = new StringReader(text);
+    reader.white();
+    if (!reader.stringIf(EXTM3U)) {
+        reader.err('Expected #EXTM3U');
+    }
+    readLine(reader);
+    let version = 1;
+    let targetDuration = 0;
+    let mediaSequence = 0;
+    let playlistType = 'LIVE';
+    let ended = false;
+    let currentKey;
+    let currentMap;
+    let pendingByteRange;
+    let pendingDiscontinuity = false;
+    let pendingDateTime;
+    const segments = [];
+    let sequenceCounter = 0;
+    while (reader.hasNext()) {
+        if (skipWhitespaceLine(reader))
+            continue;
+        const line = readLine(reader);
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith(EXTINF)) {
+            const durationStr = trimmed.substring(EXTINF.length).split(',')[0];
+            const duration = Number(durationStr);
+            // Find the URI, skipping any tags that come between EXTINF and URI
+            let uri = '';
+            while (reader.hasNext()) {
+                if (skipWhitespaceLine(reader))
+                    continue;
+                const nextLine = readLine(reader).trim();
+                if (!nextLine.startsWith('#')) {
+                    uri = variables
+                        ? substitute(nextLine, variables, HLS_VARIABLE_PATTERN)
+                        : nextLine;
+                    break;
+                }
+                // Process tags that come between EXTINF and URI
+                if (nextLine.startsWith(EXT_X_BYTERANGE)) {
+                    const rangeStr = nextLine.substring(EXT_X_BYTERANGE.length);
+                    pendingByteRange = parseByteRangeString(rangeStr);
+                }
+                else if (nextLine === EXT_X_DISCONTINUITY) {
+                    pendingDiscontinuity = true;
+                }
+                else if (nextLine.startsWith(EXT_X_PROGRAM_DATE_TIME)) {
+                    pendingDateTime = nextLine.substring(EXT_X_PROGRAM_DATE_TIME.length);
+                }
+                else if (nextLine.startsWith(EXT_X_MAP)) {
+                    const attrStr = nextLine.substring(EXT_X_MAP.length);
+                    const attrReader = new StringReader(attrStr);
+                    const attrs = parseAttributes(attrReader);
+                    const mapUri = attrs['URI'];
+                    if (mapUri) {
+                        const byteRangeStr = attrs['BYTERANGE'];
+                        currentMap = {
+                            uri: mapUri,
+                            ...(byteRangeStr && {
+                                byteRange: parseByteRangeString(byteRangeStr),
+                            }),
+                        };
+                    }
+                }
+            }
+            segments.push({
+                uri,
+                duration,
+                sequenceNumber: mediaSequence + sequenceCounter,
+                ...(currentKey && { key: currentKey }),
+                ...(currentMap && { map: currentMap }),
+                ...(pendingByteRange && { byteRange: pendingByteRange }),
+                discontinuity: pendingDiscontinuity,
+                ...(pendingDateTime && { programDateTime: pendingDateTime }),
+            });
+            sequenceCounter++;
+            pendingByteRange = undefined;
+            pendingDiscontinuity = false;
+            pendingDateTime = undefined;
+        }
+        else if (trimmed.startsWith(EXT_X_TARGETDURATION)) {
+            targetDuration = Number(trimmed.substring(EXT_X_TARGETDURATION.length));
+        }
+        else if (trimmed.startsWith(EXT_X_MEDIA_SEQUENCE)) {
+            mediaSequence = Number(trimmed.substring(EXT_X_MEDIA_SEQUENCE.length));
+        }
+        else if (trimmed === EXT_X_ENDLIST) {
+            ended = true;
+        }
+        else if (trimmed.startsWith(EXT_X_PLAYLIST_TYPE)) {
+            const val = trimmed.substring(EXT_X_PLAYLIST_TYPE.length).trim();
+            if (val === 'VOD' || val === 'EVENT') {
+                playlistType = val;
+            }
+        }
+        else if (trimmed.startsWith(EXT_X_VERSION)) {
+            version = Number(trimmed.substring(EXT_X_VERSION.length));
+        }
+        else if (trimmed.startsWith(EXT_X_KEY)) {
+            const attrStr = trimmed.substring(EXT_X_KEY.length);
+            const attrReader = new StringReader(attrStr);
+            const attrs = parseAttributes(attrReader);
+            const method = attrs['METHOD'];
+            encryptionMethodValidator.assert(method);
+            currentKey = addIfPresent({
+                method,
+            }, attrs, {
+                URI: 'uri',
+                IV: 'iv',
+                KEYFORMAT: 'keyFormat',
+                KEYFORMATVERSIONS: 'keyFormatVersions',
+            });
+        }
+        else if (trimmed.startsWith(EXT_X_MAP)) {
+            const attrStr = trimmed.substring(EXT_X_MAP.length);
+            const attrReader = new StringReader(attrStr);
+            const attrs = parseAttributes(attrReader);
+            const mapUri = attrs['URI'];
+            if (mapUri) {
+                const byteRangeStr = attrs['BYTERANGE'];
+                currentMap = {
+                    uri: mapUri,
+                    ...(byteRangeStr && {
+                        byteRange: parseByteRangeString(byteRangeStr),
+                    }),
+                };
+            }
+        }
+        else if (trimmed.startsWith(EXT_X_BYTERANGE)) {
+            const rangeStr = trimmed.substring(EXT_X_BYTERANGE.length);
+            pendingByteRange = parseByteRangeString(rangeStr);
+        }
+        else if (trimmed === EXT_X_DISCONTINUITY) {
+            pendingDiscontinuity = true;
+        }
+        else if (trimmed.startsWith(EXT_X_PROGRAM_DATE_TIME)) {
+            pendingDateTime = trimmed.substring(EXT_X_PROGRAM_DATE_TIME.length);
+        }
+        // Unrecognized tags and comments are silently skipped
+    }
+    return {
+        version,
+        targetDuration,
+        mediaSequence,
+        playlistType,
+        ended,
+        segments,
+    };
+}
+/**
+ * Parses a byte range string (e.g. "1000@500" or "1000") into length and offset.
+ */
+function parseByteRangeString(str) {
+    const parts = str.split('@');
+    return {
+        length: Number(parts[0]),
+        offset: parts.length > 1 ? Number(parts[1]) : 0,
+    };
+}

package/dist/types/current/parse/parseUtil.d.ts

@@ -0,0 +1,17 @@
+import { type StringReader } from '@amazon/vinyl-util';
+/**
+ * Reads a line from the StringReader, advancing past the line ending.
+ * Returns the line content without the line ending.
+ */
+export declare function readLine(reader: StringReader): string;
+/**
+ * Skips whitespace-only content at the current position up to and including
+ * the next line ending. Returns true if a whitespace-only line was skipped.
+ */
+export declare function skipWhitespaceLine(reader: StringReader): boolean;
+/**
+ * Conditionally adds properties from an attribute map to an object.
+ * Only adds a property if the corresponding attribute key exists and is truthy.
+ */
+export declare function addIfPresent<T extends Record<string, any>>(obj: T, attrs: Record<string, string>, mappings: Record<string, string>): T;
+//# sourceMappingURL=parseUtil.d.ts.map

package/dist/types/current/parse/parseUtil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseUtil.d.ts","sourceRoot":"","sources":["../../../../src/parse/parseUtil.ts"],"names":[],"mappings":"AAKA,OAAO,EAA0B,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAK9E;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAKrD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAYhE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACtD,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,CAAC,CAOH"}

package/dist/types/current/parse/parseUtil.js

@@ -0,0 +1,51 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { char, isWhitespaceChar } from '@amazon/vinyl-util';
+const LF = char('\n');
+const CR = char('\r');
+/**
+ * Reads a line from the StringReader, advancing past the line ending.
+ * Returns the line content without the line ending.
+ */
+export function readLine(reader) {
+    const line = reader.substringUntil((cc) => cc === LF || cc === CR);
+    if (reader.hasNext() && reader.peek === CR)
+        reader.next();
+    if (reader.hasNext() && reader.peek === LF)
+        reader.next();
+    return line;
+}
+/**
+ * Skips whitespace-only content at the current position up to and including
+ * the next line ending. Returns true if a whitespace-only line was skipped.
+ */
+export function skipWhitespaceLine(reader) {
+    const start = reader.position;
+    reader.while((cc) => isWhitespaceChar(cc) && cc !== LF && cc !== CR);
+    if (!reader.hasNext() || reader.peek === LF || reader.peek === CR) {
+        if (reader.hasNext()) {
+            if (reader.peek === CR)
+                reader.next();
+            if (reader.hasNext() && reader.peek === LF)
+                reader.next();
+        }
+        return true;
+    }
+    reader.position = start;
+    return false;
+}
+/**
+ * Conditionally adds properties from an attribute map to an object.
+ * Only adds a property if the corresponding attribute key exists and is truthy.
+ */
+export function addIfPresent(obj, attrs, mappings) {
+    for (const [attrKey, objKey] of Object.entries(mappings)) {
+        if (attrs[attrKey]) {
+            ;
+            obj[objKey] = attrs[attrKey];
+        }
+    }
+    return obj;
+}