openclaw-multi-auto 1.2.7 → 1.2.9

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/matroska/MatroskaParser.js

@@ -1,143 +0,0 @@
-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');
-/**
- * Extensible Binary Meta Language (EBML) parser
- * https://en.wikipedia.org/wiki/Extensible_Binary_Meta_Language
- * http://matroska.sourceforge.net/technical/specs/rfc/index.html
- *
- * WEBM VP8 AUDIO FILE
- */
-export class MatroskaParser extends 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;
-    }
-    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;
-                            }
-                        }
-                        return ParseAction.IgnoreElement;
-                    default:
-                        return ParseAction.ReadNext;
-                }
-            },
-            elementValue: async (element, value, offset) => {
-                debug(`Received: name=${element.name}, value=${value}`);
-                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
-                            })));
-                        }
-                        break;
-                }
-            }
-        });
-    }
-    async addTag(tagId, value) {
-        await this.metadata.addTag('matroska', tagId, value);
-    }
-}

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/matroska/MatroskaTagMapper.d.ts

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

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/matroska/MatroskaTagMapper.js

@@ -1,32 +0,0 @@
-import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
-/**
- * EBML Tag map
- */
-const ebmlTagMap = {
-    'segment:title': 'title',
-    'album:ARTIST': 'albumartist',
-    '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',
-    'track:ARTISTSORT': 'artistsort',
-    'track:TITLE': 'title',
-    'track:PART_NUMBER': 'track',
-    'track:MUSICBRAINZ_TRACKID': 'musicbrainz_recordingid',
-    'track:MUSICBRAINZ_ALBUMID': 'musicbrainz_albumid',
-    'track:MUSICBRAINZ_ARTISTID': 'musicbrainz_artistid',
-    'track:PUBLISHER': 'label',
-    'track:GENRE': 'genre',
-    'track:ENCODER': 'encodedby',
-    'track:ENCODER_OPTIONS': 'encodersettings',
-    'edition:TOTAL_PARTS': 'totaldiscs',
-    picture: 'picture'
-};
-export class MatroskaTagMapper extends CaseInsensitiveTagMap {
-    constructor() {
-        super(['matroska'], ebmlTagMap);
-    }
-}

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/matroska/types.d.ts

@@ -1,142 +0,0 @@
-import type { IEbmlDoc } from '../ebml/types.js';
-export interface ISeek {
-    id: Uint8Array;
-    position: number;
-}
-export interface ISeekHead {
-    seek: ISeek[];
-}
-export interface ISegmentInformation {
-    uid?: Uint8Array;
-    timecodeScale?: number;
-    duration?: number;
-    dateUTC?: number;
-    title?: string;
-    muxingApp?: string;
-    writingApp?: string;
-}
-export interface ITrackEntry {
-    uid?: Uint8Array;
-    trackNumber: number;
-    trackType?: TrackType;
-    audio: ITrackAudio;
-    video?: ITrackVideo;
-    flagEnabled?: boolean;
-    flagDefault?: boolean;
-    flagLacing?: boolean;
-    defaultDuration?: number;
-    trackTimecodeScale?: number;
-    name?: string;
-    language?: string;
-    codecID: string;
-    codecPrivate?: Uint8Array;
-    codecName?: string;
-    codecSettings?: string;
-    codecInfoUrl?: string;
-    codecDownloadUrl?: string;
-    codecDecodeAll?: string;
-    trackOverlay?: string;
-}
-export interface ITrackVideo {
-    flagInterlaced?: boolean;
-    stereoMode?: number;
-    pixelWidth?: number;
-    pixelHeight?: number;
-    displayWidth?: number;
-    displayHeight?: number;
-    displayUnit?: number;
-    aspectRatioType?: number;
-    colourSpace?: Uint8Array;
-    gammaValue?: number;
-}
-export interface ITrackAudio {
-    samplingFrequency?: number;
-    outputSamplingFrequency?: number;
-    channels?: number;
-    channelPositions?: Uint8Array;
-    bitDepth?: number;
-}
-export interface ICuePoint {
-    cueTime?: number;
-    cueTrackPositions: ICueTrackPosition[];
-}
-export interface ICueTrackPosition {
-    cueTrack?: number;
-    cueClusterPosition?: number;
-    cueBlockNumber?: number;
-    cueCodecState?: number;
-    cueReference?: ICueReference;
-}
-export interface ICueReference {
-    cueRefTime?: number;
-    cueRefCluster?: number;
-    cueRefNumber?: number;
-    cueRefCodecState?: number;
-}
-export interface ISimpleTag {
-    name?: string;
-    'string'?: string;
-    binary?: Uint8Array;
-    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 interface ITarget {
-    trackUID?: Uint8Array;
-    chapterUID?: Uint8Array;
-    attachmentUID?: Uint8Array;
-    targetTypeValue?: keyof typeof TargetType;
-    targetType?: string;
-}
-export interface ITag {
-    target: ITarget;
-    simpleTags: ISimpleTag[];
-}
-export interface ITags {
-    tag: ITag[];
-}
-export interface ITrackElement {
-    entries?: ITrackEntry[];
-}
-export interface IAttachmedFile {
-    description?: string;
-    name: string;
-    mimeType: string;
-    data: Uint8Array;
-    uid: string;
-}
-export interface IAttachments {
-    attachedFiles: IAttachmedFile[];
-}
-export interface IMatroskaSegment {
-    metaSeekInfo?: ISeekHead;
-    seekHeads?: ISeek[];
-    info?: ISegmentInformation;
-    tracks?: ITrackElement;
-    tags?: ITags;
-    cues?: ICuePoint[];
-    attachments?: IAttachments;
-}
-export interface IMatroskaDoc extends IEbmlDoc {
-    segment: IMatroskaSegment;
-}

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/matroska/types.js

@@ -1,27 +0,0 @@
-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'
-};

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/mp4/Atom.d.ts

