@dragon708/docmind-markdown 1.2.5 → 1.2.7

package/node_modules/music-metadata/lib/matroska/MatroskaParser.js

@@ -1,9 +1,12 @@
-import initDebug from 'debug';
-import { BasicParser } from '../common/BasicParser.js';
-import { matroskaDtd } from './MatroskaDtd.js';
-import { TargetType, TrackType } from './types.js';
-import { EbmlIterator, ParseAction } from '../ebml/EbmlIterator.js';
-const debug = initDebug('music-metadata:parser:matroska');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatroskaParser = void 0;
+const token_types_1 = require("token-types");
+const debug_1 = require("debug");
+const BasicParser_1 = require("../common/BasicParser");
+const types_1 = require("./types");
+const matroskaDtd = require("./MatroskaDtd");
+const debug = (0, debug_1.default)('music-metadata:parser:matroska');
 /**
  * Extensible Binary Meta Language (EBML) parser
  * https://en.wikipedia.org/wiki/Extensible_Binary_Meta_Language
@@ -11,133 +14,224 @@ const debug = initDebug('music-metadata:parser:matroska');
  *
  * WEBM VP8 AUDIO FILE
  */
-export class MatroskaParser extends BasicParser {
+class MatroskaParser extends BasicParser_1.BasicParser {
     constructor() {
-        super(...arguments);
-        this.seekHeadOffset = 0;
-        /**
-         * Use index to skip multiple segment/cluster elements at once.
-         * Significant performance impact
-         */
-        this.flagUseIndexToSkipClusters = this.options.mkvUseIndex ?? false;
+        super();
+        this.padding = 0;
+        this.parserMap = new Map();
+        this.ebmlMaxIDLength = 4;
+        this.ebmlMaxSizeLength = 8;
+        this.parserMap.set(types_1.DataType.uint, e => this.readUint(e));
+        this.parserMap.set(types_1.DataType.string, e => this.readString(e));
+        this.parserMap.set(types_1.DataType.binary, e => this.readBuffer(e));
+        this.parserMap.set(types_1.DataType.uid, async (e) => await this.readUint(e) === 1);
+        this.parserMap.set(types_1.DataType.bool, e => this.readFlag(e));
+        this.parserMap.set(types_1.DataType.float, e => this.readFloat(e));
+    }
+    /**
+     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
+     * @param {INativeMetadataCollector} metadata Output
+     * @param {ITokenizer} tokenizer Input
+     * @param {IOptions} options Parsing options
+     */
+    init(metadata, tokenizer, options) {
+        super.init(metadata, tokenizer, options);
+        return this;
     }
     async parse() {
-        const containerSize = this.tokenizer.fileInfo.size ?? Number.MAX_SAFE_INTEGER;
-        const matroskaIterator = new EbmlIterator(this.tokenizer);
-        debug('Initializing DTD end MatroskaIterator');
-        await matroskaIterator.iterate(matroskaDtd, containerSize, {
-            startNext: (element) => {
-                switch (element.id) {
-                    // case 0x1f43b675: // cluster
-                    case 0x1c53bb6b: // Cueing Data
-                        debug(`Skip element: name=${element.name}, id=0x${element.id.toString(16)}`);
-                        return ParseAction.IgnoreElement;
-                    case 0x1f43b675: // cluster
-                        if (this.flagUseIndexToSkipClusters && this.seekHead) {
-                            const index = this.seekHead.seek.find(index => index.position + this.seekHeadOffset > this.tokenizer.position);
-                            if (index) {
-                                // Go to next index position
-                                const ignoreSize = index.position + this.seekHeadOffset - this.tokenizer.position;
-                                debug(`Use index to go to next position, ignoring ${ignoreSize} bytes`);
-                                this.tokenizer.ignore(ignoreSize);
-                                return ParseAction.SkipElement;
-                            }
+        const matroska = await this.parseContainer(matroskaDtd.elements, this.tokenizer.fileInfo.size, []);
+        this.metadata.setFormat('container', `EBML/${matroska.ebml.docType}`);
+        if (matroska.segment) {
+            const info = matroska.segment.info;
+            if (info) {
+                const timecodeScale = info.timecodeScale ? info.timecodeScale : 1000000;
+                if (typeof info.duration === 'number') {
+                    const duration = info.duration * timecodeScale / 1000000000;
+                    this.addTag('segment:title', info.title);
+                    this.metadata.setFormat('duration', duration);
+                }
+            }
+            const audioTracks = matroska.segment.tracks;
+            if (audioTracks && audioTracks.entries) {
+                audioTracks.entries.forEach(entry => {
+                    const stream = {
+                        codecName: entry.codecID.replace('A_', '').replace('V_', ''),
+                        codecSettings: entry.codecSettings,
+                        flagDefault: entry.flagDefault,
+                        flagLacing: entry.flagLacing,
+                        flagEnabled: entry.flagEnabled,
+                        language: entry.language,
+                        name: entry.name,
+                        type: entry.trackType,
+                        audio: entry.audio,
+                        video: entry.video
+                    };
+                    this.metadata.addStreamInfo(stream);
+                });
+                const audioTrack = audioTracks.entries
+                    .filter(entry => {
+                    return entry.trackType === types_1.TrackType.audio.valueOf();
+                })
+                    .reduce((acc, cur) => {
+                    if (!acc) {
+                        return cur;
+                    }
+                    if (!acc.flagDefault && cur.flagDefault) {
+                        return cur;
+                    }
+                    if (cur.trackNumber && cur.trackNumber < acc.trackNumber) {
+                        return cur;
+                    }
+                    return acc;
+                }, null);
+                if (audioTrack) {
+                    this.metadata.setFormat('codec', audioTrack.codecID.replace('A_', ''));
+                    this.metadata.setFormat('sampleRate', audioTrack.audio.samplingFrequency);
+                    this.metadata.setFormat('numberOfChannels', audioTrack.audio.channels);
+                }
+                if (matroska.segment.tags) {
+                    matroska.segment.tags.tag.forEach(tag => {
+                        const target = tag.target;
+                        const targetType = (target === null || target === void 0 ? void 0 : target.targetTypeValue) ? types_1.TargetType[target.targetTypeValue] : ((target === null || target === void 0 ? void 0 : target.targetType) ? target.targetType : 'track');
+                        tag.simpleTags.forEach(simpleTag => {
+                            const value = simpleTag.string ? simpleTag.string : simpleTag.binary;
+                            this.addTag(`${targetType}:${simpleTag.name}`, value);
+                        });
+                    });
+                }
+                if (matroska.segment.attachments) {
+                    matroska.segment.attachments.attachedFiles
+                        .filter(file => file.mimeType.startsWith('image/'))
+                        .map(file => {
+                        return {
+                            data: file.data,
+                            format: file.mimeType,
+                            description: file.description,
+                            name: file.name
+                        };
+                    }).forEach(picture => {
+                        this.addTag('picture', picture);
+                    });
+                }
+            }
+        }
+    }
+    async parseContainer(container, posDone, path) {
+        const tree = {};
+        while (this.tokenizer.position < posDone) {
+            let element;
+            try {
+                element = await this.readElement();
+            }
+            catch (error) {
+                if (error.message === 'End-Of-Stream') {
+                    break;
+                }
+                throw error;
+            }
+            const type = container[element.id];
+            if (type) {
+                debug(`Element: name=${type.name}, container=${!!type.container}`);
+                if (type.container) {
+                    const res = await this.parseContainer(type.container, element.len >= 0 ? this.tokenizer.position + element.len : -1, path.concat([type.name]));
+                    if (type.multiple) {
+                        if (!tree[type.name]) {
+                            tree[type.name] = [];
                         }
-                        return ParseAction.IgnoreElement;
-                    default:
-                        return ParseAction.ReadNext;
+                        tree[type.name].push(res);
+                    }
+                    else {
+                        tree[type.name] = res;
+                    }
+                }
+                else {
+                    tree[type.name] = await this.parserMap.get(type.value)(element);
                 }
-            },
-            elementValue: async (element, value, offset) => {
-                debug(`Received: name=${element.name}, value=${value}`);
+            }
+            else {
                 switch (element.id) {
-                    case 0x4282: // docType
-                        this.metadata.setFormat('container', `EBML/${value}`);
-                        break;
-                    case 0x114d9b74:
-                        this.seekHead = value;
-                        this.seekHeadOffset = offset;
-                        break;
-                    case 0x1549a966:
-                        { // Info (Segment Information)
-                            const info = value;
-                            const timecodeScale = info.timecodeScale ? info.timecodeScale : 1000000;
-                            if (typeof info.duration === 'number') {
-                                const duration = info.duration * timecodeScale / 1000000000;
-                                await this.addTag('segment:title', info.title);
-                                this.metadata.setFormat('duration', Number(duration));
-                            }
-                        }
-                        break;
-                    case 0x1654ae6b:
-                        { // tracks
-                            const audioTracks = value;
-                            if (audioTracks?.entries) {
-                                audioTracks.entries.forEach(entry => {
-                                    const stream = {
-                                        codecName: entry.codecID.replace('A_', '').replace('V_', ''),
-                                        codecSettings: entry.codecSettings,
-                                        flagDefault: entry.flagDefault,
-                                        flagLacing: entry.flagLacing,
-                                        flagEnabled: entry.flagEnabled,
-                                        language: entry.language,
-                                        name: entry.name,
-                                        type: entry.trackType,
-                                        audio: entry.audio,
-                                        video: entry.video
-                                    };
-                                    this.metadata.addStreamInfo(stream);
-                                });
-                                const audioTrack = audioTracks.entries
-                                    .filter(entry => entry.trackType === TrackType.audio)
-                                    .reduce((acc, cur) => {
-                                    if (!acc)
-                                        return cur;
-                                    if (cur.flagDefault && !acc.flagDefault)
-                                        return cur;
-                                    if (cur.trackNumber < acc.trackNumber)
-                                        return cur;
-                                    return acc;
-                                }, null);
-                                if (audioTrack) {
-                                    this.metadata.setFormat('codec', audioTrack.codecID.replace('A_', ''));
-                                    this.metadata.setFormat('sampleRate', audioTrack.audio.samplingFrequency);
-                                    this.metadata.setFormat('numberOfChannels', audioTrack.audio.channels);
-                                }
-                            }
-                        }
-                        break;
-                    case 0x1254c367:
-                        { // tags
-                            const tags = value;
-                            await Promise.all(tags.tag.map(async (tag) => {
-                                const target = tag.target;
-                                const targetType = target?.targetTypeValue ? TargetType[target.targetTypeValue] : (target?.targetType ? target.targetType : 'track');
-                                await Promise.all(tag.simpleTags.map(async (simpleTag) => {
-                                    const value = simpleTag.string ? simpleTag.string : simpleTag.binary;
-                                    await this.addTag(`${targetType}:${simpleTag.name}`, value);
-                                }));
-                            }));
-                        }
-                        break;
-                    case 0x1941a469:
-                        { // attachments
-                            const attachments = value;
-                            await Promise.all(attachments.attachedFiles
-                                .filter(file => file.mimeType.startsWith('image/'))
-                                .map(file => this.addTag('picture', {
-                                data: file.data,
-                                format: file.mimeType,
-                                description: file.description,
-                                name: file.name
-                            })));
-                        }
+                    case 0xec: // void
+                        this.padding += element.len;
+                        await this.tokenizer.ignore(element.len);
                         break;
+                    default:
+                        debug(`parseEbml: path=${path.join('/')}, unknown element: id=${element.id.toString(16)}`);
+                        this.padding += element.len;
+                        await this.tokenizer.ignore(element.len);
                 }
             }
-        });
+        }
+        return tree;
+    }
+    async readVintData(maxLength) {
+        const msb = await this.tokenizer.peekNumber(token_types_1.UINT8);
+        let mask = 0x80;
+        let oc = 1;
+        // Calculate VINT_WIDTH
+        while ((msb & mask) === 0) {
+            if (oc > maxLength) {
+                throw new Error('VINT value exceeding maximum size');
+            }
+            ++oc;
+            mask >>= 1;
+        }
+        const id = Buffer.alloc(oc);
+        await this.tokenizer.readBuffer(id);
+        return id;
+    }
+    async readElement() {
+        const id = await this.readVintData(this.ebmlMaxIDLength);
+        const lenField = await this.readVintData(this.ebmlMaxSizeLength);
+        lenField[0] ^= 0x80 >> (lenField.length - 1);
+        const nrLen = Math.min(6, lenField.length); // JavaScript can max read 6 bytes integer
+        return {
+            id: id.readUIntBE(0, id.length),
+            len: lenField.readUIntBE(lenField.length - nrLen, nrLen)
+        };
+    }
+    isMaxValue(vintData) {
+        if (vintData.length === this.ebmlMaxSizeLength) {
+            for (let n = 1; n < this.ebmlMaxSizeLength; ++n) {
+                if (vintData[n] !== 0xff)
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    async readFloat(e) {
+        switch (e.len) {
+            case 0:
+                return 0.0;
+            case 4:
+                return this.tokenizer.readNumber(token_types_1.Float32_BE);
+            case 8:
+                return this.tokenizer.readNumber(token_types_1.Float64_BE);
+            case 10:
+                return this.tokenizer.readNumber(token_types_1.Float64_BE);
+            default:
+                throw new Error(`Invalid IEEE-754 float length: ${e.len}`);
+        }
+    }
+    async readFlag(e) {
+        return (await this.readUint(e)) === 1;
+    }
+    async readUint(e) {
+        const buf = await this.readBuffer(e);
+        const nrLen = Math.min(6, e.len); // JavaScript can max read 6 bytes integer
+        return buf.readUIntBE(e.len - nrLen, nrLen);
+    }
+    async readString(e) {
+        const rawString = await this.tokenizer.readToken(new token_types_1.StringType(e.len, 'utf-8'));
+        return rawString.replace(/\00.*$/g, '');
+    }
+    async readBuffer(e) {
+        const buf = Buffer.alloc(e.len);
+        await this.tokenizer.readBuffer(buf);
+        return buf;
     }
-    async addTag(tagId, value) {
-        await this.metadata.addTag('matroska', tagId, value);
+    addTag(tagId, value) {
+        this.metadata.addTag('matroska', tagId, value);
     }
 }
+exports.MatroskaParser = MatroskaParser;

package/node_modules/music-metadata/lib/matroska/MatroskaTagMapper.d.ts

@@ -1,4 +1,4 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap';
 export declare class MatroskaTagMapper extends CaseInsensitiveTagMap {
     constructor();
 }

package/node_modules/music-metadata/lib/matroska/MatroskaTagMapper.js

@@ -1,4 +1,7 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatroskaTagMapper = void 0;
+const CaseInsensitiveTagMap_1 = require("../common/CaseInsensitiveTagMap");
 /**
  * EBML Tag map
  */
@@ -8,7 +11,6 @@ const ebmlTagMap = {
     'album:ARTISTSORT': 'albumartistsort',
     'album:TITLE': 'album',
     'album:DATE_RECORDED': 'originaldate',
-    'album:DATE_RELEASED': 'releasedate',
     'album:PART_NUMBER': 'disk',
     'album:TOTAL_PARTS': 'totaltracks',
     'track:ARTIST': 'artist',
@@ -25,8 +27,10 @@ const ebmlTagMap = {
     'edition:TOTAL_PARTS': 'totaldiscs',
     picture: 'picture'
 };
-export class MatroskaTagMapper extends CaseInsensitiveTagMap {
+class MatroskaTagMapper extends CaseInsensitiveTagMap_1.CaseInsensitiveTagMap {
     constructor() {
         super(['matroska'], ebmlTagMap);
     }
 }
+exports.MatroskaTagMapper = MatroskaTagMapper;
+//# sourceMappingURL=MatroskaTagMapper.js.map

package/node_modules/music-metadata/lib/matroska/types.d.ts

@@ -1,13 +1,37 @@
-import type { IEbmlDoc } from '../ebml/types.js';
-export interface ISeek {
-    id: Uint8Array;
-    position: number;
+/// <reference types="node" />
+export interface IHeader {
+    id: number;
+    len: number;
+}
+export declare enum DataType {
+    'string' = 0,
+    uint = 1,
+    uid = 2,
+    bool = 3,
+    binary = 4,
+    float = 5
+}
+export interface IElementType<T> {
+    readonly name: string;
+    readonly value?: DataType;
+    readonly container?: IContainerType;
+    readonly multiple?: boolean;
+}
+export interface IContainerType {
+    [id: number]: IElementType<string | number | boolean | Buffer>;
+}
+export interface ITree {
+    [name: string]: string | number | boolean | Buffer | ITree | ITree[];
 }
 export interface ISeekHead {
-    seek: ISeek[];
+    id?: Buffer;
+    position?: number;
+}
+export interface IMetaSeekInformation {
+    seekHeads: ISeekHead[];
 }
 export interface ISegmentInformation {
-    uid?: Uint8Array;
+    uid?: Buffer;
     timecodeScale?: number;
     duration?: number;
     dateUTC?: number;
@@ -16,10 +40,10 @@ export interface ISegmentInformation {
     writingApp?: string;
 }
 export interface ITrackEntry {
-    uid?: Uint8Array;
-    trackNumber: number;
+    uid?: Buffer;
+    trackNumber?: number;
     trackType?: TrackType;
-    audio: ITrackAudio;
+    audio?: ITrackAudio;
     video?: ITrackVideo;
     flagEnabled?: boolean;
     flagDefault?: boolean;
@@ -28,8 +52,8 @@ export interface ITrackEntry {
     trackTimecodeScale?: number;
     name?: string;
     language?: string;
-    codecID: string;
-    codecPrivate?: Uint8Array;
+    codecID?: string;
+    codecPrivate?: Buffer;
     codecName?: string;
     codecSettings?: string;
     codecInfoUrl?: string;
@@ -46,14 +70,14 @@ export interface ITrackVideo {
     displayHeight?: number;
     displayUnit?: number;
     aspectRatioType?: number;
-    colourSpace?: Uint8Array;
+    colourSpace?: Buffer;
     gammaValue?: number;
 }
 export interface ITrackAudio {
     samplingFrequency?: number;
     outputSamplingFrequency?: number;
     channels?: number;
-    channelPositions?: Uint8Array;
+    channelPositions?: Buffer;
     bitDepth?: number;
 }
 export interface ICuePoint {
@@ -76,36 +100,33 @@ export interface ICueReference {
 export interface ISimpleTag {
     name?: string;
     'string'?: string;
-    binary?: Uint8Array;
+    binary?: Buffer;
     language?: string;
     default?: boolean;
 }
-export declare const TargetType: {
-    10: string;
-    20: string;
-    30: string;
-    40: string;
-    50: string;
-    60: string;
-    70: string;
-};
-export declare const TrackType: {
-    video: number;
-    audio: number;
-    complex: number;
-    logo: number;
-    subtitle: number;
-    button: number;
-    control: number;
-};
-export type TrackType = typeof TrackType[keyof typeof TrackType];
-export type TrackTypeKey = keyof typeof TrackType;
-export declare const TrackTypeValueToKeyMap: Record<TrackType, TrackTypeKey>;
+export declare enum TargetType {
+    shot = 10,
+    scene = 20,
+    track = 30,
+    part = 40,
+    album = 50,
+    edition = 60,
+    collection = 70
+}
+export declare enum TrackType {
+    video = 1,
+    audio = 2,
+    complex = 3,
+    logo = 4,
+    subtitle = 17,
+    button = 18,
+    control = 32
+}
 export interface ITarget {
-    trackUID?: Uint8Array;
-    chapterUID?: Uint8Array;
-    attachmentUID?: Uint8Array;
-    targetTypeValue?: keyof typeof TargetType;
+    trackUID?: Buffer;
+    chapterUID?: Buffer;
+    attachmentUID?: Buffer;
+    targetTypeValue?: TargetType;
     targetType?: string;
 }
 export interface ITag {
@@ -122,21 +143,33 @@ export interface IAttachmedFile {
     description?: string;
     name: string;
     mimeType: string;
-    data: Uint8Array;
+    data: Buffer;
     uid: string;
 }
 export interface IAttachments {
-    attachedFiles: IAttachmedFile[];
+    attachedFiles?: IAttachmedFile[];
 }
 export interface IMatroskaSegment {
-    metaSeekInfo?: ISeekHead;
-    seekHeads?: ISeek[];
+    metaSeekInfo?: IMetaSeekInformation;
+    seekHeads?: ISeekHead[];
     info?: ISegmentInformation;
     tracks?: ITrackElement;
     tags?: ITags;
     cues?: ICuePoint[];
     attachments?: IAttachments;
 }
+export interface IEbmlElements {
+    version?: number;
+    readVersion?: number;
+    maxIDWidth?: number;
+    maxSizeWidth?: number;
+    docType?: string;
+    docTypeVersion?: number;
+    docTypeReadVersion?: number;
+}
+export interface IEbmlDoc {
+    ebml: IEbmlElements;
+}
 export interface IMatroskaDoc extends IEbmlDoc {
     segment: IMatroskaSegment;
 }

package/node_modules/music-metadata/lib/matroska/types.js

@@ -1,27 +1,33 @@
-export const TargetType = {
-    10: 'shot',
-    20: 'scene',
-    30: 'track',
-    40: 'part',
-    50: 'album',
-    60: 'edition',
-    70: 'collection'
-};
-export const TrackType = {
-    video: 0x01,
-    audio: 0x02,
-    complex: 0x03,
-    logo: 0x04,
-    subtitle: 0x11,
-    button: 0x12,
-    control: 0x20
-};
-export const TrackTypeValueToKeyMap = {
-    [TrackType.video]: 'video',
-    [TrackType.audio]: 'audio',
-    [TrackType.complex]: 'complex',
-    [TrackType.logo]: 'logo',
-    [TrackType.subtitle]: 'subtitle',
-    [TrackType.button]: 'button',
-    [TrackType.control]: 'control'
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackType = exports.TargetType = exports.DataType = void 0;
+var DataType;
+(function (DataType) {
+    DataType[DataType["string"] = 0] = "string";
+    DataType[DataType["uint"] = 1] = "uint";
+    DataType[DataType["uid"] = 2] = "uid";
+    DataType[DataType["bool"] = 3] = "bool";
+    DataType[DataType["binary"] = 4] = "binary";
+    DataType[DataType["float"] = 5] = "float";
+})(DataType = exports.DataType || (exports.DataType = {}));
+var TargetType;
+(function (TargetType) {
+    TargetType[TargetType["shot"] = 10] = "shot";
+    TargetType[TargetType["scene"] = 20] = "scene";
+    TargetType[TargetType["track"] = 30] = "track";
+    TargetType[TargetType["part"] = 40] = "part";
+    TargetType[TargetType["album"] = 50] = "album";
+    TargetType[TargetType["edition"] = 60] = "edition";
+    TargetType[TargetType["collection"] = 70] = "collection";
+})(TargetType = exports.TargetType || (exports.TargetType = {}));
+var TrackType;
+(function (TrackType) {
+    TrackType[TrackType["video"] = 1] = "video";
+    TrackType[TrackType["audio"] = 2] = "audio";
+    TrackType[TrackType["complex"] = 3] = "complex";
+    TrackType[TrackType["logo"] = 4] = "logo";
+    TrackType[TrackType["subtitle"] = 17] = "subtitle";
+    TrackType[TrackType["button"] = 18] = "button";
+    TrackType[TrackType["control"] = 32] = "control";
+})(TrackType = exports.TrackType || (exports.TrackType = {}));
+//# sourceMappingURL=types.js.map

package/node_modules/music-metadata/lib/mp4/Atom.d.ts

@@ -1,14 +1,14 @@
-import * as AtomToken from './AtomToken.js';
-import type { ITokenizer } from 'strtok3';
+import { ITokenizer } from 'strtok3/lib/core';
+import * as AtomToken from './AtomToken';
 export type AtomDataHandler = (atom: Atom, remaining: number) => Promise<void>;
 export declare class Atom {
-    static readAtom(tokenizer: ITokenizer, dataHandler: AtomDataHandler, parent: Atom | null, remaining: number): Promise<Atom>;
-    readonly children: Atom[];
-    readonly atomPath: string;
     readonly header: AtomToken.IAtomHeader;
     extended: boolean;
-    readonly parent: Atom | null;
-    constructor(header: AtomToken.IAtomHeader, extended: boolean, parent: Atom | null);
+    readonly parent: Atom;
+    static readAtom(tokenizer: ITokenizer, dataHandler: AtomDataHandler, parent: Atom, remaining: number): Promise<Atom>;
+    readonly children: Atom[];
+    readonly atomPath: string;
+    constructor(header: AtomToken.IAtomHeader, extended: boolean, parent: Atom);
     getHeaderLength(): number;
     getPayloadLength(remaining: number): number;
     readAtoms(tokenizer: ITokenizer, dataHandler: AtomDataHandler, size: number): Promise<void>;