@@ -1,16 +0,0 @@
-import * as AtomToken from './AtomToken.js';
-import type { ITokenizer } from 'strtok3';
-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);
-    getHeaderLength(): number;
-    getPayloadLength(remaining: number): number;
-    readAtoms(tokenizer: ITokenizer, dataHandler: AtomDataHandler, size: number): Promise<void>;
-    private readData;
-}

package/node_modules/.pnpm/@whiskeysockets+baileys@7.0.0-rc.9_sharp@0.34.5/node_modules/music-metadata/lib/mp4/Atom.js

@@ -1,65 +0,0 @@
-import initDebug from 'debug';
-import * as AtomToken from './AtomToken.js';
-import { Header } from './AtomToken.js';
-const debug = initDebug('music-metadata:parser:MP4:Atom');
-export class Atom {
-    static async readAtom(tokenizer, dataHandler, parent, remaining) {
-        // Parse atom header
-        const offset = tokenizer.position;
-        debug(`Reading next token on offset=${offset}...`); //  buf.toString('ascii')
-        const header = await tokenizer.readToken(AtomToken.Header);
-        const extended = header.length === 1n;
-        if (extended) {
-            header.length = await tokenizer.readToken(AtomToken.ExtendedSize);
-        }
-        const atomBean = new Atom(header, extended, parent);
-        const payloadLength = atomBean.getPayloadLength(remaining);
-        debug(`parse atom name=${atomBean.atomPath}, extended=${atomBean.extended}, offset=${offset}, len=${atomBean.header.length}`); //  buf.toString('ascii')
-        await atomBean.readData(tokenizer, dataHandler, payloadLength);
-        return atomBean;
-    }
-    constructor(header, extended, parent) {
-        this.header = header;
-        this.extended = extended;
-        this.parent = parent;
-        this.children = [];
-        this.atomPath = (this.parent ? `${this.parent.atomPath}.` : '') + this.header.name;
-    }
-    getHeaderLength() {
-        return this.extended ? 16 : 8;
-    }
-    getPayloadLength(remaining) {
-        return (this.header.length === 0n ? remaining : Number(this.header.length)) - this.getHeaderLength();
-    }
-    async readAtoms(tokenizer, dataHandler, size) {
-        while (size > 0) {
-            const atomBean = await Atom.readAtom(tokenizer, dataHandler, this, size);
-            this.children.push(atomBean);
-            size -= atomBean.header.length === 0n ? size : Number(atomBean.header.length);
-        }
-    }
-    async readData(tokenizer, dataHandler, remaining) {
-        switch (this.header.name) {
-            // "Container" atoms, contains nested atoms
-            case 'moov': // The Movie Atom: contains other atoms
-            case 'udta': // User defined atom
-            case 'mdia': // Media atom
-            case 'minf': // Media Information Atom
-            case 'stbl': // The Sample Table Atom
-            case '<id>':
-            case 'ilst':
-            case 'tref':
-            case 'moof':
-                return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining));
-            case 'meta': { // Metadata Atom, ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW8
-                // meta has 4 bytes of padding, ignore
-                const peekHeader = await tokenizer.peekToken(Header);
-                const paddingLength = peekHeader.name === 'hdlr' ? 0 : 4;
-                await tokenizer.ignore(paddingLength);
-                return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining) - paddingLength);
-            }
-            default:
-                return dataHandler(this, remaining);
-        }
-    }
-}