From de27ac99319ea4756cdc10a365ac690526763ba4 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Wed, 4 Dec 2024 18:11:08 -0300 Subject: [PATCH 01/14] refactor: lib build changed to rollup and simple web created --- lib/package.json | 50 +- lib/playback/audio.ts | 9 +- lib/playback/backend.ts | 9 +- lib/playback/index.ts | 2 +- lib/rollup.config.js | 31 + lib/tsconfig.json | 46 +- lib/types/workers.d.ts | 9 + package.json | 6 +- simple-web/index.js | 29 + simple-web/package.json | 17 + simple-web/public/index.html | 23 + simple-web/public/moq-player.umd.js | 11800 ++++++++++++++++++++++ simple-web/public/moq-player.umd.js.map | 1 + 13 files changed, 11973 insertions(+), 59 deletions(-) create mode 100644 lib/rollup.config.js create mode 100644 lib/types/workers.d.ts create mode 100644 simple-web/index.js create mode 100644 simple-web/package.json create mode 100644 simple-web/public/index.html create mode 100644 simple-web/public/moq-player.umd.js create mode 100644 simple-web/public/moq-player.umd.js.map diff --git a/lib/package.json b/lib/package.json index 46e6e8e..b67dd19 100644 --- a/lib/package.json +++ b/lib/package.json @@ -1,29 +1,61 @@ { - "name": "@kixelated/moq", - "type": "module", - "version": "0.1.4", + "name": "moq-player", + "version": "0.0.1", "description": "Media over QUIC library", "license": "(MIT OR Apache-2.0)", - "repository": "github:kixelated/moq-js", + "entry": "playback/index.ts", + "main": "dist/next/moq-player.cjs.js", + "module": "dist/next/moq-player.esm.js", + "iife": "dist/iife/moq-player.umd.js", + "types": "dist/types/moq-player.d.ts", "scripts": { - "build": "tsc -b && cp ../LICENSE* ./dist && cp ./README.md ./dist && cp ./package.json ./dist", - "lint": "eslint .", + "build": "rollup -c", + "dev": "rollup -c -w", + "lint": "eslint . --ext .js,.ts,.jsx,.tsx", "fmt": "prettier --write ." }, "devDependencies": { + "@typescript-eslint/eslint-plugin": "^6.4.0", + "@typescript-eslint/parser": "^6.4.0", + "@rollup/plugin-commonjs": "^28.0.1", + "@rollup/plugin-node-resolve": "^15.3.0", + "@rollup/plugin-terser": "^0.4.4", + "@rollup/plugin-typescript": "^12.1.1", "@types/audioworklet": "^0.0.50", "@types/dom-mediacapture-transform": "^0.1.6", "@types/dom-webcodecs": "^0.1.8", "@typescript/lib-dom": "npm:@types/web@^0.0.115", - "@typescript-eslint/eslint-plugin": "^6.4.0", - "@typescript-eslint/parser": "^6.4.0", + "cross-env": "^7.0.2", "eslint": "^8.47.0", "eslint-config-prettier": "^9.0.0", "eslint-plugin-prettier": "^5.0.0", + "npm-run-all": "^4.1.5", "prettier": "^3.0.1", - "typescript": "^5.1.6" + "rollup-plugin-commonjs": "^10.1.0", + "rollup-plugin-node-resolve": "^5.2.0", + "rollup-plugin-sourcemaps": "^0.6.2", + "rollup-plugin-typescript2": "^0.27.1", + "tslib": "^1.12.0", + "typescript": "^5.7.2", + "rollup": "^4.28.0", + "rollup-plugin-base64": "^1.0.1", + "rollup-plugin-web-worker-loader": "github:htoooth/rollup-plugin-web-worker-loader" }, "dependencies": { "mp4box": "^0.5.2" + }, + "browserslist": { + "production": [ + "chrome >= 97", + "edge >= 98", + "firefox >= 130", + "opera >= 83", + "safari >= 18" + ], + "development": [ + "last 1 chrome version", + "last 1 firefox version", + "last 1 safari version" + ] } } diff --git a/lib/playback/audio.ts b/lib/playback/audio.ts index 687885a..493d660 100644 --- a/lib/playback/audio.ts +++ b/lib/playback/audio.ts @@ -1,10 +1,6 @@ -/// - import * as Message from "./worker/message" -// This is a non-standard way of importing worklet/workers. -// Unfortunately, it's the only option because of a Vite bug: https://github.com/vitejs/vite/issues/11823 -import workletURL from "./worklet/index.ts?worker&url" +import registerMyAudioWorklet from "audio-worklet:./worklet/index.ts" // NOTE: This must be on the main thread export class Audio { @@ -22,8 +18,7 @@ export class Audio { private async load(config: Message.ConfigAudio): Promise { // Load the worklet source code. - await this.context.audioWorklet.addModule(workletURL) - + await registerMyAudioWorklet(this.context) const volume = this.context.createGain() volume.gain.value = 2.0 diff --git a/lib/playback/backend.ts b/lib/playback/backend.ts index 5505958..cbf131f 100644 --- a/lib/playback/backend.ts +++ b/lib/playback/backend.ts @@ -1,9 +1,9 @@ -/// - import * as Message from "./worker/message" import { Audio } from "./audio" -import MediaWorker from "./worker?worker" +// import WebWorker from 'web-worker:./Worker.ts'; +import MediaWorker from "web-worker:./worker/index.ts" + import { RingShared } from "../common/ring" import { Root, isAudioTrack } from "../media/catalog" import { GroupHeader } from "../transport/objects" @@ -26,8 +26,7 @@ export default class Backend { constructor(config: PlayerConfig) { // TODO does this block the main thread? If so, make this async - // @ts-expect-error: The Vite typing is wrong https://github.com/vitejs/vite/blob/22bd67d70a1390daae19ca33d7de162140d533d6/packages/vite/client.d.ts#L182 - this.#worker = new MediaWorker({ format: "es" }) + this.#worker = new MediaWorker() this.#worker.addEventListener("message", this.on.bind(this)) let sampleRate: number | undefined diff --git a/lib/playback/index.ts b/lib/playback/index.ts index 5f770ce..12d0213 100644 --- a/lib/playback/index.ts +++ b/lib/playback/index.ts @@ -20,7 +20,7 @@ export interface PlayerConfig { } // This class must be created on the main thread due to AudioContext. -export class Player { +export default class Player { #backend: Backend // A periodically updated timeline diff --git a/lib/rollup.config.js b/lib/rollup.config.js new file mode 100644 index 0000000..05274b3 --- /dev/null +++ b/lib/rollup.config.js @@ -0,0 +1,31 @@ +"use strict" +const path = require("path") +const resolve = require("rollup-plugin-node-resolve") +const commonjs = require("rollup-plugin-commonjs") +const typescript = require("rollup-plugin-typescript2") +const workerLoader = require("rollup-plugin-web-worker-loader") +const sourceMaps = require("rollup-plugin-sourcemaps") +const pkg = require("./package.json") + +const config = [] + +config.push({ + input: pkg.entry, + output: { + file: pkg.iife, + format: "iife", + name: "moqplayer", + sourcemap: true, + }, + plugins: [ + resolve(), + commonjs(), + workerLoader({ preserveSource: true }), + typescript({ + typescript: require("typescript"), + }), + sourceMaps(), + ], +}) + +module.exports = config diff --git a/lib/tsconfig.json b/lib/tsconfig.json index 2ab7124..5bb37cf 100644 --- a/lib/tsconfig.json +++ b/lib/tsconfig.json @@ -1,42 +1,18 @@ { - "files": [], // don't build anything with these settings. "compilerOptions": { - "target": "es2022", - "module": "es2022", + "sourceMap": true, "moduleResolution": "node", - "rootDir": ".", + "module": "esnext", + "target": "esnext", + "lib": ["esnext", "dom"], "outDir": "./dist", - "declaration": true, "strict": true, - "composite": true, - "declarationMap": true, - "sourceMap": true, - "isolatedModules": true, - "types": [], // Don't automatically import any @types modules. - "lib": ["es2022", "dom"], - "typeRoots": ["./types", "../node_modules/@types"] + "allowJs": false, + "allowSyntheticDefaultImports": true, + "downlevelIteration": true, + "removeComments": false, + "isolatedModules": false, + "noEmit": false }, - "references": [ - { - "path": "./common" - }, - { - "path": "./playback" - }, - { - "path": "./playback/worklet" - }, - { - "path": "./contribute" - }, - { - "path": "./transport" - }, - { - "path": "./media" - } - ], - "paths": { - "@/*": ["*"] - } + "exclude": ["node_modules"] } diff --git a/lib/types/workers.d.ts b/lib/types/workers.d.ts new file mode 100644 index 0000000..4bca7cc --- /dev/null +++ b/lib/types/workers.d.ts @@ -0,0 +1,9 @@ +declare module "web-worker:*" { + const WorkerFactory: new () => Worker + export default WorkerFactory +} + +declare module "audio-worklet:*" { + const value: any + export default value +} diff --git a/package.json b/package.json index 06c43e5..0bed20c 100644 --- a/package.json +++ b/package.json @@ -4,10 +4,12 @@ "private": true, "workspaces": [ "lib", - "web" + "web", + "simple-web" ], "scripts": { - "dev": "npm run dev --workspace web", + "dev": "npm run build --workspace moq-player && cp ./lib/dist/iife/* ./simple-web/public/ && npm run dev --workspace simple-moq-web", + "dev-web": "npm run dev --workspace web", "build": "npm run build --workspaces", "lint": "npm run lint --workspaces", "fmt": "npm run fmt --workspaces" diff --git a/simple-web/index.js b/simple-web/index.js new file mode 100644 index 0000000..26c2663 --- /dev/null +++ b/simple-web/index.js @@ -0,0 +1,29 @@ +const express = require("express") +const cors = require("cors") +const path = require("path") + +const app = express() +const PORT = 3000 + +// Middleware para habilitar CORS +app.use(cors()) + +// Middleware para configurar los headers globalmente +app.use((req, res, next) => { + res.setHeader("Cross-Origin-Opener-Policy", "same-origin") + res.setHeader("Cross-Origin-Embedder-Policy", "require-corp") + next() +}) + +// Servir archivos estáticos desde la carpeta 'public' +app.use(express.static(path.join(__dirname, "public"))) + +// Ruta de ejemplo +app.get("/api", (req, res) => { + res.json({ message: "Headers configurados correctamente con CORS habilitado" }) +}) + +// Inicializar servidor +app.listen(PORT, () => { + console.log(`Servidor ejecutándose en http://localhost:${PORT}`) +}) diff --git a/simple-web/package.json b/simple-web/package.json new file mode 100644 index 0000000..516aa96 --- /dev/null +++ b/simple-web/package.json @@ -0,0 +1,17 @@ +{ + "name": "simple-moq-web", + "version": "1.0.0", + "scripts": { + "start": "node index.js", + "dev": "nodemon index.js" + }, + "license": "MIT", + "dependencies": { + "cors": "^2.8.5", + "express": "^4.21.1", + "path": "^0.12.7" + }, + "devDependencies": { + "nodemon": "^3.0.1" + } +} diff --git a/simple-web/public/index.html b/simple-web/public/index.html new file mode 100644 index 0000000..274d98b --- /dev/null +++ b/simple-web/public/index.html @@ -0,0 +1,23 @@ + + + + + + + + diff --git a/simple-web/public/moq-player.umd.js b/simple-web/public/moq-player.umd.js new file mode 100644 index 0000000..9d5c274 --- /dev/null +++ b/simple-web/public/moq-player.umd.js @@ -0,0 +1,11800 @@ +var moqplayer = (function () { + 'use strict'; + + // I hate javascript + function asError(e) { + if (e instanceof Error) { + return e; + } + else if (typeof e === "string") { + return new Error(e); + } + else { + return new Error(String(e)); + } + } + + function decode(raw) { + const decoder = new TextDecoder(); + const str = decoder.decode(raw); + const catalog = JSON.parse(str); + if (!isRoot(catalog)) { + throw new Error("invalid catalog"); + } + // Merge common track fields into each track. + for (const track of catalog.tracks) { + track.altGroup ??= catalog.commonTrackFields.altGroup; + track.namespace ??= catalog.commonTrackFields.namespace; + track.packaging ??= catalog.commonTrackFields.packaging; + track.renderGroup ??= catalog.commonTrackFields.renderGroup; + } + return catalog; + } + async function fetch$1(connection, namespace) { + const subscribe = await connection.subscribe(namespace, ".catalog"); + try { + const segment = await subscribe.data(); + if (!segment) + throw new Error("no catalog data"); + const chunk = await segment.read(); + if (!chunk) + throw new Error("no catalog chunk"); + await segment.close(); + await subscribe.close(); // we done + if (chunk.payload instanceof Uint8Array) { + return decode(chunk.payload); + } + else { + throw new Error("invalid catalog chunk"); + } + } + catch (e) { + const err = asError(e); + // Close the subscription after we're done. + await subscribe.close(1n, err.message); + throw err; + } + } + function isRoot(catalog) { + if (!isCatalogFieldValid(catalog, "packaging")) + return false; + if (!isCatalogFieldValid(catalog, "namespace")) + return false; + if (!Array.isArray(catalog.tracks)) + return false; + return catalog.tracks.every((track) => isTrack(track)); + } + function isTrack(track) { + if (typeof track.name !== "string") + return false; + return true; + } + function isVideoTrack(track) { + if (!isTrack(track)) + return false; + return isVideoSelectionParams(track.selectionParams); + } + function isVideoSelectionParams(params) { + if (typeof params.width !== "number") + return false; + if (typeof params.height !== "number") + return false; + return true; + } + function isAudioTrack(track) { + if (!isTrack(track)) + return false; + return isAudioSelectionParams(track.selectionParams); + } + function isAudioSelectionParams(params) { + if (typeof params.channelConfig !== "string") + return false; + if (typeof params.samplerate !== "number") + return false; + return true; + } + function isCatalogFieldValid(catalog, field) { + //packaging,namespace if common would be listed in commonTrackFields but if fields + //in commonTrackFields are mentiond in Tracks , the fields in Tracks precedes + function isValidPackaging(packaging) { + return packaging === "cmaf" || packaging === "loc"; + } + function isValidNamespace(namespace) { + return typeof namespace === "string"; + } + let isValidField; + if (field === "packaging") { + isValidField = isValidPackaging; + } + else if (field === "namespace") { + isValidField = isValidNamespace; + } + else { + throw new Error(`Invalid field: ${field}`); + } + if (catalog.commonTrackFields[field] !== undefined && !isValidField(catalog.commonTrackFields[field])) { + return false; + } + for (const track of catalog.tracks) { + if (track[field] !== undefined && !isValidField(track[field])) { + return false; + } + } + return true; + } + + function funcToSource(fn, sourcemapArg) { + var source = fn.toString(); + var lines = source.split('\n'); + lines.pop(); + lines.shift(); + var blankPrefixLength = lines[0].search(/\S/); + var regex = /(['"])__worker_loader_strict__(['"])/g; + for (var i = 0, n = lines.length; i < n; ++i) { + lines[i] = lines[i].substring(blankPrefixLength).replace(regex, '$1use strict$2') + '\n'; + } + return lines; + } + + function createURL$1(fn, sourcemapArg) { + var lines = funcToSource(fn); + var blob = new Blob(lines, { type: 'application/javascript' }); + return URL.createObjectURL(blob); + } + + function createInlineAudioWorkletFactory$1(fn, sourcemapArg) { + var url; + return async function AudioWorkletFactory(audioContext, options) { + url = url || createURL$1(fn); + return await audioContext.audioWorklet.addModule(url, options); + }; + } + + var kIsNodeJS = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'; + + function isNodeJS() { + return kIsNodeJS; + } + + function createInlineAudioWorkletFactory(fn, sourcemapArg) { + if (isNodeJS()) { + throw new Error('rollup-plugin-web-worker-loader does not support Audio Worklet in Node.JS'); + } + return createInlineAudioWorkletFactory$1(fn); + } + + var WorkerFactory$1 = /*#__PURE__*/createInlineAudioWorkletFactory(/* rollup-plugin-web-worker-loader */function () { + (function () { + '__worker_loader_strict__'; + + // Ring buffer with audio samples. + var STATE; + (function (STATE) { + STATE[STATE["READ_POS"] = 0] = "READ_POS"; + STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; + STATE[STATE["LENGTH"] = 2] = "LENGTH"; + })(STATE || (STATE = {})); + class Ring { + state; + channels; + capacity; + constructor(shared) { + this.state = new Int32Array(shared.state); + this.channels = []; + for (const channel of shared.channels) { + this.channels.push(new Float32Array(channel)); + } + this.capacity = shared.capacity; + } + // Write samples for single audio frame, returning the total number written. + write(frame) { + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + const startPos = writePos; + let endPos = writePos + frame.numberOfFrames; + if (endPos > readPos + this.capacity) { + endPos = readPos + this.capacity; + if (endPos <= startPos) { + // No space to write + return 0; + } + } + const startIndex = startPos % this.capacity; + const endIndex = endPos % this.capacity; + // Loop over each channel + for (let i = 0; i < this.channels.length; i += 1) { + const channel = this.channels[i]; + // If the AudioData doesn't have enough channels, duplicate it. + const planeIndex = Math.min(i, frame.numberOfChannels - 1); + if (startIndex < endIndex) { + // One continuous range to copy. + const full = channel.subarray(startIndex, endIndex); + frame.copyTo(full, { + planeIndex, + frameCount: endIndex - startIndex, + }); + } + else { + const first = channel.subarray(startIndex); + const second = channel.subarray(0, endIndex); + frame.copyTo(first, { + planeIndex, + frameCount: first.length, + }); + // We need this conditional when startIndex == 0 and endIndex == 0 + // When capacity=4410 and frameCount=1024, this was happening 52s into the audio. + if (second.length) { + frame.copyTo(second, { + planeIndex, + frameOffset: first.length, + frameCount: second.length, + }); + } + } + } + Atomics.store(this.state, STATE.WRITE_POS, endPos); + return endPos - startPos; + } + read(dst) { + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + const startPos = readPos; + let endPos = startPos + dst[0].length; + if (endPos > writePos) { + endPos = writePos; + if (endPos <= startPos) { + // Nothing to read + return 0; + } + } + const startIndex = startPos % this.capacity; + const endIndex = endPos % this.capacity; + // Loop over each channel + for (let i = 0; i < dst.length; i += 1) { + if (i >= this.channels.length) ; + const input = this.channels[i]; + const output = dst[i]; + if (startIndex < endIndex) { + const full = input.subarray(startIndex, endIndex); + output.set(full); + } + else { + const first = input.subarray(startIndex); + const second = input.subarray(0, endIndex); + output.set(first); + output.set(second, first.length); + } + } + Atomics.store(this.state, STATE.READ_POS, endPos); + return endPos - startPos; + } + clear() { + const pos = Atomics.load(this.state, STATE.WRITE_POS); + Atomics.store(this.state, STATE.READ_POS, pos); + } + size() { + // TODO is this thread safe? + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + return writePos - readPos; + } + } + + // TODO add support for @/ to avoid relative imports + class Renderer extends AudioWorkletProcessor { + ring; + base; + constructor() { + // The super constructor call is required. + super(); + this.base = 0; + this.port.onmessage = this.onMessage.bind(this); + } + onMessage(e) { + const msg = e.data; + if (msg.config) { + this.onConfig(msg.config); + } + } + onConfig(config) { + this.ring = new Ring(config.ring); + } + // Inputs and outputs in groups of 128 samples. + process(inputs, outputs, _parameters) { + if (!this.ring) { + // Paused + return true; + } + if (inputs.length != 1 && outputs.length != 1) { + throw new Error("only a single track is supported"); + } + if (this.ring.size() == this.ring.capacity) { + // This is a hack to clear any latency in the ring buffer. + // The proper solution is to play back slightly faster? + console.warn("resyncing ring buffer"); + this.ring.clear(); + return true; + } + const output = outputs[0]; + const size = this.ring.read(output); + if (size < output.length) ; + return true; + } + } + registerProcessor("renderer", Renderer); + + })(); + + }); + /* eslint-enable */ + + // NOTE: This must be on the main thread + class Audio { + context; + worklet; + constructor(config) { + this.context = new AudioContext({ + latencyHint: "interactive", + sampleRate: config.sampleRate, + }); + this.worklet = this.load(config); + } + async load(config) { + // Load the worklet source code. + await WorkerFactory$1(this.context); + const volume = this.context.createGain(); + volume.gain.value = 2.0; + // Create the worklet + const worklet = new AudioWorkletNode(this.context, "renderer"); + worklet.port.addEventListener("message", this.on.bind(this)); + worklet.onprocessorerror = (e) => { + console.error("Audio worklet error:", e); + }; + // Connect the worklet to the volume node and then to the speakers + worklet.connect(volume); + volume.connect(this.context.destination); + worklet.port.postMessage({ config }); + return worklet; + } + on(_event) { + // TODO + } + } + + var WorkerClass = null; + + try { + var WorkerThreads = + typeof module !== 'undefined' && typeof module.require === 'function' && module.require('worker_threads') || + typeof __non_webpack_require__ === 'function' && __non_webpack_require__('worker_threads') || + typeof require === 'function' && require('worker_threads'); + WorkerClass = WorkerThreads.Worker; + } catch(e) {} // eslint-disable-line + + function createInlineWorkerFactory$2(fn, sourcemapArg) { + var lines = funcToSource(fn); + var concat = lines.join('\n'); + return function WorkerFactory(options) { + return new WorkerClass(concat, Object.assign({}, options, { eval: true })); + }; + } + + function createURL(fn, sourcemapArg) { + var lines = funcToSource(fn); + var blob = new Blob(lines, { type: 'application/javascript' }); + return URL.createObjectURL(blob); + } + + function createInlineWorkerFactory$1(fn, sourcemapArg) { + var url; + return function WorkerFactory(options) { + url = url || createURL(fn); + return new Worker(url, options); + }; + } + + function createInlineWorkerFactory(fn, sourcemapArg) { + if (isNodeJS()) { + return createInlineWorkerFactory$2(fn); + } + return createInlineWorkerFactory$1(fn); + } + + var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-worker-loader */function () { + (function () { + '__worker_loader_strict__'; + + class Timeline { + // Maintain audio and video seprarately + audio; + video; + // Construct a timeline + constructor() { + this.audio = new Component(); + this.video = new Component(); + } + } + class Component { + #current; + frames; + #segments; + constructor() { + this.frames = new ReadableStream({ + pull: this.#pull.bind(this), + cancel: this.#cancel.bind(this), + }); + // This is a hack to have an async channel with 100 items. + this.#segments = new TransformStream({}, { highWaterMark: 100 }); + } + get segments() { + return this.#segments.writable; + } + async #pull(controller) { + for (;;) { + // Get the next segment to render. + const segments = this.#segments.readable.getReader(); + let res; + if (this.#current) { + // Get the next frame to render. + const frames = this.#current.frames.getReader(); + // Wait for either the frames or segments to be ready. + // NOTE: This assume that the first promise gets priority. + res = await Promise.race([frames.read(), segments.read()]); + frames.releaseLock(); + } + else { + res = await segments.read(); + } + segments.releaseLock(); + const { value, done } = res; + if (done) { + // We assume the current segment has been closed + // TODO support the segments stream closing + this.#current = undefined; + continue; + } + if (!isSegment(value)) { + // Return so the reader can decide when to get the next frame. + controller.enqueue(value); + return; + } + // We didn't get any frames, and instead got a new segment. + if (this.#current) { + if (value.sequence < this.#current.sequence) { + // Our segment is older than the current, abandon it. + await value.frames.cancel("skipping segment; too old"); + continue; + } + else { + // Our segment is newer than the current, cancel the old one. + await this.#current.frames.cancel("skipping segment; too slow"); + } + } + this.#current = value; + } + } + async #cancel(reason) { + if (this.#current) { + await this.#current.frames.cancel(reason); + } + const segments = this.#segments.readable.getReader(); + for (;;) { + const { value: segment, done } = await segments.read(); + if (done) + break; + await segment.frames.cancel(reason); + } + } + } + // Return if a type is a segment or frame + // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents + function isSegment(value) { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + return value.frames !== undefined; + } + + // Ring buffer with audio samples. + var STATE; + (function (STATE) { + STATE[STATE["READ_POS"] = 0] = "READ_POS"; + STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; + STATE[STATE["LENGTH"] = 2] = "LENGTH"; + })(STATE || (STATE = {})); + class Ring { + state; + channels; + capacity; + constructor(shared) { + this.state = new Int32Array(shared.state); + this.channels = []; + for (const channel of shared.channels) { + this.channels.push(new Float32Array(channel)); + } + this.capacity = shared.capacity; + } + // Write samples for single audio frame, returning the total number written. + write(frame) { + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + const startPos = writePos; + let endPos = writePos + frame.numberOfFrames; + if (endPos > readPos + this.capacity) { + endPos = readPos + this.capacity; + if (endPos <= startPos) { + // No space to write + return 0; + } + } + const startIndex = startPos % this.capacity; + const endIndex = endPos % this.capacity; + // Loop over each channel + for (let i = 0; i < this.channels.length; i += 1) { + const channel = this.channels[i]; + // If the AudioData doesn't have enough channels, duplicate it. + const planeIndex = Math.min(i, frame.numberOfChannels - 1); + if (startIndex < endIndex) { + // One continuous range to copy. + const full = channel.subarray(startIndex, endIndex); + frame.copyTo(full, { + planeIndex, + frameCount: endIndex - startIndex, + }); + } + else { + const first = channel.subarray(startIndex); + const second = channel.subarray(0, endIndex); + frame.copyTo(first, { + planeIndex, + frameCount: first.length, + }); + // We need this conditional when startIndex == 0 and endIndex == 0 + // When capacity=4410 and frameCount=1024, this was happening 52s into the audio. + if (second.length) { + frame.copyTo(second, { + planeIndex, + frameOffset: first.length, + frameCount: second.length, + }); + } + } + } + Atomics.store(this.state, STATE.WRITE_POS, endPos); + return endPos - startPos; + } + read(dst) { + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + const startPos = readPos; + let endPos = startPos + dst[0].length; + if (endPos > writePos) { + endPos = writePos; + if (endPos <= startPos) { + // Nothing to read + return 0; + } + } + const startIndex = startPos % this.capacity; + const endIndex = endPos % this.capacity; + // Loop over each channel + for (let i = 0; i < dst.length; i += 1) { + if (i >= this.channels.length) ; + const input = this.channels[i]; + const output = dst[i]; + if (startIndex < endIndex) { + const full = input.subarray(startIndex, endIndex); + output.set(full); + } + else { + const first = input.subarray(startIndex); + const second = input.subarray(0, endIndex); + output.set(first); + output.set(second, first.length); + } + } + Atomics.store(this.state, STATE.READ_POS, endPos); + return endPos - startPos; + } + clear() { + const pos = Atomics.load(this.state, STATE.WRITE_POS); + Atomics.store(this.state, STATE.READ_POS, pos); + } + size() { + // TODO is this thread safe? + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + return writePos - readPos; + } + } + + function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; + } + + var mp4box_all = createCommonjsModule(function (module, exports) { + // file:src/log.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var Log = (function (){ + var start = new Date(); + var LOG_LEVEL_ERROR = 4; + var LOG_LEVEL_WARNING = 3; + var LOG_LEVEL_INFO = 2; + var LOG_LEVEL_DEBUG = 1; + var log_level = LOG_LEVEL_ERROR; + var logObject = { + setLogLevel : function(level) { + if (level == this.debug) log_level = LOG_LEVEL_DEBUG; + else if (level == this.info) log_level = LOG_LEVEL_INFO; + else if (level == this.warn) log_level = LOG_LEVEL_WARNING; + else if (level == this.error) log_level = LOG_LEVEL_ERROR; + else log_level = LOG_LEVEL_ERROR; + }, + debug : function(module, msg) { + if (console.debug === undefined) { + console.debug = console.log; + } + if (LOG_LEVEL_DEBUG >= log_level) { + console.debug("["+Log.getDurationString(new Date()-start,1000)+"]","["+module+"]",msg); + } + }, + log : function(module, msg) { + this.debug(module.msg); + }, + info : function(module, msg) { + if (LOG_LEVEL_INFO >= log_level) { + console.info("["+Log.getDurationString(new Date()-start,1000)+"]","["+module+"]",msg); + } + }, + warn : function(module, msg) { + if (LOG_LEVEL_WARNING >= log_level) { + console.warn("["+Log.getDurationString(new Date()-start,1000)+"]","["+module+"]",msg); + } + }, + error : function(module, msg) { + if (LOG_LEVEL_ERROR >= log_level) { + console.error("["+Log.getDurationString(new Date()-start,1000)+"]","["+module+"]",msg); + } + } + }; + return logObject; + })(); + + /* Helper function to print a duration value in the form H:MM:SS.MS */ + Log.getDurationString = function(duration, _timescale) { + var neg; + /* Helper function to print a number on a fixed number of digits */ + function pad(number, length) { + var str = '' + number; + var a = str.split('.'); + while (a[0].length < length) { + a[0] = '0' + a[0]; + } + return a.join('.'); + } + if (duration < 0) { + neg = true; + duration = -duration; + } else { + neg = false; + } + var timescale = _timescale || 1; + var duration_sec = duration/timescale; + var hours = Math.floor(duration_sec/3600); + duration_sec -= hours * 3600; + var minutes = Math.floor(duration_sec/60); + duration_sec -= minutes * 60; + var msec = duration_sec*1000; + duration_sec = Math.floor(duration_sec); + msec -= duration_sec*1000; + msec = Math.floor(msec); + return (neg ? "-": "")+hours+":"+pad(minutes,2)+":"+pad(duration_sec,2)+"."+pad(msec,3); + }; + + /* Helper function to stringify HTML5 TimeRanges objects */ + Log.printRanges = function(ranges) { + var length = ranges.length; + if (length > 0) { + var str = ""; + for (var i = 0; i < length; i++) { + if (i > 0) str += ","; + str += "["+Log.getDurationString(ranges.start(i))+ ","+Log.getDurationString(ranges.end(i))+"]"; + } + return str; + } else { + return "(empty)"; + } + }; + + { + exports.Log = Log; + } + // file:src/stream.js + var MP4BoxStream = function(arrayBuffer) { + if (arrayBuffer instanceof ArrayBuffer) { + this.buffer = arrayBuffer; + this.dataview = new DataView(arrayBuffer); + } else { + throw ("Needs an array buffer"); + } + this.position = 0; + }; + + /************************************************************************* + Common API between MultiBufferStream and SimpleStream + *************************************************************************/ + MP4BoxStream.prototype.getPosition = function() { + return this.position; + }; + + MP4BoxStream.prototype.getEndPosition = function() { + return this.buffer.byteLength; + }; + + MP4BoxStream.prototype.getLength = function() { + return this.buffer.byteLength; + }; + + MP4BoxStream.prototype.seek = function (pos) { + var npos = Math.max(0, Math.min(this.buffer.byteLength, pos)); + this.position = (isNaN(npos) || !isFinite(npos)) ? 0 : npos; + return true; + }; + + MP4BoxStream.prototype.isEos = function () { + return this.getPosition() >= this.getEndPosition(); + }; + + /************************************************************************* + Read methods, simimar to DataStream but simpler + *************************************************************************/ + MP4BoxStream.prototype.readAnyInt = function(size, signed) { + var res = 0; + if (this.position + size <= this.buffer.byteLength) { + switch (size) { + case 1: + if (signed) { + res = this.dataview.getInt8(this.position); + } else { + res = this.dataview.getUint8(this.position); + } + break; + case 2: + if (signed) { + res = this.dataview.getInt16(this.position); + } else { + res = this.dataview.getUint16(this.position); + } + break; + case 3: + if (signed) { + throw ("No method for reading signed 24 bits values"); + } else { + res = this.dataview.getUint8(this.position) << 16; + res |= this.dataview.getUint8(this.position+1) << 8; + res |= this.dataview.getUint8(this.position+2); + } + break; + case 4: + if (signed) { + res = this.dataview.getInt32(this.position); + } else { + res = this.dataview.getUint32(this.position); + } + break; + case 8: + if (signed) { + throw ("No method for reading signed 64 bits values"); + } else { + res = this.dataview.getUint32(this.position) << 32; + res |= this.dataview.getUint32(this.position+4); + } + break; + default: + throw ("readInt method not implemented for size: "+size); + } + this.position+= size; + return res; + } else { + throw ("Not enough bytes in buffer"); + } + }; + + MP4BoxStream.prototype.readUint8 = function() { + return this.readAnyInt(1, false); + }; + + MP4BoxStream.prototype.readUint16 = function() { + return this.readAnyInt(2, false); + }; + + MP4BoxStream.prototype.readUint24 = function() { + return this.readAnyInt(3, false); + }; + + MP4BoxStream.prototype.readUint32 = function() { + return this.readAnyInt(4, false); + }; + + MP4BoxStream.prototype.readUint64 = function() { + return this.readAnyInt(8, false); + }; + + MP4BoxStream.prototype.readString = function(length) { + if (this.position + length <= this.buffer.byteLength) { + var s = ""; + for (var i = 0; i < length; i++) { + s += String.fromCharCode(this.readUint8()); + } + return s; + } else { + throw ("Not enough bytes in buffer"); + } + }; + + MP4BoxStream.prototype.readCString = function() { + var arr = []; + while(true) { + var b = this.readUint8(); + if (b !== 0) { + arr.push(b); + } else { + break; + } + } + return String.fromCharCode.apply(null, arr); + }; + + MP4BoxStream.prototype.readInt8 = function() { + return this.readAnyInt(1, true); + }; + + MP4BoxStream.prototype.readInt16 = function() { + return this.readAnyInt(2, true); + }; + + MP4BoxStream.prototype.readInt32 = function() { + return this.readAnyInt(4, true); + }; + + MP4BoxStream.prototype.readInt64 = function() { + return this.readAnyInt(8, false); + }; + + MP4BoxStream.prototype.readUint8Array = function(length) { + var arr = new Uint8Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readUint8(); + } + return arr; + }; + + MP4BoxStream.prototype.readInt16Array = function(length) { + var arr = new Int16Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readInt16(); + } + return arr; + }; + + MP4BoxStream.prototype.readUint16Array = function(length) { + var arr = new Int16Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readUint16(); + } + return arr; + }; + + MP4BoxStream.prototype.readUint32Array = function(length) { + var arr = new Uint32Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readUint32(); + } + return arr; + }; + + MP4BoxStream.prototype.readInt32Array = function(length) { + var arr = new Int32Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readInt32(); + } + return arr; + }; + + { + exports.MP4BoxStream = MP4BoxStream; + }// file:src/DataStream.js + /** + DataStream reads scalars, arrays and structs of data from an ArrayBuffer. + It's like a file-like DataView on steroids. + + @param {ArrayBuffer} arrayBuffer ArrayBuffer to read from. + @param {?Number} byteOffset Offset from arrayBuffer beginning for the DataStream. + @param {?Boolean} endianness DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN (the default). + */ + var DataStream = function(arrayBuffer, byteOffset, endianness) { + this._byteOffset = byteOffset || 0; + if (arrayBuffer instanceof ArrayBuffer) { + this.buffer = arrayBuffer; + } else if (typeof arrayBuffer == "object") { + this.dataView = arrayBuffer; + if (byteOffset) { + this._byteOffset += byteOffset; + } + } else { + this.buffer = new ArrayBuffer(arrayBuffer || 0); + } + this.position = 0; + this.endianness = endianness == null ? DataStream.LITTLE_ENDIAN : endianness; + }; + DataStream.prototype = {}; + + DataStream.prototype.getPosition = function() { + return this.position; + }; + + /** + Internal function to resize the DataStream buffer when required. + @param {number} extra Number of bytes to add to the buffer allocation. + @return {null} + */ + DataStream.prototype._realloc = function(extra) { + if (!this._dynamicSize) { + return; + } + var req = this._byteOffset + this.position + extra; + var blen = this._buffer.byteLength; + if (req <= blen) { + if (req > this._byteLength) { + this._byteLength = req; + } + return; + } + if (blen < 1) { + blen = 1; + } + while (req > blen) { + blen *= 2; + } + var buf = new ArrayBuffer(blen); + var src = new Uint8Array(this._buffer); + var dst = new Uint8Array(buf, 0, src.length); + dst.set(src); + this.buffer = buf; + this._byteLength = req; + }; + + /** + Internal function to trim the DataStream buffer when required. + Used for stripping out the extra bytes from the backing buffer when + the virtual byteLength is smaller than the buffer byteLength (happens after + growing the buffer with writes and not filling the extra space completely). + + @return {null} + */ + DataStream.prototype._trimAlloc = function() { + if (this._byteLength == this._buffer.byteLength) { + return; + } + var buf = new ArrayBuffer(this._byteLength); + var dst = new Uint8Array(buf); + var src = new Uint8Array(this._buffer, 0, dst.length); + dst.set(src); + this.buffer = buf; + }; + + + /** + Big-endian const to use as default endianness. + @type {boolean} + */ + DataStream.BIG_ENDIAN = false; + + /** + Little-endian const to use as default endianness. + @type {boolean} + */ + DataStream.LITTLE_ENDIAN = true; + + /** + Virtual byte length of the DataStream backing buffer. + Updated to be max of original buffer size and last written size. + If dynamicSize is false is set to buffer size. + @type {number} + */ + DataStream.prototype._byteLength = 0; + + /** + Returns the byte length of the DataStream object. + @type {number} + */ + Object.defineProperty(DataStream.prototype, 'byteLength', + { get: function() { + return this._byteLength - this._byteOffset; + }}); + + /** + Set/get the backing ArrayBuffer of the DataStream object. + The setter updates the DataView to point to the new buffer. + @type {Object} + */ + Object.defineProperty(DataStream.prototype, 'buffer', + { get: function() { + this._trimAlloc(); + return this._buffer; + }, + set: function(v) { + this._buffer = v; + this._dataView = new DataView(this._buffer, this._byteOffset); + this._byteLength = this._buffer.byteLength; + } }); + + /** + Set/get the byteOffset of the DataStream object. + The setter updates the DataView to point to the new byteOffset. + @type {number} + */ + Object.defineProperty(DataStream.prototype, 'byteOffset', + { get: function() { + return this._byteOffset; + }, + set: function(v) { + this._byteOffset = v; + this._dataView = new DataView(this._buffer, this._byteOffset); + this._byteLength = this._buffer.byteLength; + } }); + + /** + Set/get the backing DataView of the DataStream object. + The setter updates the buffer and byteOffset to point to the DataView values. + @type {Object} + */ + Object.defineProperty(DataStream.prototype, 'dataView', + { get: function() { + return this._dataView; + }, + set: function(v) { + this._byteOffset = v.byteOffset; + this._buffer = v.buffer; + this._dataView = new DataView(this._buffer, this._byteOffset); + this._byteLength = this._byteOffset + v.byteLength; + } }); + + /** + Sets the DataStream read/write position to given position. + Clamps between 0 and DataStream length. + + @param {number} pos Position to seek to. + @return {null} + */ + DataStream.prototype.seek = function(pos) { + var npos = Math.max(0, Math.min(this.byteLength, pos)); + this.position = (isNaN(npos) || !isFinite(npos)) ? 0 : npos; + }; + + /** + Returns true if the DataStream seek pointer is at the end of buffer and + there's no more data to read. + + @return {boolean} True if the seek pointer is at the end of the buffer. + */ + DataStream.prototype.isEof = function() { + return (this.position >= this._byteLength); + }; + + + /** + Maps a Uint8Array into the DataStream buffer. + + Nice for quickly reading in data. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Uint8Array to the DataStream backing buffer. + */ + DataStream.prototype.mapUint8Array = function(length) { + this._realloc(length * 1); + var arr = new Uint8Array(this._buffer, this.byteOffset+this.position, length); + this.position += length * 1; + return arr; + }; + + + /** + Reads an Int32Array of desired length and endianness from the DataStream. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Int32Array. + */ + DataStream.prototype.readInt32Array = function(length, e) { + length = length == null ? (this.byteLength-this.position / 4) : length; + var arr = new Int32Array(length); + DataStream.memcpy(arr.buffer, 0, + this.buffer, this.byteOffset+this.position, + length*arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads an Int16Array of desired length and endianness from the DataStream. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Int16Array. + */ + DataStream.prototype.readInt16Array = function(length, e) { + length = length == null ? (this.byteLength-this.position / 2) : length; + var arr = new Int16Array(length); + DataStream.memcpy(arr.buffer, 0, + this.buffer, this.byteOffset+this.position, + length*arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads an Int8Array of desired length from the DataStream. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Int8Array. + */ + DataStream.prototype.readInt8Array = function(length) { + length = length == null ? (this.byteLength-this.position) : length; + var arr = new Int8Array(length); + DataStream.memcpy(arr.buffer, 0, + this.buffer, this.byteOffset+this.position, + length*arr.BYTES_PER_ELEMENT); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Uint32Array of desired length and endianness from the DataStream. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Uint32Array. + */ + DataStream.prototype.readUint32Array = function(length, e) { + length = length == null ? (this.byteLength-this.position / 4) : length; + var arr = new Uint32Array(length); + DataStream.memcpy(arr.buffer, 0, + this.buffer, this.byteOffset+this.position, + length*arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Uint16Array of desired length and endianness from the DataStream. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Uint16Array. + */ + DataStream.prototype.readUint16Array = function(length, e) { + length = length == null ? (this.byteLength-this.position / 2) : length; + var arr = new Uint16Array(length); + DataStream.memcpy(arr.buffer, 0, + this.buffer, this.byteOffset+this.position, + length*arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Uint8Array of desired length from the DataStream. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Uint8Array. + */ + DataStream.prototype.readUint8Array = function(length) { + length = length == null ? (this.byteLength-this.position) : length; + var arr = new Uint8Array(length); + DataStream.memcpy(arr.buffer, 0, + this.buffer, this.byteOffset+this.position, + length*arr.BYTES_PER_ELEMENT); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Float64Array of desired length and endianness from the DataStream. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Float64Array. + */ + DataStream.prototype.readFloat64Array = function(length, e) { + length = length == null ? (this.byteLength-this.position / 8) : length; + var arr = new Float64Array(length); + DataStream.memcpy(arr.buffer, 0, + this.buffer, this.byteOffset+this.position, + length*arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Float32Array of desired length and endianness from the DataStream. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Float32Array. + */ + DataStream.prototype.readFloat32Array = function(length, e) { + length = length == null ? (this.byteLength-this.position / 4) : length; + var arr = new Float32Array(length); + DataStream.memcpy(arr.buffer, 0, + this.buffer, this.byteOffset+this.position, + length*arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + + /** + Reads a 32-bit int from the DataStream with the desired endianness. + + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readInt32 = function(e) { + var v = this._dataView.getInt32(this.position, e == null ? this.endianness : e); + this.position += 4; + return v; + }; + + /** + Reads a 16-bit int from the DataStream with the desired endianness. + + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readInt16 = function(e) { + var v = this._dataView.getInt16(this.position, e == null ? this.endianness : e); + this.position += 2; + return v; + }; + + /** + Reads an 8-bit int from the DataStream. + + @return {number} The read number. + */ + DataStream.prototype.readInt8 = function() { + var v = this._dataView.getInt8(this.position); + this.position += 1; + return v; + }; + + /** + Reads a 32-bit unsigned int from the DataStream with the desired endianness. + + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readUint32 = function(e) { + var v = this._dataView.getUint32(this.position, e == null ? this.endianness : e); + this.position += 4; + return v; + }; + + /** + Reads a 16-bit unsigned int from the DataStream with the desired endianness. + + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readUint16 = function(e) { + var v = this._dataView.getUint16(this.position, e == null ? this.endianness : e); + this.position += 2; + return v; + }; + + /** + Reads an 8-bit unsigned int from the DataStream. + + @return {number} The read number. + */ + DataStream.prototype.readUint8 = function() { + var v = this._dataView.getUint8(this.position); + this.position += 1; + return v; + }; + + /** + Reads a 32-bit float from the DataStream with the desired endianness. + + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readFloat32 = function(e) { + var v = this._dataView.getFloat32(this.position, e == null ? this.endianness : e); + this.position += 4; + return v; + }; + + /** + Reads a 64-bit float from the DataStream with the desired endianness. + + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readFloat64 = function(e) { + var v = this._dataView.getFloat64(this.position, e == null ? this.endianness : e); + this.position += 8; + return v; + }; + + /** + Native endianness. Either DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN + depending on the platform endianness. + + @type {boolean} + */ + DataStream.endianness = new Int8Array(new Int16Array([1]).buffer)[0] > 0; + + /** + Copies byteLength bytes from the src buffer at srcOffset to the + dst buffer at dstOffset. + + @param {Object} dst Destination ArrayBuffer to write to. + @param {number} dstOffset Offset to the destination ArrayBuffer. + @param {Object} src Source ArrayBuffer to read from. + @param {number} srcOffset Offset to the source ArrayBuffer. + @param {number} byteLength Number of bytes to copy. + */ + DataStream.memcpy = function(dst, dstOffset, src, srcOffset, byteLength) { + var dstU8 = new Uint8Array(dst, dstOffset, byteLength); + var srcU8 = new Uint8Array(src, srcOffset, byteLength); + dstU8.set(srcU8); + }; + + /** + Converts array to native endianness in-place. + + @param {Object} array Typed array to convert. + @param {boolean} arrayIsLittleEndian True if the data in the array is + little-endian. Set false for big-endian. + @return {Object} The converted typed array. + */ + DataStream.arrayToNative = function(array, arrayIsLittleEndian) { + if (arrayIsLittleEndian == this.endianness) { + return array; + } else { + return this.flipArrayEndianness(array); + } + }; + + /** + Converts native endianness array to desired endianness in-place. + + @param {Object} array Typed array to convert. + @param {boolean} littleEndian True if the converted array should be + little-endian. Set false for big-endian. + @return {Object} The converted typed array. + */ + DataStream.nativeToEndian = function(array, littleEndian) { + if (this.endianness == littleEndian) { + return array; + } else { + return this.flipArrayEndianness(array); + } + }; + + /** + Flips typed array endianness in-place. + + @param {Object} array Typed array to flip. + @return {Object} The converted typed array. + */ + DataStream.flipArrayEndianness = function(array) { + var u8 = new Uint8Array(array.buffer, array.byteOffset, array.byteLength); + for (var i=0; ik; j--, k++) { + var tmp = u8[k]; + u8[k] = u8[j]; + u8[j] = tmp; + } + } + return array; + }; + + /** + Seek position where DataStream#readStruct ran into a problem. + Useful for debugging struct parsing. + + @type {number} + */ + DataStream.prototype.failurePosition = 0; + + String.fromCharCodeUint8 = function(uint8arr) { + var arr = []; + for (var i = 0; i < uint8arr.length; i++) { + arr[i] = uint8arr[i]; + } + return String.fromCharCode.apply(null, arr); + }; + /** + Read a string of desired length and encoding from the DataStream. + + @param {number} length The length of the string to read in bytes. + @param {?string} encoding The encoding of the string data in the DataStream. + Defaults to ASCII. + @return {string} The read string. + */ + DataStream.prototype.readString = function(length, encoding) { + if (encoding == null || encoding == "ASCII") { + return String.fromCharCodeUint8.apply(null, [this.mapUint8Array(length == null ? this.byteLength-this.position : length)]); + } else { + return (new TextDecoder(encoding)).decode(this.mapUint8Array(length)); + } + }; + + /** + Read null-terminated string of desired length from the DataStream. Truncates + the returned string so that the null byte is not a part of it. + + @param {?number} length The length of the string to read. + @return {string} The read string. + */ + DataStream.prototype.readCString = function(length) { + var blen = this.byteLength-this.position; + var u8 = new Uint8Array(this._buffer, this._byteOffset + this.position); + var len = blen; + if (length != null) { + len = Math.min(length, blen); + } + for (var i = 0; i < len && u8[i] !== 0; i++); // find first zero byte + var s = String.fromCharCodeUint8.apply(null, [this.mapUint8Array(i)]); + if (length != null) { + this.position += len-i; + } else if (i != blen) { + this.position += 1; // trailing zero if not at end of buffer + } + return s; + }; + + /* + TODO: fix endianness for 24/64-bit fields + TODO: check range/support for 64-bits numbers in JavaScript + */ + var MAX_SIZE = Math.pow(2, 32); + + DataStream.prototype.readInt64 = function () { + return (this.readInt32()*MAX_SIZE)+this.readUint32(); + }; + DataStream.prototype.readUint64 = function () { + return (this.readUint32()*MAX_SIZE)+this.readUint32(); + }; + + DataStream.prototype.readInt64 = function () { + return (this.readUint32()*MAX_SIZE)+this.readUint32(); + }; + + DataStream.prototype.readUint24 = function () { + return (this.readUint8()<<16)+(this.readUint8()<<8)+this.readUint8(); + }; + + { + exports.DataStream = DataStream; + } + // file:src/DataStream-write.js + /** + Saves the DataStream contents to the given filename. + Uses Chrome's anchor download property to initiate download. + + @param {string} filename Filename to save as. + @return {null} + */ + DataStream.prototype.save = function(filename) { + var blob = new Blob([this.buffer]); + if (window.URL && URL.createObjectURL) { + var url = window.URL.createObjectURL(blob); + var a = document.createElement('a'); + // Required in Firefox: + document.body.appendChild(a); + a.setAttribute('href', url); + a.setAttribute('download', filename); + // Required in Firefox: + a.setAttribute('target', '_self'); + a.click(); + window.URL.revokeObjectURL(url); + } else { + throw("DataStream.save: Can't create object URL."); + } + }; + + /** + Whether to extend DataStream buffer when trying to write beyond its size. + If set, the buffer is reallocated to twice its current size until the + requested write fits the buffer. + @type {boolean} + */ + DataStream.prototype._dynamicSize = true; + Object.defineProperty(DataStream.prototype, 'dynamicSize', + { get: function() { + return this._dynamicSize; + }, + set: function(v) { + if (!v) { + this._trimAlloc(); + } + this._dynamicSize = v; + } }); + + /** + Internal function to trim the DataStream buffer when required. + Used for stripping out the first bytes when not needed anymore. + + @return {null} + */ + DataStream.prototype.shift = function(offset) { + var buf = new ArrayBuffer(this._byteLength-offset); + var dst = new Uint8Array(buf); + var src = new Uint8Array(this._buffer, offset, dst.length); + dst.set(src); + this.buffer = buf; + this.position -= offset; + }; + + /** + Writes an Int32Array of specified endianness to the DataStream. + + @param {Object} arr The array to write. + @param {?boolean} e Endianness of the data to write. + */ + DataStream.prototype.writeInt32Array = function(arr, e) { + this._realloc(arr.length * 4); + if (arr instanceof Int32Array && + this.byteOffset+this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset+this.position, + arr.buffer, 0, + arr.byteLength); + this.mapInt32Array(arr.length, e); + } else { + for (var i=0; i>16); + this.writeUint8((v & 0x0000FF00)>>8); + this.writeUint8((v & 0x000000FF)); + }; + + DataStream.prototype.adjustUint32 = function(position, value) { + var pos = this.position; + this.seek(position); + this.writeUint32(value); + this.seek(pos); + }; + // file:src/DataStream-map.js + /** + Maps an Int32Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Int32Array to the DataStream backing buffer. + */ + DataStream.prototype.mapInt32Array = function(length, e) { + this._realloc(length * 4); + var arr = new Int32Array(this._buffer, this.byteOffset+this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 4; + return arr; + }; + + /** + Maps an Int16Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Int16Array to the DataStream backing buffer. + */ + DataStream.prototype.mapInt16Array = function(length, e) { + this._realloc(length * 2); + var arr = new Int16Array(this._buffer, this.byteOffset+this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 2; + return arr; + }; + + /** + Maps an Int8Array into the DataStream buffer. + + Nice for quickly reading in data. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Int8Array to the DataStream backing buffer. + */ + DataStream.prototype.mapInt8Array = function(length) { + this._realloc(length * 1); + var arr = new Int8Array(this._buffer, this.byteOffset+this.position, length); + this.position += length * 1; + return arr; + }; + + /** + Maps a Uint32Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Uint32Array to the DataStream backing buffer. + */ + DataStream.prototype.mapUint32Array = function(length, e) { + this._realloc(length * 4); + var arr = new Uint32Array(this._buffer, this.byteOffset+this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 4; + return arr; + }; + + /** + Maps a Uint16Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Uint16Array to the DataStream backing buffer. + */ + DataStream.prototype.mapUint16Array = function(length, e) { + this._realloc(length * 2); + var arr = new Uint16Array(this._buffer, this.byteOffset+this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 2; + return arr; + }; + + /** + Maps a Float64Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Float64Array to the DataStream backing buffer. + */ + DataStream.prototype.mapFloat64Array = function(length, e) { + this._realloc(length * 8); + var arr = new Float64Array(this._buffer, this.byteOffset+this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 8; + return arr; + }; + + /** + Maps a Float32Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Float32Array to the DataStream backing buffer. + */ + DataStream.prototype.mapFloat32Array = function(length, e) { + this._realloc(length * 4); + var arr = new Float32Array(this._buffer, this.byteOffset+this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 4; + return arr; + }; + // file:src/buffer.js + /** + * MultiBufferStream is a class that acts as a SimpleStream for parsing + * It holds several, possibly non-contiguous ArrayBuffer objects, each with a fileStart property + * containing the offset for the buffer data in an original/virtual file + * + * It inherits also from DataStream for all read/write/alloc operations + */ + + /** + * Constructor + */ + var MultiBufferStream = function(buffer) { + /* List of ArrayBuffers, with a fileStart property, sorted in fileStart order and non overlapping */ + this.buffers = []; + this.bufferIndex = -1; + if (buffer) { + this.insertBuffer(buffer); + this.bufferIndex = 0; + } + }; + MultiBufferStream.prototype = new DataStream(new ArrayBuffer(), 0, DataStream.BIG_ENDIAN); + + /************************************************************************************ + Methods for the managnement of the buffers (insertion, removal, concatenation, ...) + ***********************************************************************************/ + + MultiBufferStream.prototype.initialized = function() { + var firstBuffer; + if (this.bufferIndex > -1) { + return true; + } else if (this.buffers.length > 0) { + firstBuffer = this.buffers[0]; + if (firstBuffer.fileStart === 0) { + this.buffer = firstBuffer; + this.bufferIndex = 0; + Log.debug("MultiBufferStream", "Stream ready for parsing"); + return true; + } else { + Log.warn("MultiBufferStream", "The first buffer should have a fileStart of 0"); + this.logBufferLevel(); + return false; + } + } else { + Log.warn("MultiBufferStream", "No buffer to start parsing from"); + this.logBufferLevel(); + return false; + } + }; + + /** + * helper functions to concatenate two ArrayBuffer objects + * @param {ArrayBuffer} buffer1 + * @param {ArrayBuffer} buffer2 + * @return {ArrayBuffer} the concatenation of buffer1 and buffer2 in that order + */ + ArrayBuffer.concat = function(buffer1, buffer2) { + Log.debug("ArrayBuffer", "Trying to create a new buffer of size: "+(buffer1.byteLength + buffer2.byteLength)); + var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength); + tmp.set(new Uint8Array(buffer1), 0); + tmp.set(new Uint8Array(buffer2), buffer1.byteLength); + return tmp.buffer; + }; + + /** + * Reduces the size of a given buffer, but taking the part between offset and offset+newlength + * @param {ArrayBuffer} buffer + * @param {Number} offset the start of new buffer + * @param {Number} newLength the length of the new buffer + * @return {ArrayBuffer} the new buffer + */ + MultiBufferStream.prototype.reduceBuffer = function(buffer, offset, newLength) { + var smallB; + smallB = new Uint8Array(newLength); + smallB.set(new Uint8Array(buffer, offset, newLength)); + smallB.buffer.fileStart = buffer.fileStart+offset; + smallB.buffer.usedBytes = 0; + return smallB.buffer; + }; + + /** + * Inserts the new buffer in the sorted list of buffers, + * making sure, it is not overlapping with existing ones (possibly reducing its size). + * if the new buffer overrides/replaces the 0-th buffer (for instance because it is bigger), + * updates the DataStream buffer for parsing + */ + MultiBufferStream.prototype.insertBuffer = function(ab) { + var to_add = true; + /* TODO: improve insertion if many buffers */ + for (var i = 0; i < this.buffers.length; i++) { + var b = this.buffers[i]; + if (ab.fileStart <= b.fileStart) { + /* the insertion position is found */ + if (ab.fileStart === b.fileStart) { + /* The new buffer overlaps with an existing buffer */ + if (ab.byteLength > b.byteLength) { + /* the new buffer is bigger than the existing one + remove the existing buffer and try again to insert + the new buffer to check overlap with the next ones */ + this.buffers.splice(i, 1); + i--; + continue; + } else { + /* the new buffer is smaller than the existing one, just drop it */ + Log.warn("MultiBufferStream", "Buffer (fileStart: "+ab.fileStart+" - Length: "+ab.byteLength+") already appended, ignoring"); + } + } else { + /* The beginning of the new buffer is not overlapping with an existing buffer + let's check the end of it */ + if (ab.fileStart + ab.byteLength <= b.fileStart) ; else { + /* There is some overlap, cut the new buffer short, and add it*/ + ab = this.reduceBuffer(ab, 0, b.fileStart - ab.fileStart); + } + Log.debug("MultiBufferStream", "Appending new buffer (fileStart: "+ab.fileStart+" - Length: "+ab.byteLength+")"); + this.buffers.splice(i, 0, ab); + /* if this new buffer is inserted in the first place in the list of the buffer, + and the DataStream is initialized, make it the buffer used for parsing */ + if (i === 0) { + this.buffer = ab; + } + } + to_add = false; + break; + } else if (ab.fileStart < b.fileStart + b.byteLength) { + /* the new buffer overlaps its beginning with the end of the current buffer */ + var offset = b.fileStart + b.byteLength - ab.fileStart; + var newLength = ab.byteLength - offset; + if (newLength > 0) { + /* the new buffer is bigger than the current overlap, drop the overlapping part and try again inserting the remaining buffer */ + ab = this.reduceBuffer(ab, offset, newLength); + } else { + /* the content of the new buffer is entirely contained in the existing buffer, drop it entirely */ + to_add = false; + break; + } + } + } + /* if the buffer has not been added, we can add it at the end */ + if (to_add) { + Log.debug("MultiBufferStream", "Appending new buffer (fileStart: "+ab.fileStart+" - Length: "+ab.byteLength+")"); + this.buffers.push(ab); + /* if this new buffer is inserted in the first place in the list of the buffer, + and the DataStream is initialized, make it the buffer used for parsing */ + if (i === 0) { + this.buffer = ab; + } + } + }; + + /** + * Displays the status of the buffers (number and used bytes) + * @param {Object} info callback method for display + */ + MultiBufferStream.prototype.logBufferLevel = function(info) { + var i; + var buffer; + var used, total; + var ranges = []; + var range; + var bufferedString = ""; + used = 0; + total = 0; + for (i = 0; i < this.buffers.length; i++) { + buffer = this.buffers[i]; + if (i === 0) { + range = {}; + ranges.push(range); + range.start = buffer.fileStart; + range.end = buffer.fileStart+buffer.byteLength; + bufferedString += "["+range.start+"-"; + } else if (range.end === buffer.fileStart) { + range.end = buffer.fileStart+buffer.byteLength; + } else { + range = {}; + range.start = buffer.fileStart; + bufferedString += (ranges[ranges.length-1].end-1)+"], ["+range.start+"-"; + range.end = buffer.fileStart+buffer.byteLength; + ranges.push(range); + } + used += buffer.usedBytes; + total += buffer.byteLength; + } + if (ranges.length > 0) { + bufferedString += (range.end-1)+"]"; + } + var log = (info ? Log.info : Log.debug); + if (this.buffers.length === 0) { + log("MultiBufferStream", "No more buffer in memory"); + } else { + log("MultiBufferStream", ""+this.buffers.length+" stored buffer(s) ("+used+"/"+total+" bytes), continuous ranges: "+bufferedString); + } + }; + + MultiBufferStream.prototype.cleanBuffers = function () { + var i; + var buffer; + for (i = 0; i < this.buffers.length; i++) { + buffer = this.buffers[i]; + if (buffer.usedBytes === buffer.byteLength) { + Log.debug("MultiBufferStream", "Removing buffer #"+i); + this.buffers.splice(i, 1); + i--; + } + } + }; + + MultiBufferStream.prototype.mergeNextBuffer = function() { + var next_buffer; + if (this.bufferIndex+1 < this.buffers.length) { + next_buffer = this.buffers[this.bufferIndex+1]; + if (next_buffer.fileStart === this.buffer.fileStart + this.buffer.byteLength) { + var oldLength = this.buffer.byteLength; + var oldUsedBytes = this.buffer.usedBytes; + var oldFileStart = this.buffer.fileStart; + this.buffers[this.bufferIndex] = ArrayBuffer.concat(this.buffer, next_buffer); + this.buffer = this.buffers[this.bufferIndex]; + this.buffers.splice(this.bufferIndex+1, 1); + this.buffer.usedBytes = oldUsedBytes; /* TODO: should it be += ? */ + this.buffer.fileStart = oldFileStart; + Log.debug("ISOFile", "Concatenating buffer for box parsing (length: "+oldLength+"->"+this.buffer.byteLength+")"); + return true; + } else { + return false; + } + } else { + return false; + } + }; + + + /************************************************************************* + Seek-related functions + *************************************************************************/ + + /** + * Finds the buffer that holds the given file position + * @param {Boolean} fromStart indicates if the search should start from the current buffer (false) + * or from the first buffer (true) + * @param {Number} filePosition position in the file to seek to + * @param {Boolean} markAsUsed indicates if the bytes in between the current position and the seek position + * should be marked as used for garbage collection + * @return {Number} the index of the buffer holding the seeked file position, -1 if not found. + */ + MultiBufferStream.prototype.findPosition = function(fromStart, filePosition, markAsUsed) { + var i; + var abuffer = null; + var index = -1; + + /* find the buffer with the largest position smaller than the given position */ + if (fromStart === true) { + /* the reposition can be in the past, we need to check from the beginning of the list of buffers */ + i = 0; + } else { + i = this.bufferIndex; + } + + while (i < this.buffers.length) { + abuffer = this.buffers[i]; + if (abuffer.fileStart <= filePosition) { + index = i; + if (markAsUsed) { + if (abuffer.fileStart + abuffer.byteLength <= filePosition) { + abuffer.usedBytes = abuffer.byteLength; + } else { + abuffer.usedBytes = filePosition - abuffer.fileStart; + } + this.logBufferLevel(); + } + } else { + break; + } + i++; + } + + if (index !== -1) { + abuffer = this.buffers[index]; + if (abuffer.fileStart + abuffer.byteLength >= filePosition) { + Log.debug("MultiBufferStream", "Found position in existing buffer #"+index); + return index; + } else { + return -1; + } + } else { + return -1; + } + }; + + /** + * Finds the largest file position contained in a buffer or in the next buffers if they are contiguous (no gap) + * starting from the given buffer index or from the current buffer if the index is not given + * + * @param {Number} inputindex Index of the buffer to start from + * @return {Number} The largest file position found in the buffers + */ + MultiBufferStream.prototype.findEndContiguousBuf = function(inputindex) { + var i; + var currentBuf; + var nextBuf; + var index = (inputindex !== undefined ? inputindex : this.bufferIndex); + currentBuf = this.buffers[index]; + /* find the end of the contiguous range of data */ + if (this.buffers.length > index+1) { + for (i = index+1; i < this.buffers.length; i++) { + nextBuf = this.buffers[i]; + if (nextBuf.fileStart === currentBuf.fileStart + currentBuf.byteLength) { + currentBuf = nextBuf; + } else { + break; + } + } + } + /* return the position of last byte in the file that we have */ + return currentBuf.fileStart + currentBuf.byteLength; + }; + + /** + * Returns the largest file position contained in the buffers, larger than the given position + * @param {Number} pos the file position to start from + * @return {Number} the largest position in the current buffer or in the buffer and the next contiguous + * buffer that holds the given position + */ + MultiBufferStream.prototype.getEndFilePositionAfter = function(pos) { + var index = this.findPosition(true, pos, false); + if (index !== -1) { + return this.findEndContiguousBuf(index); + } else { + return pos; + } + }; + + /************************************************************************* + Garbage collection related functions + *************************************************************************/ + + /** + * Marks a given number of bytes as used in the current buffer for garbage collection + * @param {Number} nbBytes + */ + MultiBufferStream.prototype.addUsedBytes = function(nbBytes) { + this.buffer.usedBytes += nbBytes; + this.logBufferLevel(); + }; + + /** + * Marks the entire current buffer as used, ready for garbage collection + */ + MultiBufferStream.prototype.setAllUsedBytes = function() { + this.buffer.usedBytes = this.buffer.byteLength; + this.logBufferLevel(); + }; + + /************************************************************************* + Common API between MultiBufferStream and SimpleStream + *************************************************************************/ + + /** + * Tries to seek to a given file position + * if possible, repositions the parsing from there and returns true + * if not possible, does not change anything and returns false + * @param {Number} filePosition position in the file to seek to + * @param {Boolean} fromStart indicates if the search should start from the current buffer (false) + * or from the first buffer (true) + * @param {Boolean} markAsUsed indicates if the bytes in between the current position and the seek position + * should be marked as used for garbage collection + * @return {Boolean} true if the seek succeeded, false otherwise + */ + MultiBufferStream.prototype.seek = function(filePosition, fromStart, markAsUsed) { + var index; + index = this.findPosition(fromStart, filePosition, markAsUsed); + if (index !== -1) { + this.buffer = this.buffers[index]; + this.bufferIndex = index; + this.position = filePosition - this.buffer.fileStart; + Log.debug("MultiBufferStream", "Repositioning parser at buffer position: "+this.position); + return true; + } else { + Log.debug("MultiBufferStream", "Position "+filePosition+" not found in buffered data"); + return false; + } + }; + + /** + * Returns the current position in the file + * @return {Number} the position in the file + */ + MultiBufferStream.prototype.getPosition = function() { + if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null) { + throw "Error accessing position in the MultiBufferStream"; + } + return this.buffers[this.bufferIndex].fileStart+this.position; + }; + + /** + * Returns the length of the current buffer + * @return {Number} the length of the current buffer + */ + MultiBufferStream.prototype.getLength = function() { + return this.byteLength; + }; + + MultiBufferStream.prototype.getEndPosition = function() { + if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null) { + throw "Error accessing position in the MultiBufferStream"; + } + return this.buffers[this.bufferIndex].fileStart+this.byteLength; + }; + + { + exports.MultiBufferStream = MultiBufferStream; + }// file:src/descriptor.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var MPEG4DescriptorParser = function () { + var ES_DescrTag = 0x03; + var DecoderConfigDescrTag = 0x04; + var DecSpecificInfoTag = 0x05; + var SLConfigDescrTag = 0x06; + + var descTagToName = []; + descTagToName[ES_DescrTag] = "ES_Descriptor"; + descTagToName[DecoderConfigDescrTag] = "DecoderConfigDescriptor"; + descTagToName[DecSpecificInfoTag] = "DecoderSpecificInfo"; + descTagToName[SLConfigDescrTag] = "SLConfigDescriptor"; + + this.getDescriptorName = function(tag) { + return descTagToName[tag]; + }; + + var that = this; + var classes = {}; + + this.parseOneDescriptor = function (stream) { + var size = 0; + var tag; + var desc; + var byteRead; + tag = stream.readUint8(); + byteRead = stream.readUint8(); + while (byteRead & 0x80) { + size = (size << 7) + (byteRead & 0x7F); + byteRead = stream.readUint8(); + } + size = (size << 7) + (byteRead & 0x7F); + Log.debug("MPEG4DescriptorParser", "Found "+(descTagToName[tag] || "Descriptor "+tag)+", size "+size+" at position "+stream.getPosition()); + if (descTagToName[tag]) { + desc = new classes[descTagToName[tag]](size); + } else { + desc = new classes.Descriptor(size); + } + desc.parse(stream); + return desc; + }; + + classes.Descriptor = function(_tag, _size) { + this.tag = _tag; + this.size = _size; + this.descs = []; + }; + + classes.Descriptor.prototype.parse = function (stream) { + this.data = stream.readUint8Array(this.size); + }; + + classes.Descriptor.prototype.findDescriptor = function (tag) { + for (var i = 0; i < this.descs.length; i++) { + if (this.descs[i].tag == tag) { + return this.descs[i]; + } + } + return null; + }; + + classes.Descriptor.prototype.parseRemainingDescriptors = function (stream) { + var start = stream.position; + while (stream.position < start+this.size) { + var desc = that.parseOneDescriptor(stream); + this.descs.push(desc); + } + }; + + classes.ES_Descriptor = function (size) { + classes.Descriptor.call(this, ES_DescrTag, size); + }; + + classes.ES_Descriptor.prototype = new classes.Descriptor(); + + classes.ES_Descriptor.prototype.parse = function(stream) { + this.ES_ID = stream.readUint16(); + this.flags = stream.readUint8(); + this.size -= 3; + if (this.flags & 0x80) { + this.dependsOn_ES_ID = stream.readUint16(); + this.size -= 2; + } else { + this.dependsOn_ES_ID = 0; + } + if (this.flags & 0x40) { + var l = stream.readUint8(); + this.URL = stream.readString(l); + this.size -= l+1; + } else { + this.URL = ""; + } + if (this.flags & 0x20) { + this.OCR_ES_ID = stream.readUint16(); + this.size -= 2; + } else { + this.OCR_ES_ID = 0; + } + this.parseRemainingDescriptors(stream); + }; + + classes.ES_Descriptor.prototype.getOTI = function(stream) { + var dcd = this.findDescriptor(DecoderConfigDescrTag); + if (dcd) { + return dcd.oti; + } else { + return 0; + } + }; + + classes.ES_Descriptor.prototype.getAudioConfig = function(stream) { + var dcd = this.findDescriptor(DecoderConfigDescrTag); + if (!dcd) return null; + var dsi = dcd.findDescriptor(DecSpecificInfoTag); + if (dsi && dsi.data) { + var audioObjectType = (dsi.data[0]& 0xF8) >> 3; + if (audioObjectType === 31 && dsi.data.length >= 2) { + audioObjectType = 32 + ((dsi.data[0] & 0x7) << 3) + ((dsi.data[1] & 0xE0) >> 5); + } + return audioObjectType; + } else { + return null; + } + }; + + classes.DecoderConfigDescriptor = function (size) { + classes.Descriptor.call(this, DecoderConfigDescrTag, size); + }; + classes.DecoderConfigDescriptor.prototype = new classes.Descriptor(); + + classes.DecoderConfigDescriptor.prototype.parse = function(stream) { + this.oti = stream.readUint8(); + this.streamType = stream.readUint8(); + this.upStream = ((this.streamType >> 1) & 1) !== 0; + this.streamType = this.streamType >>> 2; + this.bufferSize = stream.readUint24(); + this.maxBitrate = stream.readUint32(); + this.avgBitrate = stream.readUint32(); + this.size -= 13; + this.parseRemainingDescriptors(stream); + }; + + classes.DecoderSpecificInfo = function (size) { + classes.Descriptor.call(this, DecSpecificInfoTag, size); + }; + classes.DecoderSpecificInfo.prototype = new classes.Descriptor(); + + classes.SLConfigDescriptor = function (size) { + classes.Descriptor.call(this, SLConfigDescrTag, size); + }; + classes.SLConfigDescriptor.prototype = new classes.Descriptor(); + + return this; + }; + + { + exports.MPEG4DescriptorParser = MPEG4DescriptorParser; + } + // file:src/box.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var BoxParser = { + ERR_INVALID_DATA : -1, + ERR_NOT_ENOUGH_DATA : 0, + OK : 1, + + // Boxes to be created with default parsing + BASIC_BOXES: [ "mdat", "idat", "free", "skip", "meco", "strk" ], + FULL_BOXES: [ "hmhd", "nmhd", "iods", "xml ", "bxml", "ipro", "mere" ], + CONTAINER_BOXES: [ + [ "moov", [ "trak", "pssh" ] ], + [ "trak" ], + [ "edts" ], + [ "mdia" ], + [ "minf" ], + [ "dinf" ], + [ "stbl", [ "sgpd", "sbgp" ] ], + [ "mvex", [ "trex" ] ], + [ "moof", [ "traf" ] ], + [ "traf", [ "trun", "sgpd", "sbgp" ] ], + [ "vttc" ], + [ "tref" ], + [ "iref" ], + [ "mfra", [ "tfra" ] ], + [ "meco" ], + [ "hnti" ], + [ "hinf" ], + [ "strk" ], + [ "strd" ], + [ "sinf" ], + [ "rinf" ], + [ "schi" ], + [ "trgr" ], + [ "udta", ["kind"] ], + [ "iprp", ["ipma"] ], + [ "ipco" ], + [ "grpl" ], + [ "j2kH" ], + [ "etyp", [ "tyco"] ] + ], + // Boxes effectively created + boxCodes : [], + fullBoxCodes : [], + containerBoxCodes : [], + sampleEntryCodes : {}, + sampleGroupEntryCodes: [], + trackGroupTypes: [], + UUIDBoxes: {}, + UUIDs: [], + initialize: function() { + BoxParser.FullBox.prototype = new BoxParser.Box(); + BoxParser.ContainerBox.prototype = new BoxParser.Box(); + BoxParser.SampleEntry.prototype = new BoxParser.Box(); + BoxParser.TrackGroupTypeBox.prototype = new BoxParser.FullBox(); + + /* creating constructors for simple boxes */ + BoxParser.BASIC_BOXES.forEach(function(type) { + BoxParser.createBoxCtor(type); + }); + BoxParser.FULL_BOXES.forEach(function(type) { + BoxParser.createFullBoxCtor(type); + }); + BoxParser.CONTAINER_BOXES.forEach(function(types) { + BoxParser.createContainerBoxCtor(types[0], null, types[1]); + }); + }, + Box: function(_type, _size, _uuid) { + this.type = _type; + this.size = _size; + this.uuid = _uuid; + }, + FullBox: function(type, size, uuid) { + BoxParser.Box.call(this, type, size, uuid); + this.flags = 0; + this.version = 0; + }, + ContainerBox: function(type, size, uuid) { + BoxParser.Box.call(this, type, size, uuid); + this.boxes = []; + }, + SampleEntry: function(type, size, hdr_size, start) { + BoxParser.ContainerBox.call(this, type, size); + this.hdr_size = hdr_size; + this.start = start; + }, + SampleGroupEntry: function(type) { + this.grouping_type = type; + }, + TrackGroupTypeBox: function(type, size) { + BoxParser.FullBox.call(this, type, size); + }, + createBoxCtor: function(type, parseMethod){ + BoxParser.boxCodes.push(type); + BoxParser[type+"Box"] = function(size) { + BoxParser.Box.call(this, type, size); + }; + BoxParser[type+"Box"].prototype = new BoxParser.Box(); + if (parseMethod) BoxParser[type+"Box"].prototype.parse = parseMethod; + }, + createFullBoxCtor: function(type, parseMethod) { + //BoxParser.fullBoxCodes.push(type); + BoxParser[type+"Box"] = function(size) { + BoxParser.FullBox.call(this, type, size); + }; + BoxParser[type+"Box"].prototype = new BoxParser.FullBox(); + BoxParser[type+"Box"].prototype.parse = function(stream) { + this.parseFullHeader(stream); + if (parseMethod) { + parseMethod.call(this, stream); + } + }; + }, + addSubBoxArrays: function(subBoxNames) { + if (subBoxNames) { + this.subBoxNames = subBoxNames; + var nbSubBoxes = subBoxNames.length; + for (var k = 0; k parentSize) { + Log.error("BoxParser", "Box of type '"+type+"' has a size "+size+" greater than its container size "+parentSize); + return { code: BoxParser.ERR_NOT_ENOUGH_DATA, type: type, size: size, hdr_size: hdr_size, start: start }; + } + if (size !== 0 && start + size > stream.getEndPosition()) { + stream.seek(start); + Log.info("BoxParser", "Not enough data in stream to parse the entire '"+type+"' box"); + return { code: BoxParser.ERR_NOT_ENOUGH_DATA, type: type, size: size, hdr_size: hdr_size, start: start }; + } + if (headerOnly) { + return { code: BoxParser.OK, type: type, size: size, hdr_size: hdr_size, start: start }; + } else { + if (BoxParser[type+"Box"]) { + box = new BoxParser[type+"Box"](size); + } else { + if (type !== "uuid") { + Log.warn("BoxParser", "Unknown box type: '"+type+"'"); + box = new BoxParser.Box(type, size); + box.has_unparsed_data = true; + } else { + if (BoxParser.UUIDBoxes[uuid]) { + box = new BoxParser.UUIDBoxes[uuid](size); + } else { + Log.warn("BoxParser", "Unknown uuid type: '"+uuid+"'"); + box = new BoxParser.Box(type, size); + box.uuid = uuid; + box.has_unparsed_data = true; + } + } + } + } + box.hdr_size = hdr_size; + /* recording the position of the box in the input stream */ + box.start = start; + if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { + Log.info("BoxParser", "'"+box_type+"' box writing not yet implemented, keeping unparsed data in memory for later write"); + box.parseDataAndRewind(stream); + } + box.parse(stream); + diff = stream.getPosition() - (box.start+box.size); + if (diff < 0) { + Log.warn("BoxParser", "Parsing of box '"+box_type+"' did not read the entire indicated box data size (missing "+(-diff)+" bytes), seeking forward"); + stream.seek(box.start+box.size); + } else if (diff > 0) { + Log.error("BoxParser", "Parsing of box '"+box_type+"' read "+diff+" more bytes than the indicated box data size, seeking backwards"); + if (box.size !== 0) stream.seek(box.start+box.size); + } + return { code: BoxParser.OK, box: box, size: box.size }; + }; + + BoxParser.Box.prototype.parse = function(stream) { + if (this.type != "mdat") { + this.data = stream.readUint8Array(this.size-this.hdr_size); + } else { + if (this.size === 0) { + stream.seek(stream.getEndPosition()); + } else { + stream.seek(this.start+this.size); + } + } + }; + + /* Used to parse a box without consuming its data, to allow detailled parsing + Useful for boxes for which a write method is not yet implemented */ + BoxParser.Box.prototype.parseDataAndRewind = function(stream) { + this.data = stream.readUint8Array(this.size-this.hdr_size); + // rewinding + stream.position -= this.size-this.hdr_size; + }; + + BoxParser.FullBox.prototype.parseDataAndRewind = function(stream) { + this.parseFullHeader(stream); + this.data = stream.readUint8Array(this.size-this.hdr_size); + // restore the header size as if the full header had not been parsed + this.hdr_size -= 4; + // rewinding + stream.position -= this.size-this.hdr_size; + }; + + BoxParser.FullBox.prototype.parseFullHeader = function (stream) { + this.version = stream.readUint8(); + this.flags = stream.readUint24(); + this.hdr_size += 4; + }; + + BoxParser.FullBox.prototype.parse = function (stream) { + this.parseFullHeader(stream); + this.data = stream.readUint8Array(this.size-this.hdr_size); + }; + + BoxParser.ContainerBox.prototype.parse = function(stream) { + var ret; + var box; + while (stream.getPosition() < this.start+this.size) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = ret.box; + /* store the box in the 'boxes' array to preserve box order (for offset) but also store box in a property for more direct access */ + this.boxes.push(box); + if (this.subBoxNames && this.subBoxNames.indexOf(box.type) != -1) { + this[this.subBoxNames[this.subBoxNames.indexOf(box.type)]+"s"].push(box); + } else { + var box_type = box.type !== "uuid" ? box.type : box.uuid; + if (this[box_type]) { + Log.warn("Box of type "+box_type+" already stored in field of this type"); + } else { + this[box_type] = box; + } + } + } else { + return; + } + } + }; + + BoxParser.Box.prototype.parseLanguage = function(stream) { + this.language = stream.readUint16(); + var chars = []; + chars[0] = (this.language>>10)&0x1F; + chars[1] = (this.language>>5)&0x1F; + chars[2] = (this.language)&0x1F; + this.languageString = String.fromCharCode(chars[0]+0x60, chars[1]+0x60, chars[2]+0x60); + }; + + // file:src/parsing/sampleentries/sampleentry.js + BoxParser.SAMPLE_ENTRY_TYPE_VISUAL = "Visual"; + BoxParser.SAMPLE_ENTRY_TYPE_AUDIO = "Audio"; + BoxParser.SAMPLE_ENTRY_TYPE_HINT = "Hint"; + BoxParser.SAMPLE_ENTRY_TYPE_METADATA = "Metadata"; + BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE = "Subtitle"; + BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM = "System"; + BoxParser.SAMPLE_ENTRY_TYPE_TEXT = "Text"; + + BoxParser.SampleEntry.prototype.parseHeader = function(stream) { + stream.readUint8Array(6); + this.data_reference_index = stream.readUint16(); + this.hdr_size += 8; + }; + + BoxParser.SampleEntry.prototype.parse = function(stream) { + this.parseHeader(stream); + this.data = stream.readUint8Array(this.size - this.hdr_size); + }; + + BoxParser.SampleEntry.prototype.parseDataAndRewind = function(stream) { + this.parseHeader(stream); + this.data = stream.readUint8Array(this.size - this.hdr_size); + // restore the header size as if the sample entry header had not been parsed + this.hdr_size -= 8; + // rewinding + stream.position -= this.size-this.hdr_size; + }; + + BoxParser.SampleEntry.prototype.parseFooter = function(stream) { + BoxParser.ContainerBox.prototype.parse.call(this, stream); + }; + + // Base SampleEntry types with default parsing + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_HINT); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_TEXT); + + //Base SampleEntry types for Audio and Video with specific parsing + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, function(stream) { + var compressorname_length; + this.parseHeader(stream); + stream.readUint16(); + stream.readUint16(); + stream.readUint32Array(3); + this.width = stream.readUint16(); + this.height = stream.readUint16(); + this.horizresolution = stream.readUint32(); + this.vertresolution = stream.readUint32(); + stream.readUint32(); + this.frame_count = stream.readUint16(); + compressorname_length = Math.min(31, stream.readUint8()); + this.compressorname = stream.readString(compressorname_length); + if (compressorname_length < 31) { + stream.readString(31 - compressorname_length); + } + this.depth = stream.readUint16(); + stream.readUint16(); + this.parseFooter(stream); + }); + + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, function(stream) { + this.parseHeader(stream); + stream.readUint32Array(2); + this.channel_count = stream.readUint16(); + this.samplesize = stream.readUint16(); + stream.readUint16(); + stream.readUint16(); + this.samplerate = (stream.readUint32()/(1<<16)); + this.parseFooter(stream); + }); + + // Sample entries inheriting from Audio and Video + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc2"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc3"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc4"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "av01"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dav1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hvc1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hev1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hvt1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "lhe1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dvh1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dvhe"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvc1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvi1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvs1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvcN"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vp08"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vp09"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avs3"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "j2ki"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "mjp2"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "mjpg"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "uncv"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mp4a"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ac-3"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ac-4"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ec-3"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "Opus"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mha1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mha2"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mhm1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mhm2"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "fLaC"); + + // Encrypted sample entries + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "encv"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "enca"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "encu"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM, "encs"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_TEXT, "enct"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "encm"); + // file:src/parsing/a1lx.js + BoxParser.createBoxCtor("a1lx", function(stream) { + var large_size = stream.readUint8() & 1; + var FieldLength = ((large_size & 1) + 1) * 16; + this.layer_size = []; + for (var i = 0; i < 3; i++) { + if (FieldLength == 16) { + this.layer_size[i] = stream.readUint16(); + } else { + this.layer_size[i] = stream.readUint32(); + } + } + });// file:src/parsing/a1op.js + BoxParser.createBoxCtor("a1op", function(stream) { + this.op_index = stream.readUint8(); + });// file:src/parsing/auxC.js + BoxParser.createFullBoxCtor("auxC", function(stream) { + this.aux_type = stream.readCString(); + var aux_subtype_length = this.size - this.hdr_size - (this.aux_type.length + 1); + this.aux_subtype = stream.readUint8Array(aux_subtype_length); + });// file:src/parsing/av1C.js + BoxParser.createBoxCtor("av1C", function(stream) { + var tmp = stream.readUint8(); + if ((tmp >> 7) & 0x1 !== 1) { + Log.error("av1C marker problem"); + return; + } + this.version = tmp & 0x7F; + if (this.version !== 1) { + Log.error("av1C version "+this.version+" not supported"); + return; + } + tmp = stream.readUint8(); + this.seq_profile = (tmp >> 5) & 0x7; + this.seq_level_idx_0 = tmp & 0x1F; + tmp = stream.readUint8(); + this.seq_tier_0 = (tmp >> 7) & 0x1; + this.high_bitdepth = (tmp >> 6) & 0x1; + this.twelve_bit = (tmp >> 5) & 0x1; + this.monochrome = (tmp >> 4) & 0x1; + this.chroma_subsampling_x = (tmp >> 3) & 0x1; + this.chroma_subsampling_y = (tmp >> 2) & 0x1; + this.chroma_sample_position = (tmp & 0x3); + tmp = stream.readUint8(); + this.reserved_1 = (tmp >> 5) & 0x7; + if (this.reserved_1 !== 0) { + Log.error("av1C reserved_1 parsing problem"); + return; + } + this.initial_presentation_delay_present = (tmp >> 4) & 0x1; + if (this.initial_presentation_delay_present === 1) { + this.initial_presentation_delay_minus_one = (tmp & 0xF); + } else { + this.reserved_2 = (tmp & 0xF); + if (this.reserved_2 !== 0) { + Log.error("av1C reserved_2 parsing problem"); + return; + } + } + + var configOBUs_length = this.size - this.hdr_size - 4; + this.configOBUs = stream.readUint8Array(configOBUs_length); + }); + + // file:src/parsing/avcC.js + BoxParser.createBoxCtor("avcC", function(stream) { + var i; + var toparse; + this.configurationVersion = stream.readUint8(); + this.AVCProfileIndication = stream.readUint8(); + this.profile_compatibility = stream.readUint8(); + this.AVCLevelIndication = stream.readUint8(); + this.lengthSizeMinusOne = (stream.readUint8() & 0x3); + this.nb_SPS_nalus = (stream.readUint8() & 0x1F); + toparse = this.size - this.hdr_size - 6; + this.SPS = []; + for (i = 0; i < this.nb_SPS_nalus; i++) { + this.SPS[i] = {}; + this.SPS[i].length = stream.readUint16(); + this.SPS[i].nalu = stream.readUint8Array(this.SPS[i].length); + toparse -= 2+this.SPS[i].length; + } + this.nb_PPS_nalus = stream.readUint8(); + toparse--; + this.PPS = []; + for (i = 0; i < this.nb_PPS_nalus; i++) { + this.PPS[i] = {}; + this.PPS[i].length = stream.readUint16(); + this.PPS[i].nalu = stream.readUint8Array(this.PPS[i].length); + toparse -= 2+this.PPS[i].length; + } + if (toparse>0) { + this.ext = stream.readUint8Array(toparse); + } + }); + + // file:src/parsing/btrt.js + BoxParser.createBoxCtor("btrt", function(stream) { + this.bufferSizeDB = stream.readUint32(); + this.maxBitrate = stream.readUint32(); + this.avgBitrate = stream.readUint32(); + }); + + // file:src/parsing/ccst.js + BoxParser.createFullBoxCtor("ccst", function(stream) { + var flags = stream.readUint8(); + this.all_ref_pics_intra = ((flags & 0x80) == 0x80); + this.intra_pred_used = ((flags & 0x40) == 0x40); + this.max_ref_per_pic = ((flags & 0x3f) >> 2); + stream.readUint24(); + }); + + // file:src/parsing/cdef.js + BoxParser.createBoxCtor("cdef", function(stream) { + var i; + this.channel_count = stream.readUint16(); + this.channel_indexes = []; + this.channel_types = []; + this.channel_associations = []; + for (i = 0; i < this.channel_count; i++) { + this.channel_indexes.push(stream.readUint16()); + this.channel_types.push(stream.readUint16()); + this.channel_associations.push(stream.readUint16()); + } + }); + + // file:src/parsing/clap.js + BoxParser.createBoxCtor("clap", function(stream) { + this.cleanApertureWidthN = stream.readUint32(); + this.cleanApertureWidthD = stream.readUint32(); + this.cleanApertureHeightN = stream.readUint32(); + this.cleanApertureHeightD = stream.readUint32(); + this.horizOffN = stream.readUint32(); + this.horizOffD = stream.readUint32(); + this.vertOffN = stream.readUint32(); + this.vertOffD = stream.readUint32(); + });// file:src/parsing/clli.js + BoxParser.createBoxCtor("clli", function(stream) { + this.max_content_light_level = stream.readUint16(); + this.max_pic_average_light_level = stream.readUint16(); + }); + + // file:src/parsing/cmex.js + BoxParser.createFullBoxCtor("cmex", function(stream) { + if (this.flags & 0x1) { + this.pos_x = stream.readInt32(); + } + if (this.flags & 0x2) { + this.pos_y = stream.readInt32(); + } + if (this.flags & 0x4) { + this.pos_z = stream.readInt32(); + } + if (this.flags & 0x8) { + if (this.version == 0) { + if (this.flags & 0x10) { + this.quat_x = stream.readInt32(); + this.quat_y = stream.readInt32(); + this.quat_z = stream.readInt32(); + } else { + this.quat_x = stream.readInt16(); + this.quat_y = stream.readInt16(); + this.quat_z = stream.readInt16(); + } + } else if (this.version == 1) ; + } + if (this.flags & 0x20) { + this.id = stream.readUint32(); + } + }); + // file:src/parsing/cmin.js + BoxParser.createFullBoxCtor("cmin", function(stream) { + this.focal_length_x = stream.readInt32(); + this.principal_point_x = stream.readInt32(); + this.principal_point_y = stream.readInt32(); + if (this.flags & 0x1) { + this.focal_length_y = stream.readInt32(); + this.skew_factor = stream.readInt32(); + } + });// file:src/parsing/cmpd.js + BoxParser.createBoxCtor("cmpd", function(stream) { + this.component_count = stream.readUint32(); + this.component_types = []; + this.component_type_urls = []; + for (i = 0; i < this.component_count; i++) { + var component_type = stream.readUint16(); + this.component_types.push(component_type); + if (component_type >= 0x8000) { + this.component_type_urls.push(stream.readCString()); + } + } + });// file:src/parsing/co64.js + BoxParser.createFullBoxCtor("co64", function(stream) { + var entry_count; + var i; + entry_count = stream.readUint32(); + this.chunk_offsets = []; + if (this.version === 0) { + for(i=0; i> 7; + } else if (this.colour_type === 'rICC') { + this.ICC_profile = stream.readUint8Array(this.size - 4); + } else if (this.colour_type === 'prof') { + this.ICC_profile = stream.readUint8Array(this.size - 4); + } + });// file:src/parsing/cprt.js + BoxParser.createFullBoxCtor("cprt", function (stream) { + this.parseLanguage(stream); + this.notice = stream.readCString(); + }); + + // file:src/parsing/cslg.js + BoxParser.createFullBoxCtor("cslg", function(stream) { + if (this.version === 0) { + this.compositionToDTSShift = stream.readInt32(); /* signed */ + this.leastDecodeToDisplayDelta = stream.readInt32(); /* signed */ + this.greatestDecodeToDisplayDelta = stream.readInt32(); /* signed */ + this.compositionStartTime = stream.readInt32(); /* signed */ + this.compositionEndTime = stream.readInt32(); /* signed */ + } + }); + + // file:src/parsing/ctts.js + BoxParser.createFullBoxCtor("ctts", function(stream) { + var entry_count; + var i; + entry_count = stream.readUint32(); + this.sample_counts = []; + this.sample_offsets = []; + if (this.version === 0) { + for(i=0; i> 6; + this.bsid = ((tmp_byte1 >> 1) & 0x1F); + this.bsmod = ((tmp_byte1 & 0x1) << 2) | ((tmp_byte2 >> 6) & 0x3); + this.acmod = ((tmp_byte2 >> 3) & 0x7); + this.lfeon = ((tmp_byte2 >> 2) & 0x1); + this.bit_rate_code = (tmp_byte2 & 0x3) | ((tmp_byte3 >> 5) & 0x7); + }); + + // file:src/parsing/dec3.js + BoxParser.createBoxCtor("dec3", function(stream) { + var tmp_16 = stream.readUint16(); + this.data_rate = tmp_16 >> 3; + this.num_ind_sub = tmp_16 & 0x7; + this.ind_subs = []; + for (var i = 0; i < this.num_ind_sub+1; i++) { + var ind_sub = {}; + this.ind_subs.push(ind_sub); + var tmp_byte1 = stream.readUint8(); + var tmp_byte2 = stream.readUint8(); + var tmp_byte3 = stream.readUint8(); + ind_sub.fscod = tmp_byte1 >> 6; + ind_sub.bsid = ((tmp_byte1 >> 1) & 0x1F); + ind_sub.bsmod = ((tmp_byte1 & 0x1) << 4) | ((tmp_byte2 >> 4) & 0xF); + ind_sub.acmod = ((tmp_byte2 >> 1) & 0x7); + ind_sub.lfeon = (tmp_byte2 & 0x1); + ind_sub.num_dep_sub = ((tmp_byte3 >> 1) & 0xF); + if (ind_sub.num_dep_sub > 0) { + ind_sub.chan_loc = ((tmp_byte3 & 0x1) << 8) | stream.readUint8(); + } + } + }); + + // file:src/parsing/dfLa.js + BoxParser.createFullBoxCtor("dfLa", function(stream) { + var BLOCKTYPE_MASK = 0x7F; + var LASTMETADATABLOCKFLAG_MASK = 0x80; + + var boxesFound = []; + var knownBlockTypes = [ + "STREAMINFO", + "PADDING", + "APPLICATION", + "SEEKTABLE", + "VORBIS_COMMENT", + "CUESHEET", + "PICTURE", + "RESERVED" + ]; + + // for (i=0; ; i++) { // to end of box + do { + var flagAndType = stream.readUint8(); + + var type = Math.min( + (flagAndType & BLOCKTYPE_MASK), + (knownBlockTypes.length - 1) + ); + + // if this is a STREAMINFO block, read the true samplerate since this + // can be different to the AudioSampleEntry samplerate. + if (!(type)) { + // read past all the other stuff + stream.readUint8Array(13); + + // extract samplerate + this.samplerate = (stream.readUint32() >> 12); + + // read to end of STREAMINFO + stream.readUint8Array(20); + } else { + // not interested in other block types so just discard length bytes + stream.readUint8Array(stream.readUint24()); + } + + boxesFound.push(knownBlockTypes[type]); + + if (!!(flagAndType & LASTMETADATABLOCKFLAG_MASK)) { + break; + } + } while (true); + + this.numMetadataBlocks = + boxesFound.length + " (" + boxesFound.join(", ") + ")"; + }); + // file:src/parsing/dimm.js + BoxParser.createBoxCtor("dimm", function(stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/dmax.js + BoxParser.createBoxCtor("dmax", function(stream) { + this.time = stream.readUint32(); + }); + + // file:src/parsing/dmed.js + BoxParser.createBoxCtor("dmed", function(stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/dOps.js + BoxParser.createBoxCtor("dOps", function(stream) { + this.Version = stream.readUint8(); + this.OutputChannelCount = stream.readUint8(); + this.PreSkip = stream.readUint16(); + this.InputSampleRate = stream.readUint32(); + this.OutputGain = stream.readInt16(); + this.ChannelMappingFamily = stream.readUint8(); + if (this.ChannelMappingFamily !== 0) { + this.StreamCount = stream.readUint8(); + this.CoupledCount = stream.readUint8(); + this.ChannelMapping = []; + for (var i = 0; i < this.OutputChannelCount; i++) { + this.ChannelMapping[i] = stream.readUint8(); + } + } + }); + + // file:src/parsing/dref.js + BoxParser.createFullBoxCtor("dref", function(stream) { + var ret; + var box; + this.entries = []; + var entry_count = stream.readUint32(); + for (var i = 0; i < entry_count; i++) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = ret.box; + this.entries.push(box); + } else { + return; + } + } + }); + + // file:src/parsing/drep.js + BoxParser.createBoxCtor("drep", function(stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/elng.js + BoxParser.createFullBoxCtor("elng", function(stream) { + this.extended_language = stream.readString(this.size-this.hdr_size); + }); + + // file:src/parsing/elst.js + BoxParser.createFullBoxCtor("elst", function(stream) { + this.entries = []; + var entry_count = stream.readUint32(); + for (var i = 0; i < entry_count; i++) { + var entry = {}; + this.entries.push(entry); + if (this.version === 1) { + entry.segment_duration = stream.readUint64(); + entry.media_time = stream.readInt64(); + } else { + entry.segment_duration = stream.readUint32(); + entry.media_time = stream.readInt32(); + } + entry.media_rate_integer = stream.readInt16(); + entry.media_rate_fraction = stream.readInt16(); + } + }); + + // file:src/parsing/emsg.js + BoxParser.createFullBoxCtor("emsg", function(stream) { + if (this.version == 1) { + this.timescale = stream.readUint32(); + this.presentation_time = stream.readUint64(); + this.event_duration = stream.readUint32(); + this.id = stream.readUint32(); + this.scheme_id_uri = stream.readCString(); + this.value = stream.readCString(); + } else { + this.scheme_id_uri = stream.readCString(); + this.value = stream.readCString(); + this.timescale = stream.readUint32(); + this.presentation_time_delta = stream.readUint32(); + this.event_duration = stream.readUint32(); + this.id = stream.readUint32(); + } + var message_size = this.size - this.hdr_size - (4*4 + (this.scheme_id_uri.length+1) + (this.value.length+1)); + if (this.version == 1) { + message_size -= 4; + } + this.message_data = stream.readUint8Array(message_size); + }); + + // file:src/parsing/EntityToGroup.js + // ISO/IEC 14496-12:2022 Section 8.18.3 Entity to group box + BoxParser.createEntityToGroupCtor = function(type, parseMethod) { + BoxParser[type+"Box"] = function(size) { + BoxParser.FullBox.call(this, type, size); + }; + BoxParser[type+"Box"].prototype = new BoxParser.FullBox(); + BoxParser[type+"Box"].prototype.parse = function(stream) { + this.parseFullHeader(stream); + if (parseMethod) { + parseMethod.call(this, stream); + } else { + this.group_id = stream.readUint32(); + this.num_entities_in_group = stream.readUint32(); + this.entity_ids = []; + for (i = 0; i < this.num_entities_in_group; i++) { + var entity_id = stream.readUint32(); + this.entity_ids.push(entity_id); + } + } + }; + }; + + // Auto exposure bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.2.1) + BoxParser.createEntityToGroupCtor("aebr"); + + // Flash exposure bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.5.1) + BoxParser.createEntityToGroupCtor("afbr"); + + // Album collection (ISO/IEC 23008-12:2022 Section 6.8.7.1) + BoxParser.createEntityToGroupCtor("albc"); + + // Alternative entity (ISO/IEC 14496-12:2022 Section 8.18.3.1) + BoxParser.createEntityToGroupCtor("altr"); + + // Burst image entity group (ISO/IEC 23008-12:2022 Section 6.8.2.2) + BoxParser.createEntityToGroupCtor("brst"); + + // Depth of field bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.6.1) + BoxParser.createEntityToGroupCtor("dobr"); + + // Equivalent entity (ISO/IEC 23008-12:2022 Section 6.8.1.1) + BoxParser.createEntityToGroupCtor("eqiv"); + + // Favourites collection (ISO/IEC 23008-12:2022 Section 6.8.7.2) + BoxParser.createEntityToGroupCtor("favc"); + + // Focus bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.4.1) + BoxParser.createEntityToGroupCtor("fobr"); + + // Audio to image entity group (ISO/IEC 23008-12:2022 Section 6.8.4) + BoxParser.createEntityToGroupCtor("iaug"); + + // Panorama (ISO/IEC 23008-12:2022 Section 6.8.8.1) + BoxParser.createEntityToGroupCtor("pano"); + + // Slideshow (ISO/IEC 23008-12:2022 Section 6.8.9.1) + BoxParser.createEntityToGroupCtor("slid"); + + // Stereo pair (ISO/IEC 23008-12:2022 Section 6.8.5) + BoxParser.createEntityToGroupCtor("ster"); + + // Time-synchronised capture entity group (ISO/IEC 23008-12:2022 Section 6.8.3) + BoxParser.createEntityToGroupCtor("tsyn"); + + // White balance bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.3.1) + BoxParser.createEntityToGroupCtor("wbbr"); + + // Alternative entity (ISO/IEC 23008-12:2022 AMD1 Section 6.8.10) + BoxParser.createEntityToGroupCtor("prgr"); + + // Image Pyramid entity group (ISO/IEC 23008-12:20xx Section 6.8.11) + BoxParser.createEntityToGroupCtor("pymd", function(stream) { + this.group_id = stream.readUint32(); + this.num_entities_in_group = stream.readUint32(); + this.entity_ids = []; + for (var i = 0; i < this.num_entities_in_group; i++) { + var entity_id = stream.readUint32(); + this.entity_ids.push(entity_id); + } + + this.tile_size_x = stream.readUint16(); + this.tile_size_y = stream.readUint16(); + this.layer_binning = []; + this.tiles_in_layer_column_minus1 = []; + this.tiles_in_layer_row_minus1 = []; + for (i = 0; i < this.num_entities_in_group; i++) { + this.layer_binning[i] = stream.readUint16(); + this.tiles_in_layer_row_minus1[i] = stream.readUint16(); + this.tiles_in_layer_column_minus1[i] = stream.readUint16(); + } + }); + + // file:src/parsing/esds.js + BoxParser.createFullBoxCtor("esds", function(stream) { + var esd_data = stream.readUint8Array(this.size-this.hdr_size); + if (typeof MPEG4DescriptorParser !== "undefined") { + var esd_parser = new MPEG4DescriptorParser(); + this.esd = esd_parser.parseOneDescriptor(new DataStream(esd_data.buffer, 0, DataStream.BIG_ENDIAN)); + } + }); + + // file:src/parsing/fiel.js + BoxParser.createBoxCtor("fiel", function(stream) { + this.fieldCount = stream.readUint8(); + this.fieldOrdering = stream.readUint8(); + }); + + // file:src/parsing/frma.js + BoxParser.createBoxCtor("frma", function(stream) { + this.data_format = stream.readString(4); + }); + + // file:src/parsing/ftyp.js + BoxParser.createBoxCtor("ftyp", function(stream) { + var toparse = this.size - this.hdr_size; + this.major_brand = stream.readString(4); + this.minor_version = stream.readUint32(); + toparse -= 8; + this.compatible_brands = []; + var i = 0; + while (toparse>=4) { + this.compatible_brands[i] = stream.readString(4); + toparse -= 4; + i++; + } + }); + + // file:src/parsing/hdlr.js + BoxParser.createFullBoxCtor("hdlr", function(stream) { + if (this.version === 0) { + stream.readUint32(); + this.handler = stream.readString(4); + stream.readUint32Array(3); + this.name = stream.readString(this.size-this.hdr_size-20); + if (this.name[this.name.length-1]==='\0') { + this.name = this.name.slice(0,-1); + } + } + }); + + // file:src/parsing/hvcC.js + BoxParser.createBoxCtor("hvcC", function(stream) { + var i, j; + var length; + var tmp_byte; + this.configurationVersion = stream.readUint8(); + tmp_byte = stream.readUint8(); + this.general_profile_space = tmp_byte >> 6; + this.general_tier_flag = (tmp_byte & 0x20) >> 5; + this.general_profile_idc = (tmp_byte & 0x1F); + this.general_profile_compatibility = stream.readUint32(); + this.general_constraint_indicator = stream.readUint8Array(6); + this.general_level_idc = stream.readUint8(); + this.min_spatial_segmentation_idc = stream.readUint16() & 0xFFF; + this.parallelismType = (stream.readUint8() & 0x3); + this.chroma_format_idc = (stream.readUint8() & 0x3); + this.bit_depth_luma_minus8 = (stream.readUint8() & 0x7); + this.bit_depth_chroma_minus8 = (stream.readUint8() & 0x7); + this.avgFrameRate = stream.readUint16(); + tmp_byte = stream.readUint8(); + this.constantFrameRate = (tmp_byte >> 6); + this.numTemporalLayers = (tmp_byte & 0XD) >> 3; + this.temporalIdNested = (tmp_byte & 0X4) >> 2; + this.lengthSizeMinusOne = (tmp_byte & 0X3); + + this.nalu_arrays = []; + var numOfArrays = stream.readUint8(); + for (i = 0; i < numOfArrays; i++) { + var nalu_array = []; + this.nalu_arrays.push(nalu_array); + tmp_byte = stream.readUint8(); + nalu_array.completeness = (tmp_byte & 0x80) >> 7; + nalu_array.nalu_type = tmp_byte & 0x3F; + var numNalus = stream.readUint16(); + for (j = 0; j < numNalus; j++) { + var nalu = {}; + nalu_array.push(nalu); + length = stream.readUint16(); + nalu.data = stream.readUint8Array(length); + } + } + }); + + // file:src/parsing/iinf.js + BoxParser.createFullBoxCtor("iinf", function(stream) { + var ret; + if (this.version === 0) { + this.entry_count = stream.readUint16(); + } else { + this.entry_count = stream.readUint32(); + } + this.item_infos = []; + for (var i = 0; i < this.entry_count; i++) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + if (ret.box.type !== "infe") { + Log.error("BoxParser", "Expected 'infe' box, got "+ret.box.type); + } + this.item_infos[i] = ret.box; + } else { + return; + } + } + }); + + // file:src/parsing/iloc.js + BoxParser.createFullBoxCtor("iloc", function(stream) { + var byte; + byte = stream.readUint8(); + this.offset_size = (byte >> 4) & 0xF; + this.length_size = byte & 0xF; + byte = stream.readUint8(); + this.base_offset_size = (byte >> 4) & 0xF; + if (this.version === 1 || this.version === 2) { + this.index_size = byte & 0xF; + } else { + this.index_size = 0; + // reserved = byte & 0xF; + } + this.items = []; + var item_count = 0; + if (this.version < 2) { + item_count = stream.readUint16(); + } else if (this.version === 2) { + item_count = stream.readUint32(); + } else { + throw "version of iloc box not supported"; + } + for (var i = 0; i < item_count; i++) { + var item = {}; + this.items.push(item); + if (this.version < 2) { + item.item_ID = stream.readUint16(); + } else if (this.version === 2) { + item.item_ID = stream.readUint32(); + } else { + throw "version of iloc box not supported"; + } + if (this.version === 1 || this.version === 2) { + item.construction_method = (stream.readUint16() & 0xF); + } else { + item.construction_method = 0; + } + item.data_reference_index = stream.readUint16(); + switch(this.base_offset_size) { + case 0: + item.base_offset = 0; + break; + case 4: + item.base_offset = stream.readUint32(); + break; + case 8: + item.base_offset = stream.readUint64(); + break; + default: + throw "Error reading base offset size"; + } + var extent_count = stream.readUint16(); + item.extents = []; + for (var j=0; j < extent_count; j++) { + var extent = {}; + item.extents.push(extent); + if (this.version === 1 || this.version === 2) { + switch(this.index_size) { + case 0: + extent.extent_index = 0; + break; + case 4: + extent.extent_index = stream.readUint32(); + break; + case 8: + extent.extent_index = stream.readUint64(); + break; + default: + throw "Error reading extent index"; + } + } + switch(this.offset_size) { + case 0: + extent.extent_offset = 0; + break; + case 4: + extent.extent_offset = stream.readUint32(); + break; + case 8: + extent.extent_offset = stream.readUint64(); + break; + default: + throw "Error reading extent index"; + } + switch(this.length_size) { + case 0: + extent.extent_length = 0; + break; + case 4: + extent.extent_length = stream.readUint32(); + break; + case 8: + extent.extent_length = stream.readUint64(); + break; + default: + throw "Error reading extent index"; + } + } + } + }); + + // file:src/parsing/imir.js + BoxParser.createBoxCtor("imir", function(stream) { + var tmp = stream.readUint8(); + this.reserved = tmp >> 7; + this.axis = tmp & 1; + });// file:src/parsing/infe.js + BoxParser.createFullBoxCtor("infe", function(stream) { + if (this.version === 0 || this.version === 1) { + this.item_ID = stream.readUint16(); + this.item_protection_index = stream.readUint16(); + this.item_name = stream.readCString(); + this.content_type = stream.readCString(); + this.content_encoding = stream.readCString(); + } + if (this.version === 1) { + this.extension_type = stream.readString(4); + Log.warn("BoxParser", "Cannot parse extension type"); + stream.seek(this.start+this.size); + return; + } + if (this.version >= 2) { + if (this.version === 2) { + this.item_ID = stream.readUint16(); + } else if (this.version === 3) { + this.item_ID = stream.readUint32(); + } + this.item_protection_index = stream.readUint16(); + this.item_type = stream.readString(4); + this.item_name = stream.readCString(); + if (this.item_type === "mime") { + this.content_type = stream.readCString(); + this.content_encoding = stream.readCString(); + } else if (this.item_type === "uri ") { + this.item_uri_type = stream.readCString(); + } + } + }); + // file:src/parsing/ipma.js + BoxParser.createFullBoxCtor("ipma", function(stream) { + var i, j; + entry_count = stream.readUint32(); + this.associations = []; + for(i=0; i> 7) === 1; + if (this.flags & 0x1) { + p.property_index = (tmp & 0x7F) << 8 | stream.readUint8(); + } else { + p.property_index = (tmp & 0x7F); + } + } + } + }); + + // file:src/parsing/iref.js + BoxParser.createFullBoxCtor("iref", function(stream) { + var ret; + var box; + this.references = []; + + while (stream.getPosition() < this.start+this.size) { + ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + if (this.version === 0) { + box = new BoxParser.SingleItemTypeReferenceBox(ret.type, ret.size, ret.hdr_size, ret.start); + } else { + box = new BoxParser.SingleItemTypeReferenceBoxLarge(ret.type, ret.size, ret.hdr_size, ret.start); + } + if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { + Log.warn("BoxParser", box.type+" box writing not yet implemented, keeping unparsed data in memory for later write"); + box.parseDataAndRewind(stream); + } + box.parse(stream); + this.references.push(box); + } else { + return; + } + } + }); + // file:src/parsing/irot.js + BoxParser.createBoxCtor("irot", function(stream) { + this.angle = stream.readUint8() & 0x3; + }); + + // file:src/parsing/ispe.js + BoxParser.createFullBoxCtor("ispe", function(stream) { + this.image_width = stream.readUint32(); + this.image_height = stream.readUint32(); + });// file:src/parsing/kind.js + BoxParser.createFullBoxCtor("kind", function(stream) { + this.schemeURI = stream.readCString(); + this.value = stream.readCString(); + }); + // file:src/parsing/leva.js + BoxParser.createFullBoxCtor("leva", function(stream) { + var count = stream.readUint8(); + this.levels = []; + for (var i = 0; i < count; i++) { + var level = {}; + this.levels[i] = level; + level.track_ID = stream.readUint32(); + var tmp_byte = stream.readUint8(); + level.padding_flag = tmp_byte >> 7; + level.assignment_type = tmp_byte & 0x7F; + switch (level.assignment_type) { + case 0: + level.grouping_type = stream.readString(4); + break; + case 1: + level.grouping_type = stream.readString(4); + level.grouping_type_parameter = stream.readUint32(); + break; + case 2: + break; + case 3: + break; + case 4: + level.sub_track_id = stream.readUint32(); + break; + default: + Log.warn("BoxParser", "Unknown leva assignement type"); + } + } + }); + + // file:src/parsing/lhvC.js + BoxParser.createBoxCtor("lhvC", function(stream) { + var i, j; + var tmp_byte; + this.configurationVersion = stream.readUint8(); + this.min_spatial_segmentation_idc = stream.readUint16() & 0xFFF; + this.parallelismType = (stream.readUint8() & 0x3); + tmp_byte = stream.readUint8(); + this.numTemporalLayers = (tmp_byte & 0XD) >> 3; + this.temporalIdNested = (tmp_byte & 0X4) >> 2; + this.lengthSizeMinusOne = (tmp_byte & 0X3); + + this.nalu_arrays = []; + var numOfArrays = stream.readUint8(); + for (i = 0; i < numOfArrays; i++) { + var nalu_array = []; + this.nalu_arrays.push(nalu_array); + tmp_byte = stream.readUint8(); + nalu_array.completeness = (tmp_byte & 0x80) >> 7; + nalu_array.nalu_type = tmp_byte & 0x3F; + var numNalus = stream.readUint16(); + for (j = 0; j < numNalus; j++) { + var nalu = {}; + nalu_array.push(nalu); + var length = stream.readUint16(); + nalu.data = stream.readUint8Array(length); + } + } + }); + + // file:src/parsing/lsel.js + BoxParser.createBoxCtor("lsel", function(stream) { + this.layer_id = stream.readUint16(); + });// file:src/parsing/maxr.js + BoxParser.createBoxCtor("maxr", function(stream) { + this.period = stream.readUint32(); + this.bytes = stream.readUint32(); + }); + + // file:src/parsing/mdcv.js + function ColorPoint(x, y) { + this.x = x; + this.y = y; + } + + ColorPoint.prototype.toString = function() { + return "("+this.x+","+this.y+")"; + }; + + BoxParser.createBoxCtor("mdcv", function(stream) { + this.display_primaries = []; + this.display_primaries[0] = new ColorPoint(stream.readUint16(),stream.readUint16()); + this.display_primaries[1] = new ColorPoint(stream.readUint16(),stream.readUint16()); + this.display_primaries[2] = new ColorPoint(stream.readUint16(),stream.readUint16()); + this.white_point = new ColorPoint(stream.readUint16(),stream.readUint16()); + this.max_display_mastering_luminance = stream.readUint32(); + this.min_display_mastering_luminance = stream.readUint32(); + }); + + // file:src/parsing/mdhd.js + BoxParser.createFullBoxCtor("mdhd", function(stream) { + if (this.version == 1) { + this.creation_time = stream.readUint64(); + this.modification_time = stream.readUint64(); + this.timescale = stream.readUint32(); + this.duration = stream.readUint64(); + } else { + this.creation_time = stream.readUint32(); + this.modification_time = stream.readUint32(); + this.timescale = stream.readUint32(); + this.duration = stream.readUint32(); + } + this.parseLanguage(stream); + stream.readUint16(); + }); + + // file:src/parsing/mehd.js + BoxParser.createFullBoxCtor("mehd", function(stream) { + if (this.flags & 0x1) { + Log.warn("BoxParser", "mehd box incorrectly uses flags set to 1, converting version to 1"); + this.version = 1; + } + if (this.version == 1) { + this.fragment_duration = stream.readUint64(); + } else { + this.fragment_duration = stream.readUint32(); + } + }); + + // file:src/parsing/meta.js + BoxParser.createFullBoxCtor("meta", function(stream) { + this.boxes = []; + BoxParser.ContainerBox.prototype.parse.call(this, stream); + }); + // file:src/parsing/mfhd.js + BoxParser.createFullBoxCtor("mfhd", function(stream) { + this.sequence_number = stream.readUint32(); + }); + + // file:src/parsing/mfro.js + BoxParser.createFullBoxCtor("mfro", function(stream) { + this._size = stream.readUint32(); + }); + + // file:src/parsing/mskC.js + BoxParser.createFullBoxCtor("mskC", function(stream) { + this.bits_per_pixel = stream.readUint8(); + }); + + // file:src/parsing/mvhd.js + BoxParser.createFullBoxCtor("mvhd", function(stream) { + if (this.version == 1) { + this.creation_time = stream.readUint64(); + this.modification_time = stream.readUint64(); + this.timescale = stream.readUint32(); + this.duration = stream.readUint64(); + } else { + this.creation_time = stream.readUint32(); + this.modification_time = stream.readUint32(); + this.timescale = stream.readUint32(); + this.duration = stream.readUint32(); + } + this.rate = stream.readUint32(); + this.volume = stream.readUint16()>>8; + stream.readUint16(); + stream.readUint32Array(2); + this.matrix = stream.readUint32Array(9); + stream.readUint32Array(6); + this.next_track_id = stream.readUint32(); + }); + // file:src/parsing/npck.js + BoxParser.createBoxCtor("npck", function(stream) { + this.packetssent = stream.readUint32(); + }); + + // file:src/parsing/nump.js + BoxParser.createBoxCtor("nump", function(stream) { + this.packetssent = stream.readUint64(); + }); + + // file:src/parsing/padb.js + BoxParser.createFullBoxCtor("padb", function(stream) { + var sample_count = stream.readUint32(); + this.padbits = []; + for (var i = 0; i < Math.floor((sample_count+1)/2); i++) { + this.padbits = stream.readUint8(); + } + }); + + // file:src/parsing/pasp.js + BoxParser.createBoxCtor("pasp", function(stream) { + this.hSpacing = stream.readUint32(); + this.vSpacing = stream.readUint32(); + });// file:src/parsing/payl.js + BoxParser.createBoxCtor("payl", function(stream) { + this.text = stream.readString(this.size - this.hdr_size); + }); + + // file:src/parsing/payt.js + BoxParser.createBoxCtor("payt", function(stream) { + this.payloadID = stream.readUint32(); + var count = stream.readUint8(); + this.rtpmap_string = stream.readString(count); + }); + + // file:src/parsing/pdin.js + BoxParser.createFullBoxCtor("pdin", function(stream) { + var count = (this.size - this.hdr_size)/8; + this.rate = []; + this.initial_delay = []; + for (var i = 0; i < count; i++) { + this.rate[i] = stream.readUint32(); + this.initial_delay[i] = stream.readUint32(); + } + }); + + // file:src/parsing/pitm.js + BoxParser.createFullBoxCtor("pitm", function(stream) { + if (this.version === 0) { + this.item_id = stream.readUint16(); + } else { + this.item_id = stream.readUint32(); + } + }); + + // file:src/parsing/pixi.js + BoxParser.createFullBoxCtor("pixi", function(stream) { + var i; + this.num_channels = stream.readUint8(); + this.bits_per_channels = []; + for (i = 0; i < this.num_channels; i++) { + this.bits_per_channels[i] = stream.readUint8(); + } + }); + + // file:src/parsing/pmax.js + BoxParser.createBoxCtor("pmax", function(stream) { + this.bytes = stream.readUint32(); + }); + + // file:src/parsing/prdi.js + BoxParser.createFullBoxCtor("prdi", function(stream) { + this.step_count = stream.readUint16(); + this.item_count = []; + if (this.flags & 0x2) { + for (var i = 0; i < this.step_count; i++) { + this.item_count[i] = stream.readUint16(); + } + } + });// file:src/parsing/prft.js + BoxParser.createFullBoxCtor("prft", function(stream) { + this.ref_track_id = stream.readUint32(); + this.ntp_timestamp = stream.readUint64(); + if (this.version === 0) { + this.media_time = stream.readUint32(); + } else { + this.media_time = stream.readUint64(); + } + }); + + // file:src/parsing/pssh.js + BoxParser.createFullBoxCtor("pssh", function(stream) { + this.system_id = BoxParser.parseHex16(stream); + if (this.version > 0) { + var count = stream.readUint32(); + this.kid = []; + for (var i = 0; i < count; i++) { + this.kid[i] = BoxParser.parseHex16(stream); + } + } + var datasize = stream.readUint32(); + if (datasize > 0) { + this.data = stream.readUint8Array(datasize); + } + }); + + // file:src/parsing/qt/clef.js + BoxParser.createFullBoxCtor("clef", function(stream) { + this.width = stream.readUint32(); + this.height = stream.readUint32(); + });// file:src/parsing/qt/enof.js + BoxParser.createFullBoxCtor("enof", function(stream) { + this.width = stream.readUint32(); + this.height = stream.readUint32(); + });// file:src/parsing/qt/prof.js + BoxParser.createFullBoxCtor("prof", function(stream) { + this.width = stream.readUint32(); + this.height = stream.readUint32(); + });// file:src/parsing/qt/tapt.js + BoxParser.createContainerBoxCtor("tapt", null, [ "clef", "prof", "enof"]);// file:src/parsing/rtp.js + BoxParser.createBoxCtor("rtp ", function(stream) { + this.descriptionformat = stream.readString(4); + this.sdptext = stream.readString(this.size - this.hdr_size - 4); + }); + + // file:src/parsing/saio.js + BoxParser.createFullBoxCtor("saio", function(stream) { + if (this.flags & 0x1) { + this.aux_info_type = stream.readString(4); + this.aux_info_type_parameter = stream.readUint32(); + } + var count = stream.readUint32(); + this.offset = []; + for (var i = 0; i < count; i++) { + if (this.version === 0) { + this.offset[i] = stream.readUint32(); + } else { + this.offset[i] = stream.readUint64(); + } + } + }); + // file:src/parsing/saiz.js + BoxParser.createFullBoxCtor("saiz", function(stream) { + if (this.flags & 0x1) { + this.aux_info_type = stream.readString(4); + this.aux_info_type_parameter = stream.readUint32(); + } + this.default_sample_info_size = stream.readUint8(); + this.sample_count = stream.readUint32(); + this.sample_info_size = []; + if (this.default_sample_info_size === 0) { + for (var i = 0; i < this.sample_count; i++) { + this.sample_info_size[i] = stream.readUint8(); + } + } + }); + + // file:src/parsing/sampleentries/mett.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "mett", function(stream) { + this.parseHeader(stream); + this.content_encoding = stream.readCString(); + this.mime_format = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/metx.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "metx", function(stream) { + this.parseHeader(stream); + this.content_encoding = stream.readCString(); + this.namespace = stream.readCString(); + this.schema_location = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/sbtt.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "sbtt", function(stream) { + this.parseHeader(stream); + this.content_encoding = stream.readCString(); + this.mime_format = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/stpp.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "stpp", function(stream) { + this.parseHeader(stream); + this.namespace = stream.readCString(); + this.schema_location = stream.readCString(); + this.auxiliary_mime_types = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/stxt.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "stxt", function(stream) { + this.parseHeader(stream); + this.content_encoding = stream.readCString(); + this.mime_format = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/tx3g.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "tx3g", function(stream) { + this.parseHeader(stream); + this.displayFlags = stream.readUint32(); + this.horizontal_justification = stream.readInt8(); + this.vertical_justification = stream.readInt8(); + this.bg_color_rgba = stream.readUint8Array(4); + this.box_record = stream.readInt16Array(4); + this.style_record = stream.readUint8Array(12); + this.parseFooter(stream); + }); + // file:src/parsing/sampleentries/wvtt.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "wvtt", function(stream) { + this.parseHeader(stream); + this.parseFooter(stream); + }); + + // file:src/parsing/samplegroups/alst.js + BoxParser.createSampleGroupCtor("alst", function(stream) { + var i; + var roll_count = stream.readUint16(); + this.first_output_sample = stream.readUint16(); + this.sample_offset = []; + for (i = 0; i < roll_count; i++) { + this.sample_offset[i] = stream.readUint32(); + } + var remaining = this.description_length - 4 - 4*roll_count; + this.num_output_samples = []; + this.num_total_samples = []; + for (i = 0; i < remaining/4; i++) { + this.num_output_samples[i] = stream.readUint16(); + this.num_total_samples[i] = stream.readUint16(); + } + }); + + // file:src/parsing/samplegroups/avll.js + BoxParser.createSampleGroupCtor("avll", function(stream) { + this.layerNumber = stream.readUint8(); + this.accurateStatisticsFlag = stream.readUint8(); + this.avgBitRate = stream.readUint16(); + this.avgFrameRate = stream.readUint16(); + }); + + // file:src/parsing/samplegroups/avss.js + BoxParser.createSampleGroupCtor("avss", function(stream) { + this.subSequenceIdentifier = stream.readUint16(); + this.layerNumber = stream.readUint8(); + var tmp_byte = stream.readUint8(); + this.durationFlag = tmp_byte >> 7; + this.avgRateFlag = (tmp_byte >> 6) & 0x1; + if (this.durationFlag) { + this.duration = stream.readUint32(); + } + if (this.avgRateFlag) { + this.accurateStatisticsFlag = stream.readUint8(); + this.avgBitRate = stream.readUint16(); + this.avgFrameRate = stream.readUint16(); + } + this.dependency = []; + var numReferences = stream.readUint8(); + for (var i = 0; i < numReferences; i++) { + var dependencyInfo = {}; + this.dependency.push(dependencyInfo); + dependencyInfo.subSeqDirectionFlag = stream.readUint8(); + dependencyInfo.layerNumber = stream.readUint8(); + dependencyInfo.subSequenceIdentifier = stream.readUint16(); + } + }); + + // file:src/parsing/samplegroups/dtrt.js + BoxParser.createSampleGroupCtor("dtrt", function(stream) { + Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); + }); + + // file:src/parsing/samplegroups/mvif.js + BoxParser.createSampleGroupCtor("mvif", function(stream) { + Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); + }); + + // file:src/parsing/samplegroups/prol.js + BoxParser.createSampleGroupCtor("prol", function(stream) { + this.roll_distance = stream.readInt16(); + }); + + // file:src/parsing/samplegroups/rap.js + BoxParser.createSampleGroupCtor("rap ", function(stream) { + var tmp_byte = stream.readUint8(); + this.num_leading_samples_known = tmp_byte >> 7; + this.num_leading_samples = tmp_byte & 0x7F; + }); + + // file:src/parsing/samplegroups/rash.js + BoxParser.createSampleGroupCtor("rash", function(stream) { + this.operation_point_count = stream.readUint16(); + if (this.description_length !== 2+(this.operation_point_count === 1?2:this.operation_point_count*6)+9) { + Log.warn("BoxParser", "Mismatch in "+this.grouping_type+" sample group length"); + this.data = stream.readUint8Array(this.description_length-2); + } else { + if (this.operation_point_count === 1) { + this.target_rate_share = stream.readUint16(); + } else { + this.target_rate_share = []; + this.available_bitrate = []; + for (var i = 0; i < this.operation_point_count; i++) { + this.available_bitrate[i] = stream.readUint32(); + this.target_rate_share[i] = stream.readUint16(); + } + } + this.maximum_bitrate = stream.readUint32(); + this.minimum_bitrate = stream.readUint32(); + this.discard_priority = stream.readUint8(); + } + }); + + // file:src/parsing/samplegroups/roll.js + BoxParser.createSampleGroupCtor("roll", function(stream) { + this.roll_distance = stream.readInt16(); + }); + + // file:src/parsing/samplegroups/samplegroup.js + BoxParser.SampleGroupEntry.prototype.parse = function(stream) { + Log.warn("BoxParser", "Unknown Sample Group type: "+this.grouping_type); + this.data = stream.readUint8Array(this.description_length); + }; + + // file:src/parsing/samplegroups/scif.js + BoxParser.createSampleGroupCtor("scif", function(stream) { + Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); + }); + + // file:src/parsing/samplegroups/scnm.js + BoxParser.createSampleGroupCtor("scnm", function(stream) { + Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); + }); + + // file:src/parsing/samplegroups/seig.js + BoxParser.createSampleGroupCtor("seig", function(stream) { + this.reserved = stream.readUint8(); + var tmp = stream.readUint8(); + this.crypt_byte_block = tmp >> 4; + this.skip_byte_block = tmp & 0xF; + this.isProtected = stream.readUint8(); + this.Per_Sample_IV_Size = stream.readUint8(); + this.KID = BoxParser.parseHex16(stream); + this.constant_IV_size = 0; + this.constant_IV = 0; + if (this.isProtected === 1 && this.Per_Sample_IV_Size === 0) { + this.constant_IV_size = stream.readUint8(); + this.constant_IV = stream.readUint8Array(this.constant_IV_size); + } + }); + + // file:src/parsing/samplegroups/stsa.js + BoxParser.createSampleGroupCtor("stsa", function(stream) { + Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); + }); + + // file:src/parsing/samplegroups/sync.js + BoxParser.createSampleGroupCtor("sync", function(stream) { + var tmp_byte = stream.readUint8(); + this.NAL_unit_type = tmp_byte & 0x3F; + }); + + // file:src/parsing/samplegroups/tele.js + BoxParser.createSampleGroupCtor("tele", function(stream) { + var tmp_byte = stream.readUint8(); + this.level_independently_decodable = tmp_byte >> 7; + }); + + // file:src/parsing/samplegroups/tsas.js + BoxParser.createSampleGroupCtor("tsas", function(stream) { + Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); + }); + + // file:src/parsing/samplegroups/tscl.js + BoxParser.createSampleGroupCtor("tscl", function(stream) { + Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); + }); + + // file:src/parsing/samplegroups/vipr.js + BoxParser.createSampleGroupCtor("vipr", function(stream) { + Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); + }); + + // file:src/parsing/sbgp.js + BoxParser.createFullBoxCtor("sbgp", function(stream) { + this.grouping_type = stream.readString(4); + if (this.version === 1) { + this.grouping_type_parameter = stream.readUint32(); + } else { + this.grouping_type_parameter = 0; + } + this.entries = []; + var entry_count = stream.readUint32(); + for (var i = 0; i < entry_count; i++) { + var entry = {}; + this.entries.push(entry); + entry.sample_count = stream.readInt32(); + entry.group_description_index = stream.readInt32(); + } + }); + + // file:src/parsing/sbpm.js + function Pixel(row, col) { + this.bad_pixel_row = row; + this.bad_pixel_column = col; + } + + Pixel.prototype.toString = function pixelToString() { + return "[row: " + this.bad_pixel_row + ", column: " + this.bad_pixel_column + "]"; + }; + + BoxParser.createFullBoxCtor("sbpm", function(stream) { + var i; + this.component_count = stream.readUint16(); + this.component_index = []; + for (i = 0; i < this.component_count; i++) { + this.component_index.push(stream.readUint16()); + } + var flags = stream.readUint8(); + this.correction_applied = (0x80 == (flags & 0x80)); + this.num_bad_rows = stream.readUint32(); + this.num_bad_cols = stream.readUint32(); + this.num_bad_pixels = stream.readUint32(); + this.bad_rows = []; + this.bad_columns = []; + this.bad_pixels = []; + for (i = 0; i < this.num_bad_rows; i++) { + this.bad_rows.push(stream.readUint32()); + } + for (i = 0; i < this.num_bad_cols; i++) { + this.bad_columns.push(stream.readUint32()); + } + for (i = 0; i < this.num_bad_pixels; i++) { + var row = stream.readUint32(); + var col = stream.readUint32(); + this.bad_pixels.push(new Pixel(row, col)); + } + }); + + // file:src/parsing/schm.js + BoxParser.createFullBoxCtor("schm", function(stream) { + this.scheme_type = stream.readString(4); + this.scheme_version = stream.readUint32(); + if (this.flags & 0x000001) { + this.scheme_uri = stream.readString(this.size - this.hdr_size - 8); + } + }); + + // file:src/parsing/sdp.js + BoxParser.createBoxCtor("sdp ", function(stream) { + this.sdptext = stream.readString(this.size - this.hdr_size); + }); + + // file:src/parsing/sdtp.js + BoxParser.createFullBoxCtor("sdtp", function(stream) { + var tmp_byte; + var count = (this.size - this.hdr_size); + this.is_leading = []; + this.sample_depends_on = []; + this.sample_is_depended_on = []; + this.sample_has_redundancy = []; + for (var i = 0; i < count; i++) { + tmp_byte = stream.readUint8(); + this.is_leading[i] = tmp_byte >> 6; + this.sample_depends_on[i] = (tmp_byte >> 4) & 0x3; + this.sample_is_depended_on[i] = (tmp_byte >> 2) & 0x3; + this.sample_has_redundancy[i] = tmp_byte & 0x3; + } + }); + + // file:src/parsing/senc.js + // Cannot be fully parsed because Per_Sample_IV_Size needs to be known + BoxParser.createFullBoxCtor("senc" /*, function(stream) { + this.parseFullHeader(stream); + var sample_count = stream.readUint32(); + this.samples = []; + for (var i = 0; i < sample_count; i++) { + var sample = {}; + // tenc.default_Per_Sample_IV_Size or seig.Per_Sample_IV_Size + sample.InitializationVector = this.readUint8Array(Per_Sample_IV_Size*8); + if (this.flags & 0x2) { + sample.subsamples = []; + subsample_count = stream.readUint16(); + for (var j = 0; j < subsample_count; j++) { + var subsample = {}; + subsample.BytesOfClearData = stream.readUint16(); + subsample.BytesOfProtectedData = stream.readUint32(); + sample.subsamples.push(subsample); + } + } + // TODO + this.samples.push(sample); + } + }*/); + // file:src/parsing/sgpd.js + BoxParser.createFullBoxCtor("sgpd", function(stream) { + this.grouping_type = stream.readString(4); + Log.debug("BoxParser", "Found Sample Groups of type "+this.grouping_type); + if (this.version === 1) { + this.default_length = stream.readUint32(); + } else { + this.default_length = 0; + } + if (this.version >= 2) { + this.default_group_description_index = stream.readUint32(); + } + this.entries = []; + var entry_count = stream.readUint32(); + for (var i = 0; i < entry_count; i++) { + var entry; + if (BoxParser[this.grouping_type+"SampleGroupEntry"]) { + entry = new BoxParser[this.grouping_type+"SampleGroupEntry"](this.grouping_type); + } else { + entry = new BoxParser.SampleGroupEntry(this.grouping_type); + } + this.entries.push(entry); + if (this.version === 1) { + if (this.default_length === 0) { + entry.description_length = stream.readUint32(); + } else { + entry.description_length = this.default_length; + } + } else { + entry.description_length = this.default_length; + } + if (entry.write === BoxParser.SampleGroupEntry.prototype.write) { + Log.info("BoxParser", "SampleGroup for type "+this.grouping_type+" writing not yet implemented, keeping unparsed data in memory for later write"); + // storing data + entry.data = stream.readUint8Array(entry.description_length); + // rewinding + stream.position -= entry.description_length; + } + entry.parse(stream); + } + }); + + // file:src/parsing/sidx.js + BoxParser.createFullBoxCtor("sidx", function(stream) { + this.reference_ID = stream.readUint32(); + this.timescale = stream.readUint32(); + if (this.version === 0) { + this.earliest_presentation_time = stream.readUint32(); + this.first_offset = stream.readUint32(); + } else { + this.earliest_presentation_time = stream.readUint64(); + this.first_offset = stream.readUint64(); + } + stream.readUint16(); + this.references = []; + var count = stream.readUint16(); + for (var i = 0; i < count; i++) { + var ref = {}; + this.references.push(ref); + var tmp_32 = stream.readUint32(); + ref.reference_type = (tmp_32 >> 31) & 0x1; + ref.referenced_size = tmp_32 & 0x7FFFFFFF; + ref.subsegment_duration = stream.readUint32(); + tmp_32 = stream.readUint32(); + ref.starts_with_SAP = (tmp_32 >> 31) & 0x1; + ref.SAP_type = (tmp_32 >> 28) & 0x7; + ref.SAP_delta_time = tmp_32 & 0xFFFFFFF; + } + }); + + // file:src/parsing/singleitemtypereference.js + BoxParser.SingleItemTypeReferenceBox = function(type, size, hdr_size, start) { + BoxParser.Box.call(this, type, size); + this.hdr_size = hdr_size; + this.start = start; + }; + BoxParser.SingleItemTypeReferenceBox.prototype = new BoxParser.Box(); + BoxParser.SingleItemTypeReferenceBox.prototype.parse = function(stream) { + this.from_item_ID = stream.readUint16(); + var count = stream.readUint16(); + this.references = []; + for(var i = 0; i < count; i++) { + this.references[i] = {}; + this.references[i].to_item_ID = stream.readUint16(); + } + }; + + // file:src/parsing/singleitemtypereferencelarge.js + BoxParser.SingleItemTypeReferenceBoxLarge = function(type, size, hdr_size, start) { + BoxParser.Box.call(this, type, size); + this.hdr_size = hdr_size; + this.start = start; + }; + BoxParser.SingleItemTypeReferenceBoxLarge.prototype = new BoxParser.Box(); + BoxParser.SingleItemTypeReferenceBoxLarge.prototype.parse = function(stream) { + this.from_item_ID = stream.readUint32(); + var count = stream.readUint16(); + this.references = []; + for(var i = 0; i < count; i++) { + this.references[i] = {}; + this.references[i].to_item_ID = stream.readUint32(); + } + }; + + // file:src/parsing/SmDm.js + BoxParser.createFullBoxCtor("SmDm", function(stream) { + this.primaryRChromaticity_x = stream.readUint16(); + this.primaryRChromaticity_y = stream.readUint16(); + this.primaryGChromaticity_x = stream.readUint16(); + this.primaryGChromaticity_y = stream.readUint16(); + this.primaryBChromaticity_x = stream.readUint16(); + this.primaryBChromaticity_y = stream.readUint16(); + this.whitePointChromaticity_x = stream.readUint16(); + this.whitePointChromaticity_y = stream.readUint16(); + this.luminanceMax = stream.readUint32(); + this.luminanceMin = stream.readUint32(); + }); + + // file:src/parsing/smhd.js + BoxParser.createFullBoxCtor("smhd", function(stream) { + this.balance = stream.readUint16(); + stream.readUint16(); + }); + + // file:src/parsing/ssix.js + BoxParser.createFullBoxCtor("ssix", function(stream) { + this.subsegments = []; + var subsegment_count = stream.readUint32(); + for (var i = 0; i < subsegment_count; i++) { + var subsegment = {}; + this.subsegments.push(subsegment); + subsegment.ranges = []; + var range_count = stream.readUint32(); + for (var j = 0; j < range_count; j++) { + var range = {}; + subsegment.ranges.push(range); + range.level = stream.readUint8(); + range.range_size = stream.readUint24(); + } + } + }); + + // file:src/parsing/stco.js + BoxParser.createFullBoxCtor("stco", function(stream) { + var entry_count; + entry_count = stream.readUint32(); + this.chunk_offsets = []; + if (this.version === 0) { + for (var i = 0; i < entry_count; i++) { + this.chunk_offsets.push(stream.readUint32()); + } + } + }); + + // file:src/parsing/stdp.js + BoxParser.createFullBoxCtor("stdp", function(stream) { + var count = (this.size - this.hdr_size)/2; + this.priority = []; + for (var i = 0; i < count; i++) { + this.priority[i] = stream.readUint16(); + } + }); + + // file:src/parsing/sthd.js + BoxParser.createFullBoxCtor("sthd"); + + // file:src/parsing/stri.js + BoxParser.createFullBoxCtor("stri", function(stream) { + this.switch_group = stream.readUint16(); + this.alternate_group = stream.readUint16(); + this.sub_track_id = stream.readUint32(); + var count = (this.size - this.hdr_size - 8)/4; + this.attribute_list = []; + for (var i = 0; i < count; i++) { + this.attribute_list[i] = stream.readUint32(); + } + }); + + // file:src/parsing/stsc.js + BoxParser.createFullBoxCtor("stsc", function(stream) { + var entry_count; + var i; + entry_count = stream.readUint32(); + this.first_chunk = []; + this.samples_per_chunk = []; + this.sample_description_index = []; + if (this.version === 0) { + for(i=0; i> 4) & 0xF; + this.sample_sizes[i+1] = tmp & 0xF; + } + } else if (this.field_size === 8) { + for (i = 0; i < sample_count; i++) { + this.sample_sizes[i] = stream.readUint8(); + } + } else if (this.field_size === 16) { + for (i = 0; i < sample_count; i++) { + this.sample_sizes[i] = stream.readUint16(); + } + } else { + Log.error("BoxParser", "Error in length field in stz2 box"); + } + } + }); + + // file:src/parsing/subs.js + BoxParser.createFullBoxCtor("subs", function(stream) { + var i,j; + var entry_count; + var subsample_count; + entry_count = stream.readUint32(); + this.entries = []; + for (i = 0; i < entry_count; i++) { + var sampleInfo = {}; + this.entries[i] = sampleInfo; + sampleInfo.sample_delta = stream.readUint32(); + sampleInfo.subsamples = []; + subsample_count = stream.readUint16(); + if (subsample_count>0) { + for (j = 0; j < subsample_count; j++) { + var subsample = {}; + sampleInfo.subsamples.push(subsample); + if (this.version == 1) { + subsample.size = stream.readUint32(); + } else { + subsample.size = stream.readUint16(); + } + subsample.priority = stream.readUint8(); + subsample.discardable = stream.readUint8(); + subsample.codec_specific_parameters = stream.readUint32(); + } + } + } + }); + + // file:src/parsing/tenc.js + BoxParser.createFullBoxCtor("tenc", function(stream) { + stream.readUint8(); // reserved + if (this.version === 0) { + stream.readUint8(); + } else { + var tmp = stream.readUint8(); + this.default_crypt_byte_block = (tmp >> 4) & 0xF; + this.default_skip_byte_block = tmp & 0xF; + } + this.default_isProtected = stream.readUint8(); + this.default_Per_Sample_IV_Size = stream.readUint8(); + this.default_KID = BoxParser.parseHex16(stream); + if (this.default_isProtected === 1 && this.default_Per_Sample_IV_Size === 0) { + this.default_constant_IV_size = stream.readUint8(); + this.default_constant_IV = stream.readUint8Array(this.default_constant_IV_size); + } + });// file:src/parsing/tfdt.js + BoxParser.createFullBoxCtor("tfdt", function(stream) { + if (this.version == 1) { + this.baseMediaDecodeTime = stream.readUint64(); + } else { + this.baseMediaDecodeTime = stream.readUint32(); + } + }); + + // file:src/parsing/tfhd.js + BoxParser.createFullBoxCtor("tfhd", function(stream) { + var readBytes = 0; + this.track_id = stream.readUint32(); + if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET)) { + this.base_data_offset = stream.readUint64(); + readBytes += 8; + } else { + this.base_data_offset = 0; + } + if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC)) { + this.default_sample_description_index = stream.readUint32(); + readBytes += 4; + } else { + this.default_sample_description_index = 0; + } + if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR)) { + this.default_sample_duration = stream.readUint32(); + readBytes += 4; + } else { + this.default_sample_duration = 0; + } + if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE)) { + this.default_sample_size = stream.readUint32(); + readBytes += 4; + } else { + this.default_sample_size = 0; + } + if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS)) { + this.default_sample_flags = stream.readUint32(); + readBytes += 4; + } else { + this.default_sample_flags = 0; + } + }); + + // file:src/parsing/tfra.js + BoxParser.createFullBoxCtor("tfra", function(stream) { + this.track_ID = stream.readUint32(); + stream.readUint24(); + var tmp_byte = stream.readUint8(); + this.length_size_of_traf_num = (tmp_byte >> 4) & 0x3; + this.length_size_of_trun_num = (tmp_byte >> 2) & 0x3; + this.length_size_of_sample_num = (tmp_byte) & 0x3; + this.entries = []; + var number_of_entries = stream.readUint32(); + for (var i = 0; i < number_of_entries; i++) { + if (this.version === 1) { + this.time = stream.readUint64(); + this.moof_offset = stream.readUint64(); + } else { + this.time = stream.readUint32(); + this.moof_offset = stream.readUint32(); + } + this.traf_number = stream["readUint"+(8*(this.length_size_of_traf_num+1))](); + this.trun_number = stream["readUint"+(8*(this.length_size_of_trun_num+1))](); + this.sample_number = stream["readUint"+(8*(this.length_size_of_sample_num+1))](); + } + }); + + // file:src/parsing/tkhd.js + BoxParser.createFullBoxCtor("tkhd", function(stream) { + if (this.version == 1) { + this.creation_time = stream.readUint64(); + this.modification_time = stream.readUint64(); + this.track_id = stream.readUint32(); + stream.readUint32(); + this.duration = stream.readUint64(); + } else { + this.creation_time = stream.readUint32(); + this.modification_time = stream.readUint32(); + this.track_id = stream.readUint32(); + stream.readUint32(); + this.duration = stream.readUint32(); + } + stream.readUint32Array(2); + this.layer = stream.readInt16(); + this.alternate_group = stream.readInt16(); + this.volume = stream.readInt16()>>8; + stream.readUint16(); + this.matrix = stream.readInt32Array(9); + this.width = stream.readUint32(); + this.height = stream.readUint32(); + }); + + // file:src/parsing/tmax.js + BoxParser.createBoxCtor("tmax", function(stream) { + this.time = stream.readUint32(); + }); + + // file:src/parsing/tmin.js + BoxParser.createBoxCtor("tmin", function(stream) { + this.time = stream.readUint32(); + }); + + // file:src/parsing/totl.js + BoxParser.createBoxCtor("totl",function(stream) { + this.bytessent = stream.readUint32(); + }); + + // file:src/parsing/tpay.js + BoxParser.createBoxCtor("tpay", function(stream) { + this.bytessent = stream.readUint32(); + }); + + // file:src/parsing/tpyl.js + BoxParser.createBoxCtor("tpyl", function(stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/TrackGroup.js + BoxParser.TrackGroupTypeBox.prototype.parse = function(stream) { + this.parseFullHeader(stream); + this.track_group_id = stream.readUint32(); + }; + + // file:src/parsing/trackgroups/msrc.js + BoxParser.createTrackGroupCtor("msrc");// file:src/parsing/TrakReference.js + BoxParser.TrackReferenceTypeBox = function(type, size, hdr_size, start) { + BoxParser.Box.call(this, type, size); + this.hdr_size = hdr_size; + this.start = start; + }; + BoxParser.TrackReferenceTypeBox.prototype = new BoxParser.Box(); + BoxParser.TrackReferenceTypeBox.prototype.parse = function(stream) { + this.track_ids = stream.readUint32Array((this.size-this.hdr_size)/4); + }; + + // file:src/parsing/tref.js + BoxParser.trefBox.prototype.parse = function(stream) { + var ret; + var box; + while (stream.getPosition() < this.start+this.size) { + ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = new BoxParser.TrackReferenceTypeBox(ret.type, ret.size, ret.hdr_size, ret.start); + if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { + Log.info("BoxParser", "TrackReference "+box.type+" box writing not yet implemented, keeping unparsed data in memory for later write"); + box.parseDataAndRewind(stream); + } + box.parse(stream); + this.boxes.push(box); + } else { + return; + } + } + }; + + // file:src/parsing/trep.js + BoxParser.createFullBoxCtor("trep", function(stream) { + this.track_ID = stream.readUint32(); + this.boxes = []; + while (stream.getPosition() < this.start+this.size) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = ret.box; + this.boxes.push(box); + } else { + return; + } + } + }); + + // file:src/parsing/trex.js + BoxParser.createFullBoxCtor("trex", function(stream) { + this.track_id = stream.readUint32(); + this.default_sample_description_index = stream.readUint32(); + this.default_sample_duration = stream.readUint32(); + this.default_sample_size = stream.readUint32(); + this.default_sample_flags = stream.readUint32(); + }); + + // file:src/parsing/trpy.js + BoxParser.createBoxCtor("trpy", function(stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/trun.js + BoxParser.createFullBoxCtor("trun", function(stream) { + var readBytes = 0; + this.sample_count = stream.readUint32(); + readBytes+= 4; + if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) ) { + this.data_offset = stream.readInt32(); //signed + readBytes += 4; + } else { + this.data_offset = 0; + } + if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) ) { + this.first_sample_flags = stream.readUint32(); + readBytes += 4; + } else { + this.first_sample_flags = 0; + } + this.sample_duration = []; + this.sample_size = []; + this.sample_flags = []; + this.sample_composition_time_offset = []; + if (this.size - this.hdr_size > readBytes) { + for (var i = 0; i < this.sample_count; i++) { + if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { + this.sample_duration[i] = stream.readUint32(); + } + if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { + this.sample_size[i] = stream.readUint32(); + } + if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { + this.sample_flags[i] = stream.readUint32(); + } + if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { + if (this.version === 0) { + this.sample_composition_time_offset[i] = stream.readUint32(); + } else { + this.sample_composition_time_offset[i] = stream.readInt32(); //signed + } + } + } + } + }); + + // file:src/parsing/tsel.js + BoxParser.createFullBoxCtor("tsel", function(stream) { + this.switch_group = stream.readUint32(); + var count = (this.size - this.hdr_size - 4)/4; + this.attribute_list = []; + for (var i = 0; i < count; i++) { + this.attribute_list[i] = stream.readUint32(); + } + }); + + // file:src/parsing/txtC.js + BoxParser.createFullBoxCtor("txtC", function(stream) { + this.config = stream.readCString(); + }); + + // file:src/parsing/tyco.js + BoxParser.createBoxCtor("tyco", function(stream) { + var count = (this.size - this.hdr_size) / 4; + this.compatible_brands = []; + for (var i = 0; i < count; i++) { + this.compatible_brands[i] = stream.readString(4); + } + }); + + // file:src/parsing/udes.js + BoxParser.createFullBoxCtor("udes", function(stream) { + this.lang = stream.readCString(); + this.name = stream.readCString(); + this.description = stream.readCString(); + this.tags = stream.readCString(); + }); + + // file:src/parsing/uncC.js + BoxParser.createFullBoxCtor("uncC", function(stream) { + var i; + this.profile = stream.readUint32(); + if (this.version == 1) ; else if (this.version == 0) { + this.component_count = stream.readUint32(); + this.component_index = []; + this.component_bit_depth_minus_one = []; + this.component_format = []; + this.component_align_size = []; + for (i = 0; i < this.component_count; i++) { + this.component_index.push(stream.readUint16()); + this.component_bit_depth_minus_one.push(stream.readUint8()); + this.component_format.push(stream.readUint8()); + this.component_align_size.push(stream.readUint8()); + } + this.sampling_type = stream.readUint8(); + this.interleave_type = stream.readUint8(); + this.block_size = stream.readUint8(); + var flags = stream.readUint8(); + this.component_little_endian = (flags >> 7) & 0x1; + this.block_pad_lsb = (flags >> 6) & 0x1; + this.block_little_endian = (flags >> 5) & 0x1; + this.block_reversed = (flags >> 4) & 0x1; + this.pad_unknown = (flags >> 3) & 0x1; + this.pixel_size = stream.readUint32(); + this.row_align_size = stream.readUint32(); + this.tile_align_size = stream.readUint32(); + this.num_tile_cols_minus_one = stream.readUint32(); + this.num_tile_rows_minus_one = stream.readUint32(); + } + }); + + // file:src/parsing/url.js + BoxParser.createFullBoxCtor("url ", function(stream) { + if (this.flags !== 0x000001) { + this.location = stream.readCString(); + } + }); + + // file:src/parsing/urn.js + BoxParser.createFullBoxCtor("urn ", function(stream) { + this.name = stream.readCString(); + if (this.size - this.hdr_size - this.name.length - 1 > 0) { + this.location = stream.readCString(); + } + }); + + // file:src/parsing/uuid/piff/piffLsm.js + BoxParser.createUUIDBox("a5d40b30e81411ddba2f0800200c9a66", true, false, function(stream) { + this.LiveServerManifest = stream.readString(this.size - this.hdr_size) + .replace(/&/g, "&") + .replace(//g, ">") + .replace(/"/g, """) + .replace(/'/g, "'"); + });// file:src/parsing/uuid/piff/piffPssh.js + BoxParser.createUUIDBox("d08a4f1810f34a82b6c832d8aba183d3", true, false, function(stream) { + this.system_id = BoxParser.parseHex16(stream); + var datasize = stream.readUint32(); + if (datasize > 0) { + this.data = stream.readUint8Array(datasize); + } + }); + + // file:src/parsing/uuid/piff/piffSenc.js + BoxParser.createUUIDBox("a2394f525a9b4f14a2446c427c648df4", true, false /*, function(stream) { + if (this.flags & 0x1) { + this.AlgorithmID = stream.readUint24(); + this.IV_size = stream.readUint8(); + this.KID = BoxParser.parseHex16(stream); + } + var sample_count = stream.readUint32(); + this.samples = []; + for (var i = 0; i < sample_count; i++) { + var sample = {}; + sample.InitializationVector = this.readUint8Array(this.IV_size*8); + if (this.flags & 0x2) { + sample.subsamples = []; + sample.NumberOfEntries = stream.readUint16(); + for (var j = 0; j < sample.NumberOfEntries; j++) { + var subsample = {}; + subsample.BytesOfClearData = stream.readUint16(); + subsample.BytesOfProtectedData = stream.readUint32(); + sample.subsamples.push(subsample); + } + } + this.samples.push(sample); + } + }*/); + // file:src/parsing/uuid/piff/piffTenc.js + BoxParser.createUUIDBox("8974dbce7be74c5184f97148f9882554", true, false, function(stream) { + this.default_AlgorithmID = stream.readUint24(); + this.default_IV_size = stream.readUint8(); + this.default_KID = BoxParser.parseHex16(stream); + });// file:src/parsing/uuid/piff/piffTfrf.js + BoxParser.createUUIDBox("d4807ef2ca3946958e5426cb9e46a79f", true, false, function(stream) { + this.fragment_count = stream.readUint8(); + this.entries = []; + + for (var i = 0; i < this.fragment_count; i++) { + var entry = {}; + var absolute_time = 0; + var absolute_duration = 0; + + if (this.version === 1) { + absolute_time = stream.readUint64(); + absolute_duration = stream.readUint64(); + } else { + absolute_time = stream.readUint32(); + absolute_duration = stream.readUint32(); + } + + entry.absolute_time = absolute_time; + entry.absolute_duration = absolute_duration; + + this.entries.push(entry); + } + });// file:src/parsing/uuid/piff/piffTfxd.js + BoxParser.createUUIDBox("6d1d9b0542d544e680e2141daff757b2", true, false, function(stream) { + if (this.version === 1) { + this.absolute_time = stream.readUint64(); + this.duration = stream.readUint64(); + } else { + this.absolute_time = stream.readUint32(); + this.duration = stream.readUint32(); + } + });// file:src/parsing/vmhd.js + BoxParser.createFullBoxCtor("vmhd", function(stream) { + this.graphicsmode = stream.readUint16(); + this.opcolor = stream.readUint16Array(3); + }); + + // file:src/parsing/vpcC.js + BoxParser.createFullBoxCtor("vpcC", function (stream) { + var tmp; + if (this.version === 1) { + this.profile = stream.readUint8(); + this.level = stream.readUint8(); + tmp = stream.readUint8(); + this.bitDepth = tmp >> 4; + this.chromaSubsampling = (tmp >> 1) & 0x7; + this.videoFullRangeFlag = tmp & 0x1; + this.colourPrimaries = stream.readUint8(); + this.transferCharacteristics = stream.readUint8(); + this.matrixCoefficients = stream.readUint8(); + this.codecIntializationDataSize = stream.readUint16(); + this.codecIntializationData = stream.readUint8Array(this.codecIntializationDataSize); + } else { + this.profile = stream.readUint8(); + this.level = stream.readUint8(); + tmp = stream.readUint8(); + this.bitDepth = (tmp >> 4) & 0xF; + this.colorSpace = tmp & 0xF; + tmp = stream.readUint8(); + this.chromaSubsampling = (tmp >> 4) & 0xF; + this.transferFunction = (tmp >> 1) & 0x7; + this.videoFullRangeFlag = tmp & 0x1; + this.codecIntializationDataSize = stream.readUint16(); + this.codecIntializationData = stream.readUint8Array(this.codecIntializationDataSize); + } + });// file:src/parsing/vttC.js + BoxParser.createBoxCtor("vttC", function(stream) { + this.text = stream.readString(this.size - this.hdr_size); + }); + + // file:src/parsing/vvcC.js + BoxParser.createFullBoxCtor("vvcC", function (stream) { + var i, j; + + // helper object to simplify extracting individual bits + var bitReader = { + held_bits: undefined, + num_held_bits: 0, + + stream_read_1_bytes: function (strm) { + this.held_bits = strm.readUint8(); + this.num_held_bits = 1 * 8; + }, + stream_read_2_bytes: function (strm) { + this.held_bits = strm.readUint16(); + this.num_held_bits = 2 * 8; + }, + + extract_bits: function (num_bits) { + var ret = (this.held_bits >> (this.num_held_bits - num_bits)) & ((1 << num_bits) - 1); + this.num_held_bits -= num_bits; + return ret; + } + }; + + // VvcDecoderConfigurationRecord + bitReader.stream_read_1_bytes(stream); + bitReader.extract_bits(5); // reserved + this.lengthSizeMinusOne = bitReader.extract_bits(2); + this.ptl_present_flag = bitReader.extract_bits(1); + + if (this.ptl_present_flag) { + bitReader.stream_read_2_bytes(stream); + this.ols_idx = bitReader.extract_bits(9); + this.num_sublayers = bitReader.extract_bits(3); + this.constant_frame_rate = bitReader.extract_bits(2); + this.chroma_format_idc = bitReader.extract_bits(2); + + bitReader.stream_read_1_bytes(stream); + this.bit_depth_minus8 = bitReader.extract_bits(3); + bitReader.extract_bits(5); // reserved + + // VvcPTLRecord + { + bitReader.stream_read_2_bytes(stream); + bitReader.extract_bits(2); // reserved + this.num_bytes_constraint_info = bitReader.extract_bits(6); + this.general_profile_idc = bitReader.extract_bits(7); + this.general_tier_flag = bitReader.extract_bits(1); + + this.general_level_idc = stream.readUint8(); + + bitReader.stream_read_1_bytes(stream); + this.ptl_frame_only_constraint_flag = bitReader.extract_bits(1); + this.ptl_multilayer_enabled_flag = bitReader.extract_bits(1); + + this.general_constraint_info = new Uint8Array(this.num_bytes_constraint_info); + if (this.num_bytes_constraint_info) { + for (i = 0; i < this.num_bytes_constraint_info - 1; i++) { + var cnstr1 = bitReader.extract_bits(6); + bitReader.stream_read_1_bytes(stream); + var cnstr2 = bitReader.extract_bits(2); + + this.general_constraint_info[i] = ((cnstr1 << 2) | cnstr2); + } + this.general_constraint_info[this.num_bytes_constraint_info - 1] = bitReader.extract_bits(6); + } else { + //forbidden in spec! + bitReader.extract_bits(6); + } + + if (this.num_sublayers > 1) { + bitReader.stream_read_1_bytes(stream); + this.ptl_sublayer_present_mask = 0; + for (j = this.num_sublayers - 2; j >= 0; --j) { + var val = bitReader.extract_bits(1); + this.ptl_sublayer_present_mask |= val << j; + } + for (j = this.num_sublayers; j <= 8 && this.num_sublayers > 1; ++j) { + bitReader.extract_bits(1); // ptl_reserved_zero_bit + } + + this.sublayer_level_idc = []; + for (j = this.num_sublayers - 2; j >= 0; --j) { + if (this.ptl_sublayer_present_mask & (1 << j)) { + this.sublayer_level_idc[j] = stream.readUint8(); + } + } + } + + this.ptl_num_sub_profiles = stream.readUint8(); + this.general_sub_profile_idc = []; + if (this.ptl_num_sub_profiles) { + for (i = 0; i < this.ptl_num_sub_profiles; i++) { + this.general_sub_profile_idc.push(stream.readUint32()); + } + } + } // end VvcPTLRecord + + this.max_picture_width = stream.readUint16(); + this.max_picture_height = stream.readUint16(); + this.avg_frame_rate = stream.readUint16(); + } + + var VVC_NALU_OPI = 12; + var VVC_NALU_DEC_PARAM = 13; + + this.nalu_arrays = []; + var num_of_arrays = stream.readUint8(); + for (i = 0; i < num_of_arrays; i++) { + var nalu_array = []; + this.nalu_arrays.push(nalu_array); + + bitReader.stream_read_1_bytes(stream); + nalu_array.completeness = bitReader.extract_bits(1); + bitReader.extract_bits(2); // reserved + nalu_array.nalu_type = bitReader.extract_bits(5); + + var numNalus = 1; + if (nalu_array.nalu_type != VVC_NALU_DEC_PARAM && nalu_array.nalu_type != VVC_NALU_OPI) { + numNalus = stream.readUint16(); + } + + for (j = 0; j < numNalus; j++) { + var len = stream.readUint16(); + nalu_array.push({ + data: stream.readUint8Array(len), + length: len + }); + } + } + }); + // file:src/parsing/vvnC.js + BoxParser.createFullBoxCtor("vvnC", function (stream) { + // VvcNALUConfigBox + var tmp = strm.readUint8(); + this.lengthSizeMinusOne = (tmp & 0x3); + }); + // file:src/box-codecs.js + BoxParser.SampleEntry.prototype.isVideo = function() { + return false; + }; + + BoxParser.SampleEntry.prototype.isAudio = function() { + return false; + }; + + BoxParser.SampleEntry.prototype.isSubtitle = function() { + return false; + }; + + BoxParser.SampleEntry.prototype.isMetadata = function() { + return false; + }; + + BoxParser.SampleEntry.prototype.isHint = function() { + return false; + }; + + BoxParser.SampleEntry.prototype.getCodec = function() { + return this.type.replace('.',''); + }; + + BoxParser.SampleEntry.prototype.getWidth = function() { + return ""; + }; + + BoxParser.SampleEntry.prototype.getHeight = function() { + return ""; + }; + + BoxParser.SampleEntry.prototype.getChannelCount = function() { + return ""; + }; + + BoxParser.SampleEntry.prototype.getSampleRate = function() { + return ""; + }; + + BoxParser.SampleEntry.prototype.getSampleSize = function() { + return ""; + }; + + BoxParser.VisualSampleEntry.prototype.isVideo = function() { + return true; + }; + + BoxParser.VisualSampleEntry.prototype.getWidth = function() { + return this.width; + }; + + BoxParser.VisualSampleEntry.prototype.getHeight = function() { + return this.height; + }; + + BoxParser.AudioSampleEntry.prototype.isAudio = function() { + return true; + }; + + BoxParser.AudioSampleEntry.prototype.getChannelCount = function() { + return this.channel_count; + }; + + BoxParser.AudioSampleEntry.prototype.getSampleRate = function() { + return this.samplerate; + }; + + BoxParser.AudioSampleEntry.prototype.getSampleSize = function() { + return this.samplesize; + }; + + BoxParser.SubtitleSampleEntry.prototype.isSubtitle = function() { + return true; + }; + + BoxParser.MetadataSampleEntry.prototype.isMetadata = function() { + return true; + }; + + + BoxParser.decimalToHex = function(d, padding) { + var hex = Number(d).toString(16); + padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding; + while (hex.length < padding) { + hex = "0" + hex; + } + return hex; + }; + + BoxParser.avc1SampleEntry.prototype.getCodec = + BoxParser.avc2SampleEntry.prototype.getCodec = + BoxParser.avc3SampleEntry.prototype.getCodec = + BoxParser.avc4SampleEntry.prototype.getCodec = function() { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.avcC) { + return baseCodec+"."+BoxParser.decimalToHex(this.avcC.AVCProfileIndication)+ + ""+BoxParser.decimalToHex(this.avcC.profile_compatibility)+ + ""+BoxParser.decimalToHex(this.avcC.AVCLevelIndication); + } else { + return baseCodec; + } + }; + + BoxParser.hev1SampleEntry.prototype.getCodec = + BoxParser.hvc1SampleEntry.prototype.getCodec = function() { + var i; + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.hvcC) { + baseCodec += '.'; + switch (this.hvcC.general_profile_space) { + case 0: + baseCodec += ''; + break; + case 1: + baseCodec += 'A'; + break; + case 2: + baseCodec += 'B'; + break; + case 3: + baseCodec += 'C'; + break; + } + baseCodec += this.hvcC.general_profile_idc; + baseCodec += '.'; + var val = this.hvcC.general_profile_compatibility; + var reversed = 0; + for (i=0; i<32; i++) { + reversed |= val & 1; + if (i==31) break; + reversed <<= 1; + val >>=1; + } + baseCodec += BoxParser.decimalToHex(reversed, 0); + baseCodec += '.'; + if (this.hvcC.general_tier_flag === 0) { + baseCodec += 'L'; + } else { + baseCodec += 'H'; + } + baseCodec += this.hvcC.general_level_idc; + var hasByte = false; + var constraint_string = ""; + for (i = 5; i >= 0; i--) { + if (this.hvcC.general_constraint_indicator[i] || hasByte) { + constraint_string = "."+BoxParser.decimalToHex(this.hvcC.general_constraint_indicator[i], 0)+constraint_string; + hasByte = true; + } + } + baseCodec += constraint_string; + } + return baseCodec; + }; + + BoxParser.vvc1SampleEntry.prototype.getCodec = + BoxParser.vvi1SampleEntry.prototype.getCodec = function () { + var i; + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.vvcC) { + baseCodec += '.' + this.vvcC.general_profile_idc; + if (this.vvcC.general_tier_flag) { + baseCodec += '.H'; + } else { + baseCodec += '.L'; + } + baseCodec += this.vvcC.general_level_idc; + + var constraint_string = ""; + if (this.vvcC.general_constraint_info) { + var bytes = []; + var byte = 0; + byte |= this.vvcC.ptl_frame_only_constraint << 7; + byte |= this.vvcC.ptl_multilayer_enabled << 6; + var last_nonzero; + for (i = 0; i < this.vvcC.general_constraint_info.length; ++i) { + byte |= (this.vvcC.general_constraint_info[i] >> 2) & 0x3f; + bytes.push(byte); + if (byte) { + last_nonzero = i; + } + + byte = (this.vvcC.general_constraint_info[i] >> 2) & 0x03; + } + + if (last_nonzero === undefined) { + constraint_string = ".CA"; + } + else { + constraint_string = ".C"; + var base32_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; + var held_bits = 0; + var num_held_bits = 0; + for (i = 0; i <= last_nonzero; ++i) { + held_bits = (held_bits << 8) | bytes[i]; + num_held_bits += 8; + + while (num_held_bits >= 5) { + var val = (held_bits >> (num_held_bits - 5)) & 0x1f; + constraint_string += base32_chars[val]; + + num_held_bits -= 5; + held_bits &= (1 << num_held_bits) - 1; + } + } + if (num_held_bits) { + held_bits <<= (5 - num_held_bits); // right-pad with zeros to 5 bits (is this correct?) + constraint_string += base32_chars[held_bits & 0x1f]; + } + } + } + baseCodec += constraint_string; + } + return baseCodec; + }; + + BoxParser.mp4aSampleEntry.prototype.getCodec = function() { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.esds && this.esds.esd) { + var oti = this.esds.esd.getOTI(); + var dsi = this.esds.esd.getAudioConfig(); + return baseCodec+"."+BoxParser.decimalToHex(oti)+(dsi ? "."+dsi: ""); + } else { + return baseCodec; + } + }; + + BoxParser.stxtSampleEntry.prototype.getCodec = function() { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if(this.mime_format) { + return baseCodec + "." + this.mime_format; + } else { + return baseCodec + } + }; + + BoxParser.vp08SampleEntry.prototype.getCodec = + BoxParser.vp09SampleEntry.prototype.getCodec = function() { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + var level = this.vpcC.level; + if (level == 0) { + level = "00"; + } + var bitDepth = this.vpcC.bitDepth; + if (bitDepth == 8) { + bitDepth = "08"; + } + return baseCodec + ".0" + this.vpcC.profile + "." + level + "." + bitDepth; + }; + + BoxParser.av01SampleEntry.prototype.getCodec = function() { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + var level = this.av1C.seq_level_idx_0; + if (level < 10) { + level = "0" + level; + } + var bitdepth; + if (this.av1C.seq_profile === 2 && this.av1C.high_bitdepth === 1) { + bitdepth = (this.av1C.twelve_bit === 1) ? "12" : "10"; + } else if ( this.av1C.seq_profile <= 2 ) { + bitdepth = (this.av1C.high_bitdepth === 1) ? "10" : "08"; + } + // TODO need to parse the SH to find color config + return baseCodec+"."+this.av1C.seq_profile+"."+level+(this.av1C.seq_tier_0?"H":"M")+"."+bitdepth;//+"."+this.av1C.monochrome+"."+this.av1C.chroma_subsampling_x+""+this.av1C.chroma_subsampling_y+""+this.av1C.chroma_sample_position; + }; + // file:src/box-write.js + /* + * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + BoxParser.Box.prototype.writeHeader = function(stream, msg) { + this.size += 8; + if (this.size > MAX_SIZE) { + this.size += 8; + } + if (this.type === "uuid") { + this.size += 16; + } + Log.debug("BoxWriter", "Writing box "+this.type+" of size: "+this.size+" at position "+stream.getPosition()+(msg || "")); + if (this.size > MAX_SIZE) { + stream.writeUint32(1); + } else { + this.sizePosition = stream.getPosition(); + stream.writeUint32(this.size); + } + stream.writeString(this.type, null, 4); + if (this.type === "uuid") { + stream.writeUint8Array(this.uuid); + } + if (this.size > MAX_SIZE) { + stream.writeUint64(this.size); + } + }; + + BoxParser.FullBox.prototype.writeHeader = function(stream) { + this.size += 4; + BoxParser.Box.prototype.writeHeader.call(this, stream, " v="+this.version+" f="+this.flags); + stream.writeUint8(this.version); + stream.writeUint24(this.flags); + }; + + BoxParser.Box.prototype.write = function(stream) { + if (this.type === "mdat") { + /* TODO: fix this */ + if (this.data) { + this.size = this.data.length; + this.writeHeader(stream); + stream.writeUint8Array(this.data); + } + } else { + this.size = (this.data ? this.data.length : 0); + this.writeHeader(stream); + if (this.data) { + stream.writeUint8Array(this.data); + } + } + }; + + BoxParser.ContainerBox.prototype.write = function(stream) { + this.size = 0; + this.writeHeader(stream); + for (var i=0; i= 2) { + stream.writeUint32(this.default_sample_description_index); + } + stream.writeUint32(this.entries.length); + for (i = 0; i < this.entries.length; i++) { + entry = this.entries[i]; + if (this.version === 1) { + if (this.default_length === 0) { + stream.writeUint32(entry.description_length); + } + } + entry.write(stream); + } + }; + + + // file:src/writing/sidx.js + BoxParser.sidxBox.prototype.write = function(stream) { + this.version = 0; + this.flags = 0; + this.size = 4*4+2+2+12*this.references.length; + this.writeHeader(stream); + stream.writeUint32(this.reference_ID); + stream.writeUint32(this.timescale); + stream.writeUint32(this.earliest_presentation_time); + stream.writeUint32(this.first_offset); + stream.writeUint16(0); + stream.writeUint16(this.references.length); + for (var i = 0; i < this.references.length; i++) { + var ref = this.references[i]; + stream.writeUint32(ref.reference_type << 31 | ref.referenced_size); + stream.writeUint32(ref.subsegment_duration); + stream.writeUint32(ref.starts_with_SAP << 31 | ref.SAP_type << 28 | ref.SAP_delta_time); + } + }; + + // file:src/writing/smhd.js + BoxParser.smhdBox.prototype.write = function(stream) { + this.version = 0; + this.flags = 1; + this.size = 4; + this.writeHeader(stream); + stream.writeUint16(this.balance); + stream.writeUint16(0); + }; + // file:src/writing/stco.js + BoxParser.stcoBox.prototype.write = function(stream) { + this.version = 0; + this.flags = 0; + this.size = 4+4*this.chunk_offsets.length; + this.writeHeader(stream); + stream.writeUint32(this.chunk_offsets.length); + stream.writeUint32Array(this.chunk_offsets); + }; + + // file:src/writing/stsc.js + BoxParser.stscBox.prototype.write = function(stream) { + var i; + this.version = 0; + this.flags = 0; + this.size = 4+12*this.first_chunk.length; + this.writeHeader(stream); + stream.writeUint32(this.first_chunk.length); + for(i=0; i 0) { + i = 0; + while (i+1 < this.sample_sizes.length) { + if (this.sample_sizes[i+1] !== this.sample_sizes[0]) { + constant = false; + break; + } else { + i++; + } + } + } else { + constant = false; + } + this.size = 8; + if (!constant) { + this.size += 4*this.sample_sizes.length; + } + this.writeHeader(stream); + if (!constant) { + stream.writeUint32(0); + } else { + stream.writeUint32(this.sample_sizes[0]); + } + stream.writeUint32(this.sample_sizes.length); + if (!constant) { + stream.writeUint32Array(this.sample_sizes); + } + }; + + // file:src/writing/stts.js + BoxParser.sttsBox.prototype.write = function(stream) { + var i; + this.version = 0; + this.flags = 0; + this.size = 4+8*this.sample_counts.length; + this.writeHeader(stream); + stream.writeUint32(this.sample_counts.length); + for(i=0; i UINT32_MAX ? 1 : 0; + this.flags = 0; + this.size = 4; + if (this.version === 1) { + this.size += 4; + } + this.writeHeader(stream); + if (this.version === 1) { + stream.writeUint64(this.baseMediaDecodeTime); + } else { + stream.writeUint32(this.baseMediaDecodeTime); + } + }; + + // file:src/writing/tfhd.js + BoxParser.tfhdBox.prototype.write = function(stream) { + this.version = 0; + this.size = 4; + if (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { + this.size += 8; + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { + this.size += 4; + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { + this.size += 4; + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { + this.size += 4; + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { + this.size += 4; + } + this.writeHeader(stream); + stream.writeUint32(this.track_id); + if (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { + stream.writeUint64(this.base_data_offset); + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { + stream.writeUint32(this.default_sample_description_index); + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { + stream.writeUint32(this.default_sample_duration); + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { + stream.writeUint32(this.default_sample_size); + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { + stream.writeUint32(this.default_sample_flags); + } + }; + + // file:src/writing/tkhd.js + BoxParser.tkhdBox.prototype.write = function(stream) { + this.version = 0; + //this.flags = 0; + this.size = 4*18+2*4; + this.writeHeader(stream); + stream.writeUint32(this.creation_time); + stream.writeUint32(this.modification_time); + stream.writeUint32(this.track_id); + stream.writeUint32(0); + stream.writeUint32(this.duration); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeInt16(this.layer); + stream.writeInt16(this.alternate_group); + stream.writeInt16(this.volume<<8); + stream.writeUint16(0); + stream.writeInt32Array(this.matrix); + stream.writeUint32(this.width); + stream.writeUint32(this.height); + }; + + // file:src/writing/trex.js + BoxParser.trexBox.prototype.write = function(stream) { + this.version = 0; + this.flags = 0; + this.size = 4*5; + this.writeHeader(stream); + stream.writeUint32(this.track_id); + stream.writeUint32(this.default_sample_description_index); + stream.writeUint32(this.default_sample_duration); + stream.writeUint32(this.default_sample_size); + stream.writeUint32(this.default_sample_flags); + }; + + // file:src/writing/trun.js + BoxParser.trunBox.prototype.write = function(stream) { + this.version = 0; + this.size = 4; + if (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { + this.size += 4; + } + if (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { + this.size += 4; + } + if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { + this.size += 4*this.sample_duration.length; + } + if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { + this.size += 4*this.sample_size.length; + } + if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { + this.size += 4*this.sample_flags.length; + } + if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { + this.size += 4*this.sample_composition_time_offset.length; + } + this.writeHeader(stream); + stream.writeUint32(this.sample_count); + if (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { + this.data_offset_position = stream.getPosition(); + stream.writeInt32(this.data_offset); //signed + } + if (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { + stream.writeUint32(this.first_sample_flags); + } + for (var i = 0; i < this.sample_count; i++) { + if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { + stream.writeUint32(this.sample_duration[i]); + } + if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { + stream.writeUint32(this.sample_size[i]); + } + if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { + stream.writeUint32(this.sample_flags[i]); + } + if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { + if (this.version === 0) { + stream.writeUint32(this.sample_composition_time_offset[i]); + } else { + stream.writeInt32(this.sample_composition_time_offset[i]); //signed + } + } + } + }; + + // file:src/writing/url.js + BoxParser["url Box"].prototype.write = function(stream) { + this.version = 0; + if (this.location) { + this.flags = 0; + this.size = this.location.length+1; + } else { + this.flags = 0x000001; + this.size = 0; + } + this.writeHeader(stream); + if (this.location) { + stream.writeCString(this.location); + } + }; + + // file:src/writing/urn.js + BoxParser["urn Box"].prototype.write = function(stream) { + this.version = 0; + this.flags = 0; + this.size = this.name.length+1+(this.location ? this.location.length+1 : 0); + this.writeHeader(stream); + stream.writeCString(this.name); + if (this.location) { + stream.writeCString(this.location); + } + }; + + // file:src/writing/vmhd.js + BoxParser.vmhdBox.prototype.write = function(stream) { + this.version = 0; + this.flags = 1; + this.size = 8; + this.writeHeader(stream); + stream.writeUint16(this.graphicsmode); + stream.writeUint16Array(this.opcolor); + }; + + // file:src/box-unpack.js + /* + * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + BoxParser.cttsBox.prototype.unpack = function(samples) { + var i, j, k; + k = 0; + for (i = 0; i < this.sample_counts.length; i++) { + for (j = 0; j < this.sample_counts[i]; j++) { + samples[k].pts = samples[k].dts + this.sample_offsets[i]; + k++; + } + } + }; + + BoxParser.sttsBox.prototype.unpack = function(samples) { + var i, j, k; + k = 0; + for (i = 0; i < this.sample_counts.length; i++) { + for (j = 0; j < this.sample_counts[i]; j++) { + if (k === 0) { + samples[k].dts = 0; + } else { + samples[k].dts = samples[k-1].dts + this.sample_deltas[i]; + } + k++; + } + } + }; + + BoxParser.stcoBox.prototype.unpack = function(samples) { + var i; + for (i = 0; i < this.chunk_offsets.length; i++) { + samples[i].offset = this.chunk_offsets[i]; + } + }; + + BoxParser.stscBox.prototype.unpack = function(samples) { + var i, j, k, l, m; + l = 0; + m = 0; + for (i = 0; i < this.first_chunk.length; i++) { + for (j = 0; j < (i+1 < this.first_chunk.length ? this.first_chunk[i+1] : Infinity); j++) { + m++; + for (k = 0; k < this.samples_per_chunk[i]; k++) { + if (samples[l]) { + samples[l].description_index = this.sample_description_index[i]; + samples[l].chunk_index = m; + } else { + return; + } + l++; + } + } + } + }; + + BoxParser.stszBox.prototype.unpack = function(samples) { + var i; + for (i = 0; i < this.sample_sizes.length; i++) { + samples[i].size = this.sample_sizes[i]; + } + }; + // file:src/box-diff.js + + BoxParser.DIFF_BOXES_PROP_NAMES = [ "boxes", "entries", "references", "subsamples", + "items", "item_infos", "extents", "associations", + "subsegments", "ranges", "seekLists", "seekPoints", + "esd", "levels"]; + + BoxParser.DIFF_PRIMITIVE_ARRAY_PROP_NAMES = [ "compatible_brands", "matrix", "opcolor", "sample_counts", "sample_counts", "sample_deltas", + "first_chunk", "samples_per_chunk", "sample_sizes", "chunk_offsets", "sample_offsets", "sample_description_index", "sample_duration" ]; + + BoxParser.boxEqualFields = function(box_a, box_b) { + if (box_a && !box_b) return false; + var prop; + for (prop in box_a) { + if (BoxParser.DIFF_BOXES_PROP_NAMES.indexOf(prop) > -1) { + continue; + // } else if (excluded_fields && excluded_fields.indexOf(prop) > -1) { + // continue; + } else if (box_a[prop] instanceof BoxParser.Box || box_b[prop] instanceof BoxParser.Box) { + continue; + } else if (typeof box_a[prop] === "undefined" || typeof box_b[prop] === "undefined") { + continue; + } else if (typeof box_a[prop] === "function" || typeof box_b[prop] === "function") { + continue; + } else if ( + (box_a.subBoxNames && box_a.subBoxNames.indexOf(prop.slice(0,4)) > -1) || + (box_b.subBoxNames && box_b.subBoxNames.indexOf(prop.slice(0,4)) > -1)) { + continue; + } else { + if (prop === "data" || prop === "start" || prop === "size" || prop === "creation_time" || prop === "modification_time") { + continue; + } else if (BoxParser.DIFF_PRIMITIVE_ARRAY_PROP_NAMES.indexOf(prop) > -1) { + continue; + } else { + if (box_a[prop] !== box_b[prop]) { + return false; + } + } + } + } + return true; + }; + + BoxParser.boxEqual = function(box_a, box_b) { + if (!BoxParser.boxEqualFields(box_a, box_b)) { + return false; + } + for (var j = 0; j < BoxParser.DIFF_BOXES_PROP_NAMES.length; j++) { + var name = BoxParser.DIFF_BOXES_PROP_NAMES[j]; + if (box_a[name] && box_b[name]) { + if (!BoxParser.boxEqual(box_a[name], box_b[name])) { + return false; + } + } + } + return true; + };// file:src/text-mp4.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var VTTin4Parser = function() { + }; + + VTTin4Parser.prototype.parseSample = function(data) { + var cues, cue; + var stream = new MP4BoxStream(data.buffer); + cues = []; + while (!stream.isEos()) { + cue = BoxParser.parseOneBox(stream, false); + if (cue.code === BoxParser.OK && cue.box.type === "vttc") { + cues.push(cue.box); + } + } + return cues; + }; + + VTTin4Parser.prototype.getText = function (startTime, endTime, data) { + function pad(n, width, z) { + z = z || '0'; + n = n + ''; + return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n; + } + function secToTimestamp(insec) { + var h = Math.floor(insec/3600); + var m = Math.floor((insec - h*3600)/60); + var s = Math.floor(insec - h*3600 - m*60); + var ms = Math.floor((insec - h*3600 - m*60 - s)*1000); + return ""+pad(h, 2)+":"+pad(m,2)+":"+pad(s, 2)+"."+pad(ms, 3); + } + var cues = this.parseSample(data); + var string = ""; + for (var i = 0; i < cues.length; i++) { + var cueIn4 = cues[i]; + string += secToTimestamp(startTime)+" --> "+secToTimestamp(endTime)+"\r\n"; + string += cueIn4.payl.text; + } + return string; + }; + + var XMLSubtitlein4Parser = function() { + }; + + XMLSubtitlein4Parser.prototype.parseSample = function(sample) { + var res = {}; + var i; + res.resources = []; + var stream = new MP4BoxStream(sample.data.buffer); + if (!sample.subsamples || sample.subsamples.length === 0) { + res.documentString = stream.readString(sample.data.length); + } else { + res.documentString = stream.readString(sample.subsamples[0].size); + if (sample.subsamples.length > 1) { + for (i = 1; i < sample.subsamples.length; i++) { + res.resources[i] = stream.readUint8Array(sample.subsamples[i].size); + } + } + } + if (typeof (DOMParser) !== "undefined") { + res.document = (new DOMParser()).parseFromString(res.documentString, "application/xml"); + } + return res; + }; + + var Textin4Parser = function() { + }; + + Textin4Parser.prototype.parseSample = function(sample) { + var textString; + var stream = new MP4BoxStream(sample.data.buffer); + textString = stream.readString(sample.data.length); + return textString; + }; + + Textin4Parser.prototype.parseConfig = function(data) { + var textString; + var stream = new MP4BoxStream(data.buffer); + stream.readUint32(); // version & flags + textString = stream.readCString(); + return textString; + }; + + { + exports.VTTin4Parser = VTTin4Parser; + exports.XMLSubtitlein4Parser = XMLSubtitlein4Parser; + exports.Textin4Parser = Textin4Parser; + } + // file:src/isofile.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var ISOFile = function (stream) { + /* MutiBufferStream object used to parse boxes */ + this.stream = stream || new MultiBufferStream(); + /* Array of all boxes (in order) found in the file */ + this.boxes = []; + /* Array of all mdats */ + this.mdats = []; + /* Array of all moofs */ + this.moofs = []; + /* Boolean indicating if the file is compatible with progressive parsing (moov first) */ + this.isProgressive = false; + /* Boolean used to fire moov start event only once */ + this.moovStartFound = false; + /* Callback called when the moov parsing starts */ + this.onMoovStart = null; + /* Boolean keeping track of the call to onMoovStart, to avoid double calls */ + this.moovStartSent = false; + /* Callback called when the moov is entirely parsed */ + this.onReady = null; + /* Boolean keeping track of the call to onReady, to avoid double calls */ + this.readySent = false; + /* Callback to call when segments are ready */ + this.onSegment = null; + /* Callback to call when samples are ready */ + this.onSamples = null; + /* Callback to call when there is an error in the parsing or processing of samples */ + this.onError = null; + /* Boolean indicating if the moov box run-length encoded tables of sample information have been processed */ + this.sampleListBuilt = false; + /* Array of Track objects for which fragmentation of samples is requested */ + this.fragmentedTracks = []; + /* Array of Track objects for which extraction of samples is requested */ + this.extractedTracks = []; + /* Boolean indicating that fragmention is ready */ + this.isFragmentationInitialized = false; + /* Boolean indicating that fragmented has started */ + this.sampleProcessingStarted = false; + /* Number of the next 'moof' to generate when fragmenting */ + this.nextMoofNumber = 0; + /* Boolean indicating if the initial list of items has been produced */ + this.itemListBuilt = false; + /* Array of items */ + this.items = []; + /* Array of entity groups */ + this.entity_groups = []; + /* Callback called when the sidx box is entirely parsed */ + this.onSidx = null; + /* Boolean keeping track of the call to onSidx, to avoid double calls */ + this.sidxSent = false; + }; + + ISOFile.prototype.setSegmentOptions = function(id, user, options) { + var trak = this.getTrackById(id); + if (trak) { + var fragTrack = {}; + this.fragmentedTracks.push(fragTrack); + fragTrack.id = id; + fragTrack.user = user; + fragTrack.trak = trak; + trak.nextSample = 0; + fragTrack.segmentStream = null; + fragTrack.nb_samples = 1000; + fragTrack.rapAlignement = true; + if (options) { + if (options.nbSamples) fragTrack.nb_samples = options.nbSamples; + if (options.rapAlignement) fragTrack.rapAlignement = options.rapAlignement; + } + } + }; + + ISOFile.prototype.unsetSegmentOptions = function(id) { + var index = -1; + for (var i = 0; i < this.fragmentedTracks.length; i++) { + var fragTrack = this.fragmentedTracks[i]; + if (fragTrack.id == id) { + index = i; + } + } + if (index > -1) { + this.fragmentedTracks.splice(index, 1); + } + }; + + ISOFile.prototype.setExtractionOptions = function(id, user, options) { + var trak = this.getTrackById(id); + if (trak) { + var extractTrack = {}; + this.extractedTracks.push(extractTrack); + extractTrack.id = id; + extractTrack.user = user; + extractTrack.trak = trak; + trak.nextSample = 0; + extractTrack.nb_samples = 1000; + extractTrack.samples = []; + if (options) { + if (options.nbSamples) extractTrack.nb_samples = options.nbSamples; + } + } + }; + + ISOFile.prototype.unsetExtractionOptions = function(id) { + var index = -1; + for (var i = 0; i < this.extractedTracks.length; i++) { + var extractTrack = this.extractedTracks[i]; + if (extractTrack.id == id) { + index = i; + } + } + if (index > -1) { + this.extractedTracks.splice(index, 1); + } + }; + + ISOFile.prototype.parse = function() { + var ret; + var box; + var parseBoxHeadersOnly = false; + + if (this.restoreParsePosition) { + if (!this.restoreParsePosition()) { + return; + } + } + + while (true) { + + if (this.hasIncompleteMdat && this.hasIncompleteMdat()) { + if (this.processIncompleteMdat()) { + continue; + } else { + return; + } + } else { + if (this.saveParsePosition) { + this.saveParsePosition(); + } + ret = BoxParser.parseOneBox(this.stream, parseBoxHeadersOnly); + if (ret.code === BoxParser.ERR_NOT_ENOUGH_DATA) { + if (this.processIncompleteBox) { + if (this.processIncompleteBox(ret)) { + continue; + } else { + return; + } + } else { + return; + } + } else { + var box_type; + /* the box is entirely parsed */ + box = ret.box; + box_type = (box.type !== "uuid" ? box.type : box.uuid); + /* store the box in the 'boxes' array to preserve box order (for file rewrite if needed) */ + this.boxes.push(box); + /* but also store box in a property for more direct access */ + switch (box_type) { + case "mdat": + this.mdats.push(box); + break; + case "moof": + this.moofs.push(box); + break; + case "moov": + this.moovStartFound = true; + if (this.mdats.length === 0) { + this.isProgressive = true; + } + /* no break */ + /* falls through */ + default: + if (this[box_type] !== undefined) { + Log.warn("ISOFile", "Duplicate Box of type: "+box_type+", overriding previous occurrence"); + } + this[box_type] = box; + break; + } + if (this.updateUsedBytes) { + this.updateUsedBytes(box, ret); + } + } + } + } + }; + + ISOFile.prototype.checkBuffer = function (ab) { + if (ab === null || ab === undefined) { + throw("Buffer must be defined and non empty"); + } + if (ab.fileStart === undefined) { + throw("Buffer must have a fileStart property"); + } + if (ab.byteLength === 0) { + Log.warn("ISOFile", "Ignoring empty buffer (fileStart: "+ab.fileStart+")"); + this.stream.logBufferLevel(); + return false; + } + Log.info("ISOFile", "Processing buffer (fileStart: "+ab.fileStart+")"); + + /* mark the bytes in the buffer as not being used yet */ + ab.usedBytes = 0; + this.stream.insertBuffer(ab); + this.stream.logBufferLevel(); + + if (!this.stream.initialized()) { + Log.warn("ISOFile", "Not ready to start parsing"); + return false; + } + return true; + }; + + /* Processes a new ArrayBuffer (with a fileStart property) + Returns the next expected file position, or undefined if not ready to parse */ + ISOFile.prototype.appendBuffer = function(ab, last) { + var nextFileStart; + if (!this.checkBuffer(ab)) { + return; + } + + /* Parse whatever is in the existing buffers */ + this.parse(); + + /* Check if the moovStart callback needs to be called */ + if (this.moovStartFound && !this.moovStartSent) { + this.moovStartSent = true; + if (this.onMoovStart) this.onMoovStart(); + } + + if (this.moov) { + /* A moov box has been entirely parsed */ + + /* if this is the first call after the moov is found we initialize the list of samples (may be empty in fragmented files) */ + if (!this.sampleListBuilt) { + this.buildSampleLists(); + this.sampleListBuilt = true; + } + + /* We update the sample information if there are any new moof boxes */ + this.updateSampleLists(); + + /* If the application needs to be informed that the 'moov' has been found, + we create the information object and callback the application */ + if (this.onReady && !this.readySent) { + this.readySent = true; + this.onReady(this.getInfo()); + } + + /* See if any sample extraction or segment creation needs to be done with the available samples */ + this.processSamples(last); + + /* Inform about the best range to fetch next */ + if (this.nextSeekPosition) { + nextFileStart = this.nextSeekPosition; + this.nextSeekPosition = undefined; + } else { + nextFileStart = this.nextParsePosition; + } + if (this.stream.getEndFilePositionAfter) { + nextFileStart = this.stream.getEndFilePositionAfter(nextFileStart); + } + } else { + if (this.nextParsePosition) { + /* moov has not been parsed but the first buffer was received, + the next fetch should probably be the next box start */ + nextFileStart = this.nextParsePosition; + } else { + /* No valid buffer has been parsed yet, we cannot know what to parse next */ + nextFileStart = 0; + } + } + if (this.sidx) { + if (this.onSidx && !this.sidxSent) { + this.onSidx(this.sidx); + this.sidxSent = true; + } + } + if (this.meta) { + if (this.flattenItemInfo && !this.itemListBuilt) { + this.flattenItemInfo(); + this.itemListBuilt = true; + } + if (this.processItems) { + this.processItems(this.onItem); + } + } + + if (this.stream.cleanBuffers) { + Log.info("ISOFile", "Done processing buffer (fileStart: "+ab.fileStart+") - next buffer to fetch should have a fileStart position of "+nextFileStart); + this.stream.logBufferLevel(); + this.stream.cleanBuffers(); + this.stream.logBufferLevel(true); + Log.info("ISOFile", "Sample data size in memory: "+this.getAllocatedSampleDataSize()); + } + return nextFileStart; + }; + + ISOFile.prototype.getInfo = function() { + var i, j; + var movie = {}; + var trak; + var track; + var ref; + var sample_desc; + var _1904 = (new Date('1904-01-01T00:00:00Z').getTime()); + + if (this.moov) { + movie.hasMoov = true; + movie.duration = this.moov.mvhd.duration; + movie.timescale = this.moov.mvhd.timescale; + movie.isFragmented = (this.moov.mvex != null); + if (movie.isFragmented && this.moov.mvex.mehd) { + movie.fragment_duration = this.moov.mvex.mehd.fragment_duration; + } + movie.isProgressive = this.isProgressive; + movie.hasIOD = (this.moov.iods != null); + movie.brands = []; + movie.brands.push(this.ftyp.major_brand); + movie.brands = movie.brands.concat(this.ftyp.compatible_brands); + movie.created = new Date(_1904+this.moov.mvhd.creation_time*1000); + movie.modified = new Date(_1904+this.moov.mvhd.modification_time*1000); + movie.tracks = []; + movie.audioTracks = []; + movie.videoTracks = []; + movie.subtitleTracks = []; + movie.metadataTracks = []; + movie.hintTracks = []; + movie.otherTracks = []; + for (i = 0; i < this.moov.traks.length; i++) { + trak = this.moov.traks[i]; + sample_desc = trak.mdia.minf.stbl.stsd.entries[0]; + track = {}; + movie.tracks.push(track); + track.id = trak.tkhd.track_id; + track.name = trak.mdia.hdlr.name; + track.references = []; + if (trak.tref) { + for (j = 0; j < trak.tref.boxes.length; j++) { + ref = {}; + track.references.push(ref); + ref.type = trak.tref.boxes[j].type; + ref.track_ids = trak.tref.boxes[j].track_ids; + } + } + if (trak.edts) { + track.edits = trak.edts.elst.entries; + } + track.created = new Date(_1904+trak.tkhd.creation_time*1000); + track.modified = new Date(_1904+trak.tkhd.modification_time*1000); + track.movie_duration = trak.tkhd.duration; + track.movie_timescale = movie.timescale; + track.layer = trak.tkhd.layer; + track.alternate_group = trak.tkhd.alternate_group; + track.volume = trak.tkhd.volume; + track.matrix = trak.tkhd.matrix; + track.track_width = trak.tkhd.width/(1<<16); + track.track_height = trak.tkhd.height/(1<<16); + track.timescale = trak.mdia.mdhd.timescale; + track.cts_shift = trak.mdia.minf.stbl.cslg; + track.duration = trak.mdia.mdhd.duration; + track.samples_duration = trak.samples_duration; + track.codec = sample_desc.getCodec(); + track.kind = (trak.udta && trak.udta.kinds.length ? trak.udta.kinds[0] : { schemeURI: "", value: ""}); + track.language = (trak.mdia.elng ? trak.mdia.elng.extended_language : trak.mdia.mdhd.languageString); + track.nb_samples = trak.samples.length; + track.size = trak.samples_size; + track.bitrate = (track.size*8*track.timescale)/track.samples_duration; + if (sample_desc.isAudio()) { + track.type = "audio"; + movie.audioTracks.push(track); + track.audio = {}; + track.audio.sample_rate = sample_desc.getSampleRate(); + track.audio.channel_count = sample_desc.getChannelCount(); + track.audio.sample_size = sample_desc.getSampleSize(); + } else if (sample_desc.isVideo()) { + track.type = "video"; + movie.videoTracks.push(track); + track.video = {}; + track.video.width = sample_desc.getWidth(); + track.video.height = sample_desc.getHeight(); + } else if (sample_desc.isSubtitle()) { + track.type = "subtitles"; + movie.subtitleTracks.push(track); + } else if (sample_desc.isHint()) { + track.type = "metadata"; + movie.hintTracks.push(track); + } else if (sample_desc.isMetadata()) { + track.type = "metadata"; + movie.metadataTracks.push(track); + } else { + track.type = "metadata"; + movie.otherTracks.push(track); + } + } + } else { + movie.hasMoov = false; + } + movie.mime = ""; + if (movie.hasMoov && movie.tracks) { + if (movie.videoTracks && movie.videoTracks.length > 0) { + movie.mime += 'video/mp4; codecs=\"'; + } else if (movie.audioTracks && movie.audioTracks.length > 0) { + movie.mime += 'audio/mp4; codecs=\"'; + } else { + movie.mime += 'application/mp4; codecs=\"'; + } + for (i = 0; i < movie.tracks.length; i++) { + if (i !== 0) movie.mime += ','; + movie.mime+= movie.tracks[i].codec; + } + movie.mime += '\"; profiles=\"'; + movie.mime += this.ftyp.compatible_brands.join(); + movie.mime += '\"'; + } + return movie; + }; + + ISOFile.prototype.setNextSeekPositionFromSample = function (sample) { + if (!sample) { + return; + } + if (this.nextSeekPosition) { + this.nextSeekPosition = Math.min(sample.offset+sample.alreadyRead,this.nextSeekPosition); + } else { + this.nextSeekPosition = sample.offset+sample.alreadyRead; + } + }; + + ISOFile.prototype.processSamples = function(last) { + var i; + var trak; + if (!this.sampleProcessingStarted) return; + + /* For each track marked for fragmentation, + check if the next sample is there (i.e. if the sample information is known (i.e. moof has arrived) and if it has been downloaded) + and create a fragment with it */ + if (this.isFragmentationInitialized && this.onSegment !== null) { + for (i = 0; i < this.fragmentedTracks.length; i++) { + var fragTrak = this.fragmentedTracks[i]; + trak = fragTrak.trak; + while (trak.nextSample < trak.samples.length && this.sampleProcessingStarted) { + /* The sample information is there (either because the file is not fragmented and this is not the last sample, + or because the file is fragmented and the moof for that sample has been received */ + Log.debug("ISOFile", "Creating media fragment on track #"+fragTrak.id +" for sample "+trak.nextSample); + var result = this.createFragment(fragTrak.id, trak.nextSample, fragTrak.segmentStream); + if (result) { + fragTrak.segmentStream = result; + trak.nextSample++; + } else { + /* The fragment could not be created because the media data is not there (not downloaded), wait for it */ + break; + } + /* A fragment is created by sample, but the segment is the accumulation in the buffer of these fragments. + It is flushed only as requested by the application (nb_samples) to avoid too many callbacks */ + if (trak.nextSample % fragTrak.nb_samples === 0 || (last || trak.nextSample >= trak.samples.length)) { + Log.info("ISOFile", "Sending fragmented data on track #"+fragTrak.id+" for samples ["+Math.max(0,trak.nextSample-fragTrak.nb_samples)+","+(trak.nextSample-1)+"]"); + Log.info("ISOFile", "Sample data size in memory: "+this.getAllocatedSampleDataSize()); + if (this.onSegment) { + this.onSegment(fragTrak.id, fragTrak.user, fragTrak.segmentStream.buffer, trak.nextSample, (last || trak.nextSample >= trak.samples.length)); + } + /* force the creation of a new buffer */ + fragTrak.segmentStream = null; + if (fragTrak !== this.fragmentedTracks[i]) { + /* make sure we can stop fragmentation if needed */ + break; + } + } + } + } + } + + if (this.onSamples !== null) { + /* For each track marked for data export, + check if the next sample is there (i.e. has been downloaded) and send it */ + for (i = 0; i < this.extractedTracks.length; i++) { + var extractTrak = this.extractedTracks[i]; + trak = extractTrak.trak; + while (trak.nextSample < trak.samples.length && this.sampleProcessingStarted) { + Log.debug("ISOFile", "Exporting on track #"+extractTrak.id +" sample #"+trak.nextSample); + var sample = this.getSample(trak, trak.nextSample); + if (sample) { + trak.nextSample++; + extractTrak.samples.push(sample); + } else { + this.setNextSeekPositionFromSample(trak.samples[trak.nextSample]); + break; + } + if (trak.nextSample % extractTrak.nb_samples === 0 || trak.nextSample >= trak.samples.length) { + Log.debug("ISOFile", "Sending samples on track #"+extractTrak.id+" for sample "+trak.nextSample); + if (this.onSamples) { + this.onSamples(extractTrak.id, extractTrak.user, extractTrak.samples); + } + extractTrak.samples = []; + if (extractTrak !== this.extractedTracks[i]) { + /* check if the extraction needs to be stopped */ + break; + } + } + } + } + } + }; + + /* Find and return specific boxes using recursion and early return */ + ISOFile.prototype.getBox = function(type) { + var result = this.getBoxes(type, true); + return (result.length ? result[0] : null); + }; + + ISOFile.prototype.getBoxes = function(type, returnEarly) { + var result = []; + ISOFile._sweep.call(this, type, result, returnEarly); + return result; + }; + + ISOFile._sweep = function(type, result, returnEarly) { + if (this.type && this.type == type) result.push(this); + for (var box in this.boxes) { + if (result.length && returnEarly) return; + ISOFile._sweep.call(this.boxes[box], type, result, returnEarly); + } + }; + + ISOFile.prototype.getTrackSamplesInfo = function(track_id) { + var track = this.getTrackById(track_id); + if (track) { + return track.samples; + } else { + return; + } + }; + + ISOFile.prototype.getTrackSample = function(track_id, number) { + var track = this.getTrackById(track_id); + var sample = this.getSample(track, number); + return sample; + }; + + /* Called by the application to release the resources associated to samples already forwarded to the application */ + ISOFile.prototype.releaseUsedSamples = function (id, sampleNum) { + var size = 0; + var trak = this.getTrackById(id); + if (!trak.lastValidSample) trak.lastValidSample = 0; + for (var i = trak.lastValidSample; i < sampleNum; i++) { + size+=this.releaseSample(trak, i); + } + Log.info("ISOFile", "Track #"+id+" released samples up to "+sampleNum+" (released size: "+size+", remaining: "+this.samplesDataSize+")"); + trak.lastValidSample = sampleNum; + }; + + ISOFile.prototype.start = function() { + this.sampleProcessingStarted = true; + this.processSamples(false); + }; + + ISOFile.prototype.stop = function() { + this.sampleProcessingStarted = false; + }; + + /* Called by the application to flush the remaining samples (e.g. once the download is finished or when no more samples will be added) */ + ISOFile.prototype.flush = function() { + Log.info("ISOFile", "Flushing remaining samples"); + this.updateSampleLists(); + this.processSamples(true); + this.stream.cleanBuffers(); + this.stream.logBufferLevel(true); + }; + + /* Finds the byte offset for a given time on a given track + also returns the time of the previous rap */ + ISOFile.prototype.seekTrack = function(time, useRap, trak) { + var j; + var sample; + var seek_offset = Infinity; + var rap_seek_sample_num = 0; + var seek_sample_num = 0; + var timescale; + + if (trak.samples.length === 0) { + Log.info("ISOFile", "No sample in track, cannot seek! Using time "+Log.getDurationString(0, 1) +" and offset: "+0); + return { offset: 0, time: 0 }; + } + + for (j = 0; j < trak.samples.length; j++) { + sample = trak.samples[j]; + if (j === 0) { + seek_sample_num = 0; + timescale = sample.timescale; + } else if (sample.cts > time * sample.timescale) { + seek_sample_num = j-1; + break; + } + if (useRap && sample.is_sync) { + rap_seek_sample_num = j; + } + } + if (useRap) { + seek_sample_num = rap_seek_sample_num; + } + time = trak.samples[seek_sample_num].cts; + trak.nextSample = seek_sample_num; + while (trak.samples[seek_sample_num].alreadyRead === trak.samples[seek_sample_num].size) { + // No remaining samples to look for, all are downloaded. + if (!trak.samples[seek_sample_num + 1]) { + break; + } + seek_sample_num++; + } + seek_offset = trak.samples[seek_sample_num].offset+trak.samples[seek_sample_num].alreadyRead; + Log.info("ISOFile", "Seeking to "+(useRap ? "RAP": "")+" sample #"+trak.nextSample+" on track "+trak.tkhd.track_id+", time "+Log.getDurationString(time, timescale) +" and offset: "+seek_offset); + return { offset: seek_offset, time: time/timescale }; + }; + + ISOFile.prototype.getTrackDuration = function (trak) { + var sample; + + if (!trak.samples) { + return Infinity; + } + sample = trak.samples[trak.samples.length - 1]; + return (sample.cts + sample.duration) / sample.timescale; + }; + + /* Finds the byte offset in the file corresponding to the given time or to the time of the previous RAP */ + ISOFile.prototype.seek = function(time, useRap) { + var moov = this.moov; + var trak; + var trak_seek_info; + var i; + var seek_info = { offset: Infinity, time: Infinity }; + if (!this.moov) { + throw "Cannot seek: moov not received!"; + } else { + for (i = 0; i this.getTrackDuration(trak)) { // skip tracks that already ended + continue; + } + trak_seek_info = this.seekTrack(time, useRap, trak); + if (trak_seek_info.offset < seek_info.offset) { + seek_info.offset = trak_seek_info.offset; + } + if (trak_seek_info.time < seek_info.time) { + seek_info.time = trak_seek_info.time; + } + } + Log.info("ISOFile", "Seeking at time "+Log.getDurationString(seek_info.time, 1)+" needs a buffer with a fileStart position of "+seek_info.offset); + if (seek_info.offset === Infinity) { + /* No sample info, in all tracks, cannot seek */ + seek_info = { offset: this.nextParsePosition, time: 0 }; + } else { + /* check if the seek position is already in some buffer and + in that case return the end of that buffer (or of the last contiguous buffer) */ + /* TODO: Should wait until append operations are done */ + seek_info.offset = this.stream.getEndFilePositionAfter(seek_info.offset); + } + Log.info("ISOFile", "Adjusted seek position (after checking data already in buffer): "+seek_info.offset); + return seek_info; + } + }; + + ISOFile.prototype.equal = function(b) { + var box_index = 0; + while (box_index < this.boxes.length && box_index < b.boxes.length) { + var a_box = this.boxes[box_index]; + var b_box = b.boxes[box_index]; + if (!BoxParser.boxEqual(a_box, b_box)) { + return false; + } + box_index++; + } + return true; + }; + + { + exports.ISOFile = ISOFile; + } + // file:src/isofile-advanced-parsing.js + /* position in the current buffer of the beginning of the last box parsed */ + ISOFile.prototype.lastBoxStartPosition = 0; + /* indicator if the parsing is stuck in the middle of an mdat box */ + ISOFile.prototype.parsingMdat = null; + /* next file position that the parser needs: + - 0 until the first buffer (i.e. fileStart ===0) has been received + - otherwise, the next box start until the moov box has been parsed + - otherwise, the position of the next sample to fetch + */ + ISOFile.prototype.nextParsePosition = 0; + /* keep mdat data */ + ISOFile.prototype.discardMdatData = false; + + ISOFile.prototype.processIncompleteBox = function(ret) { + var box; + var merged; + var found; + + /* we did not have enough bytes in the current buffer to parse the entire box */ + if (ret.type === "mdat") { + /* we had enough bytes to get its type and size and it's an 'mdat' */ + + /* special handling for mdat boxes, since we don't actually need to parse it linearly + we create the box */ + box = new BoxParser[ret.type+"Box"](ret.size); + this.parsingMdat = box; + this.boxes.push(box); + this.mdats.push(box); + box.start = ret.start; + box.hdr_size = ret.hdr_size; + this.stream.addUsedBytes(box.hdr_size); + + /* indicate that the parsing should start from the end of the box */ + this.lastBoxStartPosition = box.start + box.size; + /* let's see if we have the end of the box in the other buffers */ + found = this.stream.seek(box.start + box.size, false, this.discardMdatData); + if (found) { + /* found the end of the box */ + this.parsingMdat = null; + /* let's see if we can parse more in this buffer */ + return true; + } else { + /* 'mdat' end not found in the existing buffers */ + /* determine the next position in the file to start parsing from */ + if (!this.moovStartFound) { + /* moov not find yet, + the file probably has 'mdat' at the beginning, and 'moov' at the end, + indicate that the downloader should not try to download those bytes now */ + this.nextParsePosition = box.start + box.size; + } else { + /* we have the start of the moov box, + the next bytes should try to complete the current 'mdat' */ + this.nextParsePosition = this.stream.findEndContiguousBuf(); + } + /* not much we can do, wait for more buffers to arrive */ + return false; + } + } else { + /* box is incomplete, we may not even know its type */ + if (ret.type === "moov") { + /* the incomplete box is a 'moov' box */ + this.moovStartFound = true; + if (this.mdats.length === 0) { + this.isProgressive = true; + } + } + /* either it's not an mdat box (and we need to parse it, we cannot skip it) + (TODO: we could skip 'free' boxes ...) + or we did not have enough data to parse the type and size of the box, + we try to concatenate the current buffer with the next buffer to restart parsing */ + merged = (this.stream.mergeNextBuffer ? this.stream.mergeNextBuffer() : false); + if (merged) { + /* The next buffer was contiguous, the merging succeeded, + we can now continue parsing, + the next best position to parse is at the end of this new buffer */ + this.nextParsePosition = this.stream.getEndPosition(); + return true; + } else { + /* we cannot concatenate existing buffers because they are not contiguous or because there is no additional buffer */ + /* The next best position to parse is still at the end of this old buffer */ + if (!ret.type) { + /* There were not enough bytes in the buffer to parse the box type and length, + the next fetch should retrieve those missing bytes, i.e. the next bytes after this buffer */ + this.nextParsePosition = this.stream.getEndPosition(); + } else { + /* we had enough bytes to parse size and type of the incomplete box + if we haven't found yet the moov box, skip this one and try the next one + if we have found the moov box, let's continue linear parsing */ + if (this.moovStartFound) { + this.nextParsePosition = this.stream.getEndPosition(); + } else { + this.nextParsePosition = this.stream.getPosition() + ret.size; + } + } + return false; + } + } + }; + + ISOFile.prototype.hasIncompleteMdat = function () { + return (this.parsingMdat !== null); + }; + + ISOFile.prototype.processIncompleteMdat = function () { + var box; + var found; + + /* we are in the parsing of an incomplete mdat box */ + box = this.parsingMdat; + + found = this.stream.seek(box.start + box.size, false, this.discardMdatData); + if (found) { + Log.debug("ISOFile", "Found 'mdat' end in buffered data"); + /* the end of the mdat has been found */ + this.parsingMdat = null; + /* we can parse more in this buffer */ + return true; + } else { + /* we don't have the end of this mdat yet, + indicate that the next byte to fetch is the end of the buffers we have so far, + return and wait for more buffer to come */ + this.nextParsePosition = this.stream.findEndContiguousBuf(); + return false; + } + }; + + ISOFile.prototype.restoreParsePosition = function() { + /* Reposition at the start position of the previous box not entirely parsed */ + return this.stream.seek(this.lastBoxStartPosition, true, this.discardMdatData); + }; + + ISOFile.prototype.saveParsePosition = function() { + /* remember the position of the box start in case we need to roll back (if the box is incomplete) */ + this.lastBoxStartPosition = this.stream.getPosition(); + }; + + ISOFile.prototype.updateUsedBytes = function(box, ret) { + if (this.stream.addUsedBytes) { + if (box.type === "mdat") { + /* for an mdat box, only its header is considered used, other bytes will be used when sample data is requested */ + this.stream.addUsedBytes(box.hdr_size); + if (this.discardMdatData) { + this.stream.addUsedBytes(box.size-box.hdr_size); + } + } else { + /* for all other boxes, the entire box data is considered used */ + this.stream.addUsedBytes(box.size); + } + } + }; + // file:src/isofile-advanced-creation.js + ISOFile.prototype.add = BoxParser.Box.prototype.add; + ISOFile.prototype.addBox = BoxParser.Box.prototype.addBox; + + ISOFile.prototype.init = function (_options) { + var options = _options || {}; + this.add("ftyp").set("major_brand", (options.brands && options.brands[0]) || "iso4") + .set("minor_version", 0) + .set("compatible_brands", options.brands || ["iso4"]); + var moov = this.add("moov"); + moov.add("mvhd").set("timescale", options.timescale || 600) + .set("rate", options.rate || 1<<16) + .set("creation_time", 0) + .set("modification_time", 0) + .set("duration", options.duration || 0) + .set("volume", (options.width) ? 0 : 0x0100) + .set("matrix", [ 1<<16, 0, 0, 0, 1<<16, 0, 0, 0, 0x40000000]) + .set("next_track_id", 1); + moov.add("mvex"); + return this; + }; + + ISOFile.prototype.addTrack = function (_options) { + if (!this.moov) { + this.init(_options); + } + + var options = _options || {}; + options.width = options.width || 320; + options.height = options.height || 320; + options.id = options.id || this.moov.mvhd.next_track_id; + options.type = options.type || "avc1"; + + var trak = this.moov.add("trak"); + this.moov.mvhd.next_track_id = options.id+1; + trak.add("tkhd").set("flags",BoxParser.TKHD_FLAG_ENABLED | + BoxParser.TKHD_FLAG_IN_MOVIE | + BoxParser.TKHD_FLAG_IN_PREVIEW) + .set("creation_time",0) + .set("modification_time", 0) + .set("track_id", options.id) + .set("duration", options.duration || 0) + .set("layer", options.layer || 0) + .set("alternate_group", 0) + .set("volume", 1) + .set("matrix", [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) + .set("width", options.width << 16) + .set("height", options.height << 16); + + var mdia = trak.add("mdia"); + mdia.add("mdhd").set("creation_time", 0) + .set("modification_time", 0) + .set("timescale", options.timescale || 1) + .set("duration", options.media_duration || 0) + .set("language", options.language || "und"); + + mdia.add("hdlr").set("handler", options.hdlr || "vide") + .set("name", options.name || "Track created with MP4Box.js"); + + mdia.add("elng").set("extended_language", options.language || "fr-FR"); + + var minf = mdia.add("minf"); + if (BoxParser[options.type+"SampleEntry"] === undefined) return; + var sample_description_entry = new BoxParser[options.type+"SampleEntry"](); + sample_description_entry.data_reference_index = 1; + var media_type = ""; + for (var mediaType in BoxParser.sampleEntryCodes) { + var codes = BoxParser.sampleEntryCodes[mediaType]; + for (var i = 0; i < codes.length; i++) { + if (codes.indexOf(options.type) > -1) { + media_type = mediaType; + break; + } + } + } + switch(media_type) { + case "Visual": + minf.add("vmhd").set("graphicsmode",0).set("opcolor", [ 0, 0, 0 ]); + sample_description_entry.set("width", options.width) + .set("height", options.height) + .set("horizresolution", 0x48<<16) + .set("vertresolution", 0x48<<16) + .set("frame_count", 1) + .set("compressorname", options.type+" Compressor") + .set("depth", 0x18); + if (options.avcDecoderConfigRecord) { + var avcC = new BoxParser.avcCBox(); + avcC.parse(new MP4BoxStream(options.avcDecoderConfigRecord)); + sample_description_entry.addBox(avcC); + } else if (options.hevcDecoderConfigRecord) { + var hvcC = new BoxParser.hvcCBox(); + hvcC.parse(new MP4BoxStream(options.hevcDecoderConfigRecord)); + sample_description_entry.addBox(hvcC); + } + break; + case "Audio": + minf.add("smhd").set("balance", options.balance || 0); + sample_description_entry.set("channel_count", options.channel_count || 2) + .set("samplesize", options.samplesize || 16) + .set("samplerate", options.samplerate || 1<<16); + break; + case "Hint": + minf.add("hmhd"); // TODO: add properties + break; + case "Subtitle": + minf.add("sthd"); + switch (options.type) { + case "stpp": + sample_description_entry.set("namespace", options.namespace || "nonamespace") + .set("schema_location", options.schema_location || "") + .set("auxiliary_mime_types", options.auxiliary_mime_types || ""); + break; + } + break; + case "Metadata": + minf.add("nmhd"); + break; + case "System": + minf.add("nmhd"); + break; + default: + minf.add("nmhd"); + break; + } + if (options.description) { + sample_description_entry.addBox(options.description); + } + if (options.description_boxes) { + options.description_boxes.forEach(function (b) { + sample_description_entry.addBox(b); + }); + } + minf.add("dinf").add("dref").addEntry((new BoxParser["url Box"]()).set("flags", 0x1)); + var stbl = minf.add("stbl"); + stbl.add("stsd").addEntry(sample_description_entry); + stbl.add("stts").set("sample_counts", []) + .set("sample_deltas", []); + stbl.add("stsc").set("first_chunk", []) + .set("samples_per_chunk", []) + .set("sample_description_index", []); + stbl.add("stco").set("chunk_offsets", []); + stbl.add("stsz").set("sample_sizes", []); + + this.moov.mvex.add("trex").set("track_id", options.id) + .set("default_sample_description_index", options.default_sample_description_index || 1) + .set("default_sample_duration", options.default_sample_duration || 0) + .set("default_sample_size", options.default_sample_size || 0) + .set("default_sample_flags", options.default_sample_flags || 0); + this.buildTrakSampleLists(trak); + return options.id; + }; + + BoxParser.Box.prototype.computeSize = function(stream_) { + var stream = stream_ || new DataStream(); + stream.endianness = DataStream.BIG_ENDIAN; + this.write(stream); + }; + + ISOFile.prototype.addSample = function (track_id, data, _options) { + var options = _options || {}; + var sample = {}; + var trak = this.getTrackById(track_id); + if (trak === null) return; + sample.number = trak.samples.length; + sample.track_id = trak.tkhd.track_id; + sample.timescale = trak.mdia.mdhd.timescale; + sample.description_index = (options.sample_description_index ? options.sample_description_index - 1: 0); + sample.description = trak.mdia.minf.stbl.stsd.entries[sample.description_index]; + sample.data = data; + sample.size = data.byteLength; + sample.alreadyRead = sample.size; + sample.duration = options.duration || 1; + sample.cts = options.cts || 0; + sample.dts = options.dts || 0; + sample.is_sync = options.is_sync || false; + sample.is_leading = options.is_leading || 0; + sample.depends_on = options.depends_on || 0; + sample.is_depended_on = options.is_depended_on || 0; + sample.has_redundancy = options.has_redundancy || 0; + sample.degradation_priority = options.degradation_priority || 0; + sample.offset = 0; + sample.subsamples = options.subsamples; + trak.samples.push(sample); + trak.samples_size += sample.size; + trak.samples_duration += sample.duration; + if (trak.first_dts === undefined) { + trak.first_dts = options.dts; + } + + this.processSamples(); + + var moof = this.createSingleSampleMoof(sample); + this.addBox(moof); + moof.computeSize(); + /* adjusting the data_offset now that the moof size is known*/ + moof.trafs[0].truns[0].data_offset = moof.size+8; //8 is mdat header + this.add("mdat").data = new Uint8Array(data); + return sample; + }; + + ISOFile.prototype.createSingleSampleMoof = function(sample) { + var sample_flags = 0; + if (sample.is_sync) + sample_flags = (1 << 25); // sample_depends_on_none (I picture) + else + sample_flags = (1 << 16); // non-sync + + var moof = new BoxParser.moofBox(); + moof.add("mfhd").set("sequence_number", this.nextMoofNumber); + this.nextMoofNumber++; + var traf = moof.add("traf"); + var trak = this.getTrackById(sample.track_id); + traf.add("tfhd").set("track_id", sample.track_id) + .set("flags", BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF); + traf.add("tfdt").set("baseMediaDecodeTime", (sample.dts - (trak.first_dts || 0))); + traf.add("trun").set("flags", BoxParser.TRUN_FLAGS_DATA_OFFSET | BoxParser.TRUN_FLAGS_DURATION | + BoxParser.TRUN_FLAGS_SIZE | BoxParser.TRUN_FLAGS_FLAGS | + BoxParser.TRUN_FLAGS_CTS_OFFSET) + .set("data_offset",0) + .set("first_sample_flags",0) + .set("sample_count",1) + .set("sample_duration",[sample.duration]) + .set("sample_size",[sample.size]) + .set("sample_flags",[sample_flags]) + .set("sample_composition_time_offset", [sample.cts - sample.dts]); + return moof; + }; + + // file:src/isofile-sample-processing.js + /* Index of the last moof box received */ + ISOFile.prototype.lastMoofIndex = 0; + + /* size of the buffers allocated for samples */ + ISOFile.prototype.samplesDataSize = 0; + + /* Resets all sample tables */ + ISOFile.prototype.resetTables = function () { + var i; + var trak, stco, stsc, stsz, stts, ctts, stss; + this.initial_duration = this.moov.mvhd.duration; + this.moov.mvhd.duration = 0; + for (i = 0; i < this.moov.traks.length; i++) { + trak = this.moov.traks[i]; + trak.tkhd.duration = 0; + trak.mdia.mdhd.duration = 0; + stco = trak.mdia.minf.stbl.stco || trak.mdia.minf.stbl.co64; + stco.chunk_offsets = []; + stsc = trak.mdia.minf.stbl.stsc; + stsc.first_chunk = []; + stsc.samples_per_chunk = []; + stsc.sample_description_index = []; + stsz = trak.mdia.minf.stbl.stsz || trak.mdia.minf.stbl.stz2; + stsz.sample_sizes = []; + stts = trak.mdia.minf.stbl.stts; + stts.sample_counts = []; + stts.sample_deltas = []; + ctts = trak.mdia.minf.stbl.ctts; + if (ctts) { + ctts.sample_counts = []; + ctts.sample_offsets = []; + } + stss = trak.mdia.minf.stbl.stss; + var k = trak.mdia.minf.stbl.boxes.indexOf(stss); + if (k != -1) trak.mdia.minf.stbl.boxes[k] = null; + } + }; + + ISOFile.initSampleGroups = function(trak, traf, sbgps, trak_sgpds, traf_sgpds) { + var l; + var k; + var sample_group_info; + var sample_group_key; + function SampleGroupInfo(_type, _parameter, _sbgp) { + this.grouping_type = _type; + this.grouping_type_parameter = _parameter; + this.sbgp = _sbgp; + this.last_sample_in_run = -1; + this.entry_index = -1; + } + if (traf) { + traf.sample_groups_info = []; + } + if (!trak.sample_groups_info) { + trak.sample_groups_info = []; + } + for (k = 0; k < sbgps.length; k++) { + sample_group_key = sbgps[k].grouping_type +"/"+ sbgps[k].grouping_type_parameter; + sample_group_info = new SampleGroupInfo(sbgps[k].grouping_type, sbgps[k].grouping_type_parameter, sbgps[k]); + if (traf) { + traf.sample_groups_info[sample_group_key] = sample_group_info; + } + if (!trak.sample_groups_info[sample_group_key]) { + trak.sample_groups_info[sample_group_key] = sample_group_info; + } + for (l=0; l = 2) { + sample_group_key = trak_sgpds[k].grouping_type +"/0"; + sample_group_info = new SampleGroupInfo(trak_sgpds[k].grouping_type, 0); + if (!trak.sample_groups_info[sample_group_key]) { + trak.sample_groups_info[sample_group_key] = sample_group_info; + } + } + } + } else { + if (traf_sgpds) { + for (k = 0; k < traf_sgpds.length; k++) { + if (!traf_sgpds[k].used && traf_sgpds[k].version >= 2) { + sample_group_key = traf_sgpds[k].grouping_type +"/0"; + sample_group_info = new SampleGroupInfo(traf_sgpds[k].grouping_type, 0); + sample_group_info.is_fragment = true; + if (!traf.sample_groups_info[sample_group_key]) { + traf.sample_groups_info[sample_group_key] = sample_group_info; + } + } + } + } + } + }; + + ISOFile.setSampleGroupProperties = function(trak, sample, sample_number, sample_groups_info) { + var k; + var index; + sample.sample_groups = []; + for (k in sample_groups_info) { + sample.sample_groups[k] = {}; + sample.sample_groups[k].grouping_type = sample_groups_info[k].grouping_type; + sample.sample_groups[k].grouping_type_parameter = sample_groups_info[k].grouping_type_parameter; + if (sample_number >= sample_groups_info[k].last_sample_in_run) { + if (sample_groups_info[k].last_sample_in_run < 0) { + sample_groups_info[k].last_sample_in_run = 0; + } + sample_groups_info[k].entry_index++; + if (sample_groups_info[k].entry_index <= sample_groups_info[k].sbgp.entries.length - 1) { + sample_groups_info[k].last_sample_in_run += sample_groups_info[k].sbgp.entries[sample_groups_info[k].entry_index].sample_count; + } + } + if (sample_groups_info[k].entry_index <= sample_groups_info[k].sbgp.entries.length - 1) { + sample.sample_groups[k].group_description_index = sample_groups_info[k].sbgp.entries[sample_groups_info[k].entry_index].group_description_index; + } else { + sample.sample_groups[k].group_description_index = -1; // special value for not defined + } + if (sample.sample_groups[k].group_description_index !== 0) { + var description; + if (sample_groups_info[k].fragment_description) { + description = sample_groups_info[k].fragment_description; + } else { + description = sample_groups_info[k].description; + } + if (sample.sample_groups[k].group_description_index > 0) { + if (sample.sample_groups[k].group_description_index > 65535) { + index = (sample.sample_groups[k].group_description_index >> 16)-1; + } else { + index = sample.sample_groups[k].group_description_index-1; + } + if (description && index >= 0) { + sample.sample_groups[k].description = description.entries[index]; + } + } else { + if (description && description.version >= 2) { + if (description.default_group_description_index > 0) { + sample.sample_groups[k].description = description.entries[description.default_group_description_index-1]; + } + } + } + } + } + }; + + ISOFile.process_sdtp = function (sdtp, sample, number) { + if (!sample) { + return; + } + if (sdtp) { + sample.is_leading = sdtp.is_leading[number]; + sample.depends_on = sdtp.sample_depends_on[number]; + sample.is_depended_on = sdtp.sample_is_depended_on[number]; + sample.has_redundancy = sdtp.sample_has_redundancy[number]; + } else { + sample.is_leading = 0; + sample.depends_on = 0; + sample.is_depended_on = 0; + sample.has_redundancy = 0; + } + }; + + /* Build initial sample list from sample tables */ + ISOFile.prototype.buildSampleLists = function() { + var i; + var trak; + for (i = 0; i < this.moov.traks.length; i++) { + trak = this.moov.traks[i]; + this.buildTrakSampleLists(trak); + } + }; + + ISOFile.prototype.buildTrakSampleLists = function(trak) { + var j; + var stco, stsc, stsz, stts, ctts, stss, stsd, subs, sbgps, sgpds, stdp; + var chunk_run_index, chunk_index, last_chunk_in_run, offset_in_chunk, last_sample_in_chunk; + var last_sample_in_stts_run, stts_run_index, last_sample_in_ctts_run, ctts_run_index, last_stss_index, subs_entry_index, last_subs_sample_index; + + trak.samples = []; + trak.samples_duration = 0; + trak.samples_size = 0; + stco = trak.mdia.minf.stbl.stco || trak.mdia.minf.stbl.co64; + stsc = trak.mdia.minf.stbl.stsc; + stsz = trak.mdia.minf.stbl.stsz || trak.mdia.minf.stbl.stz2; + stts = trak.mdia.minf.stbl.stts; + ctts = trak.mdia.minf.stbl.ctts; + stss = trak.mdia.minf.stbl.stss; + stsd = trak.mdia.minf.stbl.stsd; + subs = trak.mdia.minf.stbl.subs; + stdp = trak.mdia.minf.stbl.stdp; + sbgps = trak.mdia.minf.stbl.sbgps; + sgpds = trak.mdia.minf.stbl.sgpds; + + last_sample_in_stts_run = -1; + stts_run_index = -1; + last_sample_in_ctts_run = -1; + ctts_run_index = -1; + last_stss_index = 0; + subs_entry_index = 0; + last_subs_sample_index = 0; + + ISOFile.initSampleGroups(trak, null, sbgps, sgpds); + + if (typeof stsz === "undefined") { + return; + } + + /* we build the samples one by one and compute their properties */ + for (j = 0; j < stsz.sample_sizes.length; j++) { + var sample = {}; + sample.number = j; + sample.track_id = trak.tkhd.track_id; + sample.timescale = trak.mdia.mdhd.timescale; + sample.alreadyRead = 0; + trak.samples[j] = sample; + /* size can be known directly */ + sample.size = stsz.sample_sizes[j]; + trak.samples_size += sample.size; + /* computing chunk-based properties (offset, sample description index)*/ + if (j === 0) { + chunk_index = 1; /* the first sample is in the first chunk (chunk indexes are 1-based) */ + chunk_run_index = 0; /* the first chunk is the first entry in the first_chunk table */ + sample.chunk_index = chunk_index; + sample.chunk_run_index = chunk_run_index; + last_sample_in_chunk = stsc.samples_per_chunk[chunk_run_index]; + offset_in_chunk = 0; + + /* Is there another entry in the first_chunk table ? */ + if (chunk_run_index + 1 < stsc.first_chunk.length) { + /* The last chunk in the run is the chunk before the next first chunk */ + last_chunk_in_run = stsc.first_chunk[chunk_run_index+1]-1; + } else { + /* There is only one entry in the table, it is valid for all future chunks*/ + last_chunk_in_run = Infinity; + } + } else { + if (j < last_sample_in_chunk) { + /* the sample is still in the current chunk */ + sample.chunk_index = chunk_index; + sample.chunk_run_index = chunk_run_index; + } else { + /* the sample is in the next chunk */ + chunk_index++; + sample.chunk_index = chunk_index; + /* reset the accumulated offset in the chunk */ + offset_in_chunk = 0; + if (chunk_index <= last_chunk_in_run) ; else { + chunk_run_index++; + /* Is there another entry in the first_chunk table ? */ + if (chunk_run_index + 1 < stsc.first_chunk.length) { + /* The last chunk in the run is the chunk before the next first chunk */ + last_chunk_in_run = stsc.first_chunk[chunk_run_index+1]-1; + } else { + /* There is only one entry in the table, it is valid for all future chunks*/ + last_chunk_in_run = Infinity; + } + + } + sample.chunk_run_index = chunk_run_index; + last_sample_in_chunk += stsc.samples_per_chunk[chunk_run_index]; + } + } + + sample.description_index = stsc.sample_description_index[sample.chunk_run_index]-1; + sample.description = stsd.entries[sample.description_index]; + sample.offset = stco.chunk_offsets[sample.chunk_index-1] + offset_in_chunk; /* chunk indexes are 1-based */ + offset_in_chunk += sample.size; + + /* setting dts, cts, duration and rap flags */ + if (j > last_sample_in_stts_run) { + stts_run_index++; + if (last_sample_in_stts_run < 0) { + last_sample_in_stts_run = 0; + } + last_sample_in_stts_run += stts.sample_counts[stts_run_index]; + } + if (j > 0) { + trak.samples[j-1].duration = stts.sample_deltas[stts_run_index]; + trak.samples_duration += trak.samples[j-1].duration; + sample.dts = trak.samples[j-1].dts + trak.samples[j-1].duration; + } else { + sample.dts = 0; + } + if (ctts) { + if (j >= last_sample_in_ctts_run) { + ctts_run_index++; + if (last_sample_in_ctts_run < 0) { + last_sample_in_ctts_run = 0; + } + last_sample_in_ctts_run += ctts.sample_counts[ctts_run_index]; + } + sample.cts = trak.samples[j].dts + ctts.sample_offsets[ctts_run_index]; + } else { + sample.cts = sample.dts; + } + if (stss) { + if (j == stss.sample_numbers[last_stss_index] - 1) { // sample numbers are 1-based + sample.is_sync = true; + last_stss_index++; + } else { + sample.is_sync = false; + sample.degradation_priority = 0; + } + if (subs) { + if (subs.entries[subs_entry_index].sample_delta + last_subs_sample_index == j+1) { + sample.subsamples = subs.entries[subs_entry_index].subsamples; + last_subs_sample_index += subs.entries[subs_entry_index].sample_delta; + subs_entry_index++; + } + } + } else { + sample.is_sync = true; + } + ISOFile.process_sdtp(trak.mdia.minf.stbl.sdtp, sample, sample.number); + if (stdp) { + sample.degradation_priority = stdp.priority[j]; + } else { + sample.degradation_priority = 0; + } + if (subs) { + if (subs.entries[subs_entry_index].sample_delta + last_subs_sample_index == j) { + sample.subsamples = subs.entries[subs_entry_index].subsamples; + last_subs_sample_index += subs.entries[subs_entry_index].sample_delta; + } + } + if (sbgps.length > 0 || sgpds.length > 0) { + ISOFile.setSampleGroupProperties(trak, sample, j, trak.sample_groups_info); + } + } + if (j>0) { + trak.samples[j-1].duration = Math.max(trak.mdia.mdhd.duration - trak.samples[j-1].dts, 0); + trak.samples_duration += trak.samples[j-1].duration; + } + }; + + /* Update sample list when new 'moof' boxes are received */ + ISOFile.prototype.updateSampleLists = function() { + var i, j, k; + var default_sample_description_index, default_sample_duration, default_sample_size, default_sample_flags; + var last_run_position; + var box, moof, traf, trak, trex; + var sample; + var sample_flags; + + if (this.moov === undefined) { + return; + } + /* if the input file is fragmented and fetched in multiple downloads, we need to update the list of samples */ + while (this.lastMoofIndex < this.moofs.length) { + box = this.moofs[this.lastMoofIndex]; + this.lastMoofIndex++; + if (box.type == "moof") { + moof = box; + for (i = 0; i < moof.trafs.length; i++) { + traf = moof.trafs[i]; + trak = this.getTrackById(traf.tfhd.track_id); + trex = this.getTrexById(traf.tfhd.track_id); + if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { + default_sample_description_index = traf.tfhd.default_sample_description_index; + } else { + default_sample_description_index = (trex ? trex.default_sample_description_index: 1); + } + if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { + default_sample_duration = traf.tfhd.default_sample_duration; + } else { + default_sample_duration = (trex ? trex.default_sample_duration : 0); + } + if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { + default_sample_size = traf.tfhd.default_sample_size; + } else { + default_sample_size = (trex ? trex.default_sample_size : 0); + } + if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { + default_sample_flags = traf.tfhd.default_sample_flags; + } else { + default_sample_flags = (trex ? trex.default_sample_flags : 0); + } + traf.sample_number = 0; + /* process sample groups */ + if (traf.sbgps.length > 0) { + ISOFile.initSampleGroups(trak, traf, traf.sbgps, trak.mdia.minf.stbl.sgpds, traf.sgpds); + } + for (j = 0; j < traf.truns.length; j++) { + var trun = traf.truns[j]; + for (k = 0; k < trun.sample_count; k++) { + sample = {}; + sample.moof_number = this.lastMoofIndex; + sample.number_in_traf = traf.sample_number; + traf.sample_number++; + sample.number = trak.samples.length; + traf.first_sample_index = trak.samples.length; + trak.samples.push(sample); + sample.track_id = trak.tkhd.track_id; + sample.timescale = trak.mdia.mdhd.timescale; + sample.description_index = default_sample_description_index-1; + sample.description = trak.mdia.minf.stbl.stsd.entries[sample.description_index]; + sample.size = default_sample_size; + if (trun.flags & BoxParser.TRUN_FLAGS_SIZE) { + sample.size = trun.sample_size[k]; + } + trak.samples_size += sample.size; + sample.duration = default_sample_duration; + if (trun.flags & BoxParser.TRUN_FLAGS_DURATION) { + sample.duration = trun.sample_duration[k]; + } + trak.samples_duration += sample.duration; + if (trak.first_traf_merged || k > 0) { + sample.dts = trak.samples[trak.samples.length-2].dts+trak.samples[trak.samples.length-2].duration; + } else { + if (traf.tfdt) { + sample.dts = traf.tfdt.baseMediaDecodeTime; + } else { + sample.dts = 0; + } + trak.first_traf_merged = true; + } + sample.cts = sample.dts; + if (trun.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { + sample.cts = sample.dts + trun.sample_composition_time_offset[k]; + } + sample_flags = default_sample_flags; + if (trun.flags & BoxParser.TRUN_FLAGS_FLAGS) { + sample_flags = trun.sample_flags[k]; + } else if (k === 0 && (trun.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG)) { + sample_flags = trun.first_sample_flags; + } + sample.is_sync = ((sample_flags >> 16 & 0x1) ? false : true); + sample.is_leading = (sample_flags >> 26 & 0x3); + sample.depends_on = (sample_flags >> 24 & 0x3); + sample.is_depended_on = (sample_flags >> 22 & 0x3); + sample.has_redundancy = (sample_flags >> 20 & 0x3); + sample.degradation_priority = (sample_flags & 0xFFFF); + //ISOFile.process_sdtp(traf.sdtp, sample, sample.number_in_traf); + var bdop = (traf.tfhd.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) ? true : false; + var dbim = (traf.tfhd.flags & BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF) ? true : false; + var dop = (trun.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) ? true : false; + var bdo = 0; + if (!bdop) { + if (!dbim) { + if (j === 0) { // the first track in the movie fragment + bdo = moof.start; // the position of the first byte of the enclosing Movie Fragment Box + } else { + bdo = last_run_position; // end of the data defined by the preceding *track* (irrespective of the track id) fragment in the moof + } + } else { + bdo = moof.start; + } + } else { + bdo = traf.tfhd.base_data_offset; + } + if (j === 0 && k === 0) { + if (dop) { + sample.offset = bdo + trun.data_offset; // If the data-offset is present, it is relative to the base-data-offset established in the track fragment header + } else { + sample.offset = bdo; // the data for this run starts the base-data-offset defined by the track fragment header + } + } else { + sample.offset = last_run_position; // this run starts immediately after the data of the previous run + } + last_run_position = sample.offset + sample.size; + if (traf.sbgps.length > 0 || traf.sgpds.length > 0 || + trak.mdia.minf.stbl.sbgps.length > 0 || trak.mdia.minf.stbl.sgpds.length > 0) { + ISOFile.setSampleGroupProperties(trak, sample, sample.number_in_traf, traf.sample_groups_info); + } + } + } + if (traf.subs) { + trak.has_fragment_subsamples = true; + var sample_index = traf.first_sample_index; + for (j = 0; j < traf.subs.entries.length; j++) { + sample_index += traf.subs.entries[j].sample_delta; + sample = trak.samples[sample_index-1]; + sample.subsamples = traf.subs.entries[j].subsamples; + } + } + } + } + } + }; + + /* Try to get sample data for a given sample: + returns null if not found + returns the same sample if already requested + */ + ISOFile.prototype.getSample = function(trak, sampleNum) { + var buffer; + var sample = trak.samples[sampleNum]; + + if (!this.moov) { + return null; + } + + if (!sample.data) { + /* Not yet fetched */ + sample.data = new Uint8Array(sample.size); + sample.alreadyRead = 0; + this.samplesDataSize += sample.size; + Log.debug("ISOFile", "Allocating sample #"+sampleNum+" on track #"+trak.tkhd.track_id+" of size "+sample.size+" (total: "+this.samplesDataSize+")"); + } else if (sample.alreadyRead == sample.size) { + /* Already fetched entirely */ + return sample; + } + + /* The sample has only been partially fetched, we need to check in all buffers */ + while(true) { + var index = this.stream.findPosition(true, sample.offset + sample.alreadyRead, false); + if (index > -1) { + buffer = this.stream.buffers[index]; + var lengthAfterStart = buffer.byteLength - (sample.offset + sample.alreadyRead - buffer.fileStart); + if (sample.size - sample.alreadyRead <= lengthAfterStart) { + /* the (rest of the) sample is entirely contained in this buffer */ + + Log.debug("ISOFile","Getting sample #"+sampleNum+" data (alreadyRead: "+sample.alreadyRead+" offset: "+ + (sample.offset+sample.alreadyRead - buffer.fileStart)+" read size: "+(sample.size - sample.alreadyRead)+" full size: "+sample.size+")"); + + DataStream.memcpy(sample.data.buffer, sample.alreadyRead, + buffer, sample.offset+sample.alreadyRead - buffer.fileStart, sample.size - sample.alreadyRead); + + /* update the number of bytes used in this buffer and check if it needs to be removed */ + buffer.usedBytes += sample.size - sample.alreadyRead; + this.stream.logBufferLevel(); + + sample.alreadyRead = sample.size; + + return sample; + } else { + /* the sample does not end in this buffer */ + + if (lengthAfterStart === 0) return null; + + Log.debug("ISOFile","Getting sample #"+sampleNum+" partial data (alreadyRead: "+sample.alreadyRead+" offset: "+ + (sample.offset+sample.alreadyRead - buffer.fileStart)+" read size: "+lengthAfterStart+" full size: "+sample.size+")"); + + DataStream.memcpy(sample.data.buffer, sample.alreadyRead, + buffer, sample.offset+sample.alreadyRead - buffer.fileStart, lengthAfterStart); + sample.alreadyRead += lengthAfterStart; + + /* update the number of bytes used in this buffer and check if it needs to be removed */ + buffer.usedBytes += lengthAfterStart; + this.stream.logBufferLevel(); + + /* keep looking in the next buffer */ + } + } else { + return null; + } + } + }; + + /* Release the memory used to store the data of the sample */ + ISOFile.prototype.releaseSample = function(trak, sampleNum) { + var sample = trak.samples[sampleNum]; + if (sample.data) { + this.samplesDataSize -= sample.size; + sample.data = null; + sample.alreadyRead = 0; + return sample.size; + } else { + return 0; + } + }; + + ISOFile.prototype.getAllocatedSampleDataSize = function() { + return this.samplesDataSize; + }; + + /* Builds the MIME Type 'codecs' sub-parameters for the whole file */ + ISOFile.prototype.getCodecs = function() { + var i; + var codecs = ""; + for (i = 0; i < this.moov.traks.length; i++) { + var trak = this.moov.traks[i]; + if (i>0) { + codecs+=","; + } + codecs += trak.mdia.minf.stbl.stsd.entries[0].getCodec(); + } + return codecs; + }; + + /* Helper function */ + ISOFile.prototype.getTrexById = function(id) { + var i; + if (!this.moov || !this.moov.mvex) return null; + for (i = 0; i < this.moov.mvex.trexs.length; i++) { + var trex = this.moov.mvex.trexs[i]; + if (trex.track_id == id) return trex; + } + return null; + }; + + /* Helper function */ + ISOFile.prototype.getTrackById = function(id) { + if (this.moov === undefined) { + return null; + } + for (var j = 0; j < this.moov.traks.length; j++) { + var trak = this.moov.traks[j]; + if (trak.tkhd.track_id == id) return trak; + } + return null; + }; + // file:src/isofile-item-processing.js + /* size of the buffers allocated for samples */ + ISOFile.prototype.itemsDataSize = 0; + + ISOFile.prototype.flattenItemInfo = function() { + var items = this.items; + var entity_groups = this.entity_groups; + var i, j; + var item; + var meta = this.meta; + if (meta === null || meta === undefined) return; + if (meta.hdlr === undefined) return; + if (meta.iinf === undefined) return; + for (i = 0; i < meta.iinf.item_infos.length; i++) { + item = {}; + item.id = meta.iinf.item_infos[i].item_ID; + items[item.id] = item; + item.ref_to = []; + item.name = meta.iinf.item_infos[i].item_name; + if (meta.iinf.item_infos[i].protection_index > 0) { + item.protection = meta.ipro.protections[meta.iinf.item_infos[i].protection_index-1]; + } + if (meta.iinf.item_infos[i].item_type) { + item.type = meta.iinf.item_infos[i].item_type; + } else { + item.type = "mime"; + } + item.content_type = meta.iinf.item_infos[i].content_type; + item.content_encoding = meta.iinf.item_infos[i].content_encoding; + } + if (meta.grpl) { + for (i = 0; i < meta.grpl.boxes.length; i++) { + entity_group = {}; + entity_group.id = meta.grpl.boxes[i].group_id; + entity_group.entity_ids = meta.grpl.boxes[i].entity_ids; + entity_group.type = meta.grpl.boxes[i].type; + entity_groups[entity_group.id] = entity_group; + } + } + if (meta.iloc) { + for(i = 0; i < meta.iloc.items.length; i++) { + var itemloc = meta.iloc.items[i]; + item = items[itemloc.item_ID]; + if (itemloc.data_reference_index !== 0) { + Log.warn("Item storage with reference to other files: not supported"); + item.source = meta.dinf.boxes[itemloc.data_reference_index-1]; + } + switch(itemloc.construction_method) { + case 0: // offset into the file referenced by the data reference index + break; + case 1: // offset into the idat box of this meta box + break; + case 2: // offset into another item + Log.warn("Item storage with construction_method : not supported"); + break; + } + item.extents = []; + item.size = 0; + for (j = 0; j < itemloc.extents.length; j++) { + item.extents[j] = {}; + item.extents[j].offset = itemloc.extents[j].extent_offset + itemloc.base_offset; + if (itemloc.construction_method == 1) { + item.extents[j].offset += meta.idat.start + meta.idat.hdr_size; + } + item.extents[j].length = itemloc.extents[j].extent_length; + item.extents[j].alreadyRead = 0; + item.size += item.extents[j].length; + } + } + } + if (meta.pitm) { + items[meta.pitm.item_id].primary = true; + } + if (meta.iref) { + for (i=0; i 0 && propEntry.property_index-1 < meta.iprp.ipco.boxes.length) { + var propbox = meta.iprp.ipco.boxes[propEntry.property_index-1]; + item.properties[propbox.type] = propbox; + item.properties.boxes.push(propbox); + } + } + } + } + } + } + }; + + ISOFile.prototype.getItem = function(item_id) { + var buffer; + var item; + + if (!this.meta) { + return null; + } + + item = this.items[item_id]; + if (!item.data && item.size) { + /* Not yet fetched */ + item.data = new Uint8Array(item.size); + item.alreadyRead = 0; + this.itemsDataSize += item.size; + Log.debug("ISOFile", "Allocating item #"+item_id+" of size "+item.size+" (total: "+this.itemsDataSize+")"); + } else if (item.alreadyRead === item.size) { + /* Already fetched entirely */ + return item; + } + + /* The item has only been partially fetched, we need to check in all buffers to find the remaining extents*/ + + for (var i = 0; i < item.extents.length; i++) { + var extent = item.extents[i]; + if (extent.alreadyRead === extent.length) { + continue; + } else { + var index = this.stream.findPosition(true, extent.offset + extent.alreadyRead, false); + if (index > -1) { + buffer = this.stream.buffers[index]; + var lengthAfterStart = buffer.byteLength - (extent.offset + extent.alreadyRead - buffer.fileStart); + if (extent.length - extent.alreadyRead <= lengthAfterStart) { + /* the (rest of the) extent is entirely contained in this buffer */ + + Log.debug("ISOFile","Getting item #"+item_id+" extent #"+i+" data (alreadyRead: "+extent.alreadyRead+ + " offset: "+(extent.offset+extent.alreadyRead - buffer.fileStart)+" read size: "+(extent.length - extent.alreadyRead)+ + " full extent size: "+extent.length+" full item size: "+item.size+")"); + + DataStream.memcpy(item.data.buffer, item.alreadyRead, + buffer, extent.offset+extent.alreadyRead - buffer.fileStart, extent.length - extent.alreadyRead); + + /* update the number of bytes used in this buffer and check if it needs to be removed */ + buffer.usedBytes += extent.length - extent.alreadyRead; + this.stream.logBufferLevel(); + + item.alreadyRead += (extent.length - extent.alreadyRead); + extent.alreadyRead = extent.length; + } else { + /* the sample does not end in this buffer */ + + Log.debug("ISOFile","Getting item #"+item_id+" extent #"+i+" partial data (alreadyRead: "+extent.alreadyRead+" offset: "+ + (extent.offset+extent.alreadyRead - buffer.fileStart)+" read size: "+lengthAfterStart+ + " full extent size: "+extent.length+" full item size: "+item.size+")"); + + DataStream.memcpy(item.data.buffer, item.alreadyRead, + buffer, extent.offset+extent.alreadyRead - buffer.fileStart, lengthAfterStart); + extent.alreadyRead += lengthAfterStart; + item.alreadyRead += lengthAfterStart; + + /* update the number of bytes used in this buffer and check if it needs to be removed */ + buffer.usedBytes += lengthAfterStart; + this.stream.logBufferLevel(); + return null; + } + } else { + return null; + } + } + } + if (item.alreadyRead === item.size) { + /* fetched entirely */ + return item; + } else { + return null; + } + }; + + /* Release the memory used to store the data of the item */ + ISOFile.prototype.releaseItem = function(item_id) { + var item = this.items[item_id]; + if (item.data) { + this.itemsDataSize -= item.size; + item.data = null; + item.alreadyRead = 0; + for (var i = 0; i < item.extents.length; i++) { + var extent = item.extents[i]; + extent.alreadyRead = 0; + } + return item.size; + } else { + return 0; + } + }; + + + ISOFile.prototype.processItems = function(callback) { + for(var i in this.items) { + var item = this.items[i]; + this.getItem(item.id); + if (callback && !item.sent) { + callback(item); + item.sent = true; + item.data = null; + } + } + }; + + ISOFile.prototype.hasItem = function(name) { + for(var i in this.items) { + var item = this.items[i]; + if (item.name === name) { + return item.id; + } + } + return -1; + }; + + ISOFile.prototype.getMetaHandler = function() { + if (!this.meta) { + return null; + } else { + return this.meta.hdlr.handler; + } + }; + + ISOFile.prototype.getPrimaryItem = function() { + if (!this.meta || !this.meta.pitm) { + return null; + } else { + return this.getItem(this.meta.pitm.item_id); + } + }; + + ISOFile.prototype.itemToFragmentedTrackFile = function(_options) { + var options = _options || {}; + var item = null; + if (options.itemId) { + item = this.getItem(options.itemId); + } else { + item = this.getPrimaryItem(); + } + if (item == null) return null; + + var file = new ISOFile(); + file.discardMdatData = false; + // assuming the track type is the same as the item type + var trackOptions = { type: item.type, description_boxes: item.properties.boxes}; + if (item.properties.ispe) { + trackOptions.width = item.properties.ispe.image_width; + trackOptions.height = item.properties.ispe.image_height; + } + var trackId = file.addTrack(trackOptions); + if (trackId) { + file.addSample(trackId, item.data); + return file; + } else { + return null; + } + }; + + // file:src/isofile-write.js + /* Rewrite the entire file */ + ISOFile.prototype.write = function(outstream) { + for (var i=0; i0 ? this.moov.traks[i].samples[0].duration: 0)); + initSegs.push(seg); + } + return initSegs; + }; + + // file:src/box-print.js + /* + * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + BoxParser.Box.prototype.printHeader = function(output) { + this.size += 8; + if (this.size > MAX_SIZE) { + this.size += 8; + } + if (this.type === "uuid") { + this.size += 16; + } + output.log(output.indent+"size:"+this.size); + output.log(output.indent+"type:"+this.type); + }; + + BoxParser.FullBox.prototype.printHeader = function(output) { + this.size += 4; + BoxParser.Box.prototype.printHeader.call(this, output); + output.log(output.indent+"version:"+this.version); + output.log(output.indent+"flags:"+this.flags); + }; + + BoxParser.Box.prototype.print = function(output) { + this.printHeader(output); + }; + + BoxParser.ContainerBox.prototype.print = function(output) { + this.printHeader(output); + for (var i=0; i>8)); + output.log(output.indent+"matrix: "+this.matrix.join(", ")); + output.log(output.indent+"next_track_id: "+this.next_track_id); + }; + + BoxParser.tkhdBox.prototype.print = function(output) { + BoxParser.FullBox.prototype.printHeader.call(this, output); + output.log(output.indent+"creation_time: "+this.creation_time); + output.log(output.indent+"modification_time: "+this.modification_time); + output.log(output.indent+"track_id: "+this.track_id); + output.log(output.indent+"duration: "+this.duration); + output.log(output.indent+"volume: "+(this.volume>>8)); + output.log(output.indent+"matrix: "+this.matrix.join(", ")); + output.log(output.indent+"layer: "+this.layer); + output.log(output.indent+"alternate_group: "+this.alternate_group); + output.log(output.indent+"width: "+this.width); + output.log(output.indent+"height: "+this.height); + };// file:src/mp4box.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var MP4Box = {}; + + MP4Box.createFile = function (_keepMdatData, _stream) { + /* Boolean indicating if bytes containing media data should be kept in memory */ + var keepMdatData = (_keepMdatData !== undefined ? _keepMdatData : true); + var file = new ISOFile(_stream); + file.discardMdatData = (keepMdatData ? false : true); + return file; + }; + + { + exports.createFile = MP4Box.createFile; + } + }); + mp4box_all.Log; + mp4box_all.MP4BoxStream; + var mp4box_all_3 = mp4box_all.DataStream; + mp4box_all.MultiBufferStream; + mp4box_all.MPEG4DescriptorParser; + var mp4box_all_6 = mp4box_all.BoxParser; + mp4box_all.VTTin4Parser; + mp4box_all.XMLSubtitlein4Parser; + mp4box_all.Textin4Parser; + mp4box_all.ISOFile; + var mp4box_all_11 = mp4box_all.createFile; + + // Decode a MP4 container into individual samples. + class Parser { + info; + #mp4 = mp4box_all_11(); + #offset = 0; + #samples = []; + constructor(init) { + this.#mp4.onError = (err) => { + console.error("MP4 error", err); + }; + this.#mp4.onReady = (info) => { + this.info = info; + // Extract all of the tracks, because we don't know if it's audio or video. + for (const track of info.tracks) { + this.#mp4.setExtractionOptions(track.id, track, { nbSamples: 1 }); + } + }; + this.#mp4.onSamples = (_track_id, track, samples) => { + for (const sample of samples) { + this.#samples.push({ track, sample }); + } + }; + this.#mp4.start(); + // For some reason we need to modify the underlying ArrayBuffer with offset + const copy = new Uint8Array(init); + const buffer = copy.buffer; + buffer.fileStart = this.#offset; + this.#mp4.appendBuffer(buffer); + this.#offset += buffer.byteLength; + this.#mp4.flush(); + if (!this.info) { + throw new Error("could not parse MP4 info"); + } + } + decode(chunk) { + const copy = new Uint8Array(chunk); + // For some reason we need to modify the underlying ArrayBuffer with offset + const buffer = copy.buffer; + buffer.fileStart = this.#offset; + // Parse the data + this.#mp4.appendBuffer(buffer); + this.#mp4.flush(); + this.#offset += buffer.byteLength; + const samples = [...this.#samples]; + this.#samples.length = 0; + return samples; + } + } + + // Rename some stuff so it's on brand. + // We need a separate file so this file can use the rename too. + function isAudioTrack(track) { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + return track.audio !== undefined; + } + function isVideoTrack(track) { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + return track.video !== undefined; + } + // TODO contribute to mp4box + mp4box_all_6.dOpsBox.prototype.write = function (stream) { + this.size = this.ChannelMappingFamily === 0 ? 11 : 13 + this.ChannelMapping.length; + this.writeHeader(stream); + stream.writeUint8(this.Version); + stream.writeUint8(this.OutputChannelCount); + stream.writeUint16(this.PreSkip); + stream.writeUint32(this.InputSampleRate); + stream.writeInt16(this.OutputGain); + stream.writeUint8(this.ChannelMappingFamily); + if (this.ChannelMappingFamily !== 0) { + stream.writeUint8(this.StreamCount); + stream.writeUint8(this.CoupledCount); + for (const mapping of this.ChannelMapping) { + stream.writeUint8(mapping); + } + } + }; + + // This is run in a worker. + let Renderer$1 = class Renderer { + #ring; + #timeline; + #decoder; + #stream; + constructor(config, timeline) { + this.#timeline = timeline; + this.#ring = new Ring(config.ring); + this.#stream = new TransformStream({ + start: this.#start.bind(this), + transform: this.#transform.bind(this), + }); + this.#run().catch(console.error); + } + #start(controller) { + this.#decoder = new AudioDecoder({ + output: (frame) => { + controller.enqueue(frame); + }, + error: console.warn, + }); + } + #transform(frame) { + if (this.#decoder.state !== "configured") { + const track = frame.track; + if (!isAudioTrack(track)) + throw new Error("expected audio track"); + // We only support OPUS right now which doesn't need a description. + this.#decoder.configure({ + codec: track.codec, + sampleRate: track.audio.sample_rate, + numberOfChannels: track.audio.channel_count, + }); + } + const chunk = new EncodedAudioChunk({ + type: frame.sample.is_sync ? "key" : "delta", + timestamp: frame.sample.dts / frame.track.timescale, + duration: frame.sample.duration, + data: frame.sample.data, + }); + this.#decoder.decode(chunk); + } + async #run() { + const reader = this.#timeline.frames.pipeThrough(this.#stream).getReader(); + for (;;) { + const { value: frame, done } = await reader.read(); + if (done) + break; + // Write audio samples to the ring buffer, dropping when there's no space. + const written = this.#ring.write(frame); + if (written < frame.numberOfFrames) { + console.warn(`droppped ${frame.numberOfFrames - written} audio samples`); + } + } + } + }; + + class Renderer { + #canvas; + #timeline; + #decoder; + #queue; + #decoderConfig; + #waitingForKeyframe = true; + constructor(config, timeline) { + this.#canvas = config.canvas; + this.#timeline = timeline; + this.#queue = new TransformStream({ + start: this.#start.bind(this), + transform: this.#transform.bind(this), + }); + this.#run().catch(console.error); + } + pause() { + console.log("pause"); + this.#waitingForKeyframe = true; + } + async #run() { + const reader = this.#timeline.frames.pipeThrough(this.#queue).getReader(); + for (;;) { + const { value: frame, done } = await reader.read(); + if (done) + break; + self.requestAnimationFrame(() => { + this.#canvas.width = frame.displayWidth; + this.#canvas.height = frame.displayHeight; + const ctx = this.#canvas.getContext("2d"); + if (!ctx) + throw new Error("failed to get canvas context"); + ctx.drawImage(frame, 0, 0, frame.displayWidth, frame.displayHeight); // TODO respect aspect ratio + frame.close(); + }); + } + } + #start(controller) { + this.#decoder = new VideoDecoder({ + output: (frame) => { + controller.enqueue(frame); + }, + error: console.error, + }); + } + #transform(frame) { + if (this.#decoder.state === "closed") { + console.warn("Decoder is closed. Skipping frame."); + return; + } + const { sample, track } = frame; + // Reset the decoder on video track change + if (this.#decoderConfig && this.#decoder.state == "configured") { + if (isVideoTrack(track)) { + const configMismatch = this.#decoderConfig.codec !== track.codec || + this.#decoderConfig.codedWidth !== track.video.width || + this.#decoderConfig.codedHeight !== track.video.height; + if (configMismatch) { + this.#decoder.reset(); + this.#decoderConfig = undefined; + } + } + } + // Configure the decoder with the first frame + if (this.#decoder.state !== "configured") { + const desc = sample.description; + const box = desc.avcC ?? desc.hvcC ?? desc.vpcC ?? desc.av1C; + if (!box) + throw new Error(`unsupported codec: ${track.codec}`); + const buffer = new mp4box_all_3(undefined, 0, mp4box_all_3.BIG_ENDIAN); + box.write(buffer); + const description = new Uint8Array(buffer.buffer, 8); // Remove the box header. + if (!isVideoTrack(track)) + throw new Error("expected video track"); + this.#decoderConfig = { + codec: track.codec, + codedHeight: track.video.height, + codedWidth: track.video.width, + description, + // optimizeForLatency: true + }; + this.#decoder.configure(this.#decoderConfig); + if (!frame.sample.is_sync) { + this.#waitingForKeyframe = true; + } + else { + this.#waitingForKeyframe = false; + } + } + //At the start of decode , VideoDecoder seems to expect a key frame after configure() or flush() + if (this.#decoder.state == "configured") { + if (this.#waitingForKeyframe && !frame.sample.is_sync) { + console.warn("Skipping non-keyframe until a keyframe is found."); + return; + } + // On arrival of a keyframe, allow decoding and stop waiting for a keyframe. + if (frame.sample.is_sync) { + this.#waitingForKeyframe = false; + } + const chunk = new EncodedVideoChunk({ + type: frame.sample.is_sync ? "key" : "delta", + data: frame.sample.data, + timestamp: frame.sample.dts / frame.track.timescale, + }); + this.#decoder.decode(chunk); + } + } + } + + // I hate javascript + function asError(e) { + if (e instanceof Error) { + return e; + } + else if (typeof e === "string") { + return new Error(e); + } + else { + return new Error(String(e)); + } + } + + class Deferred { + promise; + resolve; + reject; + pending = true; + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = (value) => { + this.pending = false; + resolve(value); + }; + this.reject = (reason) => { + this.pending = false; + reject(reason); + }; + }); + } + } + + const MAX_U53 = Number.MAX_SAFE_INTEGER; + // Reader wraps a stream and provides convience methods for reading pieces from a stream + // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet. + class Reader { + #buffer; + #stream; + #reader; + constructor(buffer, stream) { + this.#buffer = buffer; + this.#stream = stream; + this.#reader = this.#stream.getReader(); + } + // Adds more data to the buffer, returning true if more data was added. + async #fill() { + const result = await this.#reader.read(); + if (result.done) { + return false; + } + const buffer = new Uint8Array(result.value); + if (this.#buffer.byteLength == 0) { + this.#buffer = buffer; + } + else { + const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength); + temp.set(this.#buffer); + temp.set(buffer, this.#buffer.byteLength); + this.#buffer = temp; + } + return true; + } + // Add more data to the buffer until it's at least size bytes. + async #fillTo(size) { + while (this.#buffer.byteLength < size) { + if (!(await this.#fill())) { + throw new Error("unexpected end of stream"); + } + } + } + // Consumes the first size bytes of the buffer. + #slice(size) { + const result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size); + this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size); + return result; + } + async read(size) { + if (size == 0) + return new Uint8Array(); + await this.#fillTo(size); + return this.#slice(size); + } + async readAll() { + // eslint-disable-next-line no-empty + while (await this.#fill()) { } + return this.#slice(this.#buffer.byteLength); + } + async string(maxLength) { + const length = await this.u53(); + if (maxLength !== undefined && length > maxLength) { + throw new Error(`string length ${length} exceeds max length ${maxLength}`); + } + const buffer = await this.read(length); + return new TextDecoder().decode(buffer); + } + async u8() { + await this.#fillTo(1); + return this.#slice(1)[0]; + } + // Returns a Number using 53-bits, the max Javascript can use for integer math + async u53() { + const v = await this.u62(); + if (v > MAX_U53) { + throw new Error("value larger than 53-bits; use v62 instead"); + } + return Number(v); + } + // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits + async u62() { + await this.#fillTo(1); + const size = (this.#buffer[0] & 0xc0) >> 6; + if (size == 0) { + const first = this.#slice(1)[0]; + return BigInt(first) & 0x3fn; + } + else if (size == 1) { + await this.#fillTo(2); + const slice = this.#slice(2); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return BigInt(view.getInt16(0)) & 0x3fffn; + } + else if (size == 2) { + await this.#fillTo(4); + const slice = this.#slice(4); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return BigInt(view.getUint32(0)) & 0x3fffffffn; + } + else if (size == 3) { + await this.#fillTo(8); + const slice = this.#slice(8); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return view.getBigUint64(0) & 0x3fffffffffffffffn; + } + else { + throw new Error("impossible"); + } + } + async done() { + if (this.#buffer.byteLength > 0) + return false; + return !(await this.#fill()); + } + async close() { + this.#reader.releaseLock(); + await this.#stream.cancel(); + } + release() { + this.#reader.releaseLock(); + return [this.#buffer, this.#stream]; + } + } + + var StreamType; + (function (StreamType) { + StreamType[StreamType["Object"] = 0] = "Object"; + StreamType[StreamType["Track"] = 80] = "Track"; + StreamType[StreamType["Group"] = 81] = "Group"; + })(StreamType || (StreamType = {})); + var Status; + (function (Status) { + Status[Status["OBJECT_NULL"] = 1] = "OBJECT_NULL"; + Status[Status["GROUP_NULL"] = 2] = "GROUP_NULL"; + Status[Status["GROUP_END"] = 3] = "GROUP_END"; + Status[Status["TRACK_END"] = 4] = "TRACK_END"; + })(Status || (Status = {})); + class GroupReader { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async read() { + if (await this.stream.done()) { + return; + } + const object = await this.stream.u53(); + const size = await this.stream.u53(); + let payload; + if (size == 0) { + payload = (await this.stream.u53()); + } + else { + payload = await this.stream.read(size); + } + return { + object, + payload, + }; + } + async close() { + await this.stream.close(); + } + } + + class Worker { + // Timeline receives samples, buffering them and choosing the timestamp to render. + #timeline = new Timeline(); + // A map of init tracks. + #inits = new Map(); + // Renderer requests samples, rendering video frames and emitting audio frames. + #audio; + #video; + on(e) { + const msg = e.data; + if (msg.config) { + this.#onConfig(msg.config); + } + else if (msg.init) { + // TODO buffer the init segmnet so we don't hold the stream open. + this.#onInit(msg.init); + } + else if (msg.segment) { + this.#onSegment(msg.segment).catch(console.warn); + } + else if (msg.pause) { + this.#onPause(msg.pause); + } + else { + throw new Error(`unknown message: + ${JSON.stringify(msg)}`); + } + } + #onConfig(msg) { + if (msg.audio) { + this.#audio = new Renderer$1(msg.audio, this.#timeline.audio); + } + if (msg.video) { + this.#video = new Renderer(msg.video, this.#timeline.video); + } + } + #onInit(msg) { + let init = this.#inits.get(msg.name); + if (!init) { + init = new Deferred(); + this.#inits.set(msg.name, init); + } + init.resolve(msg.data); + } + async #onSegment(msg) { + let init = this.#inits.get(msg.init); + if (!init) { + init = new Deferred(); + this.#inits.set(msg.init, init); + } + // Create a new stream that we will use to decode. + const container = new Parser(await init.promise); + const timeline = msg.kind === "audio" ? this.#timeline.audio : this.#timeline.video; + const reader = new GroupReader(msg.header, new Reader(msg.buffer, msg.stream)); + // Create a queue that will contain each MP4 frame. + const queue = new TransformStream({}); + const segment = queue.writable.getWriter(); + // Add the segment to the timeline + const segments = timeline.segments.getWriter(); + await segments.write({ + sequence: msg.header.group, + frames: queue.readable, + }); + segments.releaseLock(); + // Read each chunk, decoding the MP4 frames and adding them to the queue. + for (;;) { + const chunk = await reader.read(); + if (!chunk) { + break; + } + if (!(chunk.payload instanceof Uint8Array)) { + throw new Error(`invalid payload: ${chunk.payload}`); + } + const frames = container.decode(chunk.payload); + for (const frame of frames) { + await segment.write(frame); + } + } + // We done. + await segment.close(); + } + #onPause(pause) { + if (this.#video && pause) { + this.#video.pause(); + } + } + } + // Pass all events to the worker + const worker = new Worker(); + self.addEventListener("message", (msg) => { + try { + worker.on(msg); + } + catch (e) { + const err = asError(e); + console.warn("worker error:", err); + } + }); + + })(); + + }); + /* eslint-enable */ + + // Ring buffer with audio samples. + var STATE; + (function (STATE) { + STATE[STATE["READ_POS"] = 0] = "READ_POS"; + STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; + STATE[STATE["LENGTH"] = 2] = "LENGTH"; + })(STATE || (STATE = {})); + // No prototype to make this easier to send via postMessage + class RingShared { + state; + channels; + capacity; + constructor(channels, capacity) { + // Store the current state in a separate ring buffer. + this.state = new SharedArrayBuffer(STATE.LENGTH * Int32Array.BYTES_PER_ELEMENT); + // Create a buffer for each audio channel + this.channels = []; + for (let i = 0; i < channels; i += 1) { + const buffer = new SharedArrayBuffer(capacity * Float32Array.BYTES_PER_ELEMENT); + this.channels.push(buffer); + } + this.capacity = capacity; + } + } + + // This is a non-standard way of importing worklet/workers. + // Unfortunately, it's the only option because of a Vite bug: https://github.com/vitejs/vite/issues/11823 + // Responsible for sending messages to the worker and worklet. + class Backend { + // General worker + #worker; + // The audio context, which must be created on the main thread. + #audio; + constructor(config) { + // TODO does this block the main thread? If so, make this async + this.#worker = new WorkerFactory(); + this.#worker.addEventListener("message", this.on.bind(this)); + let sampleRate; + let channels; + for (const track of config.catalog.tracks) { + if (isAudioTrack(track)) { + if (sampleRate && track.selectionParams.samplerate !== sampleRate) { + throw new Error(`TODO multiple audio tracks with different sample rates`); + } + sampleRate = track.selectionParams.samplerate; + // TODO properly handle weird channel configs + channels = Math.max(+track.selectionParams.channelConfig, channels ?? 0); + } + } + const msg = {}; + // Only configure audio is we have an audio track + if (sampleRate && channels) { + msg.audio = { + channels: channels, + sampleRate: sampleRate, + ring: new RingShared(2, sampleRate / 10), // 100ms + }; + this.#audio = new Audio(msg.audio); + } + // TODO only send the canvas if we have a video track + msg.video = { + canvas: config.canvas, + }; + this.send({ config: msg }, msg.video.canvas); + } + pause() { + this.send({ pause: true }); + } + async mute() { + await this.#audio?.context.suspend(); + } + async unmute() { + await this.#audio?.context.resume(); + } + init(init) { + this.send({ init }); + } + segment(segment) { + this.send({ segment }, segment.stream); + } + async close() { + this.#worker.terminate(); + await this.#audio?.context.close(); + } + // Enforce we're sending valid types to the worker + send(msg, ...transfer) { + //console.log("sent message from main to worker", msg) + this.#worker.postMessage(msg, transfer); + } + on(e) { + const msg = e.data; + // Don't print the verbose timeline message. + if (!msg.timeline) ; + } + } + + const MAX_U6 = Math.pow(2, 6) - 1; + const MAX_U14 = Math.pow(2, 14) - 1; + const MAX_U30 = Math.pow(2, 30) - 1; + const MAX_U31 = Math.pow(2, 31) - 1; + const MAX_U53 = Number.MAX_SAFE_INTEGER; + const MAX_U62 = 2n ** 62n - 1n; + // Reader wraps a stream and provides convience methods for reading pieces from a stream + // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet. + class Reader { + #buffer; + #stream; + #reader; + constructor(buffer, stream) { + this.#buffer = buffer; + this.#stream = stream; + this.#reader = this.#stream.getReader(); + } + // Adds more data to the buffer, returning true if more data was added. + async #fill() { + const result = await this.#reader.read(); + if (result.done) { + return false; + } + const buffer = new Uint8Array(result.value); + if (this.#buffer.byteLength == 0) { + this.#buffer = buffer; + } + else { + const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength); + temp.set(this.#buffer); + temp.set(buffer, this.#buffer.byteLength); + this.#buffer = temp; + } + return true; + } + // Add more data to the buffer until it's at least size bytes. + async #fillTo(size) { + while (this.#buffer.byteLength < size) { + if (!(await this.#fill())) { + throw new Error("unexpected end of stream"); + } + } + } + // Consumes the first size bytes of the buffer. + #slice(size) { + const result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size); + this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size); + return result; + } + async read(size) { + if (size == 0) + return new Uint8Array(); + await this.#fillTo(size); + return this.#slice(size); + } + async readAll() { + // eslint-disable-next-line no-empty + while (await this.#fill()) { } + return this.#slice(this.#buffer.byteLength); + } + async string(maxLength) { + const length = await this.u53(); + if (maxLength !== undefined && length > maxLength) { + throw new Error(`string length ${length} exceeds max length ${maxLength}`); + } + const buffer = await this.read(length); + return new TextDecoder().decode(buffer); + } + async u8() { + await this.#fillTo(1); + return this.#slice(1)[0]; + } + // Returns a Number using 53-bits, the max Javascript can use for integer math + async u53() { + const v = await this.u62(); + if (v > MAX_U53) { + throw new Error("value larger than 53-bits; use v62 instead"); + } + return Number(v); + } + // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits + async u62() { + await this.#fillTo(1); + const size = (this.#buffer[0] & 0xc0) >> 6; + if (size == 0) { + const first = this.#slice(1)[0]; + return BigInt(first) & 0x3fn; + } + else if (size == 1) { + await this.#fillTo(2); + const slice = this.#slice(2); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return BigInt(view.getInt16(0)) & 0x3fffn; + } + else if (size == 2) { + await this.#fillTo(4); + const slice = this.#slice(4); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return BigInt(view.getUint32(0)) & 0x3fffffffn; + } + else if (size == 3) { + await this.#fillTo(8); + const slice = this.#slice(8); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return view.getBigUint64(0) & 0x3fffffffffffffffn; + } + else { + throw new Error("impossible"); + } + } + async done() { + if (this.#buffer.byteLength > 0) + return false; + return !(await this.#fill()); + } + async close() { + this.#reader.releaseLock(); + await this.#stream.cancel(); + } + release() { + this.#reader.releaseLock(); + return [this.#buffer, this.#stream]; + } + } + // Writer wraps a stream and writes chunks of data + class Writer { + #scratch; + #writer; + #stream; + constructor(stream) { + this.#stream = stream; + this.#scratch = new Uint8Array(8); + this.#writer = this.#stream.getWriter(); + } + async u8(v) { + await this.write(setUint8(this.#scratch, v)); + } + async i32(v) { + if (Math.abs(v) > MAX_U31) { + throw new Error(`overflow, value larger than 32-bits: ${v}`); + } + // We don't use a VarInt, so it always takes 4 bytes. + // This could be improved but nothing is standardized yet. + await this.write(setInt32(this.#scratch, v)); + } + async u53(v) { + if (v < 0) { + throw new Error(`underflow, value is negative: ${v}`); + } + else if (v > MAX_U53) { + throw new Error(`overflow, value larger than 53-bits: ${v}`); + } + await this.write(setVint53(this.#scratch, v)); + } + async u62(v) { + if (v < 0) { + throw new Error(`underflow, value is negative: ${v}`); + } + else if (v >= MAX_U62) { + throw new Error(`overflow, value larger than 62-bits: ${v}`); + } + await this.write(setVint62(this.#scratch, v)); + } + async write(v) { + await this.#writer.write(v); + } + async string(str) { + const data = new TextEncoder().encode(str); + await this.u53(data.byteLength); + await this.write(data); + } + async close() { + this.#writer.releaseLock(); + await this.#stream.close(); + } + release() { + this.#writer.releaseLock(); + return this.#stream; + } + } + function setUint8(dst, v) { + dst[0] = v; + return dst.slice(0, 1); + } + function setUint16(dst, v) { + const view = new DataView(dst.buffer, dst.byteOffset, 2); + view.setUint16(0, v); + return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); + } + function setInt32(dst, v) { + const view = new DataView(dst.buffer, dst.byteOffset, 4); + view.setInt32(0, v); + return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); + } + function setUint32(dst, v) { + const view = new DataView(dst.buffer, dst.byteOffset, 4); + view.setUint32(0, v); + return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); + } + function setVint53(dst, v) { + if (v <= MAX_U6) { + return setUint8(dst, v); + } + else if (v <= MAX_U14) { + return setUint16(dst, v | 0x4000); + } + else if (v <= MAX_U30) { + return setUint32(dst, v | 0x80000000); + } + else if (v <= MAX_U53) { + return setUint64(dst, BigInt(v) | 0xc000000000000000n); + } + else { + throw new Error(`overflow, value larger than 53-bits: ${v}`); + } + } + function setVint62(dst, v) { + if (v < MAX_U6) { + return setUint8(dst, Number(v)); + } + else if (v < MAX_U14) { + return setUint16(dst, Number(v) | 0x4000); + } + else if (v <= MAX_U30) { + return setUint32(dst, Number(v) | 0x80000000); + } + else if (v <= MAX_U62) { + return setUint64(dst, BigInt(v) | 0xc000000000000000n); + } + else { + throw new Error(`overflow, value larger than 62-bits: ${v}`); + } + } + function setUint64(dst, v) { + const view = new DataView(dst.buffer, dst.byteOffset, 8); + view.setBigUint64(0, v); + return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); + } + + var Version; + (function (Version) { + Version[Version["DRAFT_00"] = 4278190080] = "DRAFT_00"; + Version[Version["DRAFT_01"] = 4278190081] = "DRAFT_01"; + Version[Version["DRAFT_02"] = 4278190082] = "DRAFT_02"; + Version[Version["DRAFT_03"] = 4278190083] = "DRAFT_03"; + Version[Version["DRAFT_04"] = 4278190084] = "DRAFT_04"; + Version[Version["DRAFT_05"] = 4278190085] = "DRAFT_05"; + Version[Version["KIXEL_00"] = 765184] = "KIXEL_00"; + Version[Version["KIXEL_01"] = 765185] = "KIXEL_01"; + })(Version || (Version = {})); + let Stream$1 = class Stream { + recv; + send; + constructor(r, w) { + this.recv = new Decoder$1(r); + this.send = new Encoder$1(w); + } + }; + let Decoder$1 = class Decoder { + r; + constructor(r) { + this.r = r; + } + async client() { + const type = await this.r.u53(); + if (type !== 0x40) + throw new Error(`client SETUP type must be 0x40, got ${type}`); + const count = await this.r.u53(); + const versions = []; + for (let i = 0; i < count; i++) { + const version = await this.r.u53(); + versions.push(version); + } + const params = await this.parameters(); + const role = this.role(params?.get(0n)); + return { + versions, + role, + params, + }; + } + async server() { + const type = await this.r.u53(); + if (type !== 0x41) + throw new Error(`server SETUP type must be 0x41, got ${type}`); + const version = await this.r.u53(); + const params = await this.parameters(); + return { + version, + params, + }; + } + async parameters() { + const count = await this.r.u53(); + if (count == 0) + return undefined; + const params = new Map(); + for (let i = 0; i < count; i++) { + const id = await this.r.u62(); + const size = await this.r.u53(); + const value = await this.r.read(size); + if (params.has(id)) { + throw new Error(`duplicate parameter id: ${id}`); + } + params.set(id, value); + } + return params; + } + role(raw) { + if (!raw) + throw new Error("missing role parameter"); + if (raw.length != 1) + throw new Error("multi-byte varint not supported"); + switch (raw[0]) { + case 1: + return "publisher"; + case 2: + return "subscriber"; + case 3: + return "both"; + default: + throw new Error(`invalid role: ${raw[0]}`); + } + } + }; + let Encoder$1 = class Encoder { + w; + constructor(w) { + this.w = w; + } + async client(c) { + await this.w.u53(0x40); + await this.w.u53(c.versions.length); + for (const v of c.versions) { + await this.w.u53(v); + } + // I hate it + const params = c.params ?? new Map(); + params.set(0n, new Uint8Array([c.role == "publisher" ? 1 : c.role == "subscriber" ? 2 : 3])); + await this.parameters(params); + } + async server(s) { + await this.w.u53(0x41); + await this.w.u53(s.version); + await this.parameters(s.params); + } + async parameters(p) { + if (!p) { + await this.w.u8(0); + return; + } + await this.w.u53(p.size); + for (const [id, value] of p) { + await this.w.u62(id); + await this.w.u53(value.length); + await this.w.write(value); + } + } + }; + + function isPublisher(m) { + return (m.kind == Msg.SubscribeOk || + m.kind == Msg.SubscribeError || + m.kind == Msg.SubscribeDone || + m.kind == Msg.Announce || + m.kind == Msg.Unannounce); + } + // I wish we didn't have to split Msg and Id into separate enums. + // However using the string in the message makes it easier to debug. + // We'll take the tiny performance hit until I'm better at Typescript. + var Msg; + (function (Msg) { + // NOTE: object and setup are in other modules + Msg["Subscribe"] = "subscribe"; + Msg["SubscribeOk"] = "subscribe_ok"; + Msg["SubscribeError"] = "subscribe_error"; + Msg["SubscribeDone"] = "subscribe_done"; + Msg["Unsubscribe"] = "unsubscribe"; + Msg["Announce"] = "announce"; + Msg["AnnounceOk"] = "announce_ok"; + Msg["AnnounceError"] = "announce_error"; + Msg["Unannounce"] = "unannounce"; + Msg["GoAway"] = "go_away"; + })(Msg || (Msg = {})); + var Id; + (function (Id) { + // NOTE: object and setup are in other modules + // Object = 0, + // Setup = 1, + Id[Id["Subscribe"] = 3] = "Subscribe"; + Id[Id["SubscribeOk"] = 4] = "SubscribeOk"; + Id[Id["SubscribeError"] = 5] = "SubscribeError"; + Id[Id["SubscribeDone"] = 11] = "SubscribeDone"; + Id[Id["Unsubscribe"] = 10] = "Unsubscribe"; + Id[Id["Announce"] = 6] = "Announce"; + Id[Id["AnnounceOk"] = 7] = "AnnounceOk"; + Id[Id["AnnounceError"] = 8] = "AnnounceError"; + Id[Id["Unannounce"] = 9] = "Unannounce"; + Id[Id["GoAway"] = 16] = "GoAway"; + })(Id || (Id = {})); + var GroupOrder; + (function (GroupOrder) { + GroupOrder[GroupOrder["Publisher"] = 0] = "Publisher"; + GroupOrder[GroupOrder["Ascending"] = 1] = "Ascending"; + GroupOrder[GroupOrder["Descending"] = 2] = "Descending"; + })(GroupOrder || (GroupOrder = {})); + class Stream { + decoder; + encoder; + #mutex = Promise.resolve(); + constructor(r, w) { + this.decoder = new Decoder(r); + this.encoder = new Encoder(w); + } + // Will error if two messages are read at once. + async recv() { + const msg = await this.decoder.message(); + console.log("received message", msg); + return msg; + } + async send(msg) { + const unlock = await this.#lock(); + try { + console.log("sending message", msg); + await this.encoder.message(msg); + } + finally { + unlock(); + } + } + async #lock() { + // Make a new promise that we can resolve later. + let done; + const p = new Promise((resolve) => { + done = () => resolve(); + }); + // Wait until the previous lock is done, then resolve our our lock. + const lock = this.#mutex.then(() => done); + // Save our lock as the next lock. + this.#mutex = p; + // Return the lock. + return lock; + } + } + class Decoder { + r; + constructor(r) { + this.r = r; + } + async msg() { + const t = await this.r.u53(); + switch (t) { + case Id.Subscribe: + return Msg.Subscribe; + case Id.SubscribeOk: + return Msg.SubscribeOk; + case Id.SubscribeDone: + return Msg.SubscribeDone; + case Id.SubscribeError: + return Msg.SubscribeError; + case Id.Unsubscribe: + return Msg.Unsubscribe; + case Id.Announce: + return Msg.Announce; + case Id.AnnounceOk: + return Msg.AnnounceOk; + case Id.AnnounceError: + return Msg.AnnounceError; + case Id.Unannounce: + return Msg.Unannounce; + case Id.GoAway: + return Msg.GoAway; + } + throw new Error(`unknown control message type: ${t}`); + } + async message() { + const t = await this.msg(); + switch (t) { + case Msg.Subscribe: + return this.subscribe(); + case Msg.SubscribeOk: + return this.subscribe_ok(); + case Msg.SubscribeError: + return this.subscribe_error(); + case Msg.SubscribeDone: + return this.subscribe_done(); + case Msg.Unsubscribe: + return this.unsubscribe(); + case Msg.Announce: + return this.announce(); + case Msg.AnnounceOk: + return this.announce_ok(); + case Msg.Unannounce: + return this.unannounce(); + case Msg.AnnounceError: + return this.announce_error(); + case Msg.GoAway: + throw new Error("TODO: implement go away"); + } + } + async subscribe() { + return { + kind: Msg.Subscribe, + id: await this.r.u62(), + trackId: await this.r.u62(), + namespace: await this.r.string(), + name: await this.r.string(), + subscriber_priority: await this.r.u8(), + group_order: await this.decodeGroupOrder(), + location: await this.location(), + params: await this.parameters(), + }; + } + async decodeGroupOrder() { + const orderCode = await this.r.u8(); + switch (orderCode) { + case 0: + return GroupOrder.Publisher; + case 1: + return GroupOrder.Ascending; + case 2: + return GroupOrder.Descending; + default: + throw new Error(`Invalid GroupOrder value: ${orderCode}`); + } + } + async location() { + const mode = await this.r.u62(); + if (mode == 1n) { + return { + mode: "latest_group", + }; + } + else if (mode == 2n) { + return { + mode: "latest_object", + }; + } + else if (mode == 3n) { + return { + mode: "absolute_start", + start_group: await this.r.u53(), + start_object: await this.r.u53(), + }; + } + else if (mode == 4n) { + return { + mode: "absolute_range", + start_group: await this.r.u53(), + start_object: await this.r.u53(), + end_group: await this.r.u53(), + end_object: await this.r.u53(), + }; + } + else { + throw new Error(`invalid filter type: ${mode}`); + } + } + async parameters() { + const count = await this.r.u53(); + if (count == 0) + return undefined; + const params = new Map(); + for (let i = 0; i < count; i++) { + const id = await this.r.u62(); + const size = await this.r.u53(); + const value = await this.r.read(size); + if (params.has(id)) { + throw new Error(`duplicate parameter id: ${id}`); + } + params.set(id, value); + } + return params; + } + async subscribe_ok() { + const id = await this.r.u62(); + const expires = await this.r.u62(); + const group_order = await this.decodeGroupOrder(); + let latest; + const flag = await this.r.u8(); + if (flag === 1) { + latest = [await this.r.u53(), await this.r.u53()]; + } + else if (flag !== 0) { + throw new Error(`invalid final flag: ${flag}`); + } + return { + kind: Msg.SubscribeOk, + id, + expires, + group_order, + latest, + }; + } + async subscribe_done() { + const id = await this.r.u62(); + const code = await this.r.u62(); + const reason = await this.r.string(); + let final; + const flag = await this.r.u8(); + if (flag === 1) { + final = [await this.r.u53(), await this.r.u53()]; + } + else if (flag !== 0) { + throw new Error(`invalid final flag: ${flag}`); + } + return { + kind: Msg.SubscribeDone, + id, + code, + reason, + final, + }; + } + async subscribe_error() { + return { + kind: Msg.SubscribeError, + id: await this.r.u62(), + code: await this.r.u62(), + reason: await this.r.string(), + }; + } + async unsubscribe() { + return { + kind: Msg.Unsubscribe, + id: await this.r.u62(), + }; + } + async announce() { + const namespace = await this.r.string(); + return { + kind: Msg.Announce, + namespace, + params: await this.parameters(), + }; + } + async announce_ok() { + return { + kind: Msg.AnnounceOk, + namespace: await this.r.string(), + }; + } + async announce_error() { + return { + kind: Msg.AnnounceError, + namespace: await this.r.string(), + code: await this.r.u62(), + reason: await this.r.string(), + }; + } + async unannounce() { + return { + kind: Msg.Unannounce, + namespace: await this.r.string(), + }; + } + } + class Encoder { + w; + constructor(w) { + this.w = w; + } + async message(m) { + switch (m.kind) { + case Msg.Subscribe: + return this.subscribe(m); + case Msg.SubscribeOk: + return this.subscribe_ok(m); + case Msg.SubscribeError: + return this.subscribe_error(m); + case Msg.SubscribeDone: + return this.subscribe_done(m); + case Msg.Unsubscribe: + return this.unsubscribe(m); + case Msg.Announce: + return this.announce(m); + case Msg.AnnounceOk: + return this.announce_ok(m); + case Msg.AnnounceError: + return this.announce_error(m); + case Msg.Unannounce: + return this.unannounce(m); + } + } + async subscribe(s) { + await this.w.u53(Id.Subscribe); + await this.w.u62(s.id); + await this.w.u62(s.trackId); + await this.w.string(s.namespace); + await this.w.string(s.name); + await this.w.u8(s.subscriber_priority ?? 127); + await this.encodeGroupOrder(s.group_order ?? GroupOrder.Publisher); + await this.location(s.location); + await this.parameters(s.params); + } + async encodeGroupOrder(order) { + switch (order) { + case GroupOrder.Publisher: + await this.w.u8(GroupOrder.Publisher); + break; + case GroupOrder.Ascending: + await this.w.u8(GroupOrder.Ascending); + break; + case GroupOrder.Descending: + await this.w.u8(GroupOrder.Descending); + break; + default: + throw new Error("Invalid GroupOrder value"); + } + } + async location(l) { + switch (l.mode) { + case "latest_group": + await this.w.u62(1n); + break; + case "latest_object": + await this.w.u62(2n); + break; + case "absolute_start": + await this.w.u62(3n); + await this.w.u53(l.start_group); + await this.w.u53(l.start_object); + break; + case "absolute_range": + await this.w.u62(3n); + await this.w.u53(l.start_group); + await this.w.u53(l.start_object); + await this.w.u53(l.end_group); + await this.w.u53(l.end_object); + } + } + async parameters(p) { + if (!p) { + await this.w.u8(0); + return; + } + await this.w.u53(p.size); + for (const [id, value] of p) { + await this.w.u62(id); + await this.w.u53(value.length); + await this.w.write(value); + } + } + async subscribe_ok(s) { + await this.w.u53(Id.SubscribeOk); + await this.w.u62(s.id); + await this.w.u62(s.expires); + await this.encodeGroupOrder(s.group_order); + if (s.latest !== undefined) { + await this.w.u8(1); + await this.w.u53(s.latest[0]); + await this.w.u53(s.latest[1]); + } + else { + await this.w.u8(0); + } + } + async subscribe_done(s) { + await this.w.u53(Id.SubscribeDone); + await this.w.u62(s.id); + await this.w.u62(s.code); + await this.w.string(s.reason); + if (s.final !== undefined) { + await this.w.u8(1); + await this.w.u53(s.final[0]); + await this.w.u53(s.final[1]); + } + else { + await this.w.u8(0); + } + } + async subscribe_error(s) { + await this.w.u53(Id.SubscribeError); + await this.w.u62(s.id); + } + async unsubscribe(s) { + await this.w.u53(Id.Unsubscribe); + await this.w.u62(s.id); + } + async announce(a) { + await this.w.u53(Id.Announce); + await this.w.string(a.namespace); + await this.w.u53(0); // parameters + } + async announce_ok(a) { + await this.w.u53(Id.AnnounceOk); + await this.w.string(a.namespace); + } + async announce_error(a) { + await this.w.u53(Id.AnnounceError); + await this.w.string(a.namespace); + await this.w.u62(a.code); + await this.w.string(a.reason); + } + async unannounce(a) { + await this.w.u53(Id.Unannounce); + await this.w.string(a.namespace); + } + } + + var StreamType; + (function (StreamType) { + StreamType[StreamType["Object"] = 0] = "Object"; + StreamType[StreamType["Track"] = 80] = "Track"; + StreamType[StreamType["Group"] = 81] = "Group"; + })(StreamType || (StreamType = {})); + var Status; + (function (Status) { + Status[Status["OBJECT_NULL"] = 1] = "OBJECT_NULL"; + Status[Status["GROUP_NULL"] = 2] = "GROUP_NULL"; + Status[Status["GROUP_END"] = 3] = "GROUP_END"; + Status[Status["TRACK_END"] = 4] = "TRACK_END"; + })(Status || (Status = {})); + class Objects { + quic; + constructor(quic) { + this.quic = quic; + } + async send(h) { + const stream = await this.quic.createUnidirectionalStream(); + const w = new Writer(stream); + await w.u53(h.type); + await w.u62(h.sub); + await w.u62(h.track); + let res; + if (h.type == StreamType.Object) { + await w.u53(h.group); + await w.u53(h.object); + await w.u8(h.publisher_priority); + await w.u53(h.status); + res = new ObjectWriter(h, w); + } + else if (h.type === StreamType.Group) { + await w.u53(h.group); + await w.u8(h.publisher_priority); + res = new GroupWriter(h, w); + } + else if (h.type === StreamType.Track) { + await w.u8(h.publisher_priority); + res = new TrackWriter(h, w); + } + else { + throw new Error("unknown header type"); + } + // console.trace("send object", res.header) + return res; + } + async recv() { + const streams = this.quic.incomingUnidirectionalStreams.getReader(); + const { value, done } = await streams.read(); + streams.releaseLock(); + if (done) + return; + const r = new Reader(new Uint8Array(), value); + const type = (await r.u53()); + let res; + if (type == StreamType.Track) { + const h = { + type, + sub: await r.u62(), + track: await r.u62(), + publisher_priority: await r.u8(), + }; + res = new TrackReader(h, r); + } + else if (type == StreamType.Group) { + const h = { + type, + sub: await r.u62(), + track: await r.u62(), + group: await r.u53(), + publisher_priority: await r.u8(), + }; + res = new GroupReader(h, r); + } + else if (type == StreamType.Object) { + const h = { + type, + sub: await r.u62(), + track: await r.u62(), + group: await r.u53(), + object: await r.u53(), + status: await r.u53(), + publisher_priority: await r.u8(), + }; + res = new ObjectReader(h, r); + } + else { + throw new Error("unknown stream type"); + } + // console.trace("receive object", res.header) + return res; + } + } + class TrackWriter { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async write(c) { + await this.stream.u53(c.group); + await this.stream.u53(c.object); + if (c.payload instanceof Uint8Array) { + await this.stream.u53(c.payload.byteLength); + await this.stream.write(c.payload); + } + else { + // empty payload with status + await this.stream.u53(0); + await this.stream.u53(c.payload); + } + } + async close() { + await this.stream.close(); + } + } + class GroupWriter { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async write(c) { + await this.stream.u53(c.object); + if (c.payload instanceof Uint8Array) { + await this.stream.u53(c.payload.byteLength); + await this.stream.write(c.payload); + } + else { + await this.stream.u53(0); + await this.stream.u53(c.payload); + } + } + async close() { + await this.stream.close(); + } + } + class ObjectWriter { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async write(c) { + await this.stream.write(c.payload); + } + async close() { + await this.stream.close(); + } + } + class TrackReader { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async read() { + if (await this.stream.done()) { + return; + } + const group = await this.stream.u53(); + const object = await this.stream.u53(); + const size = await this.stream.u53(); + let payload; + if (size == 0) { + payload = (await this.stream.u53()); + } + else { + payload = await this.stream.read(size); + } + return { + group, + object, + payload, + }; + } + async close() { + await this.stream.close(); + } + } + class GroupReader { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async read() { + if (await this.stream.done()) { + return; + } + const object = await this.stream.u53(); + const size = await this.stream.u53(); + let payload; + if (size == 0) { + payload = (await this.stream.u53()); + } + else { + payload = await this.stream.read(size); + } + return { + object, + payload, + }; + } + async close() { + await this.stream.close(); + } + } + class ObjectReader { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + // NOTE: Can only be called once. + async read() { + if (await this.stream.done()) { + return; + } + return { + payload: await this.stream.readAll(), + }; + } + async close() { + await this.stream.close(); + } + } + + class Deferred { + promise; + resolve; + reject; + pending = true; + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = (value) => { + this.pending = false; + resolve(value); + }; + this.reject = (reason) => { + this.pending = false; + reject(reason); + }; + }); + } + } + class Watch { + #current; + #next = new Deferred(); + constructor(init) { + this.#next = new Deferred(); + this.#current = [init, this.#next.promise]; + } + value() { + return this.#current; + } + update(v) { + if (!this.#next.pending) { + throw new Error("already closed"); + } + // If we're given a function, call it with the current value + if (v instanceof Function) { + v = v(this.#current[0]); + } + const next = new Deferred(); + this.#current = [v, next.promise]; + this.#next.resolve(this.#current); + this.#next = next; + } + close() { + this.#current[1] = undefined; + this.#next.resolve(this.#current); + } + } + // Allows queuing N values, like a Channel. + class Queue { + #stream; + #closed = false; + constructor(capacity = 1) { + const queue = new CountQueuingStrategy({ highWaterMark: capacity }); + this.#stream = new TransformStream({}, undefined, queue); + } + async push(v) { + const w = this.#stream.writable.getWriter(); + await w.write(v); + w.releaseLock(); + } + async next() { + const r = this.#stream.readable.getReader(); + const { value, done } = await r.read(); + r.releaseLock(); + if (done) + return; + return value; + } + async abort(err) { + if (this.#closed) + return; + await this.#stream.writable.abort(err); + this.#closed = true; + } + async close() { + if (this.#closed) + return; + await this.#stream.writable.close(); + this.#closed = true; + } + closed() { + return this.#closed; + } + } + + class Publisher { + // Used to send control messages + #control; + // Use to send objects. + #objects; + // Our announced tracks. + #announce = new Map(); + // Their subscribed tracks. + #subscribe = new Map(); + #subscribeQueue = new Queue(Number.MAX_SAFE_INTEGER); // Unbounded queue in case there's no receiver + constructor(control, objects) { + this.#control = control; + this.#objects = objects; + } + // Announce a track namespace. + async announce(namespace) { + if (this.#announce.has(namespace)) { + throw new Error(`already announce: ${namespace}`); + } + const announce = new AnnounceSend(this.#control, namespace); + this.#announce.set(namespace, announce); + await this.#control.send({ + kind: Msg.Announce, + namespace, + }); + return announce; + } + // Receive the next new subscription + async subscribed() { + return await this.#subscribeQueue.next(); + } + async recv(msg) { + if (msg.kind == Msg.Subscribe) { + await this.recvSubscribe(msg); + } + else if (msg.kind == Msg.Unsubscribe) { + this.recvUnsubscribe(msg); + } + else if (msg.kind == Msg.AnnounceOk) { + this.recvAnnounceOk(msg); + } + else if (msg.kind == Msg.AnnounceError) { + this.recvAnnounceError(msg); + } + else { + throw new Error(`unknown control message`); // impossible + } + } + recvAnnounceOk(msg) { + const announce = this.#announce.get(msg.namespace); + if (!announce) { + throw new Error(`announce OK for unknown announce: ${msg.namespace}`); + } + announce.onOk(); + } + recvAnnounceError(msg) { + const announce = this.#announce.get(msg.namespace); + if (!announce) { + // TODO debug this + console.warn(`announce error for unknown announce: ${msg.namespace}`); + return; + } + announce.onError(msg.code, msg.reason); + } + async recvSubscribe(msg) { + if (this.#subscribe.has(msg.id)) { + throw new Error(`duplicate subscribe for id: ${msg.id}`); + } + const subscribe = new SubscribeRecv(this.#control, this.#objects, msg); + this.#subscribe.set(msg.id, subscribe); + await this.#subscribeQueue.push(subscribe); + await this.#control.send({ + kind: Msg.SubscribeOk, + id: msg.id, + expires: 0n, + group_order: msg.group_order, + }); + } + recvUnsubscribe(_msg) { + throw new Error("TODO unsubscribe"); + } + } + class AnnounceSend { + #control; + namespace; + // The current state, updated by control messages. + #state = new Watch("init"); + constructor(control, namespace) { + this.#control = control; + this.namespace = namespace; + } + async ok() { + for (;;) { + const [state, next] = this.#state.value(); + if (state === "ack") + return; + if (state instanceof Error) + throw state; + if (!next) + throw new Error("closed"); + await next; + } + } + async active() { + for (;;) { + const [state, next] = this.#state.value(); + if (state instanceof Error) + throw state; + if (!next) + return; + await next; + } + } + async close() { + // TODO implement unsubscribe + // await this.#inner.sendUnsubscribe() + } + closed() { + const [state, next] = this.#state.value(); + return state instanceof Error || next == undefined; + } + onOk() { + if (this.closed()) + return; + this.#state.update("ack"); + } + onError(code, reason) { + if (this.closed()) + return; + const err = new Error(`ANNOUNCE_ERROR (${code})` + reason ? `: ${reason}` : ""); + this.#state.update(err); + } + } + class SubscribeRecv { + #control; + #objects; + #id; + #trackId; + #subscriberPriority; + groupOrder; + namespace; + track; + // The current state of the subscription. + #state = "init"; + constructor(control, objects, msg) { + this.#control = control; // so we can send messages + this.#objects = objects; // so we can send objects + this.#id = msg.id; + this.#trackId = msg.trackId; + this.namespace = msg.namespace; + this.track = msg.name; + this.#subscriberPriority = msg.subscriber_priority; + this.groupOrder = msg.group_order; + } + // Acknowledge the subscription as valid. + async ack() { + if (this.#state !== "init") + return; + this.#state = "ack"; + // Send the control message. + return this.#control.send({ + kind: Msg.SubscribeOk, + id: this.#id, + expires: 0n, + group_order: this.groupOrder, + }); + } + // Close the subscription with an error. + async close(code = 0n, reason = "") { + if (this.#state === "closed") + return; + this.#state = "closed"; + return this.#control.send({ + kind: Msg.SubscribeDone, + id: this.#id, + code, + reason, + }); + } + // Create a writable data stream for the entire track + async serve(props) { + return this.#objects.send({ + type: StreamType.Track, + sub: this.#id, + track: this.#trackId, + publisher_priority: props?.priority ?? 127, + }); + } + // Create a writable data stream for a group within the track + async group(props) { + return this.#objects.send({ + type: StreamType.Group, + sub: this.#id, + track: this.#trackId, + group: props.group, + publisher_priority: props.priority ?? 127, + }); + } + // Create a writable data stream for a single object within the track + async object(props) { + return this.#objects.send({ + type: StreamType.Object, + sub: this.#id, + track: this.#trackId, + group: props.group, + object: props.object, + publisher_priority: props.priority ?? 127, + status: 0, + }); + } + } + + class Subscriber { + // Use to send control messages. + #control; + // Use to send objects. + #objects; + // Announced broadcasts. + #announce = new Map(); + #announceQueue = new Watch([]); + // Our subscribed tracks. + #subscribe = new Map(); + #subscribeNext = 0n; + #trackToIDMap = new Map(); + constructor(control, objects) { + this.#control = control; + this.#objects = objects; + } + announced() { + return this.#announceQueue; + } + async recv(msg) { + if (msg.kind == Msg.Announce) { + await this.recvAnnounce(msg); + } + else if (msg.kind == Msg.Unannounce) { + this.recvUnannounce(msg); + } + else if (msg.kind == Msg.SubscribeOk) { + this.recvSubscribeOk(msg); + } + else if (msg.kind == Msg.SubscribeError) { + await this.recvSubscribeError(msg); + } + else if (msg.kind == Msg.SubscribeDone) { + await this.recvSubscribeDone(msg); + } + else { + throw new Error(`unknown control message`); // impossible + } + } + async recvAnnounce(msg) { + if (this.#announce.has(msg.namespace)) { + throw new Error(`duplicate announce for namespace: ${msg.namespace}`); + } + await this.#control.send({ kind: Msg.AnnounceOk, namespace: msg.namespace }); + const announce = new AnnounceRecv(this.#control, msg.namespace); + this.#announce.set(msg.namespace, announce); + this.#announceQueue.update((queue) => [...queue, announce]); + } + recvUnannounce(_msg) { + throw new Error(`TODO Unannounce`); + } + async subscribe(namespace, track) { + const id = this.#subscribeNext++; + const subscribe = new SubscribeSend(this.#control, id, namespace, track); + this.#subscribe.set(id, subscribe); + this.#trackToIDMap.set(track, id); + await this.#control.send({ + kind: Msg.Subscribe, + id, + trackId: id, + namespace, + name: track, + subscriber_priority: 127, // default to mid value, see: https://github.com/moq-wg/moq-transport/issues/504 + group_order: GroupOrder.Publisher, + location: { + mode: "latest_group", + }, + }); + return subscribe; + } + async unsubscribe(track) { + if (this.#trackToIDMap.has(track)) { + const trackID = this.#trackToIDMap.get(track); + if (trackID === undefined) { + console.warn(`Exception track ${track} not found in trackToIDMap.`); + return; + } + try { + await this.#control.send({ kind: Msg.Unsubscribe, id: trackID }); + this.#trackToIDMap.delete(track); + } + catch (error) { + console.error(`Failed to unsubscribe from track ${track}:`, error); + } + } + else { + console.warn(`During unsubscribe request initiation attempt track ${track} not found in trackToIDMap.`); + } + } + recvSubscribeOk(msg) { + const subscribe = this.#subscribe.get(msg.id); + if (!subscribe) { + throw new Error(`subscribe ok for unknown id: ${msg.id}`); + } + subscribe.onOk(); + } + async recvSubscribeError(msg) { + const subscribe = this.#subscribe.get(msg.id); + if (!subscribe) { + throw new Error(`subscribe error for unknown id: ${msg.id}`); + } + await subscribe.onError(msg.code, msg.reason); + } + async recvSubscribeDone(msg) { + const subscribe = this.#subscribe.get(msg.id); + if (!subscribe) { + throw new Error(`subscribe error for unknown id: ${msg.id}`); + } + await subscribe.onError(msg.code, msg.reason); + } + async recvObject(reader) { + const subscribe = this.#subscribe.get(reader.header.track); + if (!subscribe) { + throw new Error(`data for for unknown track: ${reader.header.track}`); + } + await subscribe.onData(reader); + } + } + class AnnounceRecv { + #control; + namespace; + // The current state of the announce + #state = "init"; + constructor(control, namespace) { + this.#control = control; // so we can send messages + this.namespace = namespace; + } + // Acknowledge the subscription as valid. + async ok() { + if (this.#state !== "init") + return; + this.#state = "ack"; + // Send the control message. + return this.#control.send({ kind: Msg.AnnounceOk, namespace: this.namespace }); + } + async close(code = 0n, reason = "") { + if (this.#state === "closed") + return; + this.#state = "closed"; + return this.#control.send({ kind: Msg.AnnounceError, namespace: this.namespace, code, reason }); + } + } + class SubscribeSend { + #control; + #id; + namespace; + track; + // A queue of received streams for this subscription. + #data = new Queue(); + constructor(control, id, namespace, track) { + this.#control = control; // so we can send messages + this.#id = id; + this.namespace = namespace; + this.track = track; + } + async close(_code = 0n, _reason = "") { + // TODO implement unsubscribe + // await this.#inner.sendReset(code, reason) + } + onOk() { + // noop + } + async onError(code, reason) { + if (code == 0n) { + return await this.#data.close(); + } + if (reason !== "") { + reason = `: ${reason}`; + } + const err = new Error(`SUBSCRIBE_ERROR (${code})${reason}`); + return await this.#data.abort(err); + } + async onData(reader) { + if (!this.#data.closed()) + await this.#data.push(reader); + } + // Receive the next a readable data stream + async data() { + return await this.#data.next(); + } + } + + class Connection { + // The established WebTransport session. + #quic; + // Use to receive/send control messages. + #control; + // Use to receive/send objects. + #objects; + // Module for contributing tracks. + #publisher; + // Module for distributing tracks. + #subscriber; + // Async work running in the background + #running; + constructor(quic, control, objects) { + this.#quic = quic; + this.#control = control; + this.#objects = objects; + this.#publisher = new Publisher(this.#control, this.#objects); + this.#subscriber = new Subscriber(this.#control, this.#objects); + this.#running = this.#run(); + } + close(code = 0, reason = "") { + this.#quic.close({ closeCode: code, reason }); + } + async #run() { + await Promise.all([this.#runControl(), this.#runObjects()]); + } + announce(namespace) { + return this.#publisher.announce(namespace); + } + announced() { + return this.#subscriber.announced(); + } + subscribe(namespace, track) { + return this.#subscriber.subscribe(namespace, track); + } + unsubscribe(track) { + return this.#subscriber.unsubscribe(track); + } + subscribed() { + return this.#publisher.subscribed(); + } + async #runControl() { + // Receive messages until the connection is closed. + for (;;) { + const msg = await this.#control.recv(); + await this.#recv(msg); + } + } + async #runObjects() { + for (;;) { + const obj = await this.#objects.recv(); + if (!obj) + break; + await this.#subscriber.recvObject(obj); + } + } + async #recv(msg) { + if (isPublisher(msg)) { + await this.#subscriber.recv(msg); + } + else { + await this.#publisher.recv(msg); + } + } + async closed() { + try { + await this.#running; + return new Error("closed"); + } + catch (e) { + return asError(e); + } + } + } + + class Client { + #fingerprint; + config; + constructor(config) { + this.config = config; + this.#fingerprint = this.#fetchFingerprint(config.fingerprint).catch((e) => { + console.warn("failed to fetch fingerprint: ", e); + return undefined; + }); + } + async connect() { + // Helper function to make creating a promise easier + const options = {}; + const fingerprint = await this.#fingerprint; + if (fingerprint) + options.serverCertificateHashes = [fingerprint]; + const quic = new WebTransport(this.config.url, options); + await quic.ready; + const stream = await quic.createBidirectionalStream(); + const writer = new Writer(stream.writable); + const reader = new Reader(new Uint8Array(), stream.readable); + const setup = new Stream$1(reader, writer); + // Send the setup message. + await setup.send.client({ versions: [Version.DRAFT_05], role: this.config.role }); + // Receive the setup message. + // TODO verify the SETUP response. + const server = await setup.recv.server(); + if (server.version != Version.DRAFT_05) { + throw new Error(`unsupported server version: ${server.version}`); + } + const control = new Stream(reader, writer); + const objects = new Objects(quic); + return new Connection(quic, control, objects); + } + async #fetchFingerprint(url) { + if (!url) + return; + // TODO remove this fingerprint when Chrome WebTransport accepts the system CA + const response = await fetch(url); + const hexString = await response.text(); + const hexBytes = new Uint8Array(hexString.length / 2); + for (let i = 0; i < hexBytes.length; i += 1) { + hexBytes[i] = parseInt(hexString.slice(2 * i, 2 * i + 2), 16); + } + return { + algorithm: "sha-256", + value: hexBytes, + }; + } + } + + // This class must be created on the main thread due to AudioContext. + class Player { + #backend; + // A periodically updated timeline + //#timeline = new Watch(undefined) + #connection; + #catalog; + #tracksByName; + #tracknum; + #audioTrackName; + #videoTrackName; + #muted; + #paused; + // Running is a promise that resolves when the player is closed. + // #close is called with no error, while #abort is called with an error. + #running; + #close; + #abort; + #trackTasks = new Map(); + constructor(connection, catalog, backend, tracknum) { + this.#connection = connection; + this.#catalog = catalog; + this.#tracksByName = new Map(catalog.tracks.map((track) => [track.name, track])); + this.#backend = backend; + this.#tracknum = tracknum; + this.#audioTrackName = ""; + this.#videoTrackName = ""; + this.#muted = false; + this.#paused = false; + const abort = new Promise((resolve, reject) => { + this.#close = resolve; + this.#abort = reject; + }); + // Async work + this.#running = abort.catch(this.#close); + this.#run().catch((err) => { + console.error("Error in #run():", err); + this.#abort(err); + }); + } + static async create(config, tracknum) { + const client = new Client({ url: config.url, fingerprint: config.fingerprint, role: "subscriber" }); + const connection = await client.connect(); + const catalog = await fetch$1(connection, config.namespace); + console.log("catalog", catalog); + const canvas = config.canvas.transferControlToOffscreen(); + const backend = new Backend({ canvas, catalog }); + return new Player(connection, catalog, backend, tracknum); + } + async #run() { + const inits = new Set(); + const tracks = new Array(); + this.#catalog.tracks.forEach((track, index) => { + if (index == this.#tracknum || isAudioTrack(track)) { + if (!track.namespace) + throw new Error("track has no namespace"); + if (track.initTrack) + inits.add([track.namespace, track.initTrack]); + tracks.push(track); + } + }); + // Call #runInit on each unique init track + // TODO do this in parallel with #runTrack to remove a round trip + await Promise.all(Array.from(inits).map((init) => this.#runInit(...init))); + // Call #runTrack on each track + tracks.forEach((track) => { + this.#runTrack(track); + }); + } + async #runInit(namespace, name) { + const sub = await this.#connection.subscribe(namespace, name); + try { + const init = await Promise.race([sub.data(), this.#running]); + if (!init) + throw new Error("no init data"); + // We don't care what type of reader we get, we just want the payload. + const chunk = await init.read(); + if (!chunk) + throw new Error("no init chunk"); + if (!(chunk.payload instanceof Uint8Array)) + throw new Error("invalid init chunk"); + this.#backend.init({ data: chunk.payload, name }); + } + finally { + await sub.close(); + } + } + async #trackTask(track) { + if (!track.namespace) + throw new Error("track has no namespace"); + if (this.#paused) + return; + const kind = isVideoTrack(track) ? "video" : isAudioTrack(track) ? "audio" : "unknown"; + if (kind == "audio" && this.#muted) + return; + const sub = await this.#connection.subscribe(track.namespace, track.name); + if (kind == "audio") { + // Save ref to last audio track we subscribed to for unmuting + this.#audioTrackName = track.name; + } + if (kind == "video") { + this.#videoTrackName = track.name; + } + try { + for (;;) { + const segment = await Promise.race([sub.data(), this.#running]); + if (!segment) + continue; + if (!(segment instanceof GroupReader)) { + throw new Error(`expected group reader for segment: ${track.name}`); + } + if (kind == "unknown") { + throw new Error(`unknown track kind: ${track.name}`); + } + if (!track.initTrack) { + throw new Error(`no init track for segment: ${track.name}`); + } + const [buffer, stream] = segment.stream.release(); + this.#backend.segment({ + init: track.initTrack, + kind, + header: segment.header, + buffer, + stream, + }); + } + } + catch (error) { + console.error("Error in #runTrack:", error); + } + finally { + await sub.close(); + } + } + #runTrack(track) { + if (this.#trackTasks.has(track.name)) { + console.warn(`Already exist a runTrack task for the track: ${track.name}`); + return; + } + const task = (async () => this.#trackTask(track))(); + this.#trackTasks.set(track.name, task); + task.catch((err) => { + console.error(`Error to subscribe to track ${track.name}`, err); + }).finally(() => { + this.#trackTasks.delete(track.name); + }); + } + getCatalog() { + return this.#catalog; + } + getCurrentTrack() { + if (this.#tracknum >= 0 && this.#tracknum < this.#catalog.tracks.length) { + return this.#catalog.tracks[this.#tracknum]; + } + else { + console.warn("Invalid track number:", this.#tracknum); + return null; + } + } + getVideoTracks() { + return this.#catalog.tracks.filter(isVideoTrack).map((track) => track.name); + } + getAudioTracks() { + return this.#catalog.tracks.filter(isAudioTrack).map((track) => track.name); + } + async switchTrack(trackname) { + const currentTrack = this.getCurrentTrack(); + if (this.#paused) { + this.#videoTrackName = trackname; + return; + } + if (currentTrack) { + console.log(`Unsubscribing from track: ${currentTrack.name} and Subscribing to track: ${trackname}`); + await this.unsubscribeFromTrack(currentTrack.name); + } + else { + console.log(`Subscribing to track: ${trackname}`); + } + this.#tracknum = this.#catalog.tracks.findIndex((track) => track.name === trackname); + const tracksToStream = this.#catalog.tracks.filter((track) => track.name === trackname); + await Promise.all(tracksToStream.map((track) => this.#runTrack(track))); + } + async mute(isMuted) { + this.#muted = isMuted; + if (isMuted) { + console.log("Unsubscribing from audio track: ", this.#audioTrackName); + await this.unsubscribeFromTrack(this.#audioTrackName); + await this.#backend.mute(); + } + else { + console.log("Subscribing to audio track: ", this.#audioTrackName); + this.subscribeFromTrackName(this.#audioTrackName); + await this.#backend.unmute(); + } + } + async unsubscribeFromTrack(trackname) { + console.log(`Unsubscribing from track: ${trackname}`); + await this.#connection.unsubscribe(trackname); + const task = this.#trackTasks.get(trackname); + if (task) { + await task; + } + } + subscribeFromTrackName(trackname) { + console.log(`Subscribing to track: ${trackname}`); + const track = this.#tracksByName.get(trackname); + if (track) { + this.#runTrack(track); + } + else { + console.warn(`Track ${trackname} not in #tracksByName`); + } + } + #onMessage(msg) { + if (msg.timeline) ; + } + async close(err) { + if (err) + this.#abort(err); + else + this.#close(); + if (this.#connection) + this.#connection.close(); + if (this.#backend) + await this.#backend.close(); + } + async closed() { + try { + await this.#running; + } + catch (e) { + return asError(e); + } + } + /* + play() { + this.#backend.play({ minBuffer: 0.5 }) // TODO configurable + } + + seek(timestamp: number) { + this.#backend.seek({ timestamp }) + } + */ + async play() { + if (this.#paused) { + this.#paused = false; + this.subscribeFromTrackName(this.#videoTrackName); + if (!this.#muted) { + this.subscribeFromTrackName(this.#audioTrackName); + await this.#backend.unmute(); + } + } + else { + await this.unsubscribeFromTrack(this.#videoTrackName); + await this.unsubscribeFromTrack(this.#audioTrackName); + await this.#backend.mute(); + this.#backend.pause(); + this.#paused = true; + } + } + } + + return Player; + +})(); +//# sourceMappingURL=moq-player.umd.js.map diff --git a/simple-web/public/moq-player.umd.js.map b/simple-web/public/moq-player.umd.js.map new file mode 100644 index 0000000..93f5f7c --- /dev/null +++ b/simple-web/public/moq-player.umd.js.map @@ -0,0 +1 @@ +{"version":3,"file":"moq-player.umd.js","sources":["../../common/error.ts","../../media/catalog/index.ts","../../playback/audio.ts","../../common/ring.ts","../../playback/backend.ts","../../transport/stream.ts","../../transport/setup.ts","../../transport/control.ts","../../transport/objects.ts","../../common/async.ts","../../transport/publisher.ts","../../transport/subscriber.ts","../../transport/connection.ts","../../transport/client.ts","../../playback/index.ts"],"sourcesContent":["// I hate javascript\nexport function asError(e: any): Error {\n\tif (e instanceof Error) {\n\t\treturn e\n\t} else if (typeof e === \"string\") {\n\t\treturn new Error(e)\n\t} else {\n\t\treturn new Error(String(e))\n\t}\n}\n\nexport function isError(e: any): e is Error {\n\treturn e instanceof Error\n}\n","import { Connection } from \"../../transport\"\nimport { asError } from \"../../common/error\"\n\nexport interface CommonTrackFields {\n\tnamespace?: string\n\tpackaging?: string\n\trenderGroup?: number\n\taltGroup?: number\n}\n\nexport interface Root {\n\tversion: number\n\tstreamingFormat: number\n\tstreamingFormatVersion: string\n\tsupportsDeltaUpdates: boolean\n\tcommonTrackFields: CommonTrackFields\n\ttracks: Track[]\n}\n\nexport function encode(catalog: Root): Uint8Array {\n\tconst encoder = new TextEncoder()\n\tconst str = JSON.stringify(catalog)\n\treturn encoder.encode(str)\n}\n\nexport function decode(raw: Uint8Array): Root {\n\tconst decoder = new TextDecoder()\n\tconst str = decoder.decode(raw)\n\n\tconst catalog = JSON.parse(str)\n\tif (!isRoot(catalog)) {\n\t\tthrow new Error(\"invalid catalog\")\n\t}\n\n\t// Merge common track fields into each track.\n\tfor (const track of catalog.tracks) {\n\t\ttrack.altGroup ??= catalog.commonTrackFields.altGroup\n\t\ttrack.namespace ??= catalog.commonTrackFields.namespace\n\t\ttrack.packaging ??= catalog.commonTrackFields.packaging\n\t\ttrack.renderGroup ??= catalog.commonTrackFields.renderGroup\n\t}\n\n\treturn catalog\n}\n\nexport async function fetch(connection: Connection, namespace: string): Promise {\n\tconst subscribe = await connection.subscribe(namespace, \".catalog\")\n\ttry {\n\t\tconst segment = await subscribe.data()\n\t\tif (!segment) throw new Error(\"no catalog data\")\n\n\t\tconst chunk = await segment.read()\n\t\tif (!chunk) throw new Error(\"no catalog chunk\")\n\n\t\tawait segment.close()\n\t\tawait subscribe.close() // we done\n\n\t\tif (chunk.payload instanceof Uint8Array) {\n\t\t\treturn decode(chunk.payload)\n\t\t} else {\n\t\t\tthrow new Error(\"invalid catalog chunk\")\n\t\t}\n\t} catch (e) {\n\t\tconst err = asError(e)\n\n\t\t// Close the subscription after we're done.\n\t\tawait subscribe.close(1n, err.message)\n\n\t\tthrow err\n\t}\n}\n\nexport function isRoot(catalog: any): catalog is Root {\n\tif (!isCatalogFieldValid(catalog, \"packaging\")) return false\n\tif (!isCatalogFieldValid(catalog, \"namespace\")) return false\n\tif (!Array.isArray(catalog.tracks)) return false\n\treturn catalog.tracks.every((track: any) => isTrack(track))\n}\n\nexport interface Track {\n\tnamespace?: string\n\tname: string\n\tdepends?: any[]\n\tpackaging?: string\n\trenderGroup?: number\n\tselectionParams: SelectionParams // technically optional but not really\n\taltGroup?: number\n\tinitTrack?: string\n\tinitData?: string\n}\n\nexport interface Mp4Track extends Track {\n\tinitTrack?: string\n\tinitData?: string\n\tselectionParams: Mp4SelectionParams\n}\n\nexport interface SelectionParams {\n\tcodec?: string\n\tmimeType?: string\n\tbitrate?: number\n\tlang?: string\n}\n\nexport interface Mp4SelectionParams extends SelectionParams {\n\tmimeType: \"video/mp4\"\n}\n\nexport interface AudioTrack extends Track {\n\tname: string\n\tselectionParams: AudioSelectionParams\n}\n\nexport interface AudioSelectionParams extends SelectionParams {\n\tsamplerate: number\n\tchannelConfig: string\n}\n\nexport interface VideoTrack extends Track {\n\tname: string\n\tselectionParams: VideoSelectionParams\n\ttemporalId?: number\n\tspatialId?: number\n}\n\nexport interface VideoSelectionParams extends SelectionParams {\n\twidth: number\n\theight: number\n\tdisplayWidth?: number\n\tdisplayHeight?: number\n\tframerate?: number\n}\n\nexport function isTrack(track: any): track is Track {\n\tif (typeof track.name !== \"string\") return false\n\treturn true\n}\n\nexport function isMp4Track(track: any): track is Mp4Track {\n\tif (!isTrack(track)) return false\n\tif (typeof track.initTrack !== \"string\" && typeof track.initData !== \"string\") return false\n\tif (typeof track.selectionParams.mimeType !== \"string\") return false\n\treturn true\n}\n\nexport function isVideoTrack(track: any): track is VideoTrack {\n\tif (!isTrack(track)) return false\n\treturn isVideoSelectionParams(track.selectionParams)\n}\n\nexport function isVideoSelectionParams(params: any): params is VideoSelectionParams {\n\tif (typeof params.width !== \"number\") return false\n\tif (typeof params.height !== \"number\") return false\n\treturn true\n}\n\nexport function isAudioTrack(track: any): track is AudioTrack {\n\tif (!isTrack(track)) return false\n\treturn isAudioSelectionParams(track.selectionParams)\n}\n\nexport function isAudioSelectionParams(params: any): params is AudioSelectionParams {\n\tif (typeof params.channelConfig !== \"string\") return false\n\tif (typeof params.samplerate !== \"number\") return false\n\treturn true\n}\n\nfunction isCatalogFieldValid(catalog: any, field: string): boolean {\n\t//packaging,namespace if common would be listed in commonTrackFields but if fields\n\t//in commonTrackFields are mentiond in Tracks , the fields in Tracks precedes\n\n\tfunction isValidPackaging(packaging: any): boolean {\n\t\treturn packaging === \"cmaf\" || packaging === \"loc\"\n\t}\n\n\tfunction isValidNamespace(namespace: any): boolean {\n\t\treturn typeof namespace === \"string\"\n\t}\n\n\tlet isValidField: (value: any) => boolean\n\tif (field === \"packaging\") {\n\t\tisValidField = isValidPackaging\n\t} else if (field === \"namespace\") {\n\t\tisValidField = isValidNamespace\n\t} else {\n\t\tthrow new Error(`Invalid field: ${field}`)\n\t}\n\n\tif (catalog.commonTrackFields[field] !== undefined && !isValidField(catalog.commonTrackFields[field])) {\n\t\treturn false\n\t}\n\n\tfor (const track of catalog.tracks) {\n\t\tif (track[field] !== undefined && !isValidField(track[field])) {\n\t\t\treturn false\n\t\t}\n\t}\n\n\treturn true\n}\n\nexport function isMediaTrack(track: any): track is Track {\n\tif (track.name.toLowerCase().includes(\"audio\") || track.name.toLowerCase().includes(\"video\")) {\n\t\treturn true\n\t}\n\n\tif (track.selectionParams && track.selectionParams.codec) {\n\t\tconst codec = track.selectionParams.codec.toLowerCase()\n\t\tconst acceptedCodecs = [\"mp4a\", \"avc1\"]\n\n\t\tfor (const acceptedCodec of acceptedCodecs) {\n\t\t\tif (codec.includes(acceptedCodec)) {\n\t\t\t\treturn true\n\t\t\t}\n\t\t}\n\t}\n\treturn false\n}\n","import * as Message from \"./worker/message\"\n\nimport registerMyAudioWorklet from \"audio-worklet:./worklet/index.ts\"\n\n// NOTE: This must be on the main thread\nexport class Audio {\n\tcontext: AudioContext\n\tworklet: Promise\n\n\tconstructor(config: Message.ConfigAudio) {\n\t\tthis.context = new AudioContext({\n\t\t\tlatencyHint: \"interactive\",\n\t\t\tsampleRate: config.sampleRate,\n\t\t})\n\n\t\tthis.worklet = this.load(config)\n\t}\n\n\tprivate async load(config: Message.ConfigAudio): Promise {\n\t\t// Load the worklet source code.\n\t\tawait registerMyAudioWorklet(this.context)\n\t\tconst volume = this.context.createGain()\n\t\tvolume.gain.value = 2.0\n\n\t\t// Create the worklet\n\t\tconst worklet = new AudioWorkletNode(this.context, \"renderer\")\n\n\t\tworklet.port.addEventListener(\"message\", this.on.bind(this))\n\t\tworklet.onprocessorerror = (e: Event) => {\n\t\t\tconsole.error(\"Audio worklet error:\", e)\n\t\t}\n\n\t\t// Connect the worklet to the volume node and then to the speakers\n\t\tworklet.connect(volume)\n\t\tvolume.connect(this.context.destination)\n\n\t\tworklet.port.postMessage({ config })\n\n\t\treturn worklet\n\t}\n\n\tprivate on(_event: MessageEvent) {\n\t\t// TODO\n\t}\n}\n","// Ring buffer with audio samples.\n\nenum STATE {\n\tREAD_POS = 0, // The current read position\n\tWRITE_POS, // The current write position\n\tLENGTH, // Clever way of saving the total number of enums values.\n}\n\ninterface FrameCopyToOptions {\n\tframeCount?: number\n\tframeOffset?: number\n\tplaneIndex: number\n}\n\n// This is implemented by AudioData in WebCodecs, but we don't import it because it's a DOM type.\ninterface Frame {\n\tnumberOfFrames: number\n\tnumberOfChannels: number\n\tcopyTo(dst: Float32Array, options: FrameCopyToOptions): void\n}\n\n// No prototype to make this easier to send via postMessage\nexport class RingShared {\n\tstate: SharedArrayBuffer\n\n\tchannels: SharedArrayBuffer[]\n\tcapacity: number\n\n\tconstructor(channels: number, capacity: number) {\n\t\t// Store the current state in a separate ring buffer.\n\t\tthis.state = new SharedArrayBuffer(STATE.LENGTH * Int32Array.BYTES_PER_ELEMENT)\n\n\t\t// Create a buffer for each audio channel\n\t\tthis.channels = []\n\t\tfor (let i = 0; i < channels; i += 1) {\n\t\t\tconst buffer = new SharedArrayBuffer(capacity * Float32Array.BYTES_PER_ELEMENT)\n\t\t\tthis.channels.push(buffer)\n\t\t}\n\n\t\tthis.capacity = capacity\n\t}\n}\n\nexport class Ring {\n\tstate: Int32Array\n\tchannels: Float32Array[]\n\tcapacity: number\n\n\tconstructor(shared: RingShared) {\n\t\tthis.state = new Int32Array(shared.state)\n\n\t\tthis.channels = []\n\t\tfor (const channel of shared.channels) {\n\t\t\tthis.channels.push(new Float32Array(channel))\n\t\t}\n\n\t\tthis.capacity = shared.capacity\n\t}\n\n\t// Write samples for single audio frame, returning the total number written.\n\twrite(frame: Frame): number {\n\t\tconst readPos = Atomics.load(this.state, STATE.READ_POS)\n\t\tconst writePos = Atomics.load(this.state, STATE.WRITE_POS)\n\n\t\tconst startPos = writePos\n\t\tlet endPos = writePos + frame.numberOfFrames\n\n\t\tif (endPos > readPos + this.capacity) {\n\t\t\tendPos = readPos + this.capacity\n\t\t\tif (endPos <= startPos) {\n\t\t\t\t// No space to write\n\t\t\t\treturn 0\n\t\t\t}\n\t\t}\n\n\t\tconst startIndex = startPos % this.capacity\n\t\tconst endIndex = endPos % this.capacity\n\n\t\t// Loop over each channel\n\t\tfor (let i = 0; i < this.channels.length; i += 1) {\n\t\t\tconst channel = this.channels[i]\n\n\t\t\t// If the AudioData doesn't have enough channels, duplicate it.\n\t\t\tconst planeIndex = Math.min(i, frame.numberOfChannels - 1)\n\n\t\t\tif (startIndex < endIndex) {\n\t\t\t\t// One continuous range to copy.\n\t\t\t\tconst full = channel.subarray(startIndex, endIndex)\n\n\t\t\t\tframe.copyTo(full, {\n\t\t\t\t\tplaneIndex,\n\t\t\t\t\tframeCount: endIndex - startIndex,\n\t\t\t\t})\n\t\t\t} else {\n\t\t\t\tconst first = channel.subarray(startIndex)\n\t\t\t\tconst second = channel.subarray(0, endIndex)\n\n\t\t\t\tframe.copyTo(first, {\n\t\t\t\t\tplaneIndex,\n\t\t\t\t\tframeCount: first.length,\n\t\t\t\t})\n\n\t\t\t\t// We need this conditional when startIndex == 0 and endIndex == 0\n\t\t\t\t// When capacity=4410 and frameCount=1024, this was happening 52s into the audio.\n\t\t\t\tif (second.length) {\n\t\t\t\t\tframe.copyTo(second, {\n\t\t\t\t\t\tplaneIndex,\n\t\t\t\t\t\tframeOffset: first.length,\n\t\t\t\t\t\tframeCount: second.length,\n\t\t\t\t\t})\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tAtomics.store(this.state, STATE.WRITE_POS, endPos)\n\n\t\treturn endPos - startPos\n\t}\n\n\tread(dst: Float32Array[]): number {\n\t\tconst readPos = Atomics.load(this.state, STATE.READ_POS)\n\t\tconst writePos = Atomics.load(this.state, STATE.WRITE_POS)\n\n\t\tconst startPos = readPos\n\t\tlet endPos = startPos + dst[0].length\n\n\t\tif (endPos > writePos) {\n\t\t\tendPos = writePos\n\t\t\tif (endPos <= startPos) {\n\t\t\t\t// Nothing to read\n\t\t\t\treturn 0\n\t\t\t}\n\t\t}\n\n\t\tconst startIndex = startPos % this.capacity\n\t\tconst endIndex = endPos % this.capacity\n\n\t\t// Loop over each channel\n\t\tfor (let i = 0; i < dst.length; i += 1) {\n\t\t\tif (i >= this.channels.length) {\n\t\t\t\t// ignore excess channels\n\t\t\t}\n\n\t\t\tconst input = this.channels[i]\n\t\t\tconst output = dst[i]\n\n\t\t\tif (startIndex < endIndex) {\n\t\t\t\tconst full = input.subarray(startIndex, endIndex)\n\t\t\t\toutput.set(full)\n\t\t\t} else {\n\t\t\t\tconst first = input.subarray(startIndex)\n\t\t\t\tconst second = input.subarray(0, endIndex)\n\n\t\t\t\toutput.set(first)\n\t\t\t\toutput.set(second, first.length)\n\t\t\t}\n\t\t}\n\n\t\tAtomics.store(this.state, STATE.READ_POS, endPos)\n\n\t\treturn endPos - startPos\n\t}\n\n\tclear() {\n\t\tconst pos = Atomics.load(this.state, STATE.WRITE_POS)\n\t\tAtomics.store(this.state, STATE.READ_POS, pos)\n\t}\n\n\tsize() {\n\t\t// TODO is this thread safe?\n\t\tconst readPos = Atomics.load(this.state, STATE.READ_POS)\n\t\tconst writePos = Atomics.load(this.state, STATE.WRITE_POS)\n\n\t\treturn writePos - readPos\n\t}\n}\n","import * as Message from \"./worker/message\"\nimport { Audio } from \"./audio\"\n\n// import WebWorker from 'web-worker:./Worker.ts';\nimport MediaWorker from \"web-worker:./worker/index.ts\"\n\nimport { RingShared } from \"../common/ring\"\nimport { Root, isAudioTrack } from \"../media/catalog\"\nimport { GroupHeader } from \"../transport/objects\"\n\nexport interface PlayerConfig {\n\tcanvas: OffscreenCanvas\n\tcatalog: Root\n}\n\n// This is a non-standard way of importing worklet/workers.\n// Unfortunately, it's the only option because of a Vite bug: https://github.com/vitejs/vite/issues/11823\n\n// Responsible for sending messages to the worker and worklet.\nexport default class Backend {\n\t// General worker\n\t#worker: Worker\n\n\t// The audio context, which must be created on the main thread.\n\t#audio?: Audio\n\n\tconstructor(config: PlayerConfig) {\n\t\t// TODO does this block the main thread? If so, make this async\n\t\tthis.#worker = new MediaWorker()\n\t\tthis.#worker.addEventListener(\"message\", this.on.bind(this))\n\n\t\tlet sampleRate: number | undefined\n\t\tlet channels: number | undefined\n\n\t\tfor (const track of config.catalog.tracks) {\n\t\t\tif (isAudioTrack(track)) {\n\t\t\t\tif (sampleRate && track.selectionParams.samplerate !== sampleRate) {\n\t\t\t\t\tthrow new Error(`TODO multiple audio tracks with different sample rates`)\n\t\t\t\t}\n\n\t\t\t\tsampleRate = track.selectionParams.samplerate\n\n\t\t\t\t// TODO properly handle weird channel configs\n\t\t\t\tchannels = Math.max(+track.selectionParams.channelConfig, channels ?? 0)\n\t\t\t}\n\t\t}\n\n\t\tconst msg: Message.Config = {}\n\n\t\t// Only configure audio is we have an audio track\n\t\tif (sampleRate && channels) {\n\t\t\tmsg.audio = {\n\t\t\t\tchannels: channels,\n\t\t\t\tsampleRate: sampleRate,\n\t\t\t\tring: new RingShared(2, sampleRate / 10), // 100ms\n\t\t\t}\n\n\t\t\tthis.#audio = new Audio(msg.audio)\n\t\t}\n\n\t\t// TODO only send the canvas if we have a video track\n\t\tmsg.video = {\n\t\t\tcanvas: config.canvas,\n\t\t}\n\n\t\tthis.send({ config: msg }, msg.video.canvas)\n\t}\n\n\tpause() {\n\t\tthis.send({ pause: true })\n\t}\n\n\tasync mute() {\n\t\tawait this.#audio?.context.suspend()\n\t}\n\n\tasync unmute() {\n\t\tawait this.#audio?.context.resume()\n\t}\n\n\tinit(init: Init) {\n\t\tthis.send({ init })\n\t}\n\n\tsegment(segment: Segment) {\n\t\tthis.send({ segment }, segment.stream)\n\t}\n\n\tasync close() {\n\t\tthis.#worker.terminate()\n\t\tawait this.#audio?.context.close()\n\t}\n\n\t// Enforce we're sending valid types to the worker\n\tprivate send(msg: Message.ToWorker, ...transfer: Transferable[]) {\n\t\t//console.log(\"sent message from main to worker\", msg)\n\t\tthis.#worker.postMessage(msg, transfer)\n\t}\n\n\tprivate on(e: MessageEvent) {\n\t\tconst msg = e.data as Message.FromWorker\n\n\t\t// Don't print the verbose timeline message.\n\t\tif (!msg.timeline) {\n\t\t\t//console.log(\"received message from worker to main\", msg)\n\t\t}\n\t}\n}\n\nexport interface Init {\n\tname: string // name of the init track\n\tdata: Uint8Array\n}\n\nexport interface Segment {\n\tinit: string // name of the init track\n\tkind: \"audio\" | \"video\"\n\theader: GroupHeader\n\tbuffer: Uint8Array\n\tstream: ReadableStream\n}\n","const MAX_U6 = Math.pow(2, 6) - 1\nconst MAX_U14 = Math.pow(2, 14) - 1\nconst MAX_U30 = Math.pow(2, 30) - 1\nconst MAX_U31 = Math.pow(2, 31) - 1\nconst MAX_U53 = Number.MAX_SAFE_INTEGER\nconst MAX_U62: bigint = 2n ** 62n - 1n\n\n// Reader wraps a stream and provides convience methods for reading pieces from a stream\n// Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet.\nexport class Reader {\n\t#buffer: Uint8Array\n\t#stream: ReadableStream\n\t#reader: ReadableStreamDefaultReader\n\n\tconstructor(buffer: Uint8Array, stream: ReadableStream) {\n\t\tthis.#buffer = buffer\n\t\tthis.#stream = stream\n\t\tthis.#reader = this.#stream.getReader()\n\t}\n\n\t// Adds more data to the buffer, returning true if more data was added.\n\tasync #fill(): Promise {\n\t\tconst result = await this.#reader.read()\n\t\tif (result.done) {\n\t\t\treturn false\n\t\t}\n\n\t\tconst buffer = new Uint8Array(result.value)\n\n\t\tif (this.#buffer.byteLength == 0) {\n\t\t\tthis.#buffer = buffer\n\t\t} else {\n\t\t\tconst temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength)\n\t\t\ttemp.set(this.#buffer)\n\t\t\ttemp.set(buffer, this.#buffer.byteLength)\n\t\t\tthis.#buffer = temp\n\t\t}\n\n\t\treturn true\n\t}\n\n\t// Add more data to the buffer until it's at least size bytes.\n\tasync #fillTo(size: number) {\n\t\twhile (this.#buffer.byteLength < size) {\n\t\t\tif (!(await this.#fill())) {\n\t\t\t\tthrow new Error(\"unexpected end of stream\")\n\t\t\t}\n\t\t}\n\t}\n\n\t// Consumes the first size bytes of the buffer.\n\t#slice(size: number): Uint8Array {\n\t\tconst result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size)\n\t\tthis.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size)\n\n\t\treturn result\n\t}\n\n\tasync read(size: number): Promise {\n\t\tif (size == 0) return new Uint8Array()\n\n\t\tawait this.#fillTo(size)\n\t\treturn this.#slice(size)\n\t}\n\n\tasync readAll(): Promise {\n\t\t// eslint-disable-next-line no-empty\n\t\twhile (await this.#fill()) {}\n\t\treturn this.#slice(this.#buffer.byteLength)\n\t}\n\n\tasync string(maxLength?: number): Promise {\n\t\tconst length = await this.u53()\n\t\tif (maxLength !== undefined && length > maxLength) {\n\t\t\tthrow new Error(`string length ${length} exceeds max length ${maxLength}`)\n\t\t}\n\n\t\tconst buffer = await this.read(length)\n\t\treturn new TextDecoder().decode(buffer)\n\t}\n\n\tasync u8(): Promise {\n\t\tawait this.#fillTo(1)\n\t\treturn this.#slice(1)[0]\n\t}\n\n\t// Returns a Number using 53-bits, the max Javascript can use for integer math\n\tasync u53(): Promise {\n\t\tconst v = await this.u62()\n\t\tif (v > MAX_U53) {\n\t\t\tthrow new Error(\"value larger than 53-bits; use v62 instead\")\n\t\t}\n\n\t\treturn Number(v)\n\t}\n\n\t// NOTE: Returns a bigint instead of a number since it may be larger than 53-bits\n\tasync u62(): Promise {\n\t\tawait this.#fillTo(1)\n\t\tconst size = (this.#buffer[0] & 0xc0) >> 6\n\n\t\tif (size == 0) {\n\t\t\tconst first = this.#slice(1)[0]\n\t\t\treturn BigInt(first) & 0x3fn\n\t\t} else if (size == 1) {\n\t\t\tawait this.#fillTo(2)\n\t\t\tconst slice = this.#slice(2)\n\t\t\tconst view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength)\n\n\t\t\treturn BigInt(view.getInt16(0)) & 0x3fffn\n\t\t} else if (size == 2) {\n\t\t\tawait this.#fillTo(4)\n\t\t\tconst slice = this.#slice(4)\n\t\t\tconst view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength)\n\n\t\t\treturn BigInt(view.getUint32(0)) & 0x3fffffffn\n\t\t} else if (size == 3) {\n\t\t\tawait this.#fillTo(8)\n\t\t\tconst slice = this.#slice(8)\n\t\t\tconst view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength)\n\n\t\t\treturn view.getBigUint64(0) & 0x3fffffffffffffffn\n\t\t} else {\n\t\t\tthrow new Error(\"impossible\")\n\t\t}\n\t}\n\n\tasync done(): Promise {\n\t\tif (this.#buffer.byteLength > 0) return false\n\t\treturn !(await this.#fill())\n\t}\n\n\tasync close() {\n\t\tthis.#reader.releaseLock()\n\t\tawait this.#stream.cancel()\n\t}\n\n\trelease(): [Uint8Array, ReadableStream] {\n\t\tthis.#reader.releaseLock()\n\t\treturn [this.#buffer, this.#stream]\n\t}\n}\n\n// Writer wraps a stream and writes chunks of data\nexport class Writer {\n\t#scratch: Uint8Array\n\t#writer: WritableStreamDefaultWriter\n\t#stream: WritableStream\n\n\tconstructor(stream: WritableStream) {\n\t\tthis.#stream = stream\n\t\tthis.#scratch = new Uint8Array(8)\n\t\tthis.#writer = this.#stream.getWriter()\n\t}\n\n\tasync u8(v: number) {\n\t\tawait this.write(setUint8(this.#scratch, v))\n\t}\n\n\tasync i32(v: number) {\n\t\tif (Math.abs(v) > MAX_U31) {\n\t\t\tthrow new Error(`overflow, value larger than 32-bits: ${v}`)\n\t\t}\n\n\t\t// We don't use a VarInt, so it always takes 4 bytes.\n\t\t// This could be improved but nothing is standardized yet.\n\t\tawait this.write(setInt32(this.#scratch, v))\n\t}\n\n\tasync u53(v: number) {\n\t\tif (v < 0) {\n\t\t\tthrow new Error(`underflow, value is negative: ${v}`)\n\t\t} else if (v > MAX_U53) {\n\t\t\tthrow new Error(`overflow, value larger than 53-bits: ${v}`)\n\t\t}\n\n\t\tawait this.write(setVint53(this.#scratch, v))\n\t}\n\n\tasync u62(v: bigint) {\n\t\tif (v < 0) {\n\t\t\tthrow new Error(`underflow, value is negative: ${v}`)\n\t\t} else if (v >= MAX_U62) {\n\t\t\tthrow new Error(`overflow, value larger than 62-bits: ${v}`)\n\t\t}\n\n\t\tawait this.write(setVint62(this.#scratch, v))\n\t}\n\n\tasync write(v: Uint8Array) {\n\t\tawait this.#writer.write(v)\n\t}\n\n\tasync string(str: string) {\n\t\tconst data = new TextEncoder().encode(str)\n\t\tawait this.u53(data.byteLength)\n\t\tawait this.write(data)\n\t}\n\n\tasync close() {\n\t\tthis.#writer.releaseLock()\n\t\tawait this.#stream.close()\n\t}\n\n\trelease(): WritableStream {\n\t\tthis.#writer.releaseLock()\n\t\treturn this.#stream\n\t}\n}\n\nfunction setUint8(dst: Uint8Array, v: number): Uint8Array {\n\tdst[0] = v\n\treturn dst.slice(0, 1)\n}\n\nfunction setUint16(dst: Uint8Array, v: number): Uint8Array {\n\tconst view = new DataView(dst.buffer, dst.byteOffset, 2)\n\tview.setUint16(0, v)\n\n\treturn new Uint8Array(view.buffer, view.byteOffset, view.byteLength)\n}\n\nfunction setInt32(dst: Uint8Array, v: number): Uint8Array {\n\tconst view = new DataView(dst.buffer, dst.byteOffset, 4)\n\tview.setInt32(0, v)\n\n\treturn new Uint8Array(view.buffer, view.byteOffset, view.byteLength)\n}\n\nfunction setUint32(dst: Uint8Array, v: number): Uint8Array {\n\tconst view = new DataView(dst.buffer, dst.byteOffset, 4)\n\tview.setUint32(0, v)\n\n\treturn new Uint8Array(view.buffer, view.byteOffset, view.byteLength)\n}\n\nfunction setVint53(dst: Uint8Array, v: number): Uint8Array {\n\tif (v <= MAX_U6) {\n\t\treturn setUint8(dst, v)\n\t} else if (v <= MAX_U14) {\n\t\treturn setUint16(dst, v | 0x4000)\n\t} else if (v <= MAX_U30) {\n\t\treturn setUint32(dst, v | 0x80000000)\n\t} else if (v <= MAX_U53) {\n\t\treturn setUint64(dst, BigInt(v) | 0xc000000000000000n)\n\t} else {\n\t\tthrow new Error(`overflow, value larger than 53-bits: ${v}`)\n\t}\n}\n\nfunction setVint62(dst: Uint8Array, v: bigint): Uint8Array {\n\tif (v < MAX_U6) {\n\t\treturn setUint8(dst, Number(v))\n\t} else if (v < MAX_U14) {\n\t\treturn setUint16(dst, Number(v) | 0x4000)\n\t} else if (v <= MAX_U30) {\n\t\treturn setUint32(dst, Number(v) | 0x80000000)\n\t} else if (v <= MAX_U62) {\n\t\treturn setUint64(dst, BigInt(v) | 0xc000000000000000n)\n\t} else {\n\t\tthrow new Error(`overflow, value larger than 62-bits: ${v}`)\n\t}\n}\n\nfunction setUint64(dst: Uint8Array, v: bigint): Uint8Array {\n\tconst view = new DataView(dst.buffer, dst.byteOffset, 8)\n\tview.setBigUint64(0, v)\n\n\treturn new Uint8Array(view.buffer, view.byteOffset, view.byteLength)\n}\n","import { Reader, Writer } from \"./stream\"\n\nexport type Message = Client | Server\nexport type Role = \"publisher\" | \"subscriber\" | \"both\"\n\nexport enum Version {\n\tDRAFT_00 = 0xff000000,\n\tDRAFT_01 = 0xff000001,\n\tDRAFT_02 = 0xff000002,\n\tDRAFT_03 = 0xff000003,\n\tDRAFT_04 = 0xff000004,\n\tDRAFT_05 = 0xff000005,\n\tKIXEL_00 = 0xbad00,\n\tKIXEL_01 = 0xbad01,\n}\n\n// NOTE: These are forked from moq-transport-00.\n// 1. messages lack a sized length\n// 2. parameters are not optional and written in order (role + path)\n// 3. role indicates local support only, not remote support\n\nexport interface Client {\n\tversions: Version[]\n\trole: Role\n\tparams?: Parameters\n}\n\nexport interface Server {\n\tversion: Version\n\tparams?: Parameters\n}\n\nexport class Stream {\n\trecv: Decoder\n\tsend: Encoder\n\n\tconstructor(r: Reader, w: Writer) {\n\t\tthis.recv = new Decoder(r)\n\t\tthis.send = new Encoder(w)\n\t}\n}\n\nexport type Parameters = Map\n\nexport class Decoder {\n\tr: Reader\n\n\tconstructor(r: Reader) {\n\t\tthis.r = r\n\t}\n\n\tasync client(): Promise {\n\t\tconst type = await this.r.u53()\n\t\tif (type !== 0x40) throw new Error(`client SETUP type must be 0x40, got ${type}`)\n\n\t\tconst count = await this.r.u53()\n\n\t\tconst versions = []\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst version = await this.r.u53()\n\t\t\tversions.push(version)\n\t\t}\n\n\t\tconst params = await this.parameters()\n\t\tconst role = this.role(params?.get(0n))\n\n\t\treturn {\n\t\t\tversions,\n\t\t\trole,\n\t\t\tparams,\n\t\t}\n\t}\n\n\tasync server(): Promise {\n\t\tconst type = await this.r.u53()\n\t\tif (type !== 0x41) throw new Error(`server SETUP type must be 0x41, got ${type}`)\n\n\t\tconst version = await this.r.u53()\n\t\tconst params = await this.parameters()\n\n\t\treturn {\n\t\t\tversion,\n\t\t\tparams,\n\t\t}\n\t}\n\n\tprivate async parameters(): Promise {\n\t\tconst count = await this.r.u53()\n\t\tif (count == 0) return undefined\n\n\t\tconst params = new Map()\n\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst id = await this.r.u62()\n\t\t\tconst size = await this.r.u53()\n\t\t\tconst value = await this.r.read(size)\n\n\t\t\tif (params.has(id)) {\n\t\t\t\tthrow new Error(`duplicate parameter id: ${id}`)\n\t\t\t}\n\n\t\t\tparams.set(id, value)\n\t\t}\n\n\t\treturn params\n\t}\n\n\trole(raw: Uint8Array | undefined): Role {\n\t\tif (!raw) throw new Error(\"missing role parameter\")\n\t\tif (raw.length != 1) throw new Error(\"multi-byte varint not supported\")\n\n\t\tswitch (raw[0]) {\n\t\t\tcase 1:\n\t\t\t\treturn \"publisher\"\n\t\t\tcase 2:\n\t\t\t\treturn \"subscriber\"\n\t\t\tcase 3:\n\t\t\t\treturn \"both\"\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`invalid role: ${raw[0]}`)\n\t\t}\n\t}\n}\n\nexport class Encoder {\n\tw: Writer\n\n\tconstructor(w: Writer) {\n\t\tthis.w = w\n\t}\n\n\tasync client(c: Client) {\n\t\tawait this.w.u53(0x40)\n\t\tawait this.w.u53(c.versions.length)\n\t\tfor (const v of c.versions) {\n\t\t\tawait this.w.u53(v)\n\t\t}\n\n\t\t// I hate it\n\t\tconst params = c.params ?? new Map()\n\t\tparams.set(0n, new Uint8Array([c.role == \"publisher\" ? 1 : c.role == \"subscriber\" ? 2 : 3]))\n\t\tawait this.parameters(params)\n\t}\n\n\tasync server(s: Server) {\n\t\tawait this.w.u53(0x41)\n\t\tawait this.w.u53(s.version)\n\t\tawait this.parameters(s.params)\n\t}\n\n\tprivate async parameters(p: Parameters | undefined) {\n\t\tif (!p) {\n\t\t\tawait this.w.u8(0)\n\t\t\treturn\n\t\t}\n\n\t\tawait this.w.u53(p.size)\n\t\tfor (const [id, value] of p) {\n\t\t\tawait this.w.u62(id)\n\t\t\tawait this.w.u53(value.length)\n\t\t\tawait this.w.write(value)\n\t\t}\n\t}\n}\n","import { Reader, Writer } from \"./stream\"\n\nexport type Message = Subscriber | Publisher\n\n// Sent by subscriber\nexport type Subscriber = Subscribe | Unsubscribe | AnnounceOk | AnnounceError\n\nexport function isSubscriber(m: Message): m is Subscriber {\n\treturn (\n\t\tm.kind == Msg.Subscribe || m.kind == Msg.Unsubscribe || m.kind == Msg.AnnounceOk || m.kind == Msg.AnnounceError\n\t)\n}\n\n// Sent by publisher\nexport type Publisher = SubscribeOk | SubscribeError | SubscribeDone | Announce | Unannounce\n\nexport function isPublisher(m: Message): m is Publisher {\n\treturn (\n\t\tm.kind == Msg.SubscribeOk ||\n\t\tm.kind == Msg.SubscribeError ||\n\t\tm.kind == Msg.SubscribeDone ||\n\t\tm.kind == Msg.Announce ||\n\t\tm.kind == Msg.Unannounce\n\t)\n}\n\n// I wish we didn't have to split Msg and Id into separate enums.\n// However using the string in the message makes it easier to debug.\n// We'll take the tiny performance hit until I'm better at Typescript.\nexport enum Msg {\n\t// NOTE: object and setup are in other modules\n\tSubscribe = \"subscribe\",\n\tSubscribeOk = \"subscribe_ok\",\n\tSubscribeError = \"subscribe_error\",\n\tSubscribeDone = \"subscribe_done\",\n\tUnsubscribe = \"unsubscribe\",\n\tAnnounce = \"announce\",\n\tAnnounceOk = \"announce_ok\",\n\tAnnounceError = \"announce_error\",\n\tUnannounce = \"unannounce\",\n\tGoAway = \"go_away\",\n}\n\nenum Id {\n\t// NOTE: object and setup are in other modules\n\t// Object = 0,\n\t// Setup = 1,\n\n\tSubscribe = 0x3,\n\tSubscribeOk = 0x4,\n\tSubscribeError = 0x5,\n\tSubscribeDone = 0xb,\n\tUnsubscribe = 0xa,\n\tAnnounce = 0x6,\n\tAnnounceOk = 0x7,\n\tAnnounceError = 0x8,\n\tUnannounce = 0x9,\n\tGoAway = 0x10,\n}\n\nexport interface Subscribe {\n\tkind: Msg.Subscribe\n\n\tid: bigint\n\ttrackId: bigint\n\tnamespace: string\n\tname: string\n\tsubscriber_priority: number\n\tgroup_order: GroupOrder\n\n\tlocation: Location\n\n\tparams?: Parameters\n}\n\nexport enum GroupOrder {\n\tPublisher = 0x0,\n\tAscending = 0x1,\n\tDescending = 0x2,\n}\n\nexport type Location = LatestGroup | LatestObject | AbsoluteStart | AbsoluteRange\n\nexport interface LatestGroup {\n\tmode: \"latest_group\"\n}\n\nexport interface LatestObject {\n\tmode: \"latest_object\"\n}\n\nexport interface AbsoluteStart {\n\tmode: \"absolute_start\"\n\tstart_group: number\n\tstart_object: number\n}\n\nexport interface AbsoluteRange {\n\tmode: \"absolute_range\"\n\tstart_group: number\n\tstart_object: number\n\tend_group: number\n\tend_object: number\n}\n\nexport type Parameters = Map\n\nexport interface SubscribeOk {\n\tkind: Msg.SubscribeOk\n\tid: bigint\n\texpires: bigint\n\tgroup_order: GroupOrder\n\tlatest?: [number, number]\n}\n\nexport interface SubscribeDone {\n\tkind: Msg.SubscribeDone\n\tid: bigint\n\tcode: bigint\n\treason: string\n\tfinal?: [number, number]\n}\n\nexport interface SubscribeError {\n\tkind: Msg.SubscribeError\n\tid: bigint\n\tcode: bigint\n\treason: string\n}\n\nexport interface Unsubscribe {\n\tkind: Msg.Unsubscribe\n\tid: bigint\n}\n\nexport interface Announce {\n\tkind: Msg.Announce\n\tnamespace: string\n\tparams?: Parameters\n}\n\nexport interface AnnounceOk {\n\tkind: Msg.AnnounceOk\n\tnamespace: string\n}\n\nexport interface AnnounceError {\n\tkind: Msg.AnnounceError\n\tnamespace: string\n\tcode: bigint\n\treason: string\n}\n\nexport interface Unannounce {\n\tkind: Msg.Unannounce\n\tnamespace: string\n}\n\nexport class Stream {\n\tprivate decoder: Decoder\n\tprivate encoder: Encoder\n\n\t#mutex = Promise.resolve()\n\n\tconstructor(r: Reader, w: Writer) {\n\t\tthis.decoder = new Decoder(r)\n\t\tthis.encoder = new Encoder(w)\n\t}\n\n\t// Will error if two messages are read at once.\n\tasync recv(): Promise {\n\t\tconst msg = await this.decoder.message()\n\t\tconsole.log(\"received message\", msg)\n\t\treturn msg\n\t}\n\n\tasync send(msg: Message) {\n\t\tconst unlock = await this.#lock()\n\t\ttry {\n\t\t\tconsole.log(\"sending message\", msg)\n\t\t\tawait this.encoder.message(msg)\n\t\t} finally {\n\t\t\tunlock()\n\t\t}\n\t}\n\n\tasync #lock() {\n\t\t// Make a new promise that we can resolve later.\n\t\tlet done: () => void\n\t\tconst p = new Promise((resolve) => {\n\t\t\tdone = () => resolve()\n\t\t})\n\n\t\t// Wait until the previous lock is done, then resolve our our lock.\n\t\tconst lock = this.#mutex.then(() => done)\n\n\t\t// Save our lock as the next lock.\n\t\tthis.#mutex = p\n\n\t\t// Return the lock.\n\t\treturn lock\n\t}\n}\n\nexport class Decoder {\n\tr: Reader\n\n\tconstructor(r: Reader) {\n\t\tthis.r = r\n\t}\n\n\tprivate async msg(): Promise {\n\t\tconst t = await this.r.u53()\n\t\tswitch (t) {\n\t\t\tcase Id.Subscribe:\n\t\t\t\treturn Msg.Subscribe\n\t\t\tcase Id.SubscribeOk:\n\t\t\t\treturn Msg.SubscribeOk\n\t\t\tcase Id.SubscribeDone:\n\t\t\t\treturn Msg.SubscribeDone\n\t\t\tcase Id.SubscribeError:\n\t\t\t\treturn Msg.SubscribeError\n\t\t\tcase Id.Unsubscribe:\n\t\t\t\treturn Msg.Unsubscribe\n\t\t\tcase Id.Announce:\n\t\t\t\treturn Msg.Announce\n\t\t\tcase Id.AnnounceOk:\n\t\t\t\treturn Msg.AnnounceOk\n\t\t\tcase Id.AnnounceError:\n\t\t\t\treturn Msg.AnnounceError\n\t\t\tcase Id.Unannounce:\n\t\t\t\treturn Msg.Unannounce\n\t\t\tcase Id.GoAway:\n\t\t\t\treturn Msg.GoAway\n\t\t}\n\n\t\tthrow new Error(`unknown control message type: ${t}`)\n\t}\n\n\tasync message(): Promise {\n\t\tconst t = await this.msg()\n\t\tswitch (t) {\n\t\t\tcase Msg.Subscribe:\n\t\t\t\treturn this.subscribe()\n\t\t\tcase Msg.SubscribeOk:\n\t\t\t\treturn this.subscribe_ok()\n\t\t\tcase Msg.SubscribeError:\n\t\t\t\treturn this.subscribe_error()\n\t\t\tcase Msg.SubscribeDone:\n\t\t\t\treturn this.subscribe_done()\n\t\t\tcase Msg.Unsubscribe:\n\t\t\t\treturn this.unsubscribe()\n\t\t\tcase Msg.Announce:\n\t\t\t\treturn this.announce()\n\t\t\tcase Msg.AnnounceOk:\n\t\t\t\treturn this.announce_ok()\n\t\t\tcase Msg.Unannounce:\n\t\t\t\treturn this.unannounce()\n\t\t\tcase Msg.AnnounceError:\n\t\t\t\treturn this.announce_error()\n\t\t\tcase Msg.GoAway:\n\t\t\t\tthrow new Error(\"TODO: implement go away\")\n\t\t}\n\t}\n\n\tprivate async subscribe(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.Subscribe,\n\t\t\tid: await this.r.u62(),\n\t\t\ttrackId: await this.r.u62(),\n\t\t\tnamespace: await this.r.string(),\n\t\t\tname: await this.r.string(),\n\t\t\tsubscriber_priority: await this.r.u8(),\n\t\t\tgroup_order: await this.decodeGroupOrder(),\n\t\t\tlocation: await this.location(),\n\t\t\tparams: await this.parameters(),\n\t\t}\n\t}\n\n\tprivate async decodeGroupOrder(): Promise {\n\t\tconst orderCode = await this.r.u8()\n\t\tswitch (orderCode) {\n\t\t\tcase 0:\n\t\t\t\treturn GroupOrder.Publisher\n\t\t\tcase 1:\n\t\t\t\treturn GroupOrder.Ascending\n\t\t\tcase 2:\n\t\t\t\treturn GroupOrder.Descending\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Invalid GroupOrder value: ${orderCode}`)\n\t\t}\n\t}\n\n\tprivate async location(): Promise {\n\t\tconst mode = await this.r.u62()\n\t\tif (mode == 1n) {\n\t\t\treturn {\n\t\t\t\tmode: \"latest_group\",\n\t\t\t}\n\t\t} else if (mode == 2n) {\n\t\t\treturn {\n\t\t\t\tmode: \"latest_object\",\n\t\t\t}\n\t\t} else if (mode == 3n) {\n\t\t\treturn {\n\t\t\t\tmode: \"absolute_start\",\n\t\t\t\tstart_group: await this.r.u53(),\n\t\t\t\tstart_object: await this.r.u53(),\n\t\t\t}\n\t\t} else if (mode == 4n) {\n\t\t\treturn {\n\t\t\t\tmode: \"absolute_range\",\n\t\t\t\tstart_group: await this.r.u53(),\n\t\t\t\tstart_object: await this.r.u53(),\n\t\t\t\tend_group: await this.r.u53(),\n\t\t\t\tend_object: await this.r.u53(),\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new Error(`invalid filter type: ${mode}`)\n\t\t}\n\t}\n\n\tprivate async parameters(): Promise {\n\t\tconst count = await this.r.u53()\n\t\tif (count == 0) return undefined\n\n\t\tconst params = new Map()\n\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst id = await this.r.u62()\n\t\t\tconst size = await this.r.u53()\n\t\t\tconst value = await this.r.read(size)\n\n\t\t\tif (params.has(id)) {\n\t\t\t\tthrow new Error(`duplicate parameter id: ${id}`)\n\t\t\t}\n\n\t\t\tparams.set(id, value)\n\t\t}\n\n\t\treturn params\n\t}\n\n\tprivate async subscribe_ok(): Promise {\n\t\tconst id = await this.r.u62()\n\t\tconst expires = await this.r.u62()\n\n\t\tconst group_order = await this.decodeGroupOrder()\n\t\tlet latest: [number, number] | undefined\n\n\t\tconst flag = await this.r.u8()\n\t\tif (flag === 1) {\n\t\t\tlatest = [await this.r.u53(), await this.r.u53()]\n\t\t} else if (flag !== 0) {\n\t\t\tthrow new Error(`invalid final flag: ${flag}`)\n\t\t}\n\n\t\treturn {\n\t\t\tkind: Msg.SubscribeOk,\n\t\t\tid,\n\t\t\texpires,\n\t\t\tgroup_order,\n\t\t\tlatest,\n\t\t}\n\t}\n\n\tprivate async subscribe_done(): Promise {\n\t\tconst id = await this.r.u62()\n\t\tconst code = await this.r.u62()\n\t\tconst reason = await this.r.string()\n\n\t\tlet final: [number, number] | undefined\n\n\t\tconst flag = await this.r.u8()\n\t\tif (flag === 1) {\n\t\t\tfinal = [await this.r.u53(), await this.r.u53()]\n\t\t} else if (flag !== 0) {\n\t\t\tthrow new Error(`invalid final flag: ${flag}`)\n\t\t}\n\n\t\treturn {\n\t\t\tkind: Msg.SubscribeDone,\n\t\t\tid,\n\t\t\tcode,\n\t\t\treason,\n\t\t\tfinal,\n\t\t}\n\t}\n\n\tprivate async subscribe_error(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.SubscribeError,\n\t\t\tid: await this.r.u62(),\n\t\t\tcode: await this.r.u62(),\n\t\t\treason: await this.r.string(),\n\t\t}\n\t}\n\n\tprivate async unsubscribe(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.Unsubscribe,\n\t\t\tid: await this.r.u62(),\n\t\t}\n\t}\n\n\tprivate async announce(): Promise {\n\t\tconst namespace = await this.r.string()\n\n\t\treturn {\n\t\t\tkind: Msg.Announce,\n\t\t\tnamespace,\n\t\t\tparams: await this.parameters(),\n\t\t}\n\t}\n\n\tprivate async announce_ok(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.AnnounceOk,\n\t\t\tnamespace: await this.r.string(),\n\t\t}\n\t}\n\n\tprivate async announce_error(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.AnnounceError,\n\t\t\tnamespace: await this.r.string(),\n\t\t\tcode: await this.r.u62(),\n\t\t\treason: await this.r.string(),\n\t\t}\n\t}\n\n\tprivate async unannounce(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.Unannounce,\n\t\t\tnamespace: await this.r.string(),\n\t\t}\n\t}\n}\n\nexport class Encoder {\n\tw: Writer\n\n\tconstructor(w: Writer) {\n\t\tthis.w = w\n\t}\n\n\tasync message(m: Message) {\n\t\tswitch (m.kind) {\n\t\t\tcase Msg.Subscribe:\n\t\t\t\treturn this.subscribe(m)\n\t\t\tcase Msg.SubscribeOk:\n\t\t\t\treturn this.subscribe_ok(m)\n\t\t\tcase Msg.SubscribeError:\n\t\t\t\treturn this.subscribe_error(m)\n\t\t\tcase Msg.SubscribeDone:\n\t\t\t\treturn this.subscribe_done(m)\n\t\t\tcase Msg.Unsubscribe:\n\t\t\t\treturn this.unsubscribe(m)\n\t\t\tcase Msg.Announce:\n\t\t\t\treturn this.announce(m)\n\t\t\tcase Msg.AnnounceOk:\n\t\t\t\treturn this.announce_ok(m)\n\t\t\tcase Msg.AnnounceError:\n\t\t\t\treturn this.announce_error(m)\n\t\t\tcase Msg.Unannounce:\n\t\t\t\treturn this.unannounce(m)\n\t\t}\n\t}\n\n\tasync subscribe(s: Subscribe) {\n\t\tawait this.w.u53(Id.Subscribe)\n\t\tawait this.w.u62(s.id)\n\t\tawait this.w.u62(s.trackId)\n\t\tawait this.w.string(s.namespace)\n\t\tawait this.w.string(s.name)\n\t\tawait this.w.u8(s.subscriber_priority ?? 127)\n\t\tawait this.encodeGroupOrder(s.group_order ?? GroupOrder.Publisher)\n\t\tawait this.location(s.location)\n\t\tawait this.parameters(s.params)\n\t}\n\n\tprivate async encodeGroupOrder(order: GroupOrder) {\n\t\tswitch (order) {\n\t\t\tcase GroupOrder.Publisher:\n\t\t\t\tawait this.w.u8(GroupOrder.Publisher)\n\t\t\t\tbreak\n\t\t\tcase GroupOrder.Ascending:\n\t\t\t\tawait this.w.u8(GroupOrder.Ascending)\n\t\t\t\tbreak\n\t\t\tcase GroupOrder.Descending:\n\t\t\t\tawait this.w.u8(GroupOrder.Descending)\n\t\t\t\tbreak\n\t\t\tdefault:\n\t\t\t\tthrow new Error(\"Invalid GroupOrder value\")\n\t\t}\n\t}\n\n\tprivate async location(l: Location) {\n\t\tswitch (l.mode) {\n\t\t\tcase \"latest_group\":\n\t\t\t\tawait this.w.u62(1n)\n\t\t\t\tbreak\n\t\t\tcase \"latest_object\":\n\t\t\t\tawait this.w.u62(2n)\n\t\t\t\tbreak\n\t\t\tcase \"absolute_start\":\n\t\t\t\tawait this.w.u62(3n)\n\t\t\t\tawait this.w.u53(l.start_group)\n\t\t\t\tawait this.w.u53(l.start_object)\n\t\t\t\tbreak\n\t\t\tcase \"absolute_range\":\n\t\t\t\tawait this.w.u62(3n)\n\t\t\t\tawait this.w.u53(l.start_group)\n\t\t\t\tawait this.w.u53(l.start_object)\n\t\t\t\tawait this.w.u53(l.end_group)\n\t\t\t\tawait this.w.u53(l.end_object)\n\t\t}\n\t}\n\n\tprivate async parameters(p: Parameters | undefined) {\n\t\tif (!p) {\n\t\t\tawait this.w.u8(0)\n\t\t\treturn\n\t\t}\n\n\t\tawait this.w.u53(p.size)\n\t\tfor (const [id, value] of p) {\n\t\t\tawait this.w.u62(id)\n\t\t\tawait this.w.u53(value.length)\n\t\t\tawait this.w.write(value)\n\t\t}\n\t}\n\n\tasync subscribe_ok(s: SubscribeOk) {\n\t\tawait this.w.u53(Id.SubscribeOk)\n\t\tawait this.w.u62(s.id)\n\t\tawait this.w.u62(s.expires)\n\n\t\tawait this.encodeGroupOrder(s.group_order)\n\t\tif (s.latest !== undefined) {\n\t\t\tawait this.w.u8(1)\n\t\t\tawait this.w.u53(s.latest[0])\n\t\t\tawait this.w.u53(s.latest[1])\n\t\t} else {\n\t\t\tawait this.w.u8(0)\n\t\t}\n\t}\n\n\tasync subscribe_done(s: SubscribeDone) {\n\t\tawait this.w.u53(Id.SubscribeDone)\n\t\tawait this.w.u62(s.id)\n\t\tawait this.w.u62(s.code)\n\t\tawait this.w.string(s.reason)\n\n\t\tif (s.final !== undefined) {\n\t\t\tawait this.w.u8(1)\n\t\t\tawait this.w.u53(s.final[0])\n\t\t\tawait this.w.u53(s.final[1])\n\t\t} else {\n\t\t\tawait this.w.u8(0)\n\t\t}\n\t}\n\n\tasync subscribe_error(s: SubscribeError) {\n\t\tawait this.w.u53(Id.SubscribeError)\n\t\tawait this.w.u62(s.id)\n\t}\n\n\tasync unsubscribe(s: Unsubscribe) {\n\t\tawait this.w.u53(Id.Unsubscribe)\n\t\tawait this.w.u62(s.id)\n\t}\n\n\tasync announce(a: Announce) {\n\t\tawait this.w.u53(Id.Announce)\n\t\tawait this.w.string(a.namespace)\n\t\tawait this.w.u53(0) // parameters\n\t}\n\n\tasync announce_ok(a: AnnounceOk) {\n\t\tawait this.w.u53(Id.AnnounceOk)\n\t\tawait this.w.string(a.namespace)\n\t}\n\n\tasync announce_error(a: AnnounceError) {\n\t\tawait this.w.u53(Id.AnnounceError)\n\t\tawait this.w.string(a.namespace)\n\t\tawait this.w.u62(a.code)\n\t\tawait this.w.string(a.reason)\n\t}\n\n\tasync unannounce(a: Unannounce) {\n\t\tawait this.w.u53(Id.Unannounce)\n\t\tawait this.w.string(a.namespace)\n\t}\n}\n","import { Reader, Writer } from \"./stream\"\nexport { Reader, Writer }\n\nexport enum StreamType {\n\tObject = 0x0,\n\tTrack = 0x50,\n\tGroup = 0x51,\n}\n\nexport enum Status {\n\tOBJECT_NULL = 1,\n\tGROUP_NULL = 2,\n\tGROUP_END = 3,\n\tTRACK_END = 4,\n}\n\nexport interface TrackHeader {\n\ttype: StreamType.Track\n\tsub: bigint\n\ttrack: bigint\n\tpublisher_priority: number // VarInt with a u32 maximum value\n}\n\nexport interface TrackChunk {\n\tgroup: number // The group sequence, as a number because 2^53 is enough.\n\tobject: number\n\tpayload: Uint8Array | Status\n}\n\nexport interface GroupHeader {\n\ttype: StreamType.Group\n\tsub: bigint\n\ttrack: bigint\n\tgroup: number // The group sequence, as a number because 2^53 is enough.\n\tpublisher_priority: number // VarInt with a u32 maximum value\n}\n\nexport interface GroupChunk {\n\tobject: number\n\tpayload: Uint8Array | Status\n}\n\nexport interface ObjectHeader {\n\ttype: StreamType.Object\n\tsub: bigint\n\ttrack: bigint\n\tgroup: number\n\tobject: number\n\tpublisher_priority: number\n\tstatus: number\n}\n\nexport interface ObjectChunk {\n\tpayload: Uint8Array\n}\n\ntype WriterType = T extends TrackHeader\n\t? TrackWriter\n\t: T extends GroupHeader\n\t? GroupWriter\n\t: T extends ObjectHeader\n\t? ObjectWriter\n\t: never\n\nexport class Objects {\n\tprivate quic: WebTransport\n\n\tconstructor(quic: WebTransport) {\n\t\tthis.quic = quic\n\t}\n\n\tasync send(h: T): Promise> {\n\t\tconst stream = await this.quic.createUnidirectionalStream()\n\t\tconst w = new Writer(stream)\n\n\t\tawait w.u53(h.type)\n\t\tawait w.u62(h.sub)\n\t\tawait w.u62(h.track)\n\n\t\tlet res: WriterType\n\n\t\tif (h.type == StreamType.Object) {\n\t\t\tawait w.u53(h.group)\n\t\t\tawait w.u53(h.object)\n\t\t\tawait w.u8(h.publisher_priority)\n\t\t\tawait w.u53(h.status)\n\n\t\t\tres = new ObjectWriter(h, w) as WriterType\n\t\t} else if (h.type === StreamType.Group) {\n\t\t\tawait w.u53(h.group)\n\t\t\tawait w.u8(h.publisher_priority)\n\n\t\t\tres = new GroupWriter(h, w) as WriterType\n\t\t} else if (h.type === StreamType.Track) {\n\t\t\tawait w.u8(h.publisher_priority)\n\n\t\t\tres = new TrackWriter(h, w) as WriterType\n\t\t} else {\n\t\t\tthrow new Error(\"unknown header type\")\n\t\t}\n\n\t\t// console.trace(\"send object\", res.header)\n\n\t\treturn res\n\t}\n\n\tasync recv(): Promise {\n\t\tconst streams = this.quic.incomingUnidirectionalStreams.getReader()\n\n\t\tconst { value, done } = await streams.read()\n\t\tstreams.releaseLock()\n\n\t\tif (done) return\n\n\t\tconst r = new Reader(new Uint8Array(), value)\n\t\tconst type = (await r.u53()) as StreamType\n\t\tlet res: TrackReader | GroupReader | ObjectReader\n\n\t\tif (type == StreamType.Track) {\n\t\t\tconst h: TrackHeader = {\n\t\t\t\ttype,\n\t\t\t\tsub: await r.u62(),\n\t\t\t\ttrack: await r.u62(),\n\t\t\t\tpublisher_priority: await r.u8(),\n\t\t\t}\n\n\t\t\tres = new TrackReader(h, r)\n\t\t} else if (type == StreamType.Group) {\n\t\t\tconst h: GroupHeader = {\n\t\t\t\ttype,\n\t\t\t\tsub: await r.u62(),\n\t\t\t\ttrack: await r.u62(),\n\t\t\t\tgroup: await r.u53(),\n\t\t\t\tpublisher_priority: await r.u8(),\n\t\t\t}\n\t\t\tres = new GroupReader(h, r)\n\t\t} else if (type == StreamType.Object) {\n\t\t\tconst h = {\n\t\t\t\ttype,\n\t\t\t\tsub: await r.u62(),\n\t\t\t\ttrack: await r.u62(),\n\t\t\t\tgroup: await r.u53(),\n\t\t\t\tobject: await r.u53(),\n\t\t\t\tstatus: await r.u53(),\n\t\t\t\tpublisher_priority: await r.u8(),\n\t\t\t}\n\n\t\t\tres = new ObjectReader(h, r)\n\t\t} else {\n\t\t\tthrow new Error(\"unknown stream type\")\n\t\t}\n\n\t\t// console.trace(\"receive object\", res.header)\n\n\t\treturn res\n\t}\n}\n\nexport class TrackWriter {\n\tconstructor(\n\t\tpublic header: TrackHeader,\n\t\tpublic stream: Writer,\n\t) {}\n\n\tasync write(c: TrackChunk) {\n\t\tawait this.stream.u53(c.group)\n\t\tawait this.stream.u53(c.object)\n\n\t\tif (c.payload instanceof Uint8Array) {\n\t\t\tawait this.stream.u53(c.payload.byteLength)\n\t\t\tawait this.stream.write(c.payload)\n\t\t} else {\n\t\t\t// empty payload with status\n\t\t\tawait this.stream.u53(0)\n\t\t\tawait this.stream.u53(c.payload as number)\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class GroupWriter {\n\tconstructor(\n\t\tpublic header: GroupHeader,\n\t\tpublic stream: Writer,\n\t) {}\n\n\tasync write(c: GroupChunk) {\n\t\tawait this.stream.u53(c.object)\n\t\tif (c.payload instanceof Uint8Array) {\n\t\t\tawait this.stream.u53(c.payload.byteLength)\n\t\t\tawait this.stream.write(c.payload)\n\t\t} else {\n\t\t\tawait this.stream.u53(0)\n\t\t\tawait this.stream.u53(c.payload as number)\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class ObjectWriter {\n\tconstructor(\n\t\tpublic header: ObjectHeader,\n\t\tpublic stream: Writer,\n\t) {}\n\n\tasync write(c: ObjectChunk) {\n\t\tawait this.stream.write(c.payload)\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class TrackReader {\n\tconstructor(\n\t\tpublic header: TrackHeader,\n\t\tpublic stream: Reader,\n\t) {}\n\n\tasync read(): Promise {\n\t\tif (await this.stream.done()) {\n\t\t\treturn\n\t\t}\n\n\t\tconst group = await this.stream.u53()\n\t\tconst object = await this.stream.u53()\n\t\tconst size = await this.stream.u53()\n\n\t\tlet payload\n\t\tif (size == 0) {\n\t\t\tpayload = (await this.stream.u53()) as Status\n\t\t} else {\n\t\t\tpayload = await this.stream.read(size)\n\t\t}\n\n\t\treturn {\n\t\t\tgroup,\n\t\t\tobject,\n\t\t\tpayload,\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class GroupReader {\n\tconstructor(\n\t\tpublic header: GroupHeader,\n\t\tpublic stream: Reader,\n\t) {}\n\n\tasync read(): Promise {\n\t\tif (await this.stream.done()) {\n\t\t\treturn\n\t\t}\n\n\t\tconst object = await this.stream.u53()\n\t\tconst size = await this.stream.u53()\n\n\t\tlet payload\n\t\tif (size == 0) {\n\t\t\tpayload = (await this.stream.u53()) as Status\n\t\t} else {\n\t\t\tpayload = await this.stream.read(size)\n\t\t}\n\n\t\treturn {\n\t\t\tobject,\n\t\t\tpayload,\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class ObjectReader {\n\tconstructor(\n\t\tpublic header: ObjectHeader,\n\t\tpublic stream: Reader,\n\t) {}\n\n\t// NOTE: Can only be called once.\n\tasync read(): Promise {\n\t\tif (await this.stream.done()) {\n\t\t\treturn\n\t\t}\n\n\t\treturn {\n\t\t\tpayload: await this.stream.readAll(),\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n","export class Deferred {\n\tpromise: Promise\n\tresolve!: (value: T | PromiseLike) => void\n\treject!: (reason: any) => void\n\tpending = true\n\n\tconstructor() {\n\t\tthis.promise = new Promise((resolve, reject) => {\n\t\t\tthis.resolve = (value) => {\n\t\t\t\tthis.pending = false\n\t\t\t\tresolve(value)\n\t\t\t}\n\t\t\tthis.reject = (reason) => {\n\t\t\t\tthis.pending = false\n\t\t\t\treject(reason)\n\t\t\t}\n\t\t})\n\t}\n}\n\nexport type WatchNext = [T, Promise> | undefined]\n\nexport class Watch {\n\t#current: WatchNext\n\t#next = new Deferred>()\n\n\tconstructor(init: T) {\n\t\tthis.#next = new Deferred>()\n\t\tthis.#current = [init, this.#next.promise]\n\t}\n\n\tvalue(): WatchNext {\n\t\treturn this.#current\n\t}\n\n\tupdate(v: T | ((v: T) => T)) {\n\t\tif (!this.#next.pending) {\n\t\t\tthrow new Error(\"already closed\")\n\t\t}\n\n\t\t// If we're given a function, call it with the current value\n\t\tif (v instanceof Function) {\n\t\t\tv = v(this.#current[0])\n\t\t}\n\n\t\tconst next = new Deferred>()\n\t\tthis.#current = [v, next.promise]\n\t\tthis.#next.resolve(this.#current)\n\t\tthis.#next = next\n\t}\n\n\tclose() {\n\t\tthis.#current[1] = undefined\n\t\tthis.#next.resolve(this.#current)\n\t}\n}\n\n// Wakes up a multiple consumers.\nexport class Notify {\n\t#next = new Deferred()\n\n\tasync wait() {\n\t\treturn this.#next.promise\n\t}\n\n\twake() {\n\t\tif (!this.#next.pending) {\n\t\t\tthrow new Error(\"closed\")\n\t\t}\n\n\t\tthis.#next.resolve()\n\t\tthis.#next = new Deferred()\n\t}\n\n\tclose() {\n\t\tthis.#next.resolve()\n\t}\n}\n\n// Allows queuing N values, like a Channel.\nexport class Queue {\n\t#stream: TransformStream\n\t#closed = false\n\n\tconstructor(capacity = 1) {\n\t\tconst queue = new CountQueuingStrategy({ highWaterMark: capacity })\n\t\tthis.#stream = new TransformStream({}, undefined, queue)\n\t}\n\n\tasync push(v: T) {\n\t\tconst w = this.#stream.writable.getWriter()\n\t\tawait w.write(v)\n\t\tw.releaseLock()\n\t}\n\n\tasync next(): Promise {\n\t\tconst r = this.#stream.readable.getReader()\n\t\tconst { value, done } = await r.read()\n\t\tr.releaseLock()\n\n\t\tif (done) return\n\t\treturn value\n\t}\n\n\tasync abort(err: Error) {\n\t\tif (this.#closed) return\n\t\tawait this.#stream.writable.abort(err)\n\t\tthis.#closed = true\n\t}\n\n\tasync close() {\n\t\tif (this.#closed) return\n\t\tawait this.#stream.writable.close()\n\t\tthis.#closed = true\n\t}\n\n\tclosed() {\n\t\treturn this.#closed\n\t}\n}\n","import * as Control from \"./control\"\nimport { Queue, Watch } from \"../common/async\"\nimport { Objects, GroupWriter, ObjectWriter, StreamType, TrackWriter } from \"./objects\"\n\nexport class Publisher {\n\t// Used to send control messages\n\t#control: Control.Stream\n\n\t// Use to send objects.\n\t#objects: Objects\n\n\t// Our announced tracks.\n\t#announce = new Map()\n\n\t// Their subscribed tracks.\n\t#subscribe = new Map()\n\t#subscribeQueue = new Queue(Number.MAX_SAFE_INTEGER) // Unbounded queue in case there's no receiver\n\n\tconstructor(control: Control.Stream, objects: Objects) {\n\t\tthis.#control = control\n\t\tthis.#objects = objects\n\t}\n\n\t// Announce a track namespace.\n\tasync announce(namespace: string): Promise {\n\t\tif (this.#announce.has(namespace)) {\n\t\t\tthrow new Error(`already announce: ${namespace}`)\n\t\t}\n\n\t\tconst announce = new AnnounceSend(this.#control, namespace)\n\t\tthis.#announce.set(namespace, announce)\n\n\t\tawait this.#control.send({\n\t\t\tkind: Control.Msg.Announce,\n\t\t\tnamespace,\n\t\t})\n\n\t\treturn announce\n\t}\n\n\t// Receive the next new subscription\n\tasync subscribed() {\n\t\treturn await this.#subscribeQueue.next()\n\t}\n\n\tasync recv(msg: Control.Subscriber) {\n\t\tif (msg.kind == Control.Msg.Subscribe) {\n\t\t\tawait this.recvSubscribe(msg)\n\t\t} else if (msg.kind == Control.Msg.Unsubscribe) {\n\t\t\tthis.recvUnsubscribe(msg)\n\t\t} else if (msg.kind == Control.Msg.AnnounceOk) {\n\t\t\tthis.recvAnnounceOk(msg)\n\t\t} else if (msg.kind == Control.Msg.AnnounceError) {\n\t\t\tthis.recvAnnounceError(msg)\n\t\t} else {\n\t\t\tthrow new Error(`unknown control message`) // impossible\n\t\t}\n\t}\n\n\trecvAnnounceOk(msg: Control.AnnounceOk) {\n\t\tconst announce = this.#announce.get(msg.namespace)\n\t\tif (!announce) {\n\t\t\tthrow new Error(`announce OK for unknown announce: ${msg.namespace}`)\n\t\t}\n\n\t\tannounce.onOk()\n\t}\n\n\trecvAnnounceError(msg: Control.AnnounceError) {\n\t\tconst announce = this.#announce.get(msg.namespace)\n\t\tif (!announce) {\n\t\t\t// TODO debug this\n\t\t\tconsole.warn(`announce error for unknown announce: ${msg.namespace}`)\n\t\t\treturn\n\t\t}\n\n\t\tannounce.onError(msg.code, msg.reason)\n\t}\n\n\tasync recvSubscribe(msg: Control.Subscribe) {\n\t\tif (this.#subscribe.has(msg.id)) {\n\t\t\tthrow new Error(`duplicate subscribe for id: ${msg.id}`)\n\t\t}\n\n\t\tconst subscribe = new SubscribeRecv(this.#control, this.#objects, msg)\n\t\tthis.#subscribe.set(msg.id, subscribe)\n\t\tawait this.#subscribeQueue.push(subscribe)\n\n\t\tawait this.#control.send({\n\t\t\tkind: Control.Msg.SubscribeOk,\n\t\t\tid: msg.id,\n\t\t\texpires: 0n,\n\t\t\tgroup_order: msg.group_order,\n\t\t})\n\t}\n\n\trecvUnsubscribe(_msg: Control.Unsubscribe) {\n\t\tthrow new Error(\"TODO unsubscribe\")\n\t}\n}\n\nexport class AnnounceSend {\n\t#control: Control.Stream\n\n\treadonly namespace: string\n\n\t// The current state, updated by control messages.\n\t#state = new Watch<\"init\" | \"ack\" | Error>(\"init\")\n\n\tconstructor(control: Control.Stream, namespace: string) {\n\t\tthis.#control = control\n\t\tthis.namespace = namespace\n\t}\n\n\tasync ok() {\n\t\tfor (;;) {\n\t\t\tconst [state, next] = this.#state.value()\n\t\t\tif (state === \"ack\") return\n\t\t\tif (state instanceof Error) throw state\n\t\t\tif (!next) throw new Error(\"closed\")\n\n\t\t\tawait next\n\t\t}\n\t}\n\n\tasync active() {\n\t\tfor (;;) {\n\t\t\tconst [state, next] = this.#state.value()\n\t\t\tif (state instanceof Error) throw state\n\t\t\tif (!next) return\n\n\t\t\tawait next\n\t\t}\n\t}\n\n\tasync close() {\n\t\t// TODO implement unsubscribe\n\t\t// await this.#inner.sendUnsubscribe()\n\t}\n\n\tclosed() {\n\t\tconst [state, next] = this.#state.value()\n\t\treturn state instanceof Error || next == undefined\n\t}\n\n\tonOk() {\n\t\tif (this.closed()) return\n\t\tthis.#state.update(\"ack\")\n\t}\n\n\tonError(code: bigint, reason: string) {\n\t\tif (this.closed()) return\n\n\t\tconst err = new Error(`ANNOUNCE_ERROR (${code})` + reason ? `: ${reason}` : \"\")\n\t\tthis.#state.update(err)\n\t}\n}\n\nexport class SubscribeRecv {\n\t#control: Control.Stream\n\t#objects: Objects\n\t#id: bigint\n\t#trackId: bigint\n\t#subscriberPriority: number\n\tgroupOrder: Control.GroupOrder\n\n\treadonly namespace: string\n\treadonly track: string\n\n\t// The current state of the subscription.\n\t#state: \"init\" | \"ack\" | \"closed\" = \"init\"\n\n\tconstructor(control: Control.Stream, objects: Objects, msg: Control.Subscribe) {\n\t\tthis.#control = control // so we can send messages\n\t\tthis.#objects = objects // so we can send objects\n\t\tthis.#id = msg.id\n\t\tthis.#trackId = msg.trackId\n\t\tthis.namespace = msg.namespace\n\t\tthis.track = msg.name\n\t\tthis.#subscriberPriority = msg.subscriber_priority\n\t\tthis.groupOrder = msg.group_order\n\t}\n\n\t// Acknowledge the subscription as valid.\n\tasync ack() {\n\t\tif (this.#state !== \"init\") return\n\t\tthis.#state = \"ack\"\n\n\t\t// Send the control message.\n\t\treturn this.#control.send({\n\t\t\tkind: Control.Msg.SubscribeOk,\n\t\t\tid: this.#id,\n\t\t\texpires: 0n,\n\t\t\tgroup_order: this.groupOrder,\n\t\t})\n\t}\n\n\t// Close the subscription with an error.\n\tasync close(code = 0n, reason = \"\") {\n\t\tif (this.#state === \"closed\") return\n\t\tthis.#state = \"closed\"\n\n\t\treturn this.#control.send({\n\t\t\tkind: Control.Msg.SubscribeDone,\n\t\t\tid: this.#id,\n\t\t\tcode,\n\t\t\treason,\n\t\t})\n\t}\n\n\t// Create a writable data stream for the entire track\n\tasync serve(props?: { priority: number }): Promise {\n\t\treturn this.#objects.send({\n\t\t\ttype: StreamType.Track,\n\t\t\tsub: this.#id,\n\t\t\ttrack: this.#trackId,\n\t\t\tpublisher_priority: props?.priority ?? 127,\n\t\t})\n\t}\n\n\t// Create a writable data stream for a group within the track\n\tasync group(props: { group: number; priority?: number }): Promise {\n\t\treturn this.#objects.send({\n\t\t\ttype: StreamType.Group,\n\t\t\tsub: this.#id,\n\t\t\ttrack: this.#trackId,\n\t\t\tgroup: props.group,\n\t\t\tpublisher_priority: props.priority ?? 127,\n\t\t})\n\t}\n\n\t// Create a writable data stream for a single object within the track\n\tasync object(props: { group: number; object: number; priority?: number }): Promise {\n\t\treturn this.#objects.send({\n\t\t\ttype: StreamType.Object,\n\t\t\tsub: this.#id,\n\t\t\ttrack: this.#trackId,\n\t\t\tgroup: props.group,\n\t\t\tobject: props.object,\n\t\t\tpublisher_priority: props.priority ?? 127,\n\t\t\tstatus: 0,\n\t\t})\n\t}\n}\n","import * as Control from \"./control\"\nimport { Queue, Watch } from \"../common/async\"\nimport { Objects } from \"./objects\"\nimport type { TrackReader, GroupReader, ObjectReader } from \"./objects\"\n\nexport class Subscriber {\n\t// Use to send control messages.\n\t#control: Control.Stream\n\n\t// Use to send objects.\n\t#objects: Objects\n\n\t// Announced broadcasts.\n\t#announce = new Map()\n\t#announceQueue = new Watch([])\n\n\t// Our subscribed tracks.\n\t#subscribe = new Map()\n\t#subscribeNext = 0n\n\n\t#trackToIDMap = new Map()\n\n\tconstructor(control: Control.Stream, objects: Objects) {\n\t\tthis.#control = control\n\t\tthis.#objects = objects\n\t}\n\n\tannounced(): Watch {\n\t\treturn this.#announceQueue\n\t}\n\n\tasync recv(msg: Control.Publisher) {\n\t\tif (msg.kind == Control.Msg.Announce) {\n\t\t\tawait this.recvAnnounce(msg)\n\t\t} else if (msg.kind == Control.Msg.Unannounce) {\n\t\t\tthis.recvUnannounce(msg)\n\t\t} else if (msg.kind == Control.Msg.SubscribeOk) {\n\t\t\tthis.recvSubscribeOk(msg)\n\t\t} else if (msg.kind == Control.Msg.SubscribeError) {\n\t\t\tawait this.recvSubscribeError(msg)\n\t\t} else if (msg.kind == Control.Msg.SubscribeDone) {\n\t\t\tawait this.recvSubscribeDone(msg)\n\t\t} else {\n\t\t\tthrow new Error(`unknown control message`) // impossible\n\t\t}\n\t}\n\n\tasync recvAnnounce(msg: Control.Announce) {\n\t\tif (this.#announce.has(msg.namespace)) {\n\t\t\tthrow new Error(`duplicate announce for namespace: ${msg.namespace}`)\n\t\t}\n\n\t\tawait this.#control.send({ kind: Control.Msg.AnnounceOk, namespace: msg.namespace })\n\n\t\tconst announce = new AnnounceRecv(this.#control, msg.namespace)\n\t\tthis.#announce.set(msg.namespace, announce)\n\n\t\tthis.#announceQueue.update((queue) => [...queue, announce])\n\t}\n\n\trecvUnannounce(_msg: Control.Unannounce) {\n\t\tthrow new Error(`TODO Unannounce`)\n\t}\n\n\tasync subscribe(namespace: string, track: string) {\n\t\tconst id = this.#subscribeNext++\n\n\t\tconst subscribe = new SubscribeSend(this.#control, id, namespace, track)\n\t\tthis.#subscribe.set(id, subscribe)\n\n\t\tthis.#trackToIDMap.set(track, id)\n\n\t\tawait this.#control.send({\n\t\t\tkind: Control.Msg.Subscribe,\n\t\t\tid,\n\t\t\ttrackId: id,\n\t\t\tnamespace,\n\t\t\tname: track,\n\t\t\tsubscriber_priority: 127, // default to mid value, see: https://github.com/moq-wg/moq-transport/issues/504\n\t\t\tgroup_order: Control.GroupOrder.Publisher,\n\t\t\tlocation: {\n\t\t\t\tmode: \"latest_group\",\n\t\t\t},\n\t\t})\n\n\t\treturn subscribe\n\t}\n\n\tasync unsubscribe(track: string) {\n\t\tif (this.#trackToIDMap.has(track)) {\n\t\t\tconst trackID = this.#trackToIDMap.get(track)\n\t\t\tif (trackID === undefined) {\n\t\t\t\tconsole.warn(`Exception track ${track} not found in trackToIDMap.`)\n\t\t\t\treturn\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tawait this.#control.send({ kind: Control.Msg.Unsubscribe, id: trackID })\n\t\t\t\tthis.#trackToIDMap.delete(track)\n\t\t\t} catch (error) {\n\t\t\t\tconsole.error(`Failed to unsubscribe from track ${track}:`, error)\n\t\t\t}\n\t\t} else {\n\t\t\tconsole.warn(`During unsubscribe request initiation attempt track ${track} not found in trackToIDMap.`)\n\t\t}\n\t}\n\n\trecvSubscribeOk(msg: Control.SubscribeOk) {\n\t\tconst subscribe = this.#subscribe.get(msg.id)\n\t\tif (!subscribe) {\n\t\t\tthrow new Error(`subscribe ok for unknown id: ${msg.id}`)\n\t\t}\n\n\t\tsubscribe.onOk()\n\t}\n\n\tasync recvSubscribeError(msg: Control.SubscribeError) {\n\t\tconst subscribe = this.#subscribe.get(msg.id)\n\t\tif (!subscribe) {\n\t\t\tthrow new Error(`subscribe error for unknown id: ${msg.id}`)\n\t\t}\n\n\t\tawait subscribe.onError(msg.code, msg.reason)\n\t}\n\n\tasync recvSubscribeDone(msg: Control.SubscribeDone) {\n\t\tconst subscribe = this.#subscribe.get(msg.id)\n\t\tif (!subscribe) {\n\t\t\tthrow new Error(`subscribe error for unknown id: ${msg.id}`)\n\t\t}\n\n\t\tawait subscribe.onError(msg.code, msg.reason)\n\t}\n\n\tasync recvObject(reader: TrackReader | GroupReader | ObjectReader) {\n\t\tconst subscribe = this.#subscribe.get(reader.header.track)\n\t\tif (!subscribe) {\n\t\t\tthrow new Error(`data for for unknown track: ${reader.header.track}`)\n\t\t}\n\n\t\tawait subscribe.onData(reader)\n\t}\n}\n\nexport class AnnounceRecv {\n\t#control: Control.Stream\n\n\treadonly namespace: string\n\n\t// The current state of the announce\n\t#state: \"init\" | \"ack\" | \"closed\" = \"init\"\n\n\tconstructor(control: Control.Stream, namespace: string) {\n\t\tthis.#control = control // so we can send messages\n\t\tthis.namespace = namespace\n\t}\n\n\t// Acknowledge the subscription as valid.\n\tasync ok() {\n\t\tif (this.#state !== \"init\") return\n\t\tthis.#state = \"ack\"\n\n\t\t// Send the control message.\n\t\treturn this.#control.send({ kind: Control.Msg.AnnounceOk, namespace: this.namespace })\n\t}\n\n\tasync close(code = 0n, reason = \"\") {\n\t\tif (this.#state === \"closed\") return\n\t\tthis.#state = \"closed\"\n\n\t\treturn this.#control.send({ kind: Control.Msg.AnnounceError, namespace: this.namespace, code, reason })\n\t}\n}\n\nexport class SubscribeSend {\n\t#control: Control.Stream\n\t#id: bigint\n\n\treadonly namespace: string\n\treadonly track: string\n\n\t// A queue of received streams for this subscription.\n\t#data = new Queue()\n\n\tconstructor(control: Control.Stream, id: bigint, namespace: string, track: string) {\n\t\tthis.#control = control // so we can send messages\n\t\tthis.#id = id\n\t\tthis.namespace = namespace\n\t\tthis.track = track\n\t}\n\n\tasync close(_code = 0n, _reason = \"\") {\n\t\t// TODO implement unsubscribe\n\t\t// await this.#inner.sendReset(code, reason)\n\t}\n\n\tonOk() {\n\t\t// noop\n\t}\n\n\tasync onError(code: bigint, reason: string) {\n\t\tif (code == 0n) {\n\t\t\treturn await this.#data.close()\n\t\t}\n\n\t\tif (reason !== \"\") {\n\t\t\treason = `: ${reason}`\n\t\t}\n\n\t\tconst err = new Error(`SUBSCRIBE_ERROR (${code})${reason}`)\n\t\treturn await this.#data.abort(err)\n\t}\n\n\tasync onData(reader: TrackReader | GroupReader | ObjectReader) {\n\t\tif (!this.#data.closed()) await this.#data.push(reader)\n\t}\n\n\t// Receive the next a readable data stream\n\tasync data() {\n\t\treturn await this.#data.next()\n\t}\n}\n","import * as Control from \"./control\"\nimport { Objects } from \"./objects\"\nimport { asError } from \"../common/error\"\n\nimport { Publisher } from \"./publisher\"\nimport { Subscriber } from \"./subscriber\"\n\nexport class Connection {\n\t// The established WebTransport session.\n\t#quic: WebTransport\n\n\t// Use to receive/send control messages.\n\t#control: Control.Stream\n\n\t// Use to receive/send objects.\n\t#objects: Objects\n\n\t// Module for contributing tracks.\n\t#publisher: Publisher\n\n\t// Module for distributing tracks.\n\t#subscriber: Subscriber\n\n\t// Async work running in the background\n\t#running: Promise\n\n\tconstructor(quic: WebTransport, control: Control.Stream, objects: Objects) {\n\t\tthis.#quic = quic\n\t\tthis.#control = control\n\t\tthis.#objects = objects\n\n\t\tthis.#publisher = new Publisher(this.#control, this.#objects)\n\t\tthis.#subscriber = new Subscriber(this.#control, this.#objects)\n\n\t\tthis.#running = this.#run()\n\t}\n\n\tclose(code = 0, reason = \"\") {\n\t\tthis.#quic.close({ closeCode: code, reason })\n\t}\n\n\tasync #run(): Promise {\n\t\tawait Promise.all([this.#runControl(), this.#runObjects()])\n\t}\n\n\tannounce(namespace: string) {\n\t\treturn this.#publisher.announce(namespace)\n\t}\n\n\tannounced() {\n\t\treturn this.#subscriber.announced()\n\t}\n\n\tsubscribe(namespace: string, track: string) {\n\t\treturn this.#subscriber.subscribe(namespace, track)\n\t}\n\n\tunsubscribe(track: string) {\n\t\treturn this.#subscriber.unsubscribe(track)\n\t}\n\n\tsubscribed() {\n\t\treturn this.#publisher.subscribed()\n\t}\n\n\tasync #runControl() {\n\t\t// Receive messages until the connection is closed.\n\t\tfor (;;) {\n\t\t\tconst msg = await this.#control.recv()\n\t\t\tawait this.#recv(msg)\n\t\t}\n\t}\n\n\tasync #runObjects() {\n\t\tfor (;;) {\n\t\t\tconst obj = await this.#objects.recv()\n\t\t\tif (!obj) break\n\n\t\t\tawait this.#subscriber.recvObject(obj)\n\t\t}\n\t}\n\n\tasync #recv(msg: Control.Message) {\n\t\tif (Control.isPublisher(msg)) {\n\t\t\tawait this.#subscriber.recv(msg)\n\t\t} else {\n\t\t\tawait this.#publisher.recv(msg)\n\t\t}\n\t}\n\n\tasync closed(): Promise {\n\t\ttry {\n\t\t\tawait this.#running\n\t\t\treturn new Error(\"closed\")\n\t\t} catch (e) {\n\t\t\treturn asError(e)\n\t\t}\n\t}\n}\n","import * as Stream from \"./stream\"\nimport * as Setup from \"./setup\"\nimport * as Control from \"./control\"\nimport { Objects } from \"./objects\"\nimport { Connection } from \"./connection\"\n\nexport interface ClientConfig {\n\turl: string\n\n\t// Parameters used to create the MoQ session\n\trole: Setup.Role\n\n\t// If set, the server fingerprint will be fetched from this URL.\n\t// This is required to use self-signed certificates with Chrome (May 2023)\n\tfingerprint?: string\n}\n\nexport class Client {\n\t#fingerprint: Promise\n\n\treadonly config: ClientConfig\n\n\tconstructor(config: ClientConfig) {\n\t\tthis.config = config\n\n\t\tthis.#fingerprint = this.#fetchFingerprint(config.fingerprint).catch((e) => {\n\t\t\tconsole.warn(\"failed to fetch fingerprint: \", e)\n\t\t\treturn undefined\n\t\t})\n\t}\n\n\tasync connect(): Promise {\n\t\t// Helper function to make creating a promise easier\n\t\tconst options: WebTransportOptions = {}\n\n\t\tconst fingerprint = await this.#fingerprint\n\t\tif (fingerprint) options.serverCertificateHashes = [fingerprint]\n\n\t\tconst quic = new WebTransport(this.config.url, options)\n\t\tawait quic.ready\n\n\t\tconst stream = await quic.createBidirectionalStream()\n\n\t\tconst writer = new Stream.Writer(stream.writable)\n\t\tconst reader = new Stream.Reader(new Uint8Array(), stream.readable)\n\n\t\tconst setup = new Setup.Stream(reader, writer)\n\n\t\t// Send the setup message.\n\t\tawait setup.send.client({ versions: [Setup.Version.DRAFT_05], role: this.config.role })\n\n\t\t// Receive the setup message.\n\t\t// TODO verify the SETUP response.\n\t\tconst server = await setup.recv.server()\n\n\t\tif (server.version != Setup.Version.DRAFT_05) {\n\t\t\tthrow new Error(`unsupported server version: ${server.version}`)\n\t\t}\n\n\t\tconst control = new Control.Stream(reader, writer)\n\t\tconst objects = new Objects(quic)\n\n\t\treturn new Connection(quic, control, objects)\n\t}\n\n\tasync #fetchFingerprint(url?: string): Promise {\n\t\tif (!url) return\n\n\t\t// TODO remove this fingerprint when Chrome WebTransport accepts the system CA\n\t\tconst response = await fetch(url)\n\t\tconst hexString = await response.text()\n\n\t\tconst hexBytes = new Uint8Array(hexString.length / 2)\n\t\tfor (let i = 0; i < hexBytes.length; i += 1) {\n\t\t\thexBytes[i] = parseInt(hexString.slice(2 * i, 2 * i + 2), 16)\n\t\t}\n\n\t\treturn {\n\t\t\talgorithm: \"sha-256\",\n\t\t\tvalue: hexBytes,\n\t\t}\n\t}\n}\n","import * as Message from \"./worker/message\"\n\nimport { Connection } from \"../transport/connection\"\nimport * as Catalog from \"../media/catalog\"\nimport { asError } from \"../common/error\"\n\nimport Backend from \"./backend\"\n\nimport { Client } from \"../transport/client\"\nimport { GroupReader } from \"../transport/objects\"\n\nexport type Range = Message.Range\nexport type Timeline = Message.Timeline\n\nexport interface PlayerConfig {\n\turl: string\n\tnamespace: string\n\tfingerprint?: string // URL to fetch TLS certificate fingerprint\n\tcanvas: HTMLCanvasElement\n}\n\n// This class must be created on the main thread due to AudioContext.\nexport default class Player {\n\t#backend: Backend\n\n\t// A periodically updated timeline\n\t//#timeline = new Watch(undefined)\n\n\t#connection: Connection\n\t#catalog: Catalog.Root\n\t#tracksByName: Map\n\t#tracknum: number\n\t#audioTrackName: string\n\t#videoTrackName: string\n\t#muted: boolean\n\t#paused: boolean\n\n\t// Running is a promise that resolves when the player is closed.\n\t// #close is called with no error, while #abort is called with an error.\n\t#running: Promise\n\t#close!: () => void\n\t#abort!: (err: Error) => void\n\t#trackTasks: Map> = new Map()\n\n\tprivate constructor(connection: Connection, catalog: Catalog.Root, backend: Backend, tracknum: number) {\n\t\tthis.#connection = connection\n\t\tthis.#catalog = catalog\n\t\tthis.#tracksByName = new Map(catalog.tracks.map((track) => [track.name, track]))\n\t\tthis.#backend = backend\n\t\tthis.#tracknum = tracknum\n\t\tthis.#audioTrackName = \"\"\n\t\tthis.#videoTrackName = \"\"\n\t\tthis.#muted = false\n\t\tthis.#paused = false\n\n\t\tconst abort = new Promise((resolve, reject) => {\n\t\t\tthis.#close = resolve\n\t\t\tthis.#abort = reject\n\t\t})\n\n\t\t// Async work\n\t\tthis.#running = abort.catch(this.#close)\n\n\t\tthis.#run().catch((err) => {\n\t\t\tconsole.error(\"Error in #run():\", err)\n\t\t\tthis.#abort(err)\n\t\t})\n\t}\n\n\tstatic async create(config: PlayerConfig, tracknum: number): Promise {\n\t\tconst client = new Client({ url: config.url, fingerprint: config.fingerprint, role: \"subscriber\" })\n\t\tconst connection = await client.connect()\n\n\t\tconst catalog = await Catalog.fetch(connection, config.namespace)\n\t\tconsole.log(\"catalog\", catalog)\n\n\t\tconst canvas = config.canvas.transferControlToOffscreen()\n\t\tconst backend = new Backend({ canvas, catalog })\n\n\t\treturn new Player(connection, catalog, backend, tracknum)\n\t}\n\n\tasync #run() {\n\t\tconst inits = new Set<[string, string]>()\n\t\tconst tracks = new Array()\n\n\t\tthis.#catalog.tracks.forEach((track, index) => {\n\t\t\tif (index == this.#tracknum || Catalog.isAudioTrack(track)) {\n\t\t\t\tif (!track.namespace) throw new Error(\"track has no namespace\")\n\t\t\t\tif (track.initTrack) inits.add([track.namespace, track.initTrack])\n\t\t\t\ttracks.push(track)\n\t\t\t}\n\t\t})\n\n\t\t// Call #runInit on each unique init track\n\t\t// TODO do this in parallel with #runTrack to remove a round trip\n\t\tawait Promise.all(Array.from(inits).map((init) => this.#runInit(...init)))\n\n\t\t// Call #runTrack on each track\n\t\ttracks.forEach((track) => {\n\t\t\tthis.#runTrack(track)\n\t\t})\n\t}\n\n\tasync #runInit(namespace: string, name: string) {\n\t\tconst sub = await this.#connection.subscribe(namespace, name)\n\t\ttry {\n\t\t\tconst init = await Promise.race([sub.data(), this.#running])\n\t\t\tif (!init) throw new Error(\"no init data\")\n\n\t\t\t// We don't care what type of reader we get, we just want the payload.\n\t\t\tconst chunk = await init.read()\n\t\t\tif (!chunk) throw new Error(\"no init chunk\")\n\t\t\tif (!(chunk.payload instanceof Uint8Array)) throw new Error(\"invalid init chunk\")\n\n\t\t\tthis.#backend.init({ data: chunk.payload, name })\n\t\t} finally {\n\t\t\tawait sub.close()\n\t\t}\n\t}\n\n\tasync #trackTask(track: Catalog.Track) {\n\t\tif (!track.namespace) throw new Error(\"track has no namespace\")\n\n\t\tif (this.#paused) return\n\n\t\tconst kind = Catalog.isVideoTrack(track) ? \"video\" : Catalog.isAudioTrack(track) ? \"audio\" : \"unknown\"\n\t\tif (kind == \"audio\" && this.#muted) return\n\n\t\tconst sub = await this.#connection.subscribe(track.namespace, track.name)\n\n\t\tif (kind == \"audio\") {\n\t\t\t// Save ref to last audio track we subscribed to for unmuting\n\t\t\tthis.#audioTrackName = track.name\n\t\t}\n\n\t\tif (kind == \"video\") {\n\t\t\tthis.#videoTrackName = track.name\n\t\t}\n\n\t\ttry {\n\t\t\tfor (;;) {\n\t\t\t\tconst segment = await Promise.race([sub.data(), this.#running])\n\t\t\t\tif (!segment) continue\n\n\t\t\t\tif (!(segment instanceof GroupReader)) {\n\t\t\t\t\tthrow new Error(`expected group reader for segment: ${track.name}`)\n\t\t\t\t}\n\n\t\t\t\tif (kind == \"unknown\") {\n\t\t\t\t\tthrow new Error(`unknown track kind: ${track.name}`)\n\t\t\t\t}\n\n\t\t\t\tif (!track.initTrack) {\n\t\t\t\t\tthrow new Error(`no init track for segment: ${track.name}`)\n\t\t\t\t}\n\n\t\t\t\tconst [buffer, stream] = segment.stream.release()\n\n\t\t\t\tthis.#backend.segment({\n\t\t\t\t\tinit: track.initTrack,\n\t\t\t\t\tkind,\n\t\t\t\t\theader: segment.header,\n\t\t\t\t\tbuffer,\n\t\t\t\t\tstream,\n\t\t\t\t})\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tconsole.error(\"Error in #runTrack:\", error)\n\t\t} finally {\n\t\t\tawait sub.close()\n\t\t}\n\t}\n\n\t#runTrack(track: Catalog.Track) {\n\t\tif (this.#trackTasks.has(track.name)) {\n\t\t\tconsole.warn(`Already exist a runTrack task for the track: ${track.name}`)\n\t\t\treturn\n\t\t}\n\n\t\tconst task = (async () => this.#trackTask(track))()\n\n\t\tthis.#trackTasks.set(track.name, task)\n\n\t\ttask.catch((err) => {\n\t\t\tconsole.error(`Error to subscribe to track ${track.name}`, err)\n\t\t}).finally(() => {\n\t\t\tthis.#trackTasks.delete(track.name)\n\t\t})\n\t}\n\n\tgetCatalog() {\n\t\treturn this.#catalog\n\t}\n\n\tgetCurrentTrack() {\n\t\tif (this.#tracknum >= 0 && this.#tracknum < this.#catalog.tracks.length) {\n\t\t\treturn this.#catalog.tracks[this.#tracknum]\n\t\t} else {\n\t\t\tconsole.warn(\"Invalid track number:\", this.#tracknum)\n\t\t\treturn null\n\t\t}\n\t}\n\n\tgetVideoTracks() {\n\t\treturn this.#catalog.tracks.filter(Catalog.isVideoTrack).map((track) => track.name)\n\t}\n\n\tgetAudioTracks() {\n\t\treturn this.#catalog.tracks.filter(Catalog.isAudioTrack).map((track) => track.name)\n\t}\n\n\tasync switchTrack(trackname: string) {\n\t\tconst currentTrack = this.getCurrentTrack()\n\t\tif (this.#paused) {\n\t\t\tthis.#videoTrackName = trackname\n\t\t\treturn\n\t\t}\n\t\tif (currentTrack) {\n\t\t\tconsole.log(`Unsubscribing from track: ${currentTrack.name} and Subscribing to track: ${trackname}`)\n\t\t\tawait this.unsubscribeFromTrack(currentTrack.name)\n\t\t} else {\n\t\t\tconsole.log(`Subscribing to track: ${trackname}`)\n\t\t}\n\t\tthis.#tracknum = this.#catalog.tracks.findIndex((track) => track.name === trackname)\n\t\tconst tracksToStream = this.#catalog.tracks.filter((track) => track.name === trackname)\n\t\tawait Promise.all(tracksToStream.map((track) => this.#runTrack(track)))\n\t}\n\n\tasync mute(isMuted: boolean) {\n\t\tthis.#muted = isMuted\n\t\tif (isMuted) {\n\t\t\tconsole.log(\"Unsubscribing from audio track: \", this.#audioTrackName)\n\t\t\tawait this.unsubscribeFromTrack(this.#audioTrackName)\n\t\t\tawait this.#backend.mute()\n\t\t} else {\n\t\t\tconsole.log(\"Subscribing to audio track: \", this.#audioTrackName)\n\t\t\tthis.subscribeFromTrackName(this.#audioTrackName)\n\t\t\tawait this.#backend.unmute()\n\t\t}\n\t}\n\n\tasync unsubscribeFromTrack(trackname: string) {\n\t\tconsole.log(`Unsubscribing from track: ${trackname}`)\n\t\tawait this.#connection.unsubscribe(trackname)\n\t\tconst task = this.#trackTasks.get(trackname)\n\t\tif (task) {\n\t\t\tawait task\n\t\t}\n\t}\n\n\tsubscribeFromTrackName(trackname: string) {\n\t\tconsole.log(`Subscribing to track: ${trackname}`)\n\t\tconst track = this.#tracksByName.get(trackname)\n\t\tif (track) {\n\t\t\tthis.#runTrack(track)\n\t\t} else {\n\t\t\tconsole.warn(`Track ${trackname} not in #tracksByName`)\n\t\t}\n\t}\n\n\t#onMessage(msg: Message.FromWorker) {\n\t\tif (msg.timeline) {\n\t\t\t//this.#timeline.update(msg.timeline)\n\t\t}\n\t}\n\n\tasync close(err?: Error) {\n\t\tif (err) this.#abort(err)\n\t\telse this.#close()\n\n\t\tif (this.#connection) this.#connection.close()\n\t\tif (this.#backend) await this.#backend.close()\n\t}\n\n\tasync closed(): Promise {\n\t\ttry {\n\t\t\tawait this.#running\n\t\t} catch (e) {\n\t\t\treturn asError(e)\n\t\t}\n\t}\n\n\t/*\n\tplay() {\n\t\tthis.#backend.play({ minBuffer: 0.5 }) // TODO configurable\n\t}\n\n\tseek(timestamp: number) {\n\t\tthis.#backend.seek({ timestamp })\n\t}\n\t*/\n\n\tasync play() {\n\t\tif (this.#paused) {\n\t\t\tthis.#paused = false\n\t\t\tthis.subscribeFromTrackName(this.#videoTrackName)\n\t\t\tif (!this.#muted) {\n\t\t\t\tthis.subscribeFromTrackName(this.#audioTrackName)\n\t\t\t\tawait this.#backend.unmute()\n\t\t\t}\n\t\t} else {\n\t\t\tawait this.unsubscribeFromTrack(this.#videoTrackName)\n\t\t\tawait this.unsubscribeFromTrack(this.#audioTrackName)\n\t\t\tawait this.#backend.mute()\n\t\t\tthis.#backend.pause()\n\t\t\tthis.#paused = true\n\t\t}\n\t}\n\n\t/*\n\tasync *timeline() {\n\t\tfor (;;) {\n\t\t\tconst [timeline, next] = this.#timeline.value()\n\t\t\tif (timeline) yield timeline\n\t\t\tif (!next) break\n\n\t\t\tawait next\n\t\t}\n\t}\n\t*/\n}\n"],"names":["fetch","registerMyAudioWorklet","MediaWorker","Decoder","Encoder","Control.Msg","Control.GroupOrder","Control.isPublisher","Stream.Writer","Stream.Reader","Setup.Stream","Setup.Version","Control.Stream","Catalog.fetch","Catalog.isAudioTrack","Catalog.isVideoTrack"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file From b02f81de12b3bc33132f78347b04d1c37dabd9e6 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Wed, 4 Dec 2024 18:28:21 -0300 Subject: [PATCH 02/14] fix: remove spanish comments --- simple-web/index.js | 35 +++++++++++++---------------------- 1 file changed, 13 insertions(+), 22 deletions(-) diff --git a/simple-web/index.js b/simple-web/index.js index 26c2663..ef1588d 100644 --- a/simple-web/index.js +++ b/simple-web/index.js @@ -1,29 +1,20 @@ -const express = require("express") -const cors = require("cors") -const path = require("path") +const express = require("express"); +const cors = require("cors"); +const path = require("path"); -const app = express() -const PORT = 3000 +const app = express(); +const PORT = 3000; -// Middleware para habilitar CORS -app.use(cors()) +app.use(cors()); -// Middleware para configurar los headers globalmente app.use((req, res, next) => { - res.setHeader("Cross-Origin-Opener-Policy", "same-origin") - res.setHeader("Cross-Origin-Embedder-Policy", "require-corp") - next() -}) + res.setHeader("Cross-Origin-Opener-Policy", "same-origin"); + res.setHeader("Cross-Origin-Embedder-Policy", "require-corp"); + next(); +}); -// Servir archivos estáticos desde la carpeta 'public' -app.use(express.static(path.join(__dirname, "public"))) +app.use(express.static(path.join(__dirname, "public"))); -// Ruta de ejemplo -app.get("/api", (req, res) => { - res.json({ message: "Headers configurados correctamente con CORS habilitado" }) -}) - -// Inicializar servidor app.listen(PORT, () => { - console.log(`Servidor ejecutándose en http://localhost:${PORT}`) -}) + console.log(`Server running in http://localhost:${PORT}`); +}); From 4b8477b64bd92fd5a4438f4323c9c03b06960a5e Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Fri, 6 Dec 2024 16:31:42 -0300 Subject: [PATCH 03/14] refactor: es module added and web modified to use it --- lib/package.json | 15 +- lib/rollup.config.js | 39 +- lib/tsconfig.json | 6 +- simple-web/public/index.html | 2 +- simple-web/public/moq-player.iife.js | 11321 ++++++++++++++++++++ simple-web/public/moq-player.iife.js.map | 1 + simple-web/public/moq-player.umd.js | 11800 --------------------- simple-web/public/moq-player.umd.js.map | 1 - web/package.json | 2 +- web/src/components/publish.tsx | 6 +- web/src/components/watch.tsx | 2 +- web/src/layouts/global.astro | 4 +- 12 files changed, 11376 insertions(+), 11823 deletions(-) create mode 100644 simple-web/public/moq-player.iife.js create mode 100644 simple-web/public/moq-player.iife.js.map delete mode 100644 simple-web/public/moq-player.umd.js delete mode 100644 simple-web/public/moq-player.umd.js.map diff --git a/lib/package.json b/lib/package.json index b67dd19..695e47c 100644 --- a/lib/package.json +++ b/lib/package.json @@ -6,7 +6,7 @@ "entry": "playback/index.ts", "main": "dist/next/moq-player.cjs.js", "module": "dist/next/moq-player.esm.js", - "iife": "dist/iife/moq-player.umd.js", + "iife": "dist/iife/moq-player.iife.js", "types": "dist/types/moq-player.d.ts", "scripts": { "build": "rollup -c", @@ -15,11 +15,14 @@ "fmt": "prettier --write ." }, "devDependencies": { + "@babel/core": "^7.26.0", + "@babel/preset-env": "^7.26.0", + "@babel/preset-typescript": "^7.26.0", "@typescript-eslint/eslint-plugin": "^6.4.0", "@typescript-eslint/parser": "^6.4.0", + "@rollup/plugin-babel": "^6.0.4", "@rollup/plugin-commonjs": "^28.0.1", "@rollup/plugin-node-resolve": "^15.3.0", - "@rollup/plugin-terser": "^0.4.4", "@rollup/plugin-typescript": "^12.1.1", "@types/audioworklet": "^0.0.50", "@types/dom-mediacapture-transform": "^0.1.6", @@ -31,14 +34,10 @@ "eslint-plugin-prettier": "^5.0.0", "npm-run-all": "^4.1.5", "prettier": "^3.0.1", - "rollup-plugin-commonjs": "^10.1.0", - "rollup-plugin-node-resolve": "^5.2.0", - "rollup-plugin-sourcemaps": "^0.6.2", - "rollup-plugin-typescript2": "^0.27.1", - "tslib": "^1.12.0", + "tslib": "^2.8.1", "typescript": "^5.7.2", "rollup": "^4.28.0", - "rollup-plugin-base64": "^1.0.1", + "rollup-plugin-sourcemaps": "^0.6.2", "rollup-plugin-web-worker-loader": "github:htoooth/rollup-plugin-web-worker-loader" }, "dependencies": { diff --git a/lib/rollup.config.js b/lib/rollup.config.js index 05274b3..debbe20 100644 --- a/lib/rollup.config.js +++ b/lib/rollup.config.js @@ -1,9 +1,10 @@ "use strict" const path = require("path") -const resolve = require("rollup-plugin-node-resolve") -const commonjs = require("rollup-plugin-commonjs") -const typescript = require("rollup-plugin-typescript2") +const resolve = require("@rollup/plugin-node-resolve") +const commonjs = require("@rollup/plugin-commonjs") +const typescript = require("@rollup/plugin-typescript") const workerLoader = require("rollup-plugin-web-worker-loader") +const babel = require("@rollup/plugin-babel") const sourceMaps = require("rollup-plugin-sourcemaps") const pkg = require("./package.json") @@ -17,6 +18,33 @@ config.push({ name: "moqplayer", sourcemap: true, }, + plugins: [ + resolve(), + commonjs({ + include: [/node_modules/, /src/], + transformMixedEsModules: true, + }), + workerLoader({ preserveSource: true }), + typescript({ + typescript: require("typescript"), + }), + sourceMaps(), + babel({ + babelHelpers: "bundled", + presets: ["@babel/preset-env", "@babel/preset-typescript"], + exclude: "./node_modules/*", + }), + ], +}) + +config.push({ + input: pkg.entry, + output: { + file: pkg.module, + format: "esm", + sourcemap: true, + }, + external: [], plugins: [ resolve(), commonjs(), @@ -25,6 +53,11 @@ config.push({ typescript: require("typescript"), }), sourceMaps(), + babel({ + babelHelpers: "bundled", + presets: ["@babel/preset-env", "@babel/preset-typescript"], + exclude: "./node_modules/*", + }), ], }) diff --git a/lib/tsconfig.json b/lib/tsconfig.json index 5bb37cf..66be865 100644 --- a/lib/tsconfig.json +++ b/lib/tsconfig.json @@ -2,9 +2,9 @@ "compilerOptions": { "sourceMap": true, "moduleResolution": "node", - "module": "esnext", - "target": "esnext", - "lib": ["esnext", "dom"], + "module": "es2022", + "target": "es2022", + "lib": ["es2022", "dom"], "outDir": "./dist", "strict": true, "allowJs": false, diff --git a/simple-web/public/index.html b/simple-web/public/index.html index 274d98b..7827aa9 100644 --- a/simple-web/public/index.html +++ b/simple-web/public/index.html @@ -1,5 +1,5 @@ - + diff --git a/simple-web/public/moq-player.iife.js b/simple-web/public/moq-player.iife.js new file mode 100644 index 0000000..7b20296 --- /dev/null +++ b/simple-web/public/moq-player.iife.js @@ -0,0 +1,11321 @@ +var moqplayer = (function () { + 'use strict'; + + // I hate javascript + function asError(e) { + if (e instanceof Error) { + return e; + } + else if (typeof e === "string") { + return new Error(e); + } + else { + return new Error(String(e)); + } + } + + function decode(raw) { + const decoder = new TextDecoder(); + const str = decoder.decode(raw); + const catalog = JSON.parse(str); + if (!isRoot(catalog)) { + throw new Error("invalid catalog"); + } + // Merge common track fields into each track. + for (const track of catalog.tracks) { + track.altGroup ??= catalog.commonTrackFields.altGroup; + track.namespace ??= catalog.commonTrackFields.namespace; + track.packaging ??= catalog.commonTrackFields.packaging; + track.renderGroup ??= catalog.commonTrackFields.renderGroup; + } + return catalog; + } + async function fetch$1(connection, namespace) { + const subscribe = await connection.subscribe(namespace, ".catalog"); + try { + const segment = await subscribe.data(); + if (!segment) + throw new Error("no catalog data"); + const chunk = await segment.read(); + if (!chunk) + throw new Error("no catalog chunk"); + await segment.close(); + await subscribe.close(); // we done + if (chunk.payload instanceof Uint8Array) { + return decode(chunk.payload); + } + else { + throw new Error("invalid catalog chunk"); + } + } + catch (e) { + const err = asError(e); + // Close the subscription after we're done. + await subscribe.close(1n, err.message); + throw err; + } + } + function isRoot(catalog) { + if (!isCatalogFieldValid(catalog, "packaging")) + return false; + if (!isCatalogFieldValid(catalog, "namespace")) + return false; + if (!Array.isArray(catalog.tracks)) + return false; + return catalog.tracks.every((track) => isTrack(track)); + } + function isTrack(track) { + if (typeof track.name !== "string") + return false; + return true; + } + function isVideoTrack(track) { + if (!isTrack(track)) + return false; + return isVideoSelectionParams(track.selectionParams); + } + function isVideoSelectionParams(params) { + if (typeof params.width !== "number") + return false; + if (typeof params.height !== "number") + return false; + return true; + } + function isAudioTrack(track) { + if (!isTrack(track)) + return false; + return isAudioSelectionParams(track.selectionParams); + } + function isAudioSelectionParams(params) { + if (typeof params.channelConfig !== "string") + return false; + if (typeof params.samplerate !== "number") + return false; + return true; + } + function isCatalogFieldValid(catalog, field) { + //packaging,namespace if common would be listed in commonTrackFields but if fields + //in commonTrackFields are mentiond in Tracks , the fields in Tracks precedes + function isValidPackaging(packaging) { + return packaging === "cmaf" || packaging === "loc"; + } + function isValidNamespace(namespace) { + return typeof namespace === "string"; + } + let isValidField; + if (field === "packaging") { + isValidField = isValidPackaging; + } + else if (field === "namespace") { + isValidField = isValidNamespace; + } + else { + throw new Error(`Invalid field: ${field}`); + } + if (catalog.commonTrackFields[field] !== undefined && !isValidField(catalog.commonTrackFields[field])) { + return false; + } + for (const track of catalog.tracks) { + if (track[field] !== undefined && !isValidField(track[field])) { + return false; + } + } + return true; + } + + function funcToSource(fn, sourcemapArg) { + var source = fn.toString(); + var lines = source.split('\n'); + lines.pop(); + lines.shift(); + var blankPrefixLength = lines[0].search(/\S/); + var regex = /(['"])__worker_loader_strict__(['"])/g; + for (var i = 0, n = lines.length; i < n; ++i) { + lines[i] = lines[i].substring(blankPrefixLength).replace(regex, '$1use strict$2') + '\n'; + } + return lines; + } + + function createURL$1(fn, sourcemapArg) { + var lines = funcToSource(fn); + var blob = new Blob(lines, { type: 'application/javascript' }); + return URL.createObjectURL(blob); + } + + function createInlineAudioWorkletFactory$1(fn, sourcemapArg) { + var url; + return async function AudioWorkletFactory(audioContext, options) { + url = url || createURL$1(fn); + return await audioContext.audioWorklet.addModule(url, options); + }; + } + + var kIsNodeJS = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'; + + function isNodeJS() { + return kIsNodeJS; + } + + function createInlineAudioWorkletFactory(fn, sourcemapArg) { + if (isNodeJS()) { + throw new Error('rollup-plugin-web-worker-loader does not support Audio Worklet in Node.JS'); + } + return createInlineAudioWorkletFactory$1(fn); + } + + var WorkerFactory$1 = /*#__PURE__*/createInlineAudioWorkletFactory(/* rollup-plugin-web-worker-loader */function () { + (function () { + '__worker_loader_strict__'; + + // Ring buffer with audio samples. + var STATE; + (function (STATE) { + STATE[STATE["READ_POS"] = 0] = "READ_POS"; + STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; + STATE[STATE["LENGTH"] = 2] = "LENGTH"; + })(STATE || (STATE = {})); + class Ring { + state; + channels; + capacity; + constructor(shared) { + this.state = new Int32Array(shared.state); + this.channels = []; + for (const channel of shared.channels) { + this.channels.push(new Float32Array(channel)); + } + this.capacity = shared.capacity; + } + // Write samples for single audio frame, returning the total number written. + write(frame) { + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + const startPos = writePos; + let endPos = writePos + frame.numberOfFrames; + if (endPos > readPos + this.capacity) { + endPos = readPos + this.capacity; + if (endPos <= startPos) { + // No space to write + return 0; + } + } + const startIndex = startPos % this.capacity; + const endIndex = endPos % this.capacity; + // Loop over each channel + for (let i = 0; i < this.channels.length; i += 1) { + const channel = this.channels[i]; + // If the AudioData doesn't have enough channels, duplicate it. + const planeIndex = Math.min(i, frame.numberOfChannels - 1); + if (startIndex < endIndex) { + // One continuous range to copy. + const full = channel.subarray(startIndex, endIndex); + frame.copyTo(full, { + planeIndex, + frameCount: endIndex - startIndex, + }); + } + else { + const first = channel.subarray(startIndex); + const second = channel.subarray(0, endIndex); + frame.copyTo(first, { + planeIndex, + frameCount: first.length, + }); + // We need this conditional when startIndex == 0 and endIndex == 0 + // When capacity=4410 and frameCount=1024, this was happening 52s into the audio. + if (second.length) { + frame.copyTo(second, { + planeIndex, + frameOffset: first.length, + frameCount: second.length, + }); + } + } + } + Atomics.store(this.state, STATE.WRITE_POS, endPos); + return endPos - startPos; + } + read(dst) { + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + const startPos = readPos; + let endPos = startPos + dst[0].length; + if (endPos > writePos) { + endPos = writePos; + if (endPos <= startPos) { + // Nothing to read + return 0; + } + } + const startIndex = startPos % this.capacity; + const endIndex = endPos % this.capacity; + // Loop over each channel + for (let i = 0; i < dst.length; i += 1) { + if (i >= this.channels.length) ; + const input = this.channels[i]; + const output = dst[i]; + if (startIndex < endIndex) { + const full = input.subarray(startIndex, endIndex); + output.set(full); + } + else { + const first = input.subarray(startIndex); + const second = input.subarray(0, endIndex); + output.set(first); + output.set(second, first.length); + } + } + Atomics.store(this.state, STATE.READ_POS, endPos); + return endPos - startPos; + } + clear() { + const pos = Atomics.load(this.state, STATE.WRITE_POS); + Atomics.store(this.state, STATE.READ_POS, pos); + } + size() { + // TODO is this thread safe? + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + return writePos - readPos; + } + } + + // TODO add support for @/ to avoid relative imports + class Renderer extends AudioWorkletProcessor { + ring; + base; + constructor() { + // The super constructor call is required. + super(); + this.base = 0; + this.port.onmessage = this.onMessage.bind(this); + } + onMessage(e) { + const msg = e.data; + if (msg.config) { + this.onConfig(msg.config); + } + } + onConfig(config) { + this.ring = new Ring(config.ring); + } + // Inputs and outputs in groups of 128 samples. + process(inputs, outputs, _parameters) { + if (!this.ring) { + // Paused + return true; + } + if (inputs.length != 1 && outputs.length != 1) { + throw new Error("only a single track is supported"); + } + if (this.ring.size() == this.ring.capacity) { + // This is a hack to clear any latency in the ring buffer. + // The proper solution is to play back slightly faster? + console.warn("resyncing ring buffer"); + this.ring.clear(); + return true; + } + const output = outputs[0]; + const size = this.ring.read(output); + if (size < output.length) ; + return true; + } + } + registerProcessor("renderer", Renderer); + + })(); + + }); + /* eslint-enable */ + + // NOTE: This must be on the main thread + class Audio { + context; + worklet; + constructor(config) { + this.context = new AudioContext({ + latencyHint: "interactive", + sampleRate: config.sampleRate, + }); + this.worklet = this.load(config); + } + async load(config) { + // Load the worklet source code. + await WorkerFactory$1(this.context); + const volume = this.context.createGain(); + volume.gain.value = 2.0; + // Create the worklet + const worklet = new AudioWorkletNode(this.context, "renderer"); + worklet.port.addEventListener("message", this.on.bind(this)); + worklet.onprocessorerror = (e) => { + console.error("Audio worklet error:", e); + }; + // Connect the worklet to the volume node and then to the speakers + worklet.connect(volume); + volume.connect(this.context.destination); + worklet.port.postMessage({ config }); + return worklet; + } + on(_event) { + // TODO + } + } + + var WorkerClass = null; + + try { + var WorkerThreads = + typeof module !== 'undefined' && typeof module.require === 'function' && module.require('worker_threads') || + typeof __non_webpack_require__ === 'function' && __non_webpack_require__('worker_threads') || + typeof require === 'function' && require('worker_threads'); + WorkerClass = WorkerThreads.Worker; + } catch(e) {} // eslint-disable-line + + function createInlineWorkerFactory$2(fn, sourcemapArg) { + var lines = funcToSource(fn); + var concat = lines.join('\n'); + return function WorkerFactory(options) { + return new WorkerClass(concat, Object.assign({}, options, { eval: true })); + }; + } + + function createURL(fn, sourcemapArg) { + var lines = funcToSource(fn); + var blob = new Blob(lines, { type: 'application/javascript' }); + return URL.createObjectURL(blob); + } + + function createInlineWorkerFactory$1(fn, sourcemapArg) { + var url; + return function WorkerFactory(options) { + url = url || createURL(fn); + return new Worker(url, options); + }; + } + + function createInlineWorkerFactory(fn, sourcemapArg) { + if (isNodeJS()) { + return createInlineWorkerFactory$2(fn); + } + return createInlineWorkerFactory$1(fn); + } + + var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-worker-loader */function () { + (function () { + '__worker_loader_strict__'; + + class Timeline { + // Maintain audio and video seprarately + audio; + video; + // Construct a timeline + constructor() { + this.audio = new Component(); + this.video = new Component(); + } + } + class Component { + #current; + frames; + #segments; + constructor() { + this.frames = new ReadableStream({ + pull: this.#pull.bind(this), + cancel: this.#cancel.bind(this), + }); + // This is a hack to have an async channel with 100 items. + this.#segments = new TransformStream({}, { highWaterMark: 100 }); + } + get segments() { + return this.#segments.writable; + } + async #pull(controller) { + for (;;) { + // Get the next segment to render. + const segments = this.#segments.readable.getReader(); + let res; + if (this.#current) { + // Get the next frame to render. + const frames = this.#current.frames.getReader(); + // Wait for either the frames or segments to be ready. + // NOTE: This assume that the first promise gets priority. + res = await Promise.race([frames.read(), segments.read()]); + frames.releaseLock(); + } + else { + res = await segments.read(); + } + segments.releaseLock(); + const { value, done } = res; + if (done) { + // We assume the current segment has been closed + // TODO support the segments stream closing + this.#current = undefined; + continue; + } + if (!isSegment(value)) { + // Return so the reader can decide when to get the next frame. + controller.enqueue(value); + return; + } + // We didn't get any frames, and instead got a new segment. + if (this.#current) { + if (value.sequence < this.#current.sequence) { + // Our segment is older than the current, abandon it. + await value.frames.cancel("skipping segment; too old"); + continue; + } + else { + // Our segment is newer than the current, cancel the old one. + await this.#current.frames.cancel("skipping segment; too slow"); + } + } + this.#current = value; + } + } + async #cancel(reason) { + if (this.#current) { + await this.#current.frames.cancel(reason); + } + const segments = this.#segments.readable.getReader(); + for (;;) { + const { value: segment, done } = await segments.read(); + if (done) + break; + await segment.frames.cancel(reason); + } + } + } + // Return if a type is a segment or frame + // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents + function isSegment(value) { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + return value.frames !== undefined; + } + + // Ring buffer with audio samples. + var STATE; + (function (STATE) { + STATE[STATE["READ_POS"] = 0] = "READ_POS"; + STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; + STATE[STATE["LENGTH"] = 2] = "LENGTH"; + })(STATE || (STATE = {})); + class Ring { + state; + channels; + capacity; + constructor(shared) { + this.state = new Int32Array(shared.state); + this.channels = []; + for (const channel of shared.channels) { + this.channels.push(new Float32Array(channel)); + } + this.capacity = shared.capacity; + } + // Write samples for single audio frame, returning the total number written. + write(frame) { + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + const startPos = writePos; + let endPos = writePos + frame.numberOfFrames; + if (endPos > readPos + this.capacity) { + endPos = readPos + this.capacity; + if (endPos <= startPos) { + // No space to write + return 0; + } + } + const startIndex = startPos % this.capacity; + const endIndex = endPos % this.capacity; + // Loop over each channel + for (let i = 0; i < this.channels.length; i += 1) { + const channel = this.channels[i]; + // If the AudioData doesn't have enough channels, duplicate it. + const planeIndex = Math.min(i, frame.numberOfChannels - 1); + if (startIndex < endIndex) { + // One continuous range to copy. + const full = channel.subarray(startIndex, endIndex); + frame.copyTo(full, { + planeIndex, + frameCount: endIndex - startIndex, + }); + } + else { + const first = channel.subarray(startIndex); + const second = channel.subarray(0, endIndex); + frame.copyTo(first, { + planeIndex, + frameCount: first.length, + }); + // We need this conditional when startIndex == 0 and endIndex == 0 + // When capacity=4410 and frameCount=1024, this was happening 52s into the audio. + if (second.length) { + frame.copyTo(second, { + planeIndex, + frameOffset: first.length, + frameCount: second.length, + }); + } + } + } + Atomics.store(this.state, STATE.WRITE_POS, endPos); + return endPos - startPos; + } + read(dst) { + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + const startPos = readPos; + let endPos = startPos + dst[0].length; + if (endPos > writePos) { + endPos = writePos; + if (endPos <= startPos) { + // Nothing to read + return 0; + } + } + const startIndex = startPos % this.capacity; + const endIndex = endPos % this.capacity; + // Loop over each channel + for (let i = 0; i < dst.length; i += 1) { + if (i >= this.channels.length) ; + const input = this.channels[i]; + const output = dst[i]; + if (startIndex < endIndex) { + const full = input.subarray(startIndex, endIndex); + output.set(full); + } + else { + const first = input.subarray(startIndex); + const second = input.subarray(0, endIndex); + output.set(first); + output.set(second, first.length); + } + } + Atomics.store(this.state, STATE.READ_POS, endPos); + return endPos - startPos; + } + clear() { + const pos = Atomics.load(this.state, STATE.WRITE_POS); + Atomics.store(this.state, STATE.READ_POS, pos); + } + size() { + // TODO is this thread safe? + const readPos = Atomics.load(this.state, STATE.READ_POS); + const writePos = Atomics.load(this.state, STATE.WRITE_POS); + return writePos - readPos; + } + } + + var mp4box_all = {}; + + var hasRequiredMp4box_all; + function requireMp4box_all() { + if (hasRequiredMp4box_all) return mp4box_all; + hasRequiredMp4box_all = 1; + (function (exports) { + // file:src/log.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var Log = function () { + var start = new Date(); + var LOG_LEVEL_ERROR = 4; + var LOG_LEVEL_WARNING = 3; + var LOG_LEVEL_INFO = 2; + var LOG_LEVEL_DEBUG = 1; + var log_level = LOG_LEVEL_ERROR; + var logObject = { + setLogLevel: function (level) { + if (level == this.debug) log_level = LOG_LEVEL_DEBUG;else if (level == this.info) log_level = LOG_LEVEL_INFO;else if (level == this.warn) log_level = LOG_LEVEL_WARNING;else if (level == this.error) log_level = LOG_LEVEL_ERROR;else log_level = LOG_LEVEL_ERROR; + }, + debug: function (module, msg) { + if (console.debug === undefined) { + console.debug = console.log; + } + if (LOG_LEVEL_DEBUG >= log_level) { + console.debug("[" + Log.getDurationString(new Date() - start, 1000) + "]", "[" + module + "]", msg); + } + }, + log: function (module, msg) { + this.debug(module.msg); + }, + info: function (module, msg) { + if (LOG_LEVEL_INFO >= log_level) { + console.info("[" + Log.getDurationString(new Date() - start, 1000) + "]", "[" + module + "]", msg); + } + }, + warn: function (module, msg) { + if (LOG_LEVEL_WARNING >= log_level) { + console.warn("[" + Log.getDurationString(new Date() - start, 1000) + "]", "[" + module + "]", msg); + } + }, + error: function (module, msg) { + if (LOG_LEVEL_ERROR >= log_level) { + console.error("[" + Log.getDurationString(new Date() - start, 1000) + "]", "[" + module + "]", msg); + } + } + }; + return logObject; + }(); + + /* Helper function to print a duration value in the form H:MM:SS.MS */ + Log.getDurationString = function (duration, _timescale) { + var neg; + /* Helper function to print a number on a fixed number of digits */ + function pad(number, length) { + var str = '' + number; + var a = str.split('.'); + while (a[0].length < length) { + a[0] = '0' + a[0]; + } + return a.join('.'); + } + if (duration < 0) { + neg = true; + duration = -duration; + } else { + neg = false; + } + var timescale = _timescale || 1; + var duration_sec = duration / timescale; + var hours = Math.floor(duration_sec / 3600); + duration_sec -= hours * 3600; + var minutes = Math.floor(duration_sec / 60); + duration_sec -= minutes * 60; + var msec = duration_sec * 1000; + duration_sec = Math.floor(duration_sec); + msec -= duration_sec * 1000; + msec = Math.floor(msec); + return (neg ? "-" : "") + hours + ":" + pad(minutes, 2) + ":" + pad(duration_sec, 2) + "." + pad(msec, 3); + }; + + /* Helper function to stringify HTML5 TimeRanges objects */ + Log.printRanges = function (ranges) { + var length = ranges.length; + if (length > 0) { + var str = ""; + for (var i = 0; i < length; i++) { + if (i > 0) str += ","; + str += "[" + Log.getDurationString(ranges.start(i)) + "," + Log.getDurationString(ranges.end(i)) + "]"; + } + return str; + } else { + return "(empty)"; + } + }; + { + exports.Log = Log; + } + // file:src/stream.js + var MP4BoxStream = function (arrayBuffer) { + if (arrayBuffer instanceof ArrayBuffer) { + this.buffer = arrayBuffer; + this.dataview = new DataView(arrayBuffer); + } else { + throw "Needs an array buffer"; + } + this.position = 0; + }; + + /************************************************************************* + Common API between MultiBufferStream and SimpleStream + *************************************************************************/ + MP4BoxStream.prototype.getPosition = function () { + return this.position; + }; + MP4BoxStream.prototype.getEndPosition = function () { + return this.buffer.byteLength; + }; + MP4BoxStream.prototype.getLength = function () { + return this.buffer.byteLength; + }; + MP4BoxStream.prototype.seek = function (pos) { + var npos = Math.max(0, Math.min(this.buffer.byteLength, pos)); + this.position = isNaN(npos) || !isFinite(npos) ? 0 : npos; + return true; + }; + MP4BoxStream.prototype.isEos = function () { + return this.getPosition() >= this.getEndPosition(); + }; + + /************************************************************************* + Read methods, simimar to DataStream but simpler + *************************************************************************/ + MP4BoxStream.prototype.readAnyInt = function (size, signed) { + var res = 0; + if (this.position + size <= this.buffer.byteLength) { + switch (size) { + case 1: + if (signed) { + res = this.dataview.getInt8(this.position); + } else { + res = this.dataview.getUint8(this.position); + } + break; + case 2: + if (signed) { + res = this.dataview.getInt16(this.position); + } else { + res = this.dataview.getUint16(this.position); + } + break; + case 3: + if (signed) { + throw "No method for reading signed 24 bits values"; + } else { + res = this.dataview.getUint8(this.position) << 16; + res |= this.dataview.getUint8(this.position + 1) << 8; + res |= this.dataview.getUint8(this.position + 2); + } + break; + case 4: + if (signed) { + res = this.dataview.getInt32(this.position); + } else { + res = this.dataview.getUint32(this.position); + } + break; + case 8: + if (signed) { + throw "No method for reading signed 64 bits values"; + } else { + res = this.dataview.getUint32(this.position) << 32; + res |= this.dataview.getUint32(this.position + 4); + } + break; + default: + throw "readInt method not implemented for size: " + size; + } + this.position += size; + return res; + } else { + throw "Not enough bytes in buffer"; + } + }; + MP4BoxStream.prototype.readUint8 = function () { + return this.readAnyInt(1, false); + }; + MP4BoxStream.prototype.readUint16 = function () { + return this.readAnyInt(2, false); + }; + MP4BoxStream.prototype.readUint24 = function () { + return this.readAnyInt(3, false); + }; + MP4BoxStream.prototype.readUint32 = function () { + return this.readAnyInt(4, false); + }; + MP4BoxStream.prototype.readUint64 = function () { + return this.readAnyInt(8, false); + }; + MP4BoxStream.prototype.readString = function (length) { + if (this.position + length <= this.buffer.byteLength) { + var s = ""; + for (var i = 0; i < length; i++) { + s += String.fromCharCode(this.readUint8()); + } + return s; + } else { + throw "Not enough bytes in buffer"; + } + }; + MP4BoxStream.prototype.readCString = function () { + var arr = []; + while (true) { + var b = this.readUint8(); + if (b !== 0) { + arr.push(b); + } else { + break; + } + } + return String.fromCharCode.apply(null, arr); + }; + MP4BoxStream.prototype.readInt8 = function () { + return this.readAnyInt(1, true); + }; + MP4BoxStream.prototype.readInt16 = function () { + return this.readAnyInt(2, true); + }; + MP4BoxStream.prototype.readInt32 = function () { + return this.readAnyInt(4, true); + }; + MP4BoxStream.prototype.readInt64 = function () { + return this.readAnyInt(8, false); + }; + MP4BoxStream.prototype.readUint8Array = function (length) { + var arr = new Uint8Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readUint8(); + } + return arr; + }; + MP4BoxStream.prototype.readInt16Array = function (length) { + var arr = new Int16Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readInt16(); + } + return arr; + }; + MP4BoxStream.prototype.readUint16Array = function (length) { + var arr = new Int16Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readUint16(); + } + return arr; + }; + MP4BoxStream.prototype.readUint32Array = function (length) { + var arr = new Uint32Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readUint32(); + } + return arr; + }; + MP4BoxStream.prototype.readInt32Array = function (length) { + var arr = new Int32Array(length); + for (var i = 0; i < length; i++) { + arr[i] = this.readInt32(); + } + return arr; + }; + { + exports.MP4BoxStream = MP4BoxStream; + } // file:src/DataStream.js + /** + DataStream reads scalars, arrays and structs of data from an ArrayBuffer. + It's like a file-like DataView on steroids. + @param {ArrayBuffer} arrayBuffer ArrayBuffer to read from. + @param {?Number} byteOffset Offset from arrayBuffer beginning for the DataStream. + @param {?Boolean} endianness DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN (the default). + */ + var DataStream = function (arrayBuffer, byteOffset, endianness) { + this._byteOffset = byteOffset || 0; + if (arrayBuffer instanceof ArrayBuffer) { + this.buffer = arrayBuffer; + } else if (typeof arrayBuffer == "object") { + this.dataView = arrayBuffer; + if (byteOffset) { + this._byteOffset += byteOffset; + } + } else { + this.buffer = new ArrayBuffer(arrayBuffer || 0); + } + this.position = 0; + this.endianness = endianness == null ? DataStream.LITTLE_ENDIAN : endianness; + }; + DataStream.prototype = {}; + DataStream.prototype.getPosition = function () { + return this.position; + }; + + /** + Internal function to resize the DataStream buffer when required. + @param {number} extra Number of bytes to add to the buffer allocation. + @return {null} + */ + DataStream.prototype._realloc = function (extra) { + if (!this._dynamicSize) { + return; + } + var req = this._byteOffset + this.position + extra; + var blen = this._buffer.byteLength; + if (req <= blen) { + if (req > this._byteLength) { + this._byteLength = req; + } + return; + } + if (blen < 1) { + blen = 1; + } + while (req > blen) { + blen *= 2; + } + var buf = new ArrayBuffer(blen); + var src = new Uint8Array(this._buffer); + var dst = new Uint8Array(buf, 0, src.length); + dst.set(src); + this.buffer = buf; + this._byteLength = req; + }; + + /** + Internal function to trim the DataStream buffer when required. + Used for stripping out the extra bytes from the backing buffer when + the virtual byteLength is smaller than the buffer byteLength (happens after + growing the buffer with writes and not filling the extra space completely). + @return {null} + */ + DataStream.prototype._trimAlloc = function () { + if (this._byteLength == this._buffer.byteLength) { + return; + } + var buf = new ArrayBuffer(this._byteLength); + var dst = new Uint8Array(buf); + var src = new Uint8Array(this._buffer, 0, dst.length); + dst.set(src); + this.buffer = buf; + }; + + /** + Big-endian const to use as default endianness. + @type {boolean} + */ + DataStream.BIG_ENDIAN = false; + + /** + Little-endian const to use as default endianness. + @type {boolean} + */ + DataStream.LITTLE_ENDIAN = true; + + /** + Virtual byte length of the DataStream backing buffer. + Updated to be max of original buffer size and last written size. + If dynamicSize is false is set to buffer size. + @type {number} + */ + DataStream.prototype._byteLength = 0; + + /** + Returns the byte length of the DataStream object. + @type {number} + */ + Object.defineProperty(DataStream.prototype, 'byteLength', { + get: function () { + return this._byteLength - this._byteOffset; + } + }); + + /** + Set/get the backing ArrayBuffer of the DataStream object. + The setter updates the DataView to point to the new buffer. + @type {Object} + */ + Object.defineProperty(DataStream.prototype, 'buffer', { + get: function () { + this._trimAlloc(); + return this._buffer; + }, + set: function (v) { + this._buffer = v; + this._dataView = new DataView(this._buffer, this._byteOffset); + this._byteLength = this._buffer.byteLength; + } + }); + + /** + Set/get the byteOffset of the DataStream object. + The setter updates the DataView to point to the new byteOffset. + @type {number} + */ + Object.defineProperty(DataStream.prototype, 'byteOffset', { + get: function () { + return this._byteOffset; + }, + set: function (v) { + this._byteOffset = v; + this._dataView = new DataView(this._buffer, this._byteOffset); + this._byteLength = this._buffer.byteLength; + } + }); + + /** + Set/get the backing DataView of the DataStream object. + The setter updates the buffer and byteOffset to point to the DataView values. + @type {Object} + */ + Object.defineProperty(DataStream.prototype, 'dataView', { + get: function () { + return this._dataView; + }, + set: function (v) { + this._byteOffset = v.byteOffset; + this._buffer = v.buffer; + this._dataView = new DataView(this._buffer, this._byteOffset); + this._byteLength = this._byteOffset + v.byteLength; + } + }); + + /** + Sets the DataStream read/write position to given position. + Clamps between 0 and DataStream length. + @param {number} pos Position to seek to. + @return {null} + */ + DataStream.prototype.seek = function (pos) { + var npos = Math.max(0, Math.min(this.byteLength, pos)); + this.position = isNaN(npos) || !isFinite(npos) ? 0 : npos; + }; + + /** + Returns true if the DataStream seek pointer is at the end of buffer and + there's no more data to read. + @return {boolean} True if the seek pointer is at the end of the buffer. + */ + DataStream.prototype.isEof = function () { + return this.position >= this._byteLength; + }; + + /** + Maps a Uint8Array into the DataStream buffer. + Nice for quickly reading in data. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Uint8Array to the DataStream backing buffer. + */ + DataStream.prototype.mapUint8Array = function (length) { + this._realloc(length * 1); + var arr = new Uint8Array(this._buffer, this.byteOffset + this.position, length); + this.position += length * 1; + return arr; + }; + + /** + Reads an Int32Array of desired length and endianness from the DataStream. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Int32Array. + */ + DataStream.prototype.readInt32Array = function (length, e) { + length = length == null ? this.byteLength - this.position / 4 : length; + var arr = new Int32Array(length); + DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads an Int16Array of desired length and endianness from the DataStream. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Int16Array. + */ + DataStream.prototype.readInt16Array = function (length, e) { + length = length == null ? this.byteLength - this.position / 2 : length; + var arr = new Int16Array(length); + DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads an Int8Array of desired length from the DataStream. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Int8Array. + */ + DataStream.prototype.readInt8Array = function (length) { + length = length == null ? this.byteLength - this.position : length; + var arr = new Int8Array(length); + DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Uint32Array of desired length and endianness from the DataStream. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Uint32Array. + */ + DataStream.prototype.readUint32Array = function (length, e) { + length = length == null ? this.byteLength - this.position / 4 : length; + var arr = new Uint32Array(length); + DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Uint16Array of desired length and endianness from the DataStream. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Uint16Array. + */ + DataStream.prototype.readUint16Array = function (length, e) { + length = length == null ? this.byteLength - this.position / 2 : length; + var arr = new Uint16Array(length); + DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Uint8Array of desired length from the DataStream. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Uint8Array. + */ + DataStream.prototype.readUint8Array = function (length) { + length = length == null ? this.byteLength - this.position : length; + var arr = new Uint8Array(length); + DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Float64Array of desired length and endianness from the DataStream. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Float64Array. + */ + DataStream.prototype.readFloat64Array = function (length, e) { + length = length == null ? this.byteLength - this.position / 8 : length; + var arr = new Float64Array(length); + DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a Float32Array of desired length and endianness from the DataStream. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} The read Float32Array. + */ + DataStream.prototype.readFloat32Array = function (length, e) { + length = length == null ? this.byteLength - this.position / 4 : length; + var arr = new Float32Array(length); + DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += arr.byteLength; + return arr; + }; + + /** + Reads a 32-bit int from the DataStream with the desired endianness. + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readInt32 = function (e) { + var v = this._dataView.getInt32(this.position, e == null ? this.endianness : e); + this.position += 4; + return v; + }; + + /** + Reads a 16-bit int from the DataStream with the desired endianness. + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readInt16 = function (e) { + var v = this._dataView.getInt16(this.position, e == null ? this.endianness : e); + this.position += 2; + return v; + }; + + /** + Reads an 8-bit int from the DataStream. + @return {number} The read number. + */ + DataStream.prototype.readInt8 = function () { + var v = this._dataView.getInt8(this.position); + this.position += 1; + return v; + }; + + /** + Reads a 32-bit unsigned int from the DataStream with the desired endianness. + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readUint32 = function (e) { + var v = this._dataView.getUint32(this.position, e == null ? this.endianness : e); + this.position += 4; + return v; + }; + + /** + Reads a 16-bit unsigned int from the DataStream with the desired endianness. + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readUint16 = function (e) { + var v = this._dataView.getUint16(this.position, e == null ? this.endianness : e); + this.position += 2; + return v; + }; + + /** + Reads an 8-bit unsigned int from the DataStream. + @return {number} The read number. + */ + DataStream.prototype.readUint8 = function () { + var v = this._dataView.getUint8(this.position); + this.position += 1; + return v; + }; + + /** + Reads a 32-bit float from the DataStream with the desired endianness. + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readFloat32 = function (e) { + var v = this._dataView.getFloat32(this.position, e == null ? this.endianness : e); + this.position += 4; + return v; + }; + + /** + Reads a 64-bit float from the DataStream with the desired endianness. + @param {?boolean} e Endianness of the number. + @return {number} The read number. + */ + DataStream.prototype.readFloat64 = function (e) { + var v = this._dataView.getFloat64(this.position, e == null ? this.endianness : e); + this.position += 8; + return v; + }; + + /** + Native endianness. Either DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN + depending on the platform endianness. + @type {boolean} + */ + DataStream.endianness = new Int8Array(new Int16Array([1]).buffer)[0] > 0; + + /** + Copies byteLength bytes from the src buffer at srcOffset to the + dst buffer at dstOffset. + @param {Object} dst Destination ArrayBuffer to write to. + @param {number} dstOffset Offset to the destination ArrayBuffer. + @param {Object} src Source ArrayBuffer to read from. + @param {number} srcOffset Offset to the source ArrayBuffer. + @param {number} byteLength Number of bytes to copy. + */ + DataStream.memcpy = function (dst, dstOffset, src, srcOffset, byteLength) { + var dstU8 = new Uint8Array(dst, dstOffset, byteLength); + var srcU8 = new Uint8Array(src, srcOffset, byteLength); + dstU8.set(srcU8); + }; + + /** + Converts array to native endianness in-place. + @param {Object} array Typed array to convert. + @param {boolean} arrayIsLittleEndian True if the data in the array is + little-endian. Set false for big-endian. + @return {Object} The converted typed array. + */ + DataStream.arrayToNative = function (array, arrayIsLittleEndian) { + if (arrayIsLittleEndian == this.endianness) { + return array; + } else { + return this.flipArrayEndianness(array); + } + }; + + /** + Converts native endianness array to desired endianness in-place. + @param {Object} array Typed array to convert. + @param {boolean} littleEndian True if the converted array should be + little-endian. Set false for big-endian. + @return {Object} The converted typed array. + */ + DataStream.nativeToEndian = function (array, littleEndian) { + if (this.endianness == littleEndian) { + return array; + } else { + return this.flipArrayEndianness(array); + } + }; + + /** + Flips typed array endianness in-place. + @param {Object} array Typed array to flip. + @return {Object} The converted typed array. + */ + DataStream.flipArrayEndianness = function (array) { + var u8 = new Uint8Array(array.buffer, array.byteOffset, array.byteLength); + for (var i = 0; i < array.byteLength; i += array.BYTES_PER_ELEMENT) { + for (var j = i + array.BYTES_PER_ELEMENT - 1, k = i; j > k; j--, k++) { + var tmp = u8[k]; + u8[k] = u8[j]; + u8[j] = tmp; + } + } + return array; + }; + + /** + Seek position where DataStream#readStruct ran into a problem. + Useful for debugging struct parsing. + @type {number} + */ + DataStream.prototype.failurePosition = 0; + String.fromCharCodeUint8 = function (uint8arr) { + var arr = []; + for (var i = 0; i < uint8arr.length; i++) { + arr[i] = uint8arr[i]; + } + return String.fromCharCode.apply(null, arr); + }; + /** + Read a string of desired length and encoding from the DataStream. + @param {number} length The length of the string to read in bytes. + @param {?string} encoding The encoding of the string data in the DataStream. + Defaults to ASCII. + @return {string} The read string. + */ + DataStream.prototype.readString = function (length, encoding) { + if (encoding == null || encoding == "ASCII") { + return String.fromCharCodeUint8.apply(null, [this.mapUint8Array(length == null ? this.byteLength - this.position : length)]); + } else { + return new TextDecoder(encoding).decode(this.mapUint8Array(length)); + } + }; + + /** + Read null-terminated string of desired length from the DataStream. Truncates + the returned string so that the null byte is not a part of it. + @param {?number} length The length of the string to read. + @return {string} The read string. + */ + DataStream.prototype.readCString = function (length) { + var blen = this.byteLength - this.position; + var u8 = new Uint8Array(this._buffer, this._byteOffset + this.position); + var len = blen; + if (length != null) { + len = Math.min(length, blen); + } + for (var i = 0; i < len && u8[i] !== 0; i++); // find first zero byte + var s = String.fromCharCodeUint8.apply(null, [this.mapUint8Array(i)]); + if (length != null) { + this.position += len - i; + } else if (i != blen) { + this.position += 1; // trailing zero if not at end of buffer + } + return s; + }; + + /* + TODO: fix endianness for 24/64-bit fields + TODO: check range/support for 64-bits numbers in JavaScript + */ + var MAX_SIZE = Math.pow(2, 32); + DataStream.prototype.readInt64 = function () { + return this.readInt32() * MAX_SIZE + this.readUint32(); + }; + DataStream.prototype.readUint64 = function () { + return this.readUint32() * MAX_SIZE + this.readUint32(); + }; + DataStream.prototype.readInt64 = function () { + return this.readUint32() * MAX_SIZE + this.readUint32(); + }; + DataStream.prototype.readUint24 = function () { + return (this.readUint8() << 16) + (this.readUint8() << 8) + this.readUint8(); + }; + { + exports.DataStream = DataStream; + } + // file:src/DataStream-write.js + /** + Saves the DataStream contents to the given filename. + Uses Chrome's anchor download property to initiate download. + + @param {string} filename Filename to save as. + @return {null} + */ + DataStream.prototype.save = function (filename) { + var blob = new Blob([this.buffer]); + if (window.URL && URL.createObjectURL) { + var url = window.URL.createObjectURL(blob); + var a = document.createElement('a'); + // Required in Firefox: + document.body.appendChild(a); + a.setAttribute('href', url); + a.setAttribute('download', filename); + // Required in Firefox: + a.setAttribute('target', '_self'); + a.click(); + window.URL.revokeObjectURL(url); + } else { + throw "DataStream.save: Can't create object URL."; + } + }; + + /** + Whether to extend DataStream buffer when trying to write beyond its size. + If set, the buffer is reallocated to twice its current size until the + requested write fits the buffer. + @type {boolean} + */ + DataStream.prototype._dynamicSize = true; + Object.defineProperty(DataStream.prototype, 'dynamicSize', { + get: function () { + return this._dynamicSize; + }, + set: function (v) { + if (!v) { + this._trimAlloc(); + } + this._dynamicSize = v; + } + }); + + /** + Internal function to trim the DataStream buffer when required. + Used for stripping out the first bytes when not needed anymore. + @return {null} + */ + DataStream.prototype.shift = function (offset) { + var buf = new ArrayBuffer(this._byteLength - offset); + var dst = new Uint8Array(buf); + var src = new Uint8Array(this._buffer, offset, dst.length); + dst.set(src); + this.buffer = buf; + this.position -= offset; + }; + + /** + Writes an Int32Array of specified endianness to the DataStream. + @param {Object} arr The array to write. + @param {?boolean} e Endianness of the data to write. + */ + DataStream.prototype.writeInt32Array = function (arr, e) { + this._realloc(arr.length * 4); + if (arr instanceof Int32Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); + this.mapInt32Array(arr.length, e); + } else { + for (var i = 0; i < arr.length; i++) { + this.writeInt32(arr[i], e); + } + } + }; + + /** + Writes an Int16Array of specified endianness to the DataStream. + @param {Object} arr The array to write. + @param {?boolean} e Endianness of the data to write. + */ + DataStream.prototype.writeInt16Array = function (arr, e) { + this._realloc(arr.length * 2); + if (arr instanceof Int16Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); + this.mapInt16Array(arr.length, e); + } else { + for (var i = 0; i < arr.length; i++) { + this.writeInt16(arr[i], e); + } + } + }; + + /** + Writes an Int8Array to the DataStream. + @param {Object} arr The array to write. + */ + DataStream.prototype.writeInt8Array = function (arr) { + this._realloc(arr.length * 1); + if (arr instanceof Int8Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); + this.mapInt8Array(arr.length); + } else { + for (var i = 0; i < arr.length; i++) { + this.writeInt8(arr[i]); + } + } + }; + + /** + Writes a Uint32Array of specified endianness to the DataStream. + @param {Object} arr The array to write. + @param {?boolean} e Endianness of the data to write. + */ + DataStream.prototype.writeUint32Array = function (arr, e) { + this._realloc(arr.length * 4); + if (arr instanceof Uint32Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); + this.mapUint32Array(arr.length, e); + } else { + for (var i = 0; i < arr.length; i++) { + this.writeUint32(arr[i], e); + } + } + }; + + /** + Writes a Uint16Array of specified endianness to the DataStream. + @param {Object} arr The array to write. + @param {?boolean} e Endianness of the data to write. + */ + DataStream.prototype.writeUint16Array = function (arr, e) { + this._realloc(arr.length * 2); + if (arr instanceof Uint16Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); + this.mapUint16Array(arr.length, e); + } else { + for (var i = 0; i < arr.length; i++) { + this.writeUint16(arr[i], e); + } + } + }; + + /** + Writes a Uint8Array to the DataStream. + @param {Object} arr The array to write. + */ + DataStream.prototype.writeUint8Array = function (arr) { + this._realloc(arr.length * 1); + if (arr instanceof Uint8Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); + this.mapUint8Array(arr.length); + } else { + for (var i = 0; i < arr.length; i++) { + this.writeUint8(arr[i]); + } + } + }; + + /** + Writes a Float64Array of specified endianness to the DataStream. + @param {Object} arr The array to write. + @param {?boolean} e Endianness of the data to write. + */ + DataStream.prototype.writeFloat64Array = function (arr, e) { + this._realloc(arr.length * 8); + if (arr instanceof Float64Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); + this.mapFloat64Array(arr.length, e); + } else { + for (var i = 0; i < arr.length; i++) { + this.writeFloat64(arr[i], e); + } + } + }; + + /** + Writes a Float32Array of specified endianness to the DataStream. + @param {Object} arr The array to write. + @param {?boolean} e Endianness of the data to write. + */ + DataStream.prototype.writeFloat32Array = function (arr, e) { + this._realloc(arr.length * 4); + if (arr instanceof Float32Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { + DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); + this.mapFloat32Array(arr.length, e); + } else { + for (var i = 0; i < arr.length; i++) { + this.writeFloat32(arr[i], e); + } + } + }; + + /** + Writes a 32-bit int to the DataStream with the desired endianness. + @param {number} v Number to write. + @param {?boolean} e Endianness of the number. + */ + DataStream.prototype.writeInt32 = function (v, e) { + this._realloc(4); + this._dataView.setInt32(this.position, v, e == null ? this.endianness : e); + this.position += 4; + }; + + /** + Writes a 16-bit int to the DataStream with the desired endianness. + @param {number} v Number to write. + @param {?boolean} e Endianness of the number. + */ + DataStream.prototype.writeInt16 = function (v, e) { + this._realloc(2); + this._dataView.setInt16(this.position, v, e == null ? this.endianness : e); + this.position += 2; + }; + + /** + Writes an 8-bit int to the DataStream. + @param {number} v Number to write. + */ + DataStream.prototype.writeInt8 = function (v) { + this._realloc(1); + this._dataView.setInt8(this.position, v); + this.position += 1; + }; + + /** + Writes a 32-bit unsigned int to the DataStream with the desired endianness. + @param {number} v Number to write. + @param {?boolean} e Endianness of the number. + */ + DataStream.prototype.writeUint32 = function (v, e) { + this._realloc(4); + this._dataView.setUint32(this.position, v, e == null ? this.endianness : e); + this.position += 4; + }; + + /** + Writes a 16-bit unsigned int to the DataStream with the desired endianness. + @param {number} v Number to write. + @param {?boolean} e Endianness of the number. + */ + DataStream.prototype.writeUint16 = function (v, e) { + this._realloc(2); + this._dataView.setUint16(this.position, v, e == null ? this.endianness : e); + this.position += 2; + }; + + /** + Writes an 8-bit unsigned int to the DataStream. + @param {number} v Number to write. + */ + DataStream.prototype.writeUint8 = function (v) { + this._realloc(1); + this._dataView.setUint8(this.position, v); + this.position += 1; + }; + + /** + Writes a 32-bit float to the DataStream with the desired endianness. + @param {number} v Number to write. + @param {?boolean} e Endianness of the number. + */ + DataStream.prototype.writeFloat32 = function (v, e) { + this._realloc(4); + this._dataView.setFloat32(this.position, v, e == null ? this.endianness : e); + this.position += 4; + }; + + /** + Writes a 64-bit float to the DataStream with the desired endianness. + @param {number} v Number to write. + @param {?boolean} e Endianness of the number. + */ + DataStream.prototype.writeFloat64 = function (v, e) { + this._realloc(8); + this._dataView.setFloat64(this.position, v, e == null ? this.endianness : e); + this.position += 8; + }; + + /** + Write a UCS-2 string of desired endianness to the DataStream. The + lengthOverride argument lets you define the number of characters to write. + If the string is shorter than lengthOverride, the extra space is padded with + zeroes. + @param {string} str The string to write. + @param {?boolean} endianness The endianness to use for the written string data. + @param {?number} lengthOverride The number of characters to write. + */ + DataStream.prototype.writeUCS2String = function (str, endianness, lengthOverride) { + if (lengthOverride == null) { + lengthOverride = str.length; + } + for (var i = 0; i < str.length && i < lengthOverride; i++) { + this.writeUint16(str.charCodeAt(i), endianness); + } + for (; i < lengthOverride; i++) { + this.writeUint16(0); + } + }; + + /** + Writes a string of desired length and encoding to the DataStream. + @param {string} s The string to write. + @param {?string} encoding The encoding for the written string data. + Defaults to ASCII. + @param {?number} length The number of characters to write. + */ + DataStream.prototype.writeString = function (s, encoding, length) { + var i = 0; + if (encoding == null || encoding == "ASCII") { + if (length != null) { + var len = Math.min(s.length, length); + for (i = 0; i < len; i++) { + this.writeUint8(s.charCodeAt(i)); + } + for (; i < length; i++) { + this.writeUint8(0); + } + } else { + for (i = 0; i < s.length; i++) { + this.writeUint8(s.charCodeAt(i)); + } + } + } else { + this.writeUint8Array(new TextEncoder(encoding).encode(s.substring(0, length))); + } + }; + + /** + Writes a null-terminated string to DataStream and zero-pads it to length + bytes. If length is not given, writes the string followed by a zero. + If string is longer than length, the written part of the string does not have + a trailing zero. + @param {string} s The string to write. + @param {?number} length The number of characters to write. + */ + DataStream.prototype.writeCString = function (s, length) { + var i = 0; + if (length != null) { + var len = Math.min(s.length, length); + for (i = 0; i < len; i++) { + this.writeUint8(s.charCodeAt(i)); + } + for (; i < length; i++) { + this.writeUint8(0); + } + } else { + for (i = 0; i < s.length; i++) { + this.writeUint8(s.charCodeAt(i)); + } + this.writeUint8(0); + } + }; + + /** + Writes a struct to the DataStream. Takes a structDefinition that gives the + types and a struct object that gives the values. Refer to readStruct for the + structure of structDefinition. + @param {Object} structDefinition Type definition of the struct. + @param {Object} struct The struct data object. + */ + DataStream.prototype.writeStruct = function (structDefinition, struct) { + for (var i = 0; i < structDefinition.length; i += 2) { + var t = structDefinition[i + 1]; + this.writeType(t, struct[structDefinition[i]], struct); + } + }; + + /** + Writes object v of type t to the DataStream. + @param {Object} t Type of data to write. + @param {Object} v Value of data to write. + @param {Object} struct Struct to pass to write callback functions. + */ + DataStream.prototype.writeType = function (t, v, struct) { + var tp; + if (typeof t == "function") { + return t(this, v); + } else if (typeof t == "object" && !(t instanceof Array)) { + return t.set(this, v, struct); + } + var lengthOverride = null; + var charset = "ASCII"; + var pos = this.position; + if (typeof t == 'string' && /:/.test(t)) { + tp = t.split(":"); + t = tp[0]; + lengthOverride = parseInt(tp[1]); + } + if (typeof t == 'string' && /,/.test(t)) { + tp = t.split(","); + t = tp[0]; + charset = parseInt(tp[1]); + } + switch (t) { + case 'uint8': + this.writeUint8(v); + break; + case 'int8': + this.writeInt8(v); + break; + case 'uint16': + this.writeUint16(v, this.endianness); + break; + case 'int16': + this.writeInt16(v, this.endianness); + break; + case 'uint32': + this.writeUint32(v, this.endianness); + break; + case 'int32': + this.writeInt32(v, this.endianness); + break; + case 'float32': + this.writeFloat32(v, this.endianness); + break; + case 'float64': + this.writeFloat64(v, this.endianness); + break; + case 'uint16be': + this.writeUint16(v, DataStream.BIG_ENDIAN); + break; + case 'int16be': + this.writeInt16(v, DataStream.BIG_ENDIAN); + break; + case 'uint32be': + this.writeUint32(v, DataStream.BIG_ENDIAN); + break; + case 'int32be': + this.writeInt32(v, DataStream.BIG_ENDIAN); + break; + case 'float32be': + this.writeFloat32(v, DataStream.BIG_ENDIAN); + break; + case 'float64be': + this.writeFloat64(v, DataStream.BIG_ENDIAN); + break; + case 'uint16le': + this.writeUint16(v, DataStream.LITTLE_ENDIAN); + break; + case 'int16le': + this.writeInt16(v, DataStream.LITTLE_ENDIAN); + break; + case 'uint32le': + this.writeUint32(v, DataStream.LITTLE_ENDIAN); + break; + case 'int32le': + this.writeInt32(v, DataStream.LITTLE_ENDIAN); + break; + case 'float32le': + this.writeFloat32(v, DataStream.LITTLE_ENDIAN); + break; + case 'float64le': + this.writeFloat64(v, DataStream.LITTLE_ENDIAN); + break; + case 'cstring': + this.writeCString(v, lengthOverride); + break; + case 'string': + this.writeString(v, charset, lengthOverride); + break; + case 'u16string': + this.writeUCS2String(v, this.endianness, lengthOverride); + break; + case 'u16stringle': + this.writeUCS2String(v, DataStream.LITTLE_ENDIAN, lengthOverride); + break; + case 'u16stringbe': + this.writeUCS2String(v, DataStream.BIG_ENDIAN, lengthOverride); + break; + default: + if (t.length == 3) { + var ta = t[1]; + for (var i = 0; i < v.length; i++) { + this.writeType(ta, v[i]); + } + break; + } else { + this.writeStruct(t, v); + break; + } + } + if (lengthOverride != null) { + this.position = pos; + this._realloc(lengthOverride); + this.position = pos + lengthOverride; + } + }; + DataStream.prototype.writeUint64 = function (v) { + var h = Math.floor(v / MAX_SIZE); + this.writeUint32(h); + this.writeUint32(v & 0xFFFFFFFF); + }; + DataStream.prototype.writeUint24 = function (v) { + this.writeUint8((v & 0x00FF0000) >> 16); + this.writeUint8((v & 0x0000FF00) >> 8); + this.writeUint8(v & 0x000000FF); + }; + DataStream.prototype.adjustUint32 = function (position, value) { + var pos = this.position; + this.seek(position); + this.writeUint32(value); + this.seek(pos); + }; + // file:src/DataStream-map.js + /** + Maps an Int32Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Int32Array to the DataStream backing buffer. + */ + DataStream.prototype.mapInt32Array = function (length, e) { + this._realloc(length * 4); + var arr = new Int32Array(this._buffer, this.byteOffset + this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 4; + return arr; + }; + + /** + Maps an Int16Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Int16Array to the DataStream backing buffer. + */ + DataStream.prototype.mapInt16Array = function (length, e) { + this._realloc(length * 2); + var arr = new Int16Array(this._buffer, this.byteOffset + this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 2; + return arr; + }; + + /** + Maps an Int8Array into the DataStream buffer. + Nice for quickly reading in data. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Int8Array to the DataStream backing buffer. + */ + DataStream.prototype.mapInt8Array = function (length) { + this._realloc(length * 1); + var arr = new Int8Array(this._buffer, this.byteOffset + this.position, length); + this.position += length * 1; + return arr; + }; + + /** + Maps a Uint32Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Uint32Array to the DataStream backing buffer. + */ + DataStream.prototype.mapUint32Array = function (length, e) { + this._realloc(length * 4); + var arr = new Uint32Array(this._buffer, this.byteOffset + this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 4; + return arr; + }; + + /** + Maps a Uint16Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Uint16Array to the DataStream backing buffer. + */ + DataStream.prototype.mapUint16Array = function (length, e) { + this._realloc(length * 2); + var arr = new Uint16Array(this._buffer, this.byteOffset + this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 2; + return arr; + }; + + /** + Maps a Float64Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Float64Array to the DataStream backing buffer. + */ + DataStream.prototype.mapFloat64Array = function (length, e) { + this._realloc(length * 8); + var arr = new Float64Array(this._buffer, this.byteOffset + this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 8; + return arr; + }; + + /** + Maps a Float32Array into the DataStream buffer, swizzling it to native + endianness in-place. The current offset from the start of the buffer needs to + be a multiple of element size, just like with typed array views. + Nice for quickly reading in data. Warning: potentially modifies the buffer + contents. + @param {number} length Number of elements to map. + @param {?boolean} e Endianness of the data to read. + @return {Object} Float32Array to the DataStream backing buffer. + */ + DataStream.prototype.mapFloat32Array = function (length, e) { + this._realloc(length * 4); + var arr = new Float32Array(this._buffer, this.byteOffset + this.position, length); + DataStream.arrayToNative(arr, e == null ? this.endianness : e); + this.position += length * 4; + return arr; + }; + // file:src/buffer.js + /** + * MultiBufferStream is a class that acts as a SimpleStream for parsing + * It holds several, possibly non-contiguous ArrayBuffer objects, each with a fileStart property + * containing the offset for the buffer data in an original/virtual file + * + * It inherits also from DataStream for all read/write/alloc operations + */ + + /** + * Constructor + */ + var MultiBufferStream = function (buffer) { + /* List of ArrayBuffers, with a fileStart property, sorted in fileStart order and non overlapping */ + this.buffers = []; + this.bufferIndex = -1; + if (buffer) { + this.insertBuffer(buffer); + this.bufferIndex = 0; + } + }; + MultiBufferStream.prototype = new DataStream(new ArrayBuffer(), 0, DataStream.BIG_ENDIAN); + + /************************************************************************************ + Methods for the managnement of the buffers (insertion, removal, concatenation, ...) + ***********************************************************************************/ + + MultiBufferStream.prototype.initialized = function () { + var firstBuffer; + if (this.bufferIndex > -1) { + return true; + } else if (this.buffers.length > 0) { + firstBuffer = this.buffers[0]; + if (firstBuffer.fileStart === 0) { + this.buffer = firstBuffer; + this.bufferIndex = 0; + Log.debug("MultiBufferStream", "Stream ready for parsing"); + return true; + } else { + Log.warn("MultiBufferStream", "The first buffer should have a fileStart of 0"); + this.logBufferLevel(); + return false; + } + } else { + Log.warn("MultiBufferStream", "No buffer to start parsing from"); + this.logBufferLevel(); + return false; + } + }; + + /** + * helper functions to concatenate two ArrayBuffer objects + * @param {ArrayBuffer} buffer1 + * @param {ArrayBuffer} buffer2 + * @return {ArrayBuffer} the concatenation of buffer1 and buffer2 in that order + */ + ArrayBuffer.concat = function (buffer1, buffer2) { + Log.debug("ArrayBuffer", "Trying to create a new buffer of size: " + (buffer1.byteLength + buffer2.byteLength)); + var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength); + tmp.set(new Uint8Array(buffer1), 0); + tmp.set(new Uint8Array(buffer2), buffer1.byteLength); + return tmp.buffer; + }; + + /** + * Reduces the size of a given buffer, but taking the part between offset and offset+newlength + * @param {ArrayBuffer} buffer + * @param {Number} offset the start of new buffer + * @param {Number} newLength the length of the new buffer + * @return {ArrayBuffer} the new buffer + */ + MultiBufferStream.prototype.reduceBuffer = function (buffer, offset, newLength) { + var smallB; + smallB = new Uint8Array(newLength); + smallB.set(new Uint8Array(buffer, offset, newLength)); + smallB.buffer.fileStart = buffer.fileStart + offset; + smallB.buffer.usedBytes = 0; + return smallB.buffer; + }; + + /** + * Inserts the new buffer in the sorted list of buffers, + * making sure, it is not overlapping with existing ones (possibly reducing its size). + * if the new buffer overrides/replaces the 0-th buffer (for instance because it is bigger), + * updates the DataStream buffer for parsing + */ + MultiBufferStream.prototype.insertBuffer = function (ab) { + var to_add = true; + /* TODO: improve insertion if many buffers */ + for (var i = 0; i < this.buffers.length; i++) { + var b = this.buffers[i]; + if (ab.fileStart <= b.fileStart) { + /* the insertion position is found */ + if (ab.fileStart === b.fileStart) { + /* The new buffer overlaps with an existing buffer */ + if (ab.byteLength > b.byteLength) { + /* the new buffer is bigger than the existing one + remove the existing buffer and try again to insert + the new buffer to check overlap with the next ones */ + this.buffers.splice(i, 1); + i--; + continue; + } else { + /* the new buffer is smaller than the existing one, just drop it */ + Log.warn("MultiBufferStream", "Buffer (fileStart: " + ab.fileStart + " - Length: " + ab.byteLength + ") already appended, ignoring"); + } + } else { + /* The beginning of the new buffer is not overlapping with an existing buffer + let's check the end of it */ + if (ab.fileStart + ab.byteLength <= b.fileStart) ; else { + /* There is some overlap, cut the new buffer short, and add it*/ + ab = this.reduceBuffer(ab, 0, b.fileStart - ab.fileStart); + } + Log.debug("MultiBufferStream", "Appending new buffer (fileStart: " + ab.fileStart + " - Length: " + ab.byteLength + ")"); + this.buffers.splice(i, 0, ab); + /* if this new buffer is inserted in the first place in the list of the buffer, + and the DataStream is initialized, make it the buffer used for parsing */ + if (i === 0) { + this.buffer = ab; + } + } + to_add = false; + break; + } else if (ab.fileStart < b.fileStart + b.byteLength) { + /* the new buffer overlaps its beginning with the end of the current buffer */ + var offset = b.fileStart + b.byteLength - ab.fileStart; + var newLength = ab.byteLength - offset; + if (newLength > 0) { + /* the new buffer is bigger than the current overlap, drop the overlapping part and try again inserting the remaining buffer */ + ab = this.reduceBuffer(ab, offset, newLength); + } else { + /* the content of the new buffer is entirely contained in the existing buffer, drop it entirely */ + to_add = false; + break; + } + } + } + /* if the buffer has not been added, we can add it at the end */ + if (to_add) { + Log.debug("MultiBufferStream", "Appending new buffer (fileStart: " + ab.fileStart + " - Length: " + ab.byteLength + ")"); + this.buffers.push(ab); + /* if this new buffer is inserted in the first place in the list of the buffer, + and the DataStream is initialized, make it the buffer used for parsing */ + if (i === 0) { + this.buffer = ab; + } + } + }; + + /** + * Displays the status of the buffers (number and used bytes) + * @param {Object} info callback method for display + */ + MultiBufferStream.prototype.logBufferLevel = function (info) { + var i; + var buffer; + var used, total; + var ranges = []; + var range; + var bufferedString = ""; + used = 0; + total = 0; + for (i = 0; i < this.buffers.length; i++) { + buffer = this.buffers[i]; + if (i === 0) { + range = {}; + ranges.push(range); + range.start = buffer.fileStart; + range.end = buffer.fileStart + buffer.byteLength; + bufferedString += "[" + range.start + "-"; + } else if (range.end === buffer.fileStart) { + range.end = buffer.fileStart + buffer.byteLength; + } else { + range = {}; + range.start = buffer.fileStart; + bufferedString += ranges[ranges.length - 1].end - 1 + "], [" + range.start + "-"; + range.end = buffer.fileStart + buffer.byteLength; + ranges.push(range); + } + used += buffer.usedBytes; + total += buffer.byteLength; + } + if (ranges.length > 0) { + bufferedString += range.end - 1 + "]"; + } + var log = info ? Log.info : Log.debug; + if (this.buffers.length === 0) { + log("MultiBufferStream", "No more buffer in memory"); + } else { + log("MultiBufferStream", "" + this.buffers.length + " stored buffer(s) (" + used + "/" + total + " bytes), continuous ranges: " + bufferedString); + } + }; + MultiBufferStream.prototype.cleanBuffers = function () { + var i; + var buffer; + for (i = 0; i < this.buffers.length; i++) { + buffer = this.buffers[i]; + if (buffer.usedBytes === buffer.byteLength) { + Log.debug("MultiBufferStream", "Removing buffer #" + i); + this.buffers.splice(i, 1); + i--; + } + } + }; + MultiBufferStream.prototype.mergeNextBuffer = function () { + var next_buffer; + if (this.bufferIndex + 1 < this.buffers.length) { + next_buffer = this.buffers[this.bufferIndex + 1]; + if (next_buffer.fileStart === this.buffer.fileStart + this.buffer.byteLength) { + var oldLength = this.buffer.byteLength; + var oldUsedBytes = this.buffer.usedBytes; + var oldFileStart = this.buffer.fileStart; + this.buffers[this.bufferIndex] = ArrayBuffer.concat(this.buffer, next_buffer); + this.buffer = this.buffers[this.bufferIndex]; + this.buffers.splice(this.bufferIndex + 1, 1); + this.buffer.usedBytes = oldUsedBytes; /* TODO: should it be += ? */ + this.buffer.fileStart = oldFileStart; + Log.debug("ISOFile", "Concatenating buffer for box parsing (length: " + oldLength + "->" + this.buffer.byteLength + ")"); + return true; + } else { + return false; + } + } else { + return false; + } + }; + + /************************************************************************* + Seek-related functions + *************************************************************************/ + + /** + * Finds the buffer that holds the given file position + * @param {Boolean} fromStart indicates if the search should start from the current buffer (false) + * or from the first buffer (true) + * @param {Number} filePosition position in the file to seek to + * @param {Boolean} markAsUsed indicates if the bytes in between the current position and the seek position + * should be marked as used for garbage collection + * @return {Number} the index of the buffer holding the seeked file position, -1 if not found. + */ + MultiBufferStream.prototype.findPosition = function (fromStart, filePosition, markAsUsed) { + var i; + var abuffer = null; + var index = -1; + + /* find the buffer with the largest position smaller than the given position */ + if (fromStart === true) { + /* the reposition can be in the past, we need to check from the beginning of the list of buffers */ + i = 0; + } else { + i = this.bufferIndex; + } + while (i < this.buffers.length) { + abuffer = this.buffers[i]; + if (abuffer.fileStart <= filePosition) { + index = i; + if (markAsUsed) { + if (abuffer.fileStart + abuffer.byteLength <= filePosition) { + abuffer.usedBytes = abuffer.byteLength; + } else { + abuffer.usedBytes = filePosition - abuffer.fileStart; + } + this.logBufferLevel(); + } + } else { + break; + } + i++; + } + if (index !== -1) { + abuffer = this.buffers[index]; + if (abuffer.fileStart + abuffer.byteLength >= filePosition) { + Log.debug("MultiBufferStream", "Found position in existing buffer #" + index); + return index; + } else { + return -1; + } + } else { + return -1; + } + }; + + /** + * Finds the largest file position contained in a buffer or in the next buffers if they are contiguous (no gap) + * starting from the given buffer index or from the current buffer if the index is not given + * + * @param {Number} inputindex Index of the buffer to start from + * @return {Number} The largest file position found in the buffers + */ + MultiBufferStream.prototype.findEndContiguousBuf = function (inputindex) { + var i; + var currentBuf; + var nextBuf; + var index = inputindex !== undefined ? inputindex : this.bufferIndex; + currentBuf = this.buffers[index]; + /* find the end of the contiguous range of data */ + if (this.buffers.length > index + 1) { + for (i = index + 1; i < this.buffers.length; i++) { + nextBuf = this.buffers[i]; + if (nextBuf.fileStart === currentBuf.fileStart + currentBuf.byteLength) { + currentBuf = nextBuf; + } else { + break; + } + } + } + /* return the position of last byte in the file that we have */ + return currentBuf.fileStart + currentBuf.byteLength; + }; + + /** + * Returns the largest file position contained in the buffers, larger than the given position + * @param {Number} pos the file position to start from + * @return {Number} the largest position in the current buffer or in the buffer and the next contiguous + * buffer that holds the given position + */ + MultiBufferStream.prototype.getEndFilePositionAfter = function (pos) { + var index = this.findPosition(true, pos, false); + if (index !== -1) { + return this.findEndContiguousBuf(index); + } else { + return pos; + } + }; + + /************************************************************************* + Garbage collection related functions + *************************************************************************/ + + /** + * Marks a given number of bytes as used in the current buffer for garbage collection + * @param {Number} nbBytes + */ + MultiBufferStream.prototype.addUsedBytes = function (nbBytes) { + this.buffer.usedBytes += nbBytes; + this.logBufferLevel(); + }; + + /** + * Marks the entire current buffer as used, ready for garbage collection + */ + MultiBufferStream.prototype.setAllUsedBytes = function () { + this.buffer.usedBytes = this.buffer.byteLength; + this.logBufferLevel(); + }; + + /************************************************************************* + Common API between MultiBufferStream and SimpleStream + *************************************************************************/ + + /** + * Tries to seek to a given file position + * if possible, repositions the parsing from there and returns true + * if not possible, does not change anything and returns false + * @param {Number} filePosition position in the file to seek to + * @param {Boolean} fromStart indicates if the search should start from the current buffer (false) + * or from the first buffer (true) + * @param {Boolean} markAsUsed indicates if the bytes in between the current position and the seek position + * should be marked as used for garbage collection + * @return {Boolean} true if the seek succeeded, false otherwise + */ + MultiBufferStream.prototype.seek = function (filePosition, fromStart, markAsUsed) { + var index; + index = this.findPosition(fromStart, filePosition, markAsUsed); + if (index !== -1) { + this.buffer = this.buffers[index]; + this.bufferIndex = index; + this.position = filePosition - this.buffer.fileStart; + Log.debug("MultiBufferStream", "Repositioning parser at buffer position: " + this.position); + return true; + } else { + Log.debug("MultiBufferStream", "Position " + filePosition + " not found in buffered data"); + return false; + } + }; + + /** + * Returns the current position in the file + * @return {Number} the position in the file + */ + MultiBufferStream.prototype.getPosition = function () { + if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null) { + throw "Error accessing position in the MultiBufferStream"; + } + return this.buffers[this.bufferIndex].fileStart + this.position; + }; + + /** + * Returns the length of the current buffer + * @return {Number} the length of the current buffer + */ + MultiBufferStream.prototype.getLength = function () { + return this.byteLength; + }; + MultiBufferStream.prototype.getEndPosition = function () { + if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null) { + throw "Error accessing position in the MultiBufferStream"; + } + return this.buffers[this.bufferIndex].fileStart + this.byteLength; + }; + { + exports.MultiBufferStream = MultiBufferStream; + } // file:src/descriptor.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var MPEG4DescriptorParser = function () { + var ES_DescrTag = 0x03; + var DecoderConfigDescrTag = 0x04; + var DecSpecificInfoTag = 0x05; + var SLConfigDescrTag = 0x06; + var descTagToName = []; + descTagToName[ES_DescrTag] = "ES_Descriptor"; + descTagToName[DecoderConfigDescrTag] = "DecoderConfigDescriptor"; + descTagToName[DecSpecificInfoTag] = "DecoderSpecificInfo"; + descTagToName[SLConfigDescrTag] = "SLConfigDescriptor"; + this.getDescriptorName = function (tag) { + return descTagToName[tag]; + }; + var that = this; + var classes = {}; + this.parseOneDescriptor = function (stream) { + var size = 0; + var tag; + var desc; + var byteRead; + tag = stream.readUint8(); + byteRead = stream.readUint8(); + while (byteRead & 0x80) { + size = (size << 7) + (byteRead & 0x7F); + byteRead = stream.readUint8(); + } + size = (size << 7) + (byteRead & 0x7F); + Log.debug("MPEG4DescriptorParser", "Found " + (descTagToName[tag] || "Descriptor " + tag) + ", size " + size + " at position " + stream.getPosition()); + if (descTagToName[tag]) { + desc = new classes[descTagToName[tag]](size); + } else { + desc = new classes.Descriptor(size); + } + desc.parse(stream); + return desc; + }; + classes.Descriptor = function (_tag, _size) { + this.tag = _tag; + this.size = _size; + this.descs = []; + }; + classes.Descriptor.prototype.parse = function (stream) { + this.data = stream.readUint8Array(this.size); + }; + classes.Descriptor.prototype.findDescriptor = function (tag) { + for (var i = 0; i < this.descs.length; i++) { + if (this.descs[i].tag == tag) { + return this.descs[i]; + } + } + return null; + }; + classes.Descriptor.prototype.parseRemainingDescriptors = function (stream) { + var start = stream.position; + while (stream.position < start + this.size) { + var desc = that.parseOneDescriptor(stream); + this.descs.push(desc); + } + }; + classes.ES_Descriptor = function (size) { + classes.Descriptor.call(this, ES_DescrTag, size); + }; + classes.ES_Descriptor.prototype = new classes.Descriptor(); + classes.ES_Descriptor.prototype.parse = function (stream) { + this.ES_ID = stream.readUint16(); + this.flags = stream.readUint8(); + this.size -= 3; + if (this.flags & 0x80) { + this.dependsOn_ES_ID = stream.readUint16(); + this.size -= 2; + } else { + this.dependsOn_ES_ID = 0; + } + if (this.flags & 0x40) { + var l = stream.readUint8(); + this.URL = stream.readString(l); + this.size -= l + 1; + } else { + this.URL = ""; + } + if (this.flags & 0x20) { + this.OCR_ES_ID = stream.readUint16(); + this.size -= 2; + } else { + this.OCR_ES_ID = 0; + } + this.parseRemainingDescriptors(stream); + }; + classes.ES_Descriptor.prototype.getOTI = function (stream) { + var dcd = this.findDescriptor(DecoderConfigDescrTag); + if (dcd) { + return dcd.oti; + } else { + return 0; + } + }; + classes.ES_Descriptor.prototype.getAudioConfig = function (stream) { + var dcd = this.findDescriptor(DecoderConfigDescrTag); + if (!dcd) return null; + var dsi = dcd.findDescriptor(DecSpecificInfoTag); + if (dsi && dsi.data) { + var audioObjectType = (dsi.data[0] & 0xF8) >> 3; + if (audioObjectType === 31 && dsi.data.length >= 2) { + audioObjectType = 32 + ((dsi.data[0] & 0x7) << 3) + ((dsi.data[1] & 0xE0) >> 5); + } + return audioObjectType; + } else { + return null; + } + }; + classes.DecoderConfigDescriptor = function (size) { + classes.Descriptor.call(this, DecoderConfigDescrTag, size); + }; + classes.DecoderConfigDescriptor.prototype = new classes.Descriptor(); + classes.DecoderConfigDescriptor.prototype.parse = function (stream) { + this.oti = stream.readUint8(); + this.streamType = stream.readUint8(); + this.upStream = (this.streamType >> 1 & 1) !== 0; + this.streamType = this.streamType >>> 2; + this.bufferSize = stream.readUint24(); + this.maxBitrate = stream.readUint32(); + this.avgBitrate = stream.readUint32(); + this.size -= 13; + this.parseRemainingDescriptors(stream); + }; + classes.DecoderSpecificInfo = function (size) { + classes.Descriptor.call(this, DecSpecificInfoTag, size); + }; + classes.DecoderSpecificInfo.prototype = new classes.Descriptor(); + classes.SLConfigDescriptor = function (size) { + classes.Descriptor.call(this, SLConfigDescrTag, size); + }; + classes.SLConfigDescriptor.prototype = new classes.Descriptor(); + return this; + }; + { + exports.MPEG4DescriptorParser = MPEG4DescriptorParser; + } + // file:src/box.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var BoxParser = { + ERR_INVALID_DATA: -1, + ERR_NOT_ENOUGH_DATA: 0, + OK: 1, + // Boxes to be created with default parsing + BASIC_BOXES: ["mdat", "idat", "free", "skip", "meco", "strk"], + FULL_BOXES: ["hmhd", "nmhd", "iods", "xml ", "bxml", "ipro", "mere"], + CONTAINER_BOXES: [["moov", ["trak", "pssh"]], ["trak"], ["edts"], ["mdia"], ["minf"], ["dinf"], ["stbl", ["sgpd", "sbgp"]], ["mvex", ["trex"]], ["moof", ["traf"]], ["traf", ["trun", "sgpd", "sbgp"]], ["vttc"], ["tref"], ["iref"], ["mfra", ["tfra"]], ["meco"], ["hnti"], ["hinf"], ["strk"], ["strd"], ["sinf"], ["rinf"], ["schi"], ["trgr"], ["udta", ["kind"]], ["iprp", ["ipma"]], ["ipco"], ["grpl"], ["j2kH"], ["etyp", ["tyco"]]], + // Boxes effectively created + boxCodes: [], + fullBoxCodes: [], + containerBoxCodes: [], + sampleEntryCodes: {}, + sampleGroupEntryCodes: [], + trackGroupTypes: [], + UUIDBoxes: {}, + UUIDs: [], + initialize: function () { + BoxParser.FullBox.prototype = new BoxParser.Box(); + BoxParser.ContainerBox.prototype = new BoxParser.Box(); + BoxParser.SampleEntry.prototype = new BoxParser.Box(); + BoxParser.TrackGroupTypeBox.prototype = new BoxParser.FullBox(); + + /* creating constructors for simple boxes */ + BoxParser.BASIC_BOXES.forEach(function (type) { + BoxParser.createBoxCtor(type); + }); + BoxParser.FULL_BOXES.forEach(function (type) { + BoxParser.createFullBoxCtor(type); + }); + BoxParser.CONTAINER_BOXES.forEach(function (types) { + BoxParser.createContainerBoxCtor(types[0], null, types[1]); + }); + }, + Box: function (_type, _size, _uuid) { + this.type = _type; + this.size = _size; + this.uuid = _uuid; + }, + FullBox: function (type, size, uuid) { + BoxParser.Box.call(this, type, size, uuid); + this.flags = 0; + this.version = 0; + }, + ContainerBox: function (type, size, uuid) { + BoxParser.Box.call(this, type, size, uuid); + this.boxes = []; + }, + SampleEntry: function (type, size, hdr_size, start) { + BoxParser.ContainerBox.call(this, type, size); + this.hdr_size = hdr_size; + this.start = start; + }, + SampleGroupEntry: function (type) { + this.grouping_type = type; + }, + TrackGroupTypeBox: function (type, size) { + BoxParser.FullBox.call(this, type, size); + }, + createBoxCtor: function (type, parseMethod) { + BoxParser.boxCodes.push(type); + BoxParser[type + "Box"] = function (size) { + BoxParser.Box.call(this, type, size); + }; + BoxParser[type + "Box"].prototype = new BoxParser.Box(); + if (parseMethod) BoxParser[type + "Box"].prototype.parse = parseMethod; + }, + createFullBoxCtor: function (type, parseMethod) { + //BoxParser.fullBoxCodes.push(type); + BoxParser[type + "Box"] = function (size) { + BoxParser.FullBox.call(this, type, size); + }; + BoxParser[type + "Box"].prototype = new BoxParser.FullBox(); + BoxParser[type + "Box"].prototype.parse = function (stream) { + this.parseFullHeader(stream); + if (parseMethod) { + parseMethod.call(this, stream); + } + }; + }, + addSubBoxArrays: function (subBoxNames) { + if (subBoxNames) { + this.subBoxNames = subBoxNames; + var nbSubBoxes = subBoxNames.length; + for (var k = 0; k < nbSubBoxes; k++) { + this[subBoxNames[k] + "s"] = []; + } + } + }, + createContainerBoxCtor: function (type, parseMethod, subBoxNames) { + //BoxParser.containerBoxCodes.push(type); + BoxParser[type + "Box"] = function (size) { + BoxParser.ContainerBox.call(this, type, size); + BoxParser.addSubBoxArrays.call(this, subBoxNames); + }; + BoxParser[type + "Box"].prototype = new BoxParser.ContainerBox(); + if (parseMethod) BoxParser[type + "Box"].prototype.parse = parseMethod; + }, + createMediaSampleEntryCtor: function (mediaType, parseMethod, subBoxNames) { + BoxParser.sampleEntryCodes[mediaType] = []; + BoxParser[mediaType + "SampleEntry"] = function (type, size) { + BoxParser.SampleEntry.call(this, type, size); + BoxParser.addSubBoxArrays.call(this, subBoxNames); + }; + BoxParser[mediaType + "SampleEntry"].prototype = new BoxParser.SampleEntry(); + if (parseMethod) BoxParser[mediaType + "SampleEntry"].prototype.parse = parseMethod; + }, + createSampleEntryCtor: function (mediaType, type, parseMethod, subBoxNames) { + BoxParser.sampleEntryCodes[mediaType].push(type); + BoxParser[type + "SampleEntry"] = function (size) { + BoxParser[mediaType + "SampleEntry"].call(this, type, size); + BoxParser.addSubBoxArrays.call(this, subBoxNames); + }; + BoxParser[type + "SampleEntry"].prototype = new BoxParser[mediaType + "SampleEntry"](); + if (parseMethod) BoxParser[type + "SampleEntry"].prototype.parse = parseMethod; + }, + createEncryptedSampleEntryCtor: function (mediaType, type, parseMethod) { + BoxParser.createSampleEntryCtor.call(this, mediaType, type, parseMethod, ["sinf"]); + }, + createSampleGroupCtor: function (type, parseMethod) { + //BoxParser.sampleGroupEntryCodes.push(type); + BoxParser[type + "SampleGroupEntry"] = function (size) { + BoxParser.SampleGroupEntry.call(this, type, size); + }; + BoxParser[type + "SampleGroupEntry"].prototype = new BoxParser.SampleGroupEntry(); + if (parseMethod) BoxParser[type + "SampleGroupEntry"].prototype.parse = parseMethod; + }, + createTrackGroupCtor: function (type, parseMethod) { + //BoxParser.trackGroupTypes.push(type); + BoxParser[type + "TrackGroupTypeBox"] = function (size) { + BoxParser.TrackGroupTypeBox.call(this, type, size); + }; + BoxParser[type + "TrackGroupTypeBox"].prototype = new BoxParser.TrackGroupTypeBox(); + if (parseMethod) BoxParser[type + "TrackGroupTypeBox"].prototype.parse = parseMethod; + }, + createUUIDBox: function (uuid, isFullBox, isContainerBox, parseMethod) { + BoxParser.UUIDs.push(uuid); + BoxParser.UUIDBoxes[uuid] = function (size) { + if (isFullBox) { + BoxParser.FullBox.call(this, "uuid", size, uuid); + } else { + if (isContainerBox) { + BoxParser.ContainerBox.call(this, "uuid", size, uuid); + } else { + BoxParser.Box.call(this, "uuid", size, uuid); + } + } + }; + BoxParser.UUIDBoxes[uuid].prototype = isFullBox ? new BoxParser.FullBox() : isContainerBox ? new BoxParser.ContainerBox() : new BoxParser.Box(); + if (parseMethod) { + if (isFullBox) { + BoxParser.UUIDBoxes[uuid].prototype.parse = function (stream) { + this.parseFullHeader(stream); + if (parseMethod) { + parseMethod.call(this, stream); + } + }; + } else { + BoxParser.UUIDBoxes[uuid].prototype.parse = parseMethod; + } + } + } + }; + BoxParser.initialize(); + BoxParser.TKHD_FLAG_ENABLED = 0x000001; + BoxParser.TKHD_FLAG_IN_MOVIE = 0x000002; + BoxParser.TKHD_FLAG_IN_PREVIEW = 0x000004; + BoxParser.TFHD_FLAG_BASE_DATA_OFFSET = 0x01; + BoxParser.TFHD_FLAG_SAMPLE_DESC = 0x02; + BoxParser.TFHD_FLAG_SAMPLE_DUR = 0x08; + BoxParser.TFHD_FLAG_SAMPLE_SIZE = 0x10; + BoxParser.TFHD_FLAG_SAMPLE_FLAGS = 0x20; + BoxParser.TFHD_FLAG_DUR_EMPTY = 0x10000; + BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF = 0x20000; + BoxParser.TRUN_FLAGS_DATA_OFFSET = 0x01; + BoxParser.TRUN_FLAGS_FIRST_FLAG = 0x04; + BoxParser.TRUN_FLAGS_DURATION = 0x100; + BoxParser.TRUN_FLAGS_SIZE = 0x200; + BoxParser.TRUN_FLAGS_FLAGS = 0x400; + BoxParser.TRUN_FLAGS_CTS_OFFSET = 0x800; + BoxParser.Box.prototype.add = function (name) { + return this.addBox(new BoxParser[name + "Box"]()); + }; + BoxParser.Box.prototype.addBox = function (box) { + this.boxes.push(box); + if (this[box.type + "s"]) { + this[box.type + "s"].push(box); + } else { + this[box.type] = box; + } + return box; + }; + BoxParser.Box.prototype.set = function (prop, value) { + this[prop] = value; + return this; + }; + BoxParser.Box.prototype.addEntry = function (value, _prop) { + var prop = _prop || "entries"; + if (!this[prop]) { + this[prop] = []; + } + this[prop].push(value); + return this; + }; + { + exports.BoxParser = BoxParser; + } + // file:src/box-parse.js + /* + * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + BoxParser.parseUUID = function (stream) { + return BoxParser.parseHex16(stream); + }; + BoxParser.parseHex16 = function (stream) { + var hex16 = ""; + for (var i = 0; i < 16; i++) { + var hex = stream.readUint8().toString(16); + hex16 += hex.length === 1 ? "0" + hex : hex; + } + return hex16; + }; + BoxParser.parseOneBox = function (stream, headerOnly, parentSize) { + var box; + var start = stream.getPosition(); + var hdr_size = 0; + var diff; + var uuid; + if (stream.getEndPosition() - start < 8) { + Log.debug("BoxParser", "Not enough data in stream to parse the type and size of the box"); + return { + code: BoxParser.ERR_NOT_ENOUGH_DATA + }; + } + if (parentSize && parentSize < 8) { + Log.debug("BoxParser", "Not enough bytes left in the parent box to parse a new box"); + return { + code: BoxParser.ERR_NOT_ENOUGH_DATA + }; + } + var size = stream.readUint32(); + var type = stream.readString(4); + var box_type = type; + Log.debug("BoxParser", "Found box of type '" + type + "' and size " + size + " at position " + start); + hdr_size = 8; + if (type == "uuid") { + if (stream.getEndPosition() - stream.getPosition() < 16 || parentSize - hdr_size < 16) { + stream.seek(start); + Log.debug("BoxParser", "Not enough bytes left in the parent box to parse a UUID box"); + return { + code: BoxParser.ERR_NOT_ENOUGH_DATA + }; + } + uuid = BoxParser.parseUUID(stream); + hdr_size += 16; + box_type = uuid; + } + if (size == 1) { + if (stream.getEndPosition() - stream.getPosition() < 8 || parentSize && parentSize - hdr_size < 8) { + stream.seek(start); + Log.warn("BoxParser", "Not enough data in stream to parse the extended size of the \"" + type + "\" box"); + return { + code: BoxParser.ERR_NOT_ENOUGH_DATA + }; + } + size = stream.readUint64(); + hdr_size += 8; + } else if (size === 0) { + /* box extends till the end of file or invalid file */ + if (parentSize) { + size = parentSize; + } else { + /* box extends till the end of file */ + if (type !== "mdat") { + Log.error("BoxParser", "Unlimited box size not supported for type: '" + type + "'"); + box = new BoxParser.Box(type, size); + return { + code: BoxParser.OK, + box: box, + size: box.size + }; + } + } + } + if (size !== 0 && size < hdr_size) { + Log.error("BoxParser", "Box of type " + type + " has an invalid size " + size + " (too small to be a box)"); + return { + code: BoxParser.ERR_NOT_ENOUGH_DATA, + type: type, + size: size, + hdr_size: hdr_size, + start: start + }; + } + if (size !== 0 && parentSize && size > parentSize) { + Log.error("BoxParser", "Box of type '" + type + "' has a size " + size + " greater than its container size " + parentSize); + return { + code: BoxParser.ERR_NOT_ENOUGH_DATA, + type: type, + size: size, + hdr_size: hdr_size, + start: start + }; + } + if (size !== 0 && start + size > stream.getEndPosition()) { + stream.seek(start); + Log.info("BoxParser", "Not enough data in stream to parse the entire '" + type + "' box"); + return { + code: BoxParser.ERR_NOT_ENOUGH_DATA, + type: type, + size: size, + hdr_size: hdr_size, + start: start + }; + } + if (headerOnly) { + return { + code: BoxParser.OK, + type: type, + size: size, + hdr_size: hdr_size, + start: start + }; + } else { + if (BoxParser[type + "Box"]) { + box = new BoxParser[type + "Box"](size); + } else { + if (type !== "uuid") { + Log.warn("BoxParser", "Unknown box type: '" + type + "'"); + box = new BoxParser.Box(type, size); + box.has_unparsed_data = true; + } else { + if (BoxParser.UUIDBoxes[uuid]) { + box = new BoxParser.UUIDBoxes[uuid](size); + } else { + Log.warn("BoxParser", "Unknown uuid type: '" + uuid + "'"); + box = new BoxParser.Box(type, size); + box.uuid = uuid; + box.has_unparsed_data = true; + } + } + } + } + box.hdr_size = hdr_size; + /* recording the position of the box in the input stream */ + box.start = start; + if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { + Log.info("BoxParser", "'" + box_type + "' box writing not yet implemented, keeping unparsed data in memory for later write"); + box.parseDataAndRewind(stream); + } + box.parse(stream); + diff = stream.getPosition() - (box.start + box.size); + if (diff < 0) { + Log.warn("BoxParser", "Parsing of box '" + box_type + "' did not read the entire indicated box data size (missing " + -diff + " bytes), seeking forward"); + stream.seek(box.start + box.size); + } else if (diff > 0) { + Log.error("BoxParser", "Parsing of box '" + box_type + "' read " + diff + " more bytes than the indicated box data size, seeking backwards"); + if (box.size !== 0) stream.seek(box.start + box.size); + } + return { + code: BoxParser.OK, + box: box, + size: box.size + }; + }; + BoxParser.Box.prototype.parse = function (stream) { + if (this.type != "mdat") { + this.data = stream.readUint8Array(this.size - this.hdr_size); + } else { + if (this.size === 0) { + stream.seek(stream.getEndPosition()); + } else { + stream.seek(this.start + this.size); + } + } + }; + + /* Used to parse a box without consuming its data, to allow detailled parsing + Useful for boxes for which a write method is not yet implemented */ + BoxParser.Box.prototype.parseDataAndRewind = function (stream) { + this.data = stream.readUint8Array(this.size - this.hdr_size); + // rewinding + stream.position -= this.size - this.hdr_size; + }; + BoxParser.FullBox.prototype.parseDataAndRewind = function (stream) { + this.parseFullHeader(stream); + this.data = stream.readUint8Array(this.size - this.hdr_size); + // restore the header size as if the full header had not been parsed + this.hdr_size -= 4; + // rewinding + stream.position -= this.size - this.hdr_size; + }; + BoxParser.FullBox.prototype.parseFullHeader = function (stream) { + this.version = stream.readUint8(); + this.flags = stream.readUint24(); + this.hdr_size += 4; + }; + BoxParser.FullBox.prototype.parse = function (stream) { + this.parseFullHeader(stream); + this.data = stream.readUint8Array(this.size - this.hdr_size); + }; + BoxParser.ContainerBox.prototype.parse = function (stream) { + var ret; + var box; + while (stream.getPosition() < this.start + this.size) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = ret.box; + /* store the box in the 'boxes' array to preserve box order (for offset) but also store box in a property for more direct access */ + this.boxes.push(box); + if (this.subBoxNames && this.subBoxNames.indexOf(box.type) != -1) { + this[this.subBoxNames[this.subBoxNames.indexOf(box.type)] + "s"].push(box); + } else { + var box_type = box.type !== "uuid" ? box.type : box.uuid; + if (this[box_type]) { + Log.warn("Box of type " + box_type + " already stored in field of this type"); + } else { + this[box_type] = box; + } + } + } else { + return; + } + } + }; + BoxParser.Box.prototype.parseLanguage = function (stream) { + this.language = stream.readUint16(); + var chars = []; + chars[0] = this.language >> 10 & 0x1F; + chars[1] = this.language >> 5 & 0x1F; + chars[2] = this.language & 0x1F; + this.languageString = String.fromCharCode(chars[0] + 0x60, chars[1] + 0x60, chars[2] + 0x60); + }; + + // file:src/parsing/sampleentries/sampleentry.js + BoxParser.SAMPLE_ENTRY_TYPE_VISUAL = "Visual"; + BoxParser.SAMPLE_ENTRY_TYPE_AUDIO = "Audio"; + BoxParser.SAMPLE_ENTRY_TYPE_HINT = "Hint"; + BoxParser.SAMPLE_ENTRY_TYPE_METADATA = "Metadata"; + BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE = "Subtitle"; + BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM = "System"; + BoxParser.SAMPLE_ENTRY_TYPE_TEXT = "Text"; + BoxParser.SampleEntry.prototype.parseHeader = function (stream) { + stream.readUint8Array(6); + this.data_reference_index = stream.readUint16(); + this.hdr_size += 8; + }; + BoxParser.SampleEntry.prototype.parse = function (stream) { + this.parseHeader(stream); + this.data = stream.readUint8Array(this.size - this.hdr_size); + }; + BoxParser.SampleEntry.prototype.parseDataAndRewind = function (stream) { + this.parseHeader(stream); + this.data = stream.readUint8Array(this.size - this.hdr_size); + // restore the header size as if the sample entry header had not been parsed + this.hdr_size -= 8; + // rewinding + stream.position -= this.size - this.hdr_size; + }; + BoxParser.SampleEntry.prototype.parseFooter = function (stream) { + BoxParser.ContainerBox.prototype.parse.call(this, stream); + }; + + // Base SampleEntry types with default parsing + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_HINT); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_TEXT); + + //Base SampleEntry types for Audio and Video with specific parsing + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, function (stream) { + var compressorname_length; + this.parseHeader(stream); + stream.readUint16(); + stream.readUint16(); + stream.readUint32Array(3); + this.width = stream.readUint16(); + this.height = stream.readUint16(); + this.horizresolution = stream.readUint32(); + this.vertresolution = stream.readUint32(); + stream.readUint32(); + this.frame_count = stream.readUint16(); + compressorname_length = Math.min(31, stream.readUint8()); + this.compressorname = stream.readString(compressorname_length); + if (compressorname_length < 31) { + stream.readString(31 - compressorname_length); + } + this.depth = stream.readUint16(); + stream.readUint16(); + this.parseFooter(stream); + }); + BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, function (stream) { + this.parseHeader(stream); + stream.readUint32Array(2); + this.channel_count = stream.readUint16(); + this.samplesize = stream.readUint16(); + stream.readUint16(); + stream.readUint16(); + this.samplerate = stream.readUint32() / (1 << 16); + this.parseFooter(stream); + }); + + // Sample entries inheriting from Audio and Video + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc2"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc3"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc4"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "av01"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dav1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hvc1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hev1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hvt1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "lhe1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dvh1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dvhe"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvc1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvi1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvs1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvcN"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vp08"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vp09"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avs3"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "j2ki"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "mjp2"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "mjpg"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "uncv"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mp4a"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ac-3"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ac-4"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ec-3"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "Opus"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mha1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mha2"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mhm1"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mhm2"); + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "fLaC"); + + // Encrypted sample entries + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "encv"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "enca"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "encu"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM, "encs"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_TEXT, "enct"); + BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "encm"); + // file:src/parsing/a1lx.js + BoxParser.createBoxCtor("a1lx", function (stream) { + var large_size = stream.readUint8() & 1; + var FieldLength = ((large_size & 1) + 1) * 16; + this.layer_size = []; + for (var i = 0; i < 3; i++) { + if (FieldLength == 16) { + this.layer_size[i] = stream.readUint16(); + } else { + this.layer_size[i] = stream.readUint32(); + } + } + }); // file:src/parsing/a1op.js + BoxParser.createBoxCtor("a1op", function (stream) { + this.op_index = stream.readUint8(); + }); // file:src/parsing/auxC.js + BoxParser.createFullBoxCtor("auxC", function (stream) { + this.aux_type = stream.readCString(); + var aux_subtype_length = this.size - this.hdr_size - (this.aux_type.length + 1); + this.aux_subtype = stream.readUint8Array(aux_subtype_length); + }); // file:src/parsing/av1C.js + BoxParser.createBoxCtor("av1C", function (stream) { + var tmp = stream.readUint8(); + if (tmp >> 7 & 0x1 !== 1) { + Log.error("av1C marker problem"); + return; + } + this.version = tmp & 0x7F; + if (this.version !== 1) { + Log.error("av1C version " + this.version + " not supported"); + return; + } + tmp = stream.readUint8(); + this.seq_profile = tmp >> 5 & 0x7; + this.seq_level_idx_0 = tmp & 0x1F; + tmp = stream.readUint8(); + this.seq_tier_0 = tmp >> 7 & 0x1; + this.high_bitdepth = tmp >> 6 & 0x1; + this.twelve_bit = tmp >> 5 & 0x1; + this.monochrome = tmp >> 4 & 0x1; + this.chroma_subsampling_x = tmp >> 3 & 0x1; + this.chroma_subsampling_y = tmp >> 2 & 0x1; + this.chroma_sample_position = tmp & 0x3; + tmp = stream.readUint8(); + this.reserved_1 = tmp >> 5 & 0x7; + if (this.reserved_1 !== 0) { + Log.error("av1C reserved_1 parsing problem"); + return; + } + this.initial_presentation_delay_present = tmp >> 4 & 0x1; + if (this.initial_presentation_delay_present === 1) { + this.initial_presentation_delay_minus_one = tmp & 0xF; + } else { + this.reserved_2 = tmp & 0xF; + if (this.reserved_2 !== 0) { + Log.error("av1C reserved_2 parsing problem"); + return; + } + } + var configOBUs_length = this.size - this.hdr_size - 4; + this.configOBUs = stream.readUint8Array(configOBUs_length); + }); + + // file:src/parsing/avcC.js + BoxParser.createBoxCtor("avcC", function (stream) { + var i; + var toparse; + this.configurationVersion = stream.readUint8(); + this.AVCProfileIndication = stream.readUint8(); + this.profile_compatibility = stream.readUint8(); + this.AVCLevelIndication = stream.readUint8(); + this.lengthSizeMinusOne = stream.readUint8() & 0x3; + this.nb_SPS_nalus = stream.readUint8() & 0x1F; + toparse = this.size - this.hdr_size - 6; + this.SPS = []; + for (i = 0; i < this.nb_SPS_nalus; i++) { + this.SPS[i] = {}; + this.SPS[i].length = stream.readUint16(); + this.SPS[i].nalu = stream.readUint8Array(this.SPS[i].length); + toparse -= 2 + this.SPS[i].length; + } + this.nb_PPS_nalus = stream.readUint8(); + toparse--; + this.PPS = []; + for (i = 0; i < this.nb_PPS_nalus; i++) { + this.PPS[i] = {}; + this.PPS[i].length = stream.readUint16(); + this.PPS[i].nalu = stream.readUint8Array(this.PPS[i].length); + toparse -= 2 + this.PPS[i].length; + } + if (toparse > 0) { + this.ext = stream.readUint8Array(toparse); + } + }); + + // file:src/parsing/btrt.js + BoxParser.createBoxCtor("btrt", function (stream) { + this.bufferSizeDB = stream.readUint32(); + this.maxBitrate = stream.readUint32(); + this.avgBitrate = stream.readUint32(); + }); + + // file:src/parsing/ccst.js + BoxParser.createFullBoxCtor("ccst", function (stream) { + var flags = stream.readUint8(); + this.all_ref_pics_intra = (flags & 0x80) == 0x80; + this.intra_pred_used = (flags & 0x40) == 0x40; + this.max_ref_per_pic = (flags & 0x3f) >> 2; + stream.readUint24(); + }); + + // file:src/parsing/cdef.js + BoxParser.createBoxCtor("cdef", function (stream) { + var i; + this.channel_count = stream.readUint16(); + this.channel_indexes = []; + this.channel_types = []; + this.channel_associations = []; + for (i = 0; i < this.channel_count; i++) { + this.channel_indexes.push(stream.readUint16()); + this.channel_types.push(stream.readUint16()); + this.channel_associations.push(stream.readUint16()); + } + }); + + // file:src/parsing/clap.js + BoxParser.createBoxCtor("clap", function (stream) { + this.cleanApertureWidthN = stream.readUint32(); + this.cleanApertureWidthD = stream.readUint32(); + this.cleanApertureHeightN = stream.readUint32(); + this.cleanApertureHeightD = stream.readUint32(); + this.horizOffN = stream.readUint32(); + this.horizOffD = stream.readUint32(); + this.vertOffN = stream.readUint32(); + this.vertOffD = stream.readUint32(); + }); // file:src/parsing/clli.js + BoxParser.createBoxCtor("clli", function (stream) { + this.max_content_light_level = stream.readUint16(); + this.max_pic_average_light_level = stream.readUint16(); + }); + + // file:src/parsing/cmex.js + BoxParser.createFullBoxCtor("cmex", function (stream) { + if (this.flags & 0x1) { + this.pos_x = stream.readInt32(); + } + if (this.flags & 0x2) { + this.pos_y = stream.readInt32(); + } + if (this.flags & 0x4) { + this.pos_z = stream.readInt32(); + } + if (this.flags & 0x8) { + if (this.version == 0) { + if (this.flags & 0x10) { + this.quat_x = stream.readInt32(); + this.quat_y = stream.readInt32(); + this.quat_z = stream.readInt32(); + } else { + this.quat_x = stream.readInt16(); + this.quat_y = stream.readInt16(); + this.quat_z = stream.readInt16(); + } + } else if (this.version == 1) ; + } + if (this.flags & 0x20) { + this.id = stream.readUint32(); + } + }); + // file:src/parsing/cmin.js + BoxParser.createFullBoxCtor("cmin", function (stream) { + this.focal_length_x = stream.readInt32(); + this.principal_point_x = stream.readInt32(); + this.principal_point_y = stream.readInt32(); + if (this.flags & 0x1) { + this.focal_length_y = stream.readInt32(); + this.skew_factor = stream.readInt32(); + } + }); // file:src/parsing/cmpd.js + BoxParser.createBoxCtor("cmpd", function (stream) { + this.component_count = stream.readUint32(); + this.component_types = []; + this.component_type_urls = []; + for (i = 0; i < this.component_count; i++) { + var component_type = stream.readUint16(); + this.component_types.push(component_type); + if (component_type >= 0x8000) { + this.component_type_urls.push(stream.readCString()); + } + } + }); // file:src/parsing/co64.js + BoxParser.createFullBoxCtor("co64", function (stream) { + var entry_count; + var i; + entry_count = stream.readUint32(); + this.chunk_offsets = []; + if (this.version === 0) { + for (i = 0; i < entry_count; i++) { + this.chunk_offsets.push(stream.readUint64()); + } + } + }); + + // file:src/parsing/CoLL.js + BoxParser.createFullBoxCtor("CoLL", function (stream) { + this.maxCLL = stream.readUint16(); + this.maxFALL = stream.readUint16(); + }); + + // file:src/parsing/colr.js + BoxParser.createBoxCtor("colr", function (stream) { + this.colour_type = stream.readString(4); + if (this.colour_type === 'nclx') { + this.colour_primaries = stream.readUint16(); + this.transfer_characteristics = stream.readUint16(); + this.matrix_coefficients = stream.readUint16(); + var tmp = stream.readUint8(); + this.full_range_flag = tmp >> 7; + } else if (this.colour_type === 'rICC') { + this.ICC_profile = stream.readUint8Array(this.size - 4); + } else if (this.colour_type === 'prof') { + this.ICC_profile = stream.readUint8Array(this.size - 4); + } + }); // file:src/parsing/cprt.js + BoxParser.createFullBoxCtor("cprt", function (stream) { + this.parseLanguage(stream); + this.notice = stream.readCString(); + }); + + // file:src/parsing/cslg.js + BoxParser.createFullBoxCtor("cslg", function (stream) { + if (this.version === 0) { + this.compositionToDTSShift = stream.readInt32(); /* signed */ + this.leastDecodeToDisplayDelta = stream.readInt32(); /* signed */ + this.greatestDecodeToDisplayDelta = stream.readInt32(); /* signed */ + this.compositionStartTime = stream.readInt32(); /* signed */ + this.compositionEndTime = stream.readInt32(); /* signed */ + } + }); + + // file:src/parsing/ctts.js + BoxParser.createFullBoxCtor("ctts", function (stream) { + var entry_count; + var i; + entry_count = stream.readUint32(); + this.sample_counts = []; + this.sample_offsets = []; + if (this.version === 0) { + for (i = 0; i < entry_count; i++) { + this.sample_counts.push(stream.readUint32()); + /* some files are buggy and declare version=0 while using signed offsets. + The likelyhood of using the most significant bit in a 32-bits time offset is very low, + so using signed value here as well */ + var value = stream.readInt32(); + if (value < 0) { + Log.warn("BoxParser", "ctts box uses negative values without using version 1"); + } + this.sample_offsets.push(value); + } + } else if (this.version == 1) { + for (i = 0; i < entry_count; i++) { + this.sample_counts.push(stream.readUint32()); + this.sample_offsets.push(stream.readInt32()); /* signed */ + } + } + }); + + // file:src/parsing/dac3.js + BoxParser.createBoxCtor("dac3", function (stream) { + var tmp_byte1 = stream.readUint8(); + var tmp_byte2 = stream.readUint8(); + var tmp_byte3 = stream.readUint8(); + this.fscod = tmp_byte1 >> 6; + this.bsid = tmp_byte1 >> 1 & 0x1F; + this.bsmod = (tmp_byte1 & 0x1) << 2 | tmp_byte2 >> 6 & 0x3; + this.acmod = tmp_byte2 >> 3 & 0x7; + this.lfeon = tmp_byte2 >> 2 & 0x1; + this.bit_rate_code = tmp_byte2 & 0x3 | tmp_byte3 >> 5 & 0x7; + }); + + // file:src/parsing/dec3.js + BoxParser.createBoxCtor("dec3", function (stream) { + var tmp_16 = stream.readUint16(); + this.data_rate = tmp_16 >> 3; + this.num_ind_sub = tmp_16 & 0x7; + this.ind_subs = []; + for (var i = 0; i < this.num_ind_sub + 1; i++) { + var ind_sub = {}; + this.ind_subs.push(ind_sub); + var tmp_byte1 = stream.readUint8(); + var tmp_byte2 = stream.readUint8(); + var tmp_byte3 = stream.readUint8(); + ind_sub.fscod = tmp_byte1 >> 6; + ind_sub.bsid = tmp_byte1 >> 1 & 0x1F; + ind_sub.bsmod = (tmp_byte1 & 0x1) << 4 | tmp_byte2 >> 4 & 0xF; + ind_sub.acmod = tmp_byte2 >> 1 & 0x7; + ind_sub.lfeon = tmp_byte2 & 0x1; + ind_sub.num_dep_sub = tmp_byte3 >> 1 & 0xF; + if (ind_sub.num_dep_sub > 0) { + ind_sub.chan_loc = (tmp_byte3 & 0x1) << 8 | stream.readUint8(); + } + } + }); + + // file:src/parsing/dfLa.js + BoxParser.createFullBoxCtor("dfLa", function (stream) { + var BLOCKTYPE_MASK = 0x7F; + var LASTMETADATABLOCKFLAG_MASK = 0x80; + var boxesFound = []; + var knownBlockTypes = ["STREAMINFO", "PADDING", "APPLICATION", "SEEKTABLE", "VORBIS_COMMENT", "CUESHEET", "PICTURE", "RESERVED"]; + + // for (i=0; ; i++) { // to end of box + do { + var flagAndType = stream.readUint8(); + var type = Math.min(flagAndType & BLOCKTYPE_MASK, knownBlockTypes.length - 1); + + // if this is a STREAMINFO block, read the true samplerate since this + // can be different to the AudioSampleEntry samplerate. + if (!type) { + // read past all the other stuff + stream.readUint8Array(13); + + // extract samplerate + this.samplerate = stream.readUint32() >> 12; + + // read to end of STREAMINFO + stream.readUint8Array(20); + } else { + // not interested in other block types so just discard length bytes + stream.readUint8Array(stream.readUint24()); + } + boxesFound.push(knownBlockTypes[type]); + if (!!(flagAndType & LASTMETADATABLOCKFLAG_MASK)) { + break; + } + } while (true); + this.numMetadataBlocks = boxesFound.length + " (" + boxesFound.join(", ") + ")"; + }); + // file:src/parsing/dimm.js + BoxParser.createBoxCtor("dimm", function (stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/dmax.js + BoxParser.createBoxCtor("dmax", function (stream) { + this.time = stream.readUint32(); + }); + + // file:src/parsing/dmed.js + BoxParser.createBoxCtor("dmed", function (stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/dOps.js + BoxParser.createBoxCtor("dOps", function (stream) { + this.Version = stream.readUint8(); + this.OutputChannelCount = stream.readUint8(); + this.PreSkip = stream.readUint16(); + this.InputSampleRate = stream.readUint32(); + this.OutputGain = stream.readInt16(); + this.ChannelMappingFamily = stream.readUint8(); + if (this.ChannelMappingFamily !== 0) { + this.StreamCount = stream.readUint8(); + this.CoupledCount = stream.readUint8(); + this.ChannelMapping = []; + for (var i = 0; i < this.OutputChannelCount; i++) { + this.ChannelMapping[i] = stream.readUint8(); + } + } + }); + + // file:src/parsing/dref.js + BoxParser.createFullBoxCtor("dref", function (stream) { + var ret; + var box; + this.entries = []; + var entry_count = stream.readUint32(); + for (var i = 0; i < entry_count; i++) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = ret.box; + this.entries.push(box); + } else { + return; + } + } + }); + + // file:src/parsing/drep.js + BoxParser.createBoxCtor("drep", function (stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/elng.js + BoxParser.createFullBoxCtor("elng", function (stream) { + this.extended_language = stream.readString(this.size - this.hdr_size); + }); + + // file:src/parsing/elst.js + BoxParser.createFullBoxCtor("elst", function (stream) { + this.entries = []; + var entry_count = stream.readUint32(); + for (var i = 0; i < entry_count; i++) { + var entry = {}; + this.entries.push(entry); + if (this.version === 1) { + entry.segment_duration = stream.readUint64(); + entry.media_time = stream.readInt64(); + } else { + entry.segment_duration = stream.readUint32(); + entry.media_time = stream.readInt32(); + } + entry.media_rate_integer = stream.readInt16(); + entry.media_rate_fraction = stream.readInt16(); + } + }); + + // file:src/parsing/emsg.js + BoxParser.createFullBoxCtor("emsg", function (stream) { + if (this.version == 1) { + this.timescale = stream.readUint32(); + this.presentation_time = stream.readUint64(); + this.event_duration = stream.readUint32(); + this.id = stream.readUint32(); + this.scheme_id_uri = stream.readCString(); + this.value = stream.readCString(); + } else { + this.scheme_id_uri = stream.readCString(); + this.value = stream.readCString(); + this.timescale = stream.readUint32(); + this.presentation_time_delta = stream.readUint32(); + this.event_duration = stream.readUint32(); + this.id = stream.readUint32(); + } + var message_size = this.size - this.hdr_size - (4 * 4 + (this.scheme_id_uri.length + 1) + (this.value.length + 1)); + if (this.version == 1) { + message_size -= 4; + } + this.message_data = stream.readUint8Array(message_size); + }); + + // file:src/parsing/EntityToGroup.js + // ISO/IEC 14496-12:2022 Section 8.18.3 Entity to group box + BoxParser.createEntityToGroupCtor = function (type, parseMethod) { + BoxParser[type + "Box"] = function (size) { + BoxParser.FullBox.call(this, type, size); + }; + BoxParser[type + "Box"].prototype = new BoxParser.FullBox(); + BoxParser[type + "Box"].prototype.parse = function (stream) { + this.parseFullHeader(stream); + if (parseMethod) { + parseMethod.call(this, stream); + } else { + this.group_id = stream.readUint32(); + this.num_entities_in_group = stream.readUint32(); + this.entity_ids = []; + for (i = 0; i < this.num_entities_in_group; i++) { + var entity_id = stream.readUint32(); + this.entity_ids.push(entity_id); + } + } + }; + }; + + // Auto exposure bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.2.1) + BoxParser.createEntityToGroupCtor("aebr"); + + // Flash exposure bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.5.1) + BoxParser.createEntityToGroupCtor("afbr"); + + // Album collection (ISO/IEC 23008-12:2022 Section 6.8.7.1) + BoxParser.createEntityToGroupCtor("albc"); + + // Alternative entity (ISO/IEC 14496-12:2022 Section 8.18.3.1) + BoxParser.createEntityToGroupCtor("altr"); + + // Burst image entity group (ISO/IEC 23008-12:2022 Section 6.8.2.2) + BoxParser.createEntityToGroupCtor("brst"); + + // Depth of field bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.6.1) + BoxParser.createEntityToGroupCtor("dobr"); + + // Equivalent entity (ISO/IEC 23008-12:2022 Section 6.8.1.1) + BoxParser.createEntityToGroupCtor("eqiv"); + + // Favourites collection (ISO/IEC 23008-12:2022 Section 6.8.7.2) + BoxParser.createEntityToGroupCtor("favc"); + + // Focus bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.4.1) + BoxParser.createEntityToGroupCtor("fobr"); + + // Audio to image entity group (ISO/IEC 23008-12:2022 Section 6.8.4) + BoxParser.createEntityToGroupCtor("iaug"); + + // Panorama (ISO/IEC 23008-12:2022 Section 6.8.8.1) + BoxParser.createEntityToGroupCtor("pano"); + + // Slideshow (ISO/IEC 23008-12:2022 Section 6.8.9.1) + BoxParser.createEntityToGroupCtor("slid"); + + // Stereo pair (ISO/IEC 23008-12:2022 Section 6.8.5) + BoxParser.createEntityToGroupCtor("ster"); + + // Time-synchronised capture entity group (ISO/IEC 23008-12:2022 Section 6.8.3) + BoxParser.createEntityToGroupCtor("tsyn"); + + // White balance bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.3.1) + BoxParser.createEntityToGroupCtor("wbbr"); + + // Alternative entity (ISO/IEC 23008-12:2022 AMD1 Section 6.8.10) + BoxParser.createEntityToGroupCtor("prgr"); + + // Image Pyramid entity group (ISO/IEC 23008-12:20xx Section 6.8.11) + BoxParser.createEntityToGroupCtor("pymd", function (stream) { + this.group_id = stream.readUint32(); + this.num_entities_in_group = stream.readUint32(); + this.entity_ids = []; + for (var i = 0; i < this.num_entities_in_group; i++) { + var entity_id = stream.readUint32(); + this.entity_ids.push(entity_id); + } + this.tile_size_x = stream.readUint16(); + this.tile_size_y = stream.readUint16(); + this.layer_binning = []; + this.tiles_in_layer_column_minus1 = []; + this.tiles_in_layer_row_minus1 = []; + for (i = 0; i < this.num_entities_in_group; i++) { + this.layer_binning[i] = stream.readUint16(); + this.tiles_in_layer_row_minus1[i] = stream.readUint16(); + this.tiles_in_layer_column_minus1[i] = stream.readUint16(); + } + }); + + // file:src/parsing/esds.js + BoxParser.createFullBoxCtor("esds", function (stream) { + var esd_data = stream.readUint8Array(this.size - this.hdr_size); + if (typeof MPEG4DescriptorParser !== "undefined") { + var esd_parser = new MPEG4DescriptorParser(); + this.esd = esd_parser.parseOneDescriptor(new DataStream(esd_data.buffer, 0, DataStream.BIG_ENDIAN)); + } + }); + + // file:src/parsing/fiel.js + BoxParser.createBoxCtor("fiel", function (stream) { + this.fieldCount = stream.readUint8(); + this.fieldOrdering = stream.readUint8(); + }); + + // file:src/parsing/frma.js + BoxParser.createBoxCtor("frma", function (stream) { + this.data_format = stream.readString(4); + }); + + // file:src/parsing/ftyp.js + BoxParser.createBoxCtor("ftyp", function (stream) { + var toparse = this.size - this.hdr_size; + this.major_brand = stream.readString(4); + this.minor_version = stream.readUint32(); + toparse -= 8; + this.compatible_brands = []; + var i = 0; + while (toparse >= 4) { + this.compatible_brands[i] = stream.readString(4); + toparse -= 4; + i++; + } + }); + + // file:src/parsing/hdlr.js + BoxParser.createFullBoxCtor("hdlr", function (stream) { + if (this.version === 0) { + stream.readUint32(); + this.handler = stream.readString(4); + stream.readUint32Array(3); + this.name = stream.readString(this.size - this.hdr_size - 20); + if (this.name[this.name.length - 1] === '\0') { + this.name = this.name.slice(0, -1); + } + } + }); + + // file:src/parsing/hvcC.js + BoxParser.createBoxCtor("hvcC", function (stream) { + var i, j; + var length; + var tmp_byte; + this.configurationVersion = stream.readUint8(); + tmp_byte = stream.readUint8(); + this.general_profile_space = tmp_byte >> 6; + this.general_tier_flag = (tmp_byte & 0x20) >> 5; + this.general_profile_idc = tmp_byte & 0x1F; + this.general_profile_compatibility = stream.readUint32(); + this.general_constraint_indicator = stream.readUint8Array(6); + this.general_level_idc = stream.readUint8(); + this.min_spatial_segmentation_idc = stream.readUint16() & 0xFFF; + this.parallelismType = stream.readUint8() & 0x3; + this.chroma_format_idc = stream.readUint8() & 0x3; + this.bit_depth_luma_minus8 = stream.readUint8() & 0x7; + this.bit_depth_chroma_minus8 = stream.readUint8() & 0x7; + this.avgFrameRate = stream.readUint16(); + tmp_byte = stream.readUint8(); + this.constantFrameRate = tmp_byte >> 6; + this.numTemporalLayers = (tmp_byte & 0XD) >> 3; + this.temporalIdNested = (tmp_byte & 0X4) >> 2; + this.lengthSizeMinusOne = tmp_byte & 0X3; + this.nalu_arrays = []; + var numOfArrays = stream.readUint8(); + for (i = 0; i < numOfArrays; i++) { + var nalu_array = []; + this.nalu_arrays.push(nalu_array); + tmp_byte = stream.readUint8(); + nalu_array.completeness = (tmp_byte & 0x80) >> 7; + nalu_array.nalu_type = tmp_byte & 0x3F; + var numNalus = stream.readUint16(); + for (j = 0; j < numNalus; j++) { + var nalu = {}; + nalu_array.push(nalu); + length = stream.readUint16(); + nalu.data = stream.readUint8Array(length); + } + } + }); + + // file:src/parsing/iinf.js + BoxParser.createFullBoxCtor("iinf", function (stream) { + var ret; + if (this.version === 0) { + this.entry_count = stream.readUint16(); + } else { + this.entry_count = stream.readUint32(); + } + this.item_infos = []; + for (var i = 0; i < this.entry_count; i++) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + if (ret.box.type !== "infe") { + Log.error("BoxParser", "Expected 'infe' box, got " + ret.box.type); + } + this.item_infos[i] = ret.box; + } else { + return; + } + } + }); + + // file:src/parsing/iloc.js + BoxParser.createFullBoxCtor("iloc", function (stream) { + var byte; + byte = stream.readUint8(); + this.offset_size = byte >> 4 & 0xF; + this.length_size = byte & 0xF; + byte = stream.readUint8(); + this.base_offset_size = byte >> 4 & 0xF; + if (this.version === 1 || this.version === 2) { + this.index_size = byte & 0xF; + } else { + this.index_size = 0; + // reserved = byte & 0xF; + } + this.items = []; + var item_count = 0; + if (this.version < 2) { + item_count = stream.readUint16(); + } else if (this.version === 2) { + item_count = stream.readUint32(); + } else { + throw "version of iloc box not supported"; + } + for (var i = 0; i < item_count; i++) { + var item = {}; + this.items.push(item); + if (this.version < 2) { + item.item_ID = stream.readUint16(); + } else if (this.version === 2) { + item.item_ID = stream.readUint32(); + } else { + throw "version of iloc box not supported"; + } + if (this.version === 1 || this.version === 2) { + item.construction_method = stream.readUint16() & 0xF; + } else { + item.construction_method = 0; + } + item.data_reference_index = stream.readUint16(); + switch (this.base_offset_size) { + case 0: + item.base_offset = 0; + break; + case 4: + item.base_offset = stream.readUint32(); + break; + case 8: + item.base_offset = stream.readUint64(); + break; + default: + throw "Error reading base offset size"; + } + var extent_count = stream.readUint16(); + item.extents = []; + for (var j = 0; j < extent_count; j++) { + var extent = {}; + item.extents.push(extent); + if (this.version === 1 || this.version === 2) { + switch (this.index_size) { + case 0: + extent.extent_index = 0; + break; + case 4: + extent.extent_index = stream.readUint32(); + break; + case 8: + extent.extent_index = stream.readUint64(); + break; + default: + throw "Error reading extent index"; + } + } + switch (this.offset_size) { + case 0: + extent.extent_offset = 0; + break; + case 4: + extent.extent_offset = stream.readUint32(); + break; + case 8: + extent.extent_offset = stream.readUint64(); + break; + default: + throw "Error reading extent index"; + } + switch (this.length_size) { + case 0: + extent.extent_length = 0; + break; + case 4: + extent.extent_length = stream.readUint32(); + break; + case 8: + extent.extent_length = stream.readUint64(); + break; + default: + throw "Error reading extent index"; + } + } + } + }); + + // file:src/parsing/imir.js + BoxParser.createBoxCtor("imir", function (stream) { + var tmp = stream.readUint8(); + this.reserved = tmp >> 7; + this.axis = tmp & 1; + }); // file:src/parsing/infe.js + BoxParser.createFullBoxCtor("infe", function (stream) { + if (this.version === 0 || this.version === 1) { + this.item_ID = stream.readUint16(); + this.item_protection_index = stream.readUint16(); + this.item_name = stream.readCString(); + this.content_type = stream.readCString(); + this.content_encoding = stream.readCString(); + } + if (this.version === 1) { + this.extension_type = stream.readString(4); + Log.warn("BoxParser", "Cannot parse extension type"); + stream.seek(this.start + this.size); + return; + } + if (this.version >= 2) { + if (this.version === 2) { + this.item_ID = stream.readUint16(); + } else if (this.version === 3) { + this.item_ID = stream.readUint32(); + } + this.item_protection_index = stream.readUint16(); + this.item_type = stream.readString(4); + this.item_name = stream.readCString(); + if (this.item_type === "mime") { + this.content_type = stream.readCString(); + this.content_encoding = stream.readCString(); + } else if (this.item_type === "uri ") { + this.item_uri_type = stream.readCString(); + } + } + }); + // file:src/parsing/ipma.js + BoxParser.createFullBoxCtor("ipma", function (stream) { + var i, j; + entry_count = stream.readUint32(); + this.associations = []; + for (i = 0; i < entry_count; i++) { + var item_assoc = {}; + this.associations.push(item_assoc); + if (this.version < 1) { + item_assoc.id = stream.readUint16(); + } else { + item_assoc.id = stream.readUint32(); + } + var association_count = stream.readUint8(); + item_assoc.props = []; + for (j = 0; j < association_count; j++) { + var tmp = stream.readUint8(); + var p = {}; + item_assoc.props.push(p); + p.essential = (tmp & 0x80) >> 7 === 1; + if (this.flags & 0x1) { + p.property_index = (tmp & 0x7F) << 8 | stream.readUint8(); + } else { + p.property_index = tmp & 0x7F; + } + } + } + }); + + // file:src/parsing/iref.js + BoxParser.createFullBoxCtor("iref", function (stream) { + var ret; + var box; + this.references = []; + while (stream.getPosition() < this.start + this.size) { + ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + if (this.version === 0) { + box = new BoxParser.SingleItemTypeReferenceBox(ret.type, ret.size, ret.hdr_size, ret.start); + } else { + box = new BoxParser.SingleItemTypeReferenceBoxLarge(ret.type, ret.size, ret.hdr_size, ret.start); + } + if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { + Log.warn("BoxParser", box.type + " box writing not yet implemented, keeping unparsed data in memory for later write"); + box.parseDataAndRewind(stream); + } + box.parse(stream); + this.references.push(box); + } else { + return; + } + } + }); + // file:src/parsing/irot.js + BoxParser.createBoxCtor("irot", function (stream) { + this.angle = stream.readUint8() & 0x3; + }); + + // file:src/parsing/ispe.js + BoxParser.createFullBoxCtor("ispe", function (stream) { + this.image_width = stream.readUint32(); + this.image_height = stream.readUint32(); + }); // file:src/parsing/kind.js + BoxParser.createFullBoxCtor("kind", function (stream) { + this.schemeURI = stream.readCString(); + this.value = stream.readCString(); + }); + // file:src/parsing/leva.js + BoxParser.createFullBoxCtor("leva", function (stream) { + var count = stream.readUint8(); + this.levels = []; + for (var i = 0; i < count; i++) { + var level = {}; + this.levels[i] = level; + level.track_ID = stream.readUint32(); + var tmp_byte = stream.readUint8(); + level.padding_flag = tmp_byte >> 7; + level.assignment_type = tmp_byte & 0x7F; + switch (level.assignment_type) { + case 0: + level.grouping_type = stream.readString(4); + break; + case 1: + level.grouping_type = stream.readString(4); + level.grouping_type_parameter = stream.readUint32(); + break; + case 2: + break; + case 3: + break; + case 4: + level.sub_track_id = stream.readUint32(); + break; + default: + Log.warn("BoxParser", "Unknown leva assignement type"); + } + } + }); + + // file:src/parsing/lhvC.js + BoxParser.createBoxCtor("lhvC", function (stream) { + var i, j; + var tmp_byte; + this.configurationVersion = stream.readUint8(); + this.min_spatial_segmentation_idc = stream.readUint16() & 0xFFF; + this.parallelismType = stream.readUint8() & 0x3; + tmp_byte = stream.readUint8(); + this.numTemporalLayers = (tmp_byte & 0XD) >> 3; + this.temporalIdNested = (tmp_byte & 0X4) >> 2; + this.lengthSizeMinusOne = tmp_byte & 0X3; + this.nalu_arrays = []; + var numOfArrays = stream.readUint8(); + for (i = 0; i < numOfArrays; i++) { + var nalu_array = []; + this.nalu_arrays.push(nalu_array); + tmp_byte = stream.readUint8(); + nalu_array.completeness = (tmp_byte & 0x80) >> 7; + nalu_array.nalu_type = tmp_byte & 0x3F; + var numNalus = stream.readUint16(); + for (j = 0; j < numNalus; j++) { + var nalu = {}; + nalu_array.push(nalu); + var length = stream.readUint16(); + nalu.data = stream.readUint8Array(length); + } + } + }); + + // file:src/parsing/lsel.js + BoxParser.createBoxCtor("lsel", function (stream) { + this.layer_id = stream.readUint16(); + }); // file:src/parsing/maxr.js + BoxParser.createBoxCtor("maxr", function (stream) { + this.period = stream.readUint32(); + this.bytes = stream.readUint32(); + }); + + // file:src/parsing/mdcv.js + function ColorPoint(x, y) { + this.x = x; + this.y = y; + } + ColorPoint.prototype.toString = function () { + return "(" + this.x + "," + this.y + ")"; + }; + BoxParser.createBoxCtor("mdcv", function (stream) { + this.display_primaries = []; + this.display_primaries[0] = new ColorPoint(stream.readUint16(), stream.readUint16()); + this.display_primaries[1] = new ColorPoint(stream.readUint16(), stream.readUint16()); + this.display_primaries[2] = new ColorPoint(stream.readUint16(), stream.readUint16()); + this.white_point = new ColorPoint(stream.readUint16(), stream.readUint16()); + this.max_display_mastering_luminance = stream.readUint32(); + this.min_display_mastering_luminance = stream.readUint32(); + }); + + // file:src/parsing/mdhd.js + BoxParser.createFullBoxCtor("mdhd", function (stream) { + if (this.version == 1) { + this.creation_time = stream.readUint64(); + this.modification_time = stream.readUint64(); + this.timescale = stream.readUint32(); + this.duration = stream.readUint64(); + } else { + this.creation_time = stream.readUint32(); + this.modification_time = stream.readUint32(); + this.timescale = stream.readUint32(); + this.duration = stream.readUint32(); + } + this.parseLanguage(stream); + stream.readUint16(); + }); + + // file:src/parsing/mehd.js + BoxParser.createFullBoxCtor("mehd", function (stream) { + if (this.flags & 0x1) { + Log.warn("BoxParser", "mehd box incorrectly uses flags set to 1, converting version to 1"); + this.version = 1; + } + if (this.version == 1) { + this.fragment_duration = stream.readUint64(); + } else { + this.fragment_duration = stream.readUint32(); + } + }); + + // file:src/parsing/meta.js + BoxParser.createFullBoxCtor("meta", function (stream) { + this.boxes = []; + BoxParser.ContainerBox.prototype.parse.call(this, stream); + }); + // file:src/parsing/mfhd.js + BoxParser.createFullBoxCtor("mfhd", function (stream) { + this.sequence_number = stream.readUint32(); + }); + + // file:src/parsing/mfro.js + BoxParser.createFullBoxCtor("mfro", function (stream) { + this._size = stream.readUint32(); + }); + + // file:src/parsing/mskC.js + BoxParser.createFullBoxCtor("mskC", function (stream) { + this.bits_per_pixel = stream.readUint8(); + }); + + // file:src/parsing/mvhd.js + BoxParser.createFullBoxCtor("mvhd", function (stream) { + if (this.version == 1) { + this.creation_time = stream.readUint64(); + this.modification_time = stream.readUint64(); + this.timescale = stream.readUint32(); + this.duration = stream.readUint64(); + } else { + this.creation_time = stream.readUint32(); + this.modification_time = stream.readUint32(); + this.timescale = stream.readUint32(); + this.duration = stream.readUint32(); + } + this.rate = stream.readUint32(); + this.volume = stream.readUint16() >> 8; + stream.readUint16(); + stream.readUint32Array(2); + this.matrix = stream.readUint32Array(9); + stream.readUint32Array(6); + this.next_track_id = stream.readUint32(); + }); + // file:src/parsing/npck.js + BoxParser.createBoxCtor("npck", function (stream) { + this.packetssent = stream.readUint32(); + }); + + // file:src/parsing/nump.js + BoxParser.createBoxCtor("nump", function (stream) { + this.packetssent = stream.readUint64(); + }); + + // file:src/parsing/padb.js + BoxParser.createFullBoxCtor("padb", function (stream) { + var sample_count = stream.readUint32(); + this.padbits = []; + for (var i = 0; i < Math.floor((sample_count + 1) / 2); i++) { + this.padbits = stream.readUint8(); + } + }); + + // file:src/parsing/pasp.js + BoxParser.createBoxCtor("pasp", function (stream) { + this.hSpacing = stream.readUint32(); + this.vSpacing = stream.readUint32(); + }); // file:src/parsing/payl.js + BoxParser.createBoxCtor("payl", function (stream) { + this.text = stream.readString(this.size - this.hdr_size); + }); + + // file:src/parsing/payt.js + BoxParser.createBoxCtor("payt", function (stream) { + this.payloadID = stream.readUint32(); + var count = stream.readUint8(); + this.rtpmap_string = stream.readString(count); + }); + + // file:src/parsing/pdin.js + BoxParser.createFullBoxCtor("pdin", function (stream) { + var count = (this.size - this.hdr_size) / 8; + this.rate = []; + this.initial_delay = []; + for (var i = 0; i < count; i++) { + this.rate[i] = stream.readUint32(); + this.initial_delay[i] = stream.readUint32(); + } + }); + + // file:src/parsing/pitm.js + BoxParser.createFullBoxCtor("pitm", function (stream) { + if (this.version === 0) { + this.item_id = stream.readUint16(); + } else { + this.item_id = stream.readUint32(); + } + }); + + // file:src/parsing/pixi.js + BoxParser.createFullBoxCtor("pixi", function (stream) { + var i; + this.num_channels = stream.readUint8(); + this.bits_per_channels = []; + for (i = 0; i < this.num_channels; i++) { + this.bits_per_channels[i] = stream.readUint8(); + } + }); + + // file:src/parsing/pmax.js + BoxParser.createBoxCtor("pmax", function (stream) { + this.bytes = stream.readUint32(); + }); + + // file:src/parsing/prdi.js + BoxParser.createFullBoxCtor("prdi", function (stream) { + this.step_count = stream.readUint16(); + this.item_count = []; + if (this.flags & 0x2) { + for (var i = 0; i < this.step_count; i++) { + this.item_count[i] = stream.readUint16(); + } + } + }); // file:src/parsing/prft.js + BoxParser.createFullBoxCtor("prft", function (stream) { + this.ref_track_id = stream.readUint32(); + this.ntp_timestamp = stream.readUint64(); + if (this.version === 0) { + this.media_time = stream.readUint32(); + } else { + this.media_time = stream.readUint64(); + } + }); + + // file:src/parsing/pssh.js + BoxParser.createFullBoxCtor("pssh", function (stream) { + this.system_id = BoxParser.parseHex16(stream); + if (this.version > 0) { + var count = stream.readUint32(); + this.kid = []; + for (var i = 0; i < count; i++) { + this.kid[i] = BoxParser.parseHex16(stream); + } + } + var datasize = stream.readUint32(); + if (datasize > 0) { + this.data = stream.readUint8Array(datasize); + } + }); + + // file:src/parsing/qt/clef.js + BoxParser.createFullBoxCtor("clef", function (stream) { + this.width = stream.readUint32(); + this.height = stream.readUint32(); + }); // file:src/parsing/qt/enof.js + BoxParser.createFullBoxCtor("enof", function (stream) { + this.width = stream.readUint32(); + this.height = stream.readUint32(); + }); // file:src/parsing/qt/prof.js + BoxParser.createFullBoxCtor("prof", function (stream) { + this.width = stream.readUint32(); + this.height = stream.readUint32(); + }); // file:src/parsing/qt/tapt.js + BoxParser.createContainerBoxCtor("tapt", null, ["clef", "prof", "enof"]); // file:src/parsing/rtp.js + BoxParser.createBoxCtor("rtp ", function (stream) { + this.descriptionformat = stream.readString(4); + this.sdptext = stream.readString(this.size - this.hdr_size - 4); + }); + + // file:src/parsing/saio.js + BoxParser.createFullBoxCtor("saio", function (stream) { + if (this.flags & 0x1) { + this.aux_info_type = stream.readString(4); + this.aux_info_type_parameter = stream.readUint32(); + } + var count = stream.readUint32(); + this.offset = []; + for (var i = 0; i < count; i++) { + if (this.version === 0) { + this.offset[i] = stream.readUint32(); + } else { + this.offset[i] = stream.readUint64(); + } + } + }); + // file:src/parsing/saiz.js + BoxParser.createFullBoxCtor("saiz", function (stream) { + if (this.flags & 0x1) { + this.aux_info_type = stream.readString(4); + this.aux_info_type_parameter = stream.readUint32(); + } + this.default_sample_info_size = stream.readUint8(); + this.sample_count = stream.readUint32(); + this.sample_info_size = []; + if (this.default_sample_info_size === 0) { + for (var i = 0; i < this.sample_count; i++) { + this.sample_info_size[i] = stream.readUint8(); + } + } + }); + + // file:src/parsing/sampleentries/mett.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "mett", function (stream) { + this.parseHeader(stream); + this.content_encoding = stream.readCString(); + this.mime_format = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/metx.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "metx", function (stream) { + this.parseHeader(stream); + this.content_encoding = stream.readCString(); + this.namespace = stream.readCString(); + this.schema_location = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/sbtt.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "sbtt", function (stream) { + this.parseHeader(stream); + this.content_encoding = stream.readCString(); + this.mime_format = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/stpp.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "stpp", function (stream) { + this.parseHeader(stream); + this.namespace = stream.readCString(); + this.schema_location = stream.readCString(); + this.auxiliary_mime_types = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/stxt.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "stxt", function (stream) { + this.parseHeader(stream); + this.content_encoding = stream.readCString(); + this.mime_format = stream.readCString(); + this.parseFooter(stream); + }); + + // file:src/parsing/sampleentries/tx3g.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "tx3g", function (stream) { + this.parseHeader(stream); + this.displayFlags = stream.readUint32(); + this.horizontal_justification = stream.readInt8(); + this.vertical_justification = stream.readInt8(); + this.bg_color_rgba = stream.readUint8Array(4); + this.box_record = stream.readInt16Array(4); + this.style_record = stream.readUint8Array(12); + this.parseFooter(stream); + }); + // file:src/parsing/sampleentries/wvtt.js + BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "wvtt", function (stream) { + this.parseHeader(stream); + this.parseFooter(stream); + }); + + // file:src/parsing/samplegroups/alst.js + BoxParser.createSampleGroupCtor("alst", function (stream) { + var i; + var roll_count = stream.readUint16(); + this.first_output_sample = stream.readUint16(); + this.sample_offset = []; + for (i = 0; i < roll_count; i++) { + this.sample_offset[i] = stream.readUint32(); + } + var remaining = this.description_length - 4 - 4 * roll_count; + this.num_output_samples = []; + this.num_total_samples = []; + for (i = 0; i < remaining / 4; i++) { + this.num_output_samples[i] = stream.readUint16(); + this.num_total_samples[i] = stream.readUint16(); + } + }); + + // file:src/parsing/samplegroups/avll.js + BoxParser.createSampleGroupCtor("avll", function (stream) { + this.layerNumber = stream.readUint8(); + this.accurateStatisticsFlag = stream.readUint8(); + this.avgBitRate = stream.readUint16(); + this.avgFrameRate = stream.readUint16(); + }); + + // file:src/parsing/samplegroups/avss.js + BoxParser.createSampleGroupCtor("avss", function (stream) { + this.subSequenceIdentifier = stream.readUint16(); + this.layerNumber = stream.readUint8(); + var tmp_byte = stream.readUint8(); + this.durationFlag = tmp_byte >> 7; + this.avgRateFlag = tmp_byte >> 6 & 0x1; + if (this.durationFlag) { + this.duration = stream.readUint32(); + } + if (this.avgRateFlag) { + this.accurateStatisticsFlag = stream.readUint8(); + this.avgBitRate = stream.readUint16(); + this.avgFrameRate = stream.readUint16(); + } + this.dependency = []; + var numReferences = stream.readUint8(); + for (var i = 0; i < numReferences; i++) { + var dependencyInfo = {}; + this.dependency.push(dependencyInfo); + dependencyInfo.subSeqDirectionFlag = stream.readUint8(); + dependencyInfo.layerNumber = stream.readUint8(); + dependencyInfo.subSequenceIdentifier = stream.readUint16(); + } + }); + + // file:src/parsing/samplegroups/dtrt.js + BoxParser.createSampleGroupCtor("dtrt", function (stream) { + Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); + }); + + // file:src/parsing/samplegroups/mvif.js + BoxParser.createSampleGroupCtor("mvif", function (stream) { + Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); + }); + + // file:src/parsing/samplegroups/prol.js + BoxParser.createSampleGroupCtor("prol", function (stream) { + this.roll_distance = stream.readInt16(); + }); + + // file:src/parsing/samplegroups/rap.js + BoxParser.createSampleGroupCtor("rap ", function (stream) { + var tmp_byte = stream.readUint8(); + this.num_leading_samples_known = tmp_byte >> 7; + this.num_leading_samples = tmp_byte & 0x7F; + }); + + // file:src/parsing/samplegroups/rash.js + BoxParser.createSampleGroupCtor("rash", function (stream) { + this.operation_point_count = stream.readUint16(); + if (this.description_length !== 2 + (this.operation_point_count === 1 ? 2 : this.operation_point_count * 6) + 9) { + Log.warn("BoxParser", "Mismatch in " + this.grouping_type + " sample group length"); + this.data = stream.readUint8Array(this.description_length - 2); + } else { + if (this.operation_point_count === 1) { + this.target_rate_share = stream.readUint16(); + } else { + this.target_rate_share = []; + this.available_bitrate = []; + for (var i = 0; i < this.operation_point_count; i++) { + this.available_bitrate[i] = stream.readUint32(); + this.target_rate_share[i] = stream.readUint16(); + } + } + this.maximum_bitrate = stream.readUint32(); + this.minimum_bitrate = stream.readUint32(); + this.discard_priority = stream.readUint8(); + } + }); + + // file:src/parsing/samplegroups/roll.js + BoxParser.createSampleGroupCtor("roll", function (stream) { + this.roll_distance = stream.readInt16(); + }); + + // file:src/parsing/samplegroups/samplegroup.js + BoxParser.SampleGroupEntry.prototype.parse = function (stream) { + Log.warn("BoxParser", "Unknown Sample Group type: " + this.grouping_type); + this.data = stream.readUint8Array(this.description_length); + }; + + // file:src/parsing/samplegroups/scif.js + BoxParser.createSampleGroupCtor("scif", function (stream) { + Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); + }); + + // file:src/parsing/samplegroups/scnm.js + BoxParser.createSampleGroupCtor("scnm", function (stream) { + Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); + }); + + // file:src/parsing/samplegroups/seig.js + BoxParser.createSampleGroupCtor("seig", function (stream) { + this.reserved = stream.readUint8(); + var tmp = stream.readUint8(); + this.crypt_byte_block = tmp >> 4; + this.skip_byte_block = tmp & 0xF; + this.isProtected = stream.readUint8(); + this.Per_Sample_IV_Size = stream.readUint8(); + this.KID = BoxParser.parseHex16(stream); + this.constant_IV_size = 0; + this.constant_IV = 0; + if (this.isProtected === 1 && this.Per_Sample_IV_Size === 0) { + this.constant_IV_size = stream.readUint8(); + this.constant_IV = stream.readUint8Array(this.constant_IV_size); + } + }); + + // file:src/parsing/samplegroups/stsa.js + BoxParser.createSampleGroupCtor("stsa", function (stream) { + Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); + }); + + // file:src/parsing/samplegroups/sync.js + BoxParser.createSampleGroupCtor("sync", function (stream) { + var tmp_byte = stream.readUint8(); + this.NAL_unit_type = tmp_byte & 0x3F; + }); + + // file:src/parsing/samplegroups/tele.js + BoxParser.createSampleGroupCtor("tele", function (stream) { + var tmp_byte = stream.readUint8(); + this.level_independently_decodable = tmp_byte >> 7; + }); + + // file:src/parsing/samplegroups/tsas.js + BoxParser.createSampleGroupCtor("tsas", function (stream) { + Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); + }); + + // file:src/parsing/samplegroups/tscl.js + BoxParser.createSampleGroupCtor("tscl", function (stream) { + Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); + }); + + // file:src/parsing/samplegroups/vipr.js + BoxParser.createSampleGroupCtor("vipr", function (stream) { + Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); + }); + + // file:src/parsing/sbgp.js + BoxParser.createFullBoxCtor("sbgp", function (stream) { + this.grouping_type = stream.readString(4); + if (this.version === 1) { + this.grouping_type_parameter = stream.readUint32(); + } else { + this.grouping_type_parameter = 0; + } + this.entries = []; + var entry_count = stream.readUint32(); + for (var i = 0; i < entry_count; i++) { + var entry = {}; + this.entries.push(entry); + entry.sample_count = stream.readInt32(); + entry.group_description_index = stream.readInt32(); + } + }); + + // file:src/parsing/sbpm.js + function Pixel(row, col) { + this.bad_pixel_row = row; + this.bad_pixel_column = col; + } + Pixel.prototype.toString = function pixelToString() { + return "[row: " + this.bad_pixel_row + ", column: " + this.bad_pixel_column + "]"; + }; + BoxParser.createFullBoxCtor("sbpm", function (stream) { + var i; + this.component_count = stream.readUint16(); + this.component_index = []; + for (i = 0; i < this.component_count; i++) { + this.component_index.push(stream.readUint16()); + } + var flags = stream.readUint8(); + this.correction_applied = 0x80 == (flags & 0x80); + this.num_bad_rows = stream.readUint32(); + this.num_bad_cols = stream.readUint32(); + this.num_bad_pixels = stream.readUint32(); + this.bad_rows = []; + this.bad_columns = []; + this.bad_pixels = []; + for (i = 0; i < this.num_bad_rows; i++) { + this.bad_rows.push(stream.readUint32()); + } + for (i = 0; i < this.num_bad_cols; i++) { + this.bad_columns.push(stream.readUint32()); + } + for (i = 0; i < this.num_bad_pixels; i++) { + var row = stream.readUint32(); + var col = stream.readUint32(); + this.bad_pixels.push(new Pixel(row, col)); + } + }); + + // file:src/parsing/schm.js + BoxParser.createFullBoxCtor("schm", function (stream) { + this.scheme_type = stream.readString(4); + this.scheme_version = stream.readUint32(); + if (this.flags & 0x000001) { + this.scheme_uri = stream.readString(this.size - this.hdr_size - 8); + } + }); + + // file:src/parsing/sdp.js + BoxParser.createBoxCtor("sdp ", function (stream) { + this.sdptext = stream.readString(this.size - this.hdr_size); + }); + + // file:src/parsing/sdtp.js + BoxParser.createFullBoxCtor("sdtp", function (stream) { + var tmp_byte; + var count = this.size - this.hdr_size; + this.is_leading = []; + this.sample_depends_on = []; + this.sample_is_depended_on = []; + this.sample_has_redundancy = []; + for (var i = 0; i < count; i++) { + tmp_byte = stream.readUint8(); + this.is_leading[i] = tmp_byte >> 6; + this.sample_depends_on[i] = tmp_byte >> 4 & 0x3; + this.sample_is_depended_on[i] = tmp_byte >> 2 & 0x3; + this.sample_has_redundancy[i] = tmp_byte & 0x3; + } + }); + + // file:src/parsing/senc.js + // Cannot be fully parsed because Per_Sample_IV_Size needs to be known + BoxParser.createFullBoxCtor("senc" /*, function(stream) { + this.parseFullHeader(stream); + var sample_count = stream.readUint32(); + this.samples = []; + for (var i = 0; i < sample_count; i++) { + var sample = {}; + // tenc.default_Per_Sample_IV_Size or seig.Per_Sample_IV_Size + sample.InitializationVector = this.readUint8Array(Per_Sample_IV_Size*8); + if (this.flags & 0x2) { + sample.subsamples = []; + subsample_count = stream.readUint16(); + for (var j = 0; j < subsample_count; j++) { + var subsample = {}; + subsample.BytesOfClearData = stream.readUint16(); + subsample.BytesOfProtectedData = stream.readUint32(); + sample.subsamples.push(subsample); + } + } + // TODO + this.samples.push(sample); + } + }*/); + // file:src/parsing/sgpd.js + BoxParser.createFullBoxCtor("sgpd", function (stream) { + this.grouping_type = stream.readString(4); + Log.debug("BoxParser", "Found Sample Groups of type " + this.grouping_type); + if (this.version === 1) { + this.default_length = stream.readUint32(); + } else { + this.default_length = 0; + } + if (this.version >= 2) { + this.default_group_description_index = stream.readUint32(); + } + this.entries = []; + var entry_count = stream.readUint32(); + for (var i = 0; i < entry_count; i++) { + var entry; + if (BoxParser[this.grouping_type + "SampleGroupEntry"]) { + entry = new BoxParser[this.grouping_type + "SampleGroupEntry"](this.grouping_type); + } else { + entry = new BoxParser.SampleGroupEntry(this.grouping_type); + } + this.entries.push(entry); + if (this.version === 1) { + if (this.default_length === 0) { + entry.description_length = stream.readUint32(); + } else { + entry.description_length = this.default_length; + } + } else { + entry.description_length = this.default_length; + } + if (entry.write === BoxParser.SampleGroupEntry.prototype.write) { + Log.info("BoxParser", "SampleGroup for type " + this.grouping_type + " writing not yet implemented, keeping unparsed data in memory for later write"); + // storing data + entry.data = stream.readUint8Array(entry.description_length); + // rewinding + stream.position -= entry.description_length; + } + entry.parse(stream); + } + }); + + // file:src/parsing/sidx.js + BoxParser.createFullBoxCtor("sidx", function (stream) { + this.reference_ID = stream.readUint32(); + this.timescale = stream.readUint32(); + if (this.version === 0) { + this.earliest_presentation_time = stream.readUint32(); + this.first_offset = stream.readUint32(); + } else { + this.earliest_presentation_time = stream.readUint64(); + this.first_offset = stream.readUint64(); + } + stream.readUint16(); + this.references = []; + var count = stream.readUint16(); + for (var i = 0; i < count; i++) { + var ref = {}; + this.references.push(ref); + var tmp_32 = stream.readUint32(); + ref.reference_type = tmp_32 >> 31 & 0x1; + ref.referenced_size = tmp_32 & 0x7FFFFFFF; + ref.subsegment_duration = stream.readUint32(); + tmp_32 = stream.readUint32(); + ref.starts_with_SAP = tmp_32 >> 31 & 0x1; + ref.SAP_type = tmp_32 >> 28 & 0x7; + ref.SAP_delta_time = tmp_32 & 0xFFFFFFF; + } + }); + + // file:src/parsing/singleitemtypereference.js + BoxParser.SingleItemTypeReferenceBox = function (type, size, hdr_size, start) { + BoxParser.Box.call(this, type, size); + this.hdr_size = hdr_size; + this.start = start; + }; + BoxParser.SingleItemTypeReferenceBox.prototype = new BoxParser.Box(); + BoxParser.SingleItemTypeReferenceBox.prototype.parse = function (stream) { + this.from_item_ID = stream.readUint16(); + var count = stream.readUint16(); + this.references = []; + for (var i = 0; i < count; i++) { + this.references[i] = {}; + this.references[i].to_item_ID = stream.readUint16(); + } + }; + + // file:src/parsing/singleitemtypereferencelarge.js + BoxParser.SingleItemTypeReferenceBoxLarge = function (type, size, hdr_size, start) { + BoxParser.Box.call(this, type, size); + this.hdr_size = hdr_size; + this.start = start; + }; + BoxParser.SingleItemTypeReferenceBoxLarge.prototype = new BoxParser.Box(); + BoxParser.SingleItemTypeReferenceBoxLarge.prototype.parse = function (stream) { + this.from_item_ID = stream.readUint32(); + var count = stream.readUint16(); + this.references = []; + for (var i = 0; i < count; i++) { + this.references[i] = {}; + this.references[i].to_item_ID = stream.readUint32(); + } + }; + + // file:src/parsing/SmDm.js + BoxParser.createFullBoxCtor("SmDm", function (stream) { + this.primaryRChromaticity_x = stream.readUint16(); + this.primaryRChromaticity_y = stream.readUint16(); + this.primaryGChromaticity_x = stream.readUint16(); + this.primaryGChromaticity_y = stream.readUint16(); + this.primaryBChromaticity_x = stream.readUint16(); + this.primaryBChromaticity_y = stream.readUint16(); + this.whitePointChromaticity_x = stream.readUint16(); + this.whitePointChromaticity_y = stream.readUint16(); + this.luminanceMax = stream.readUint32(); + this.luminanceMin = stream.readUint32(); + }); + + // file:src/parsing/smhd.js + BoxParser.createFullBoxCtor("smhd", function (stream) { + this.balance = stream.readUint16(); + stream.readUint16(); + }); + + // file:src/parsing/ssix.js + BoxParser.createFullBoxCtor("ssix", function (stream) { + this.subsegments = []; + var subsegment_count = stream.readUint32(); + for (var i = 0; i < subsegment_count; i++) { + var subsegment = {}; + this.subsegments.push(subsegment); + subsegment.ranges = []; + var range_count = stream.readUint32(); + for (var j = 0; j < range_count; j++) { + var range = {}; + subsegment.ranges.push(range); + range.level = stream.readUint8(); + range.range_size = stream.readUint24(); + } + } + }); + + // file:src/parsing/stco.js + BoxParser.createFullBoxCtor("stco", function (stream) { + var entry_count; + entry_count = stream.readUint32(); + this.chunk_offsets = []; + if (this.version === 0) { + for (var i = 0; i < entry_count; i++) { + this.chunk_offsets.push(stream.readUint32()); + } + } + }); + + // file:src/parsing/stdp.js + BoxParser.createFullBoxCtor("stdp", function (stream) { + var count = (this.size - this.hdr_size) / 2; + this.priority = []; + for (var i = 0; i < count; i++) { + this.priority[i] = stream.readUint16(); + } + }); + + // file:src/parsing/sthd.js + BoxParser.createFullBoxCtor("sthd"); + + // file:src/parsing/stri.js + BoxParser.createFullBoxCtor("stri", function (stream) { + this.switch_group = stream.readUint16(); + this.alternate_group = stream.readUint16(); + this.sub_track_id = stream.readUint32(); + var count = (this.size - this.hdr_size - 8) / 4; + this.attribute_list = []; + for (var i = 0; i < count; i++) { + this.attribute_list[i] = stream.readUint32(); + } + }); + + // file:src/parsing/stsc.js + BoxParser.createFullBoxCtor("stsc", function (stream) { + var entry_count; + var i; + entry_count = stream.readUint32(); + this.first_chunk = []; + this.samples_per_chunk = []; + this.sample_description_index = []; + if (this.version === 0) { + for (i = 0; i < entry_count; i++) { + this.first_chunk.push(stream.readUint32()); + this.samples_per_chunk.push(stream.readUint32()); + this.sample_description_index.push(stream.readUint32()); + } + } + }); + + // file:src/parsing/stsd.js + BoxParser.createFullBoxCtor("stsd", function (stream) { + var i; + var ret; + var entryCount; + var box; + this.entries = []; + entryCount = stream.readUint32(); + for (i = 1; i <= entryCount; i++) { + ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + if (BoxParser[ret.type + "SampleEntry"]) { + box = new BoxParser[ret.type + "SampleEntry"](ret.size); + box.hdr_size = ret.hdr_size; + box.start = ret.start; + } else { + Log.warn("BoxParser", "Unknown sample entry type: " + ret.type); + box = new BoxParser.SampleEntry(ret.type, ret.size, ret.hdr_size, ret.start); + } + if (box.write === BoxParser.SampleEntry.prototype.write) { + Log.info("BoxParser", "SampleEntry " + box.type + " box writing not yet implemented, keeping unparsed data in memory for later write"); + box.parseDataAndRewind(stream); + } + box.parse(stream); + this.entries.push(box); + } else { + return; + } + } + }); + + // file:src/parsing/stsg.js + BoxParser.createFullBoxCtor("stsg", function (stream) { + this.grouping_type = stream.readUint32(); + var count = stream.readUint16(); + this.group_description_index = []; + for (var i = 0; i < count; i++) { + this.group_description_index[i] = stream.readUint32(); + } + }); + + // file:src/parsing/stsh.js + BoxParser.createFullBoxCtor("stsh", function (stream) { + var entry_count; + var i; + entry_count = stream.readUint32(); + this.shadowed_sample_numbers = []; + this.sync_sample_numbers = []; + if (this.version === 0) { + for (i = 0; i < entry_count; i++) { + this.shadowed_sample_numbers.push(stream.readUint32()); + this.sync_sample_numbers.push(stream.readUint32()); + } + } + }); + + // file:src/parsing/stss.js + BoxParser.createFullBoxCtor("stss", function (stream) { + var i; + var entry_count; + entry_count = stream.readUint32(); + if (this.version === 0) { + this.sample_numbers = []; + for (i = 0; i < entry_count; i++) { + this.sample_numbers.push(stream.readUint32()); + } + } + }); + + // file:src/parsing/stsz.js + BoxParser.createFullBoxCtor("stsz", function (stream) { + var i; + this.sample_sizes = []; + if (this.version === 0) { + this.sample_size = stream.readUint32(); + this.sample_count = stream.readUint32(); + for (i = 0; i < this.sample_count; i++) { + if (this.sample_size === 0) { + this.sample_sizes.push(stream.readUint32()); + } else { + this.sample_sizes[i] = this.sample_size; + } + } + } + }); + + // file:src/parsing/stts.js + BoxParser.createFullBoxCtor("stts", function (stream) { + var entry_count; + var i; + var delta; + entry_count = stream.readUint32(); + this.sample_counts = []; + this.sample_deltas = []; + if (this.version === 0) { + for (i = 0; i < entry_count; i++) { + this.sample_counts.push(stream.readUint32()); + delta = stream.readInt32(); + if (delta < 0) { + Log.warn("BoxParser", "File uses negative stts sample delta, using value 1 instead, sync may be lost!"); + delta = 1; + } + this.sample_deltas.push(delta); + } + } + }); + + // file:src/parsing/stvi.js + BoxParser.createFullBoxCtor("stvi", function (stream) { + var tmp32 = stream.readUint32(); + this.single_view_allowed = tmp32 & 0x3; + this.stereo_scheme = stream.readUint32(); + var length = stream.readUint32(); + this.stereo_indication_type = stream.readString(length); + var ret; + var box; + this.boxes = []; + while (stream.getPosition() < this.start + this.size) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = ret.box; + this.boxes.push(box); + this[box.type] = box; + } else { + return; + } + } + }); + + // file:src/parsing/styp.js + BoxParser.createBoxCtor("styp", function (stream) { + BoxParser.ftypBox.prototype.parse.call(this, stream); + }); + + // file:src/parsing/stz2.js + BoxParser.createFullBoxCtor("stz2", function (stream) { + var i; + var sample_count; + this.sample_sizes = []; + if (this.version === 0) { + this.reserved = stream.readUint24(); + this.field_size = stream.readUint8(); + sample_count = stream.readUint32(); + if (this.field_size === 4) { + for (i = 0; i < sample_count; i += 2) { + var tmp = stream.readUint8(); + this.sample_sizes[i] = tmp >> 4 & 0xF; + this.sample_sizes[i + 1] = tmp & 0xF; + } + } else if (this.field_size === 8) { + for (i = 0; i < sample_count; i++) { + this.sample_sizes[i] = stream.readUint8(); + } + } else if (this.field_size === 16) { + for (i = 0; i < sample_count; i++) { + this.sample_sizes[i] = stream.readUint16(); + } + } else { + Log.error("BoxParser", "Error in length field in stz2 box"); + } + } + }); + + // file:src/parsing/subs.js + BoxParser.createFullBoxCtor("subs", function (stream) { + var i, j; + var entry_count; + var subsample_count; + entry_count = stream.readUint32(); + this.entries = []; + for (i = 0; i < entry_count; i++) { + var sampleInfo = {}; + this.entries[i] = sampleInfo; + sampleInfo.sample_delta = stream.readUint32(); + sampleInfo.subsamples = []; + subsample_count = stream.readUint16(); + if (subsample_count > 0) { + for (j = 0; j < subsample_count; j++) { + var subsample = {}; + sampleInfo.subsamples.push(subsample); + if (this.version == 1) { + subsample.size = stream.readUint32(); + } else { + subsample.size = stream.readUint16(); + } + subsample.priority = stream.readUint8(); + subsample.discardable = stream.readUint8(); + subsample.codec_specific_parameters = stream.readUint32(); + } + } + } + }); + + // file:src/parsing/tenc.js + BoxParser.createFullBoxCtor("tenc", function (stream) { + stream.readUint8(); // reserved + if (this.version === 0) { + stream.readUint8(); + } else { + var tmp = stream.readUint8(); + this.default_crypt_byte_block = tmp >> 4 & 0xF; + this.default_skip_byte_block = tmp & 0xF; + } + this.default_isProtected = stream.readUint8(); + this.default_Per_Sample_IV_Size = stream.readUint8(); + this.default_KID = BoxParser.parseHex16(stream); + if (this.default_isProtected === 1 && this.default_Per_Sample_IV_Size === 0) { + this.default_constant_IV_size = stream.readUint8(); + this.default_constant_IV = stream.readUint8Array(this.default_constant_IV_size); + } + }); // file:src/parsing/tfdt.js + BoxParser.createFullBoxCtor("tfdt", function (stream) { + if (this.version == 1) { + this.baseMediaDecodeTime = stream.readUint64(); + } else { + this.baseMediaDecodeTime = stream.readUint32(); + } + }); + + // file:src/parsing/tfhd.js + BoxParser.createFullBoxCtor("tfhd", function (stream) { + var readBytes = 0; + this.track_id = stream.readUint32(); + if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { + this.base_data_offset = stream.readUint64(); + readBytes += 8; + } else { + this.base_data_offset = 0; + } + if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { + this.default_sample_description_index = stream.readUint32(); + readBytes += 4; + } else { + this.default_sample_description_index = 0; + } + if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { + this.default_sample_duration = stream.readUint32(); + readBytes += 4; + } else { + this.default_sample_duration = 0; + } + if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { + this.default_sample_size = stream.readUint32(); + readBytes += 4; + } else { + this.default_sample_size = 0; + } + if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { + this.default_sample_flags = stream.readUint32(); + readBytes += 4; + } else { + this.default_sample_flags = 0; + } + }); + + // file:src/parsing/tfra.js + BoxParser.createFullBoxCtor("tfra", function (stream) { + this.track_ID = stream.readUint32(); + stream.readUint24(); + var tmp_byte = stream.readUint8(); + this.length_size_of_traf_num = tmp_byte >> 4 & 0x3; + this.length_size_of_trun_num = tmp_byte >> 2 & 0x3; + this.length_size_of_sample_num = tmp_byte & 0x3; + this.entries = []; + var number_of_entries = stream.readUint32(); + for (var i = 0; i < number_of_entries; i++) { + if (this.version === 1) { + this.time = stream.readUint64(); + this.moof_offset = stream.readUint64(); + } else { + this.time = stream.readUint32(); + this.moof_offset = stream.readUint32(); + } + this.traf_number = stream["readUint" + 8 * (this.length_size_of_traf_num + 1)](); + this.trun_number = stream["readUint" + 8 * (this.length_size_of_trun_num + 1)](); + this.sample_number = stream["readUint" + 8 * (this.length_size_of_sample_num + 1)](); + } + }); + + // file:src/parsing/tkhd.js + BoxParser.createFullBoxCtor("tkhd", function (stream) { + if (this.version == 1) { + this.creation_time = stream.readUint64(); + this.modification_time = stream.readUint64(); + this.track_id = stream.readUint32(); + stream.readUint32(); + this.duration = stream.readUint64(); + } else { + this.creation_time = stream.readUint32(); + this.modification_time = stream.readUint32(); + this.track_id = stream.readUint32(); + stream.readUint32(); + this.duration = stream.readUint32(); + } + stream.readUint32Array(2); + this.layer = stream.readInt16(); + this.alternate_group = stream.readInt16(); + this.volume = stream.readInt16() >> 8; + stream.readUint16(); + this.matrix = stream.readInt32Array(9); + this.width = stream.readUint32(); + this.height = stream.readUint32(); + }); + + // file:src/parsing/tmax.js + BoxParser.createBoxCtor("tmax", function (stream) { + this.time = stream.readUint32(); + }); + + // file:src/parsing/tmin.js + BoxParser.createBoxCtor("tmin", function (stream) { + this.time = stream.readUint32(); + }); + + // file:src/parsing/totl.js + BoxParser.createBoxCtor("totl", function (stream) { + this.bytessent = stream.readUint32(); + }); + + // file:src/parsing/tpay.js + BoxParser.createBoxCtor("tpay", function (stream) { + this.bytessent = stream.readUint32(); + }); + + // file:src/parsing/tpyl.js + BoxParser.createBoxCtor("tpyl", function (stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/TrackGroup.js + BoxParser.TrackGroupTypeBox.prototype.parse = function (stream) { + this.parseFullHeader(stream); + this.track_group_id = stream.readUint32(); + }; + + // file:src/parsing/trackgroups/msrc.js + BoxParser.createTrackGroupCtor("msrc"); // file:src/parsing/TrakReference.js + BoxParser.TrackReferenceTypeBox = function (type, size, hdr_size, start) { + BoxParser.Box.call(this, type, size); + this.hdr_size = hdr_size; + this.start = start; + }; + BoxParser.TrackReferenceTypeBox.prototype = new BoxParser.Box(); + BoxParser.TrackReferenceTypeBox.prototype.parse = function (stream) { + this.track_ids = stream.readUint32Array((this.size - this.hdr_size) / 4); + }; + + // file:src/parsing/tref.js + BoxParser.trefBox.prototype.parse = function (stream) { + var ret; + var box; + while (stream.getPosition() < this.start + this.size) { + ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = new BoxParser.TrackReferenceTypeBox(ret.type, ret.size, ret.hdr_size, ret.start); + if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { + Log.info("BoxParser", "TrackReference " + box.type + " box writing not yet implemented, keeping unparsed data in memory for later write"); + box.parseDataAndRewind(stream); + } + box.parse(stream); + this.boxes.push(box); + } else { + return; + } + } + }; + + // file:src/parsing/trep.js + BoxParser.createFullBoxCtor("trep", function (stream) { + this.track_ID = stream.readUint32(); + this.boxes = []; + while (stream.getPosition() < this.start + this.size) { + ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); + if (ret.code === BoxParser.OK) { + box = ret.box; + this.boxes.push(box); + } else { + return; + } + } + }); + + // file:src/parsing/trex.js + BoxParser.createFullBoxCtor("trex", function (stream) { + this.track_id = stream.readUint32(); + this.default_sample_description_index = stream.readUint32(); + this.default_sample_duration = stream.readUint32(); + this.default_sample_size = stream.readUint32(); + this.default_sample_flags = stream.readUint32(); + }); + + // file:src/parsing/trpy.js + BoxParser.createBoxCtor("trpy", function (stream) { + this.bytessent = stream.readUint64(); + }); + + // file:src/parsing/trun.js + BoxParser.createFullBoxCtor("trun", function (stream) { + var readBytes = 0; + this.sample_count = stream.readUint32(); + readBytes += 4; + if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { + this.data_offset = stream.readInt32(); //signed + readBytes += 4; + } else { + this.data_offset = 0; + } + if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { + this.first_sample_flags = stream.readUint32(); + readBytes += 4; + } else { + this.first_sample_flags = 0; + } + this.sample_duration = []; + this.sample_size = []; + this.sample_flags = []; + this.sample_composition_time_offset = []; + if (this.size - this.hdr_size > readBytes) { + for (var i = 0; i < this.sample_count; i++) { + if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { + this.sample_duration[i] = stream.readUint32(); + } + if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { + this.sample_size[i] = stream.readUint32(); + } + if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { + this.sample_flags[i] = stream.readUint32(); + } + if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { + if (this.version === 0) { + this.sample_composition_time_offset[i] = stream.readUint32(); + } else { + this.sample_composition_time_offset[i] = stream.readInt32(); //signed + } + } + } + } + }); + + // file:src/parsing/tsel.js + BoxParser.createFullBoxCtor("tsel", function (stream) { + this.switch_group = stream.readUint32(); + var count = (this.size - this.hdr_size - 4) / 4; + this.attribute_list = []; + for (var i = 0; i < count; i++) { + this.attribute_list[i] = stream.readUint32(); + } + }); + + // file:src/parsing/txtC.js + BoxParser.createFullBoxCtor("txtC", function (stream) { + this.config = stream.readCString(); + }); + + // file:src/parsing/tyco.js + BoxParser.createBoxCtor("tyco", function (stream) { + var count = (this.size - this.hdr_size) / 4; + this.compatible_brands = []; + for (var i = 0; i < count; i++) { + this.compatible_brands[i] = stream.readString(4); + } + }); + + // file:src/parsing/udes.js + BoxParser.createFullBoxCtor("udes", function (stream) { + this.lang = stream.readCString(); + this.name = stream.readCString(); + this.description = stream.readCString(); + this.tags = stream.readCString(); + }); + + // file:src/parsing/uncC.js + BoxParser.createFullBoxCtor("uncC", function (stream) { + var i; + this.profile = stream.readUint32(); + if (this.version == 1) ; else if (this.version == 0) { + this.component_count = stream.readUint32(); + this.component_index = []; + this.component_bit_depth_minus_one = []; + this.component_format = []; + this.component_align_size = []; + for (i = 0; i < this.component_count; i++) { + this.component_index.push(stream.readUint16()); + this.component_bit_depth_minus_one.push(stream.readUint8()); + this.component_format.push(stream.readUint8()); + this.component_align_size.push(stream.readUint8()); + } + this.sampling_type = stream.readUint8(); + this.interleave_type = stream.readUint8(); + this.block_size = stream.readUint8(); + var flags = stream.readUint8(); + this.component_little_endian = flags >> 7 & 0x1; + this.block_pad_lsb = flags >> 6 & 0x1; + this.block_little_endian = flags >> 5 & 0x1; + this.block_reversed = flags >> 4 & 0x1; + this.pad_unknown = flags >> 3 & 0x1; + this.pixel_size = stream.readUint32(); + this.row_align_size = stream.readUint32(); + this.tile_align_size = stream.readUint32(); + this.num_tile_cols_minus_one = stream.readUint32(); + this.num_tile_rows_minus_one = stream.readUint32(); + } + }); + + // file:src/parsing/url.js + BoxParser.createFullBoxCtor("url ", function (stream) { + if (this.flags !== 0x000001) { + this.location = stream.readCString(); + } + }); + + // file:src/parsing/urn.js + BoxParser.createFullBoxCtor("urn ", function (stream) { + this.name = stream.readCString(); + if (this.size - this.hdr_size - this.name.length - 1 > 0) { + this.location = stream.readCString(); + } + }); + + // file:src/parsing/uuid/piff/piffLsm.js + BoxParser.createUUIDBox("a5d40b30e81411ddba2f0800200c9a66", true, false, function (stream) { + this.LiveServerManifest = stream.readString(this.size - this.hdr_size).replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'"); + }); // file:src/parsing/uuid/piff/piffPssh.js + BoxParser.createUUIDBox("d08a4f1810f34a82b6c832d8aba183d3", true, false, function (stream) { + this.system_id = BoxParser.parseHex16(stream); + var datasize = stream.readUint32(); + if (datasize > 0) { + this.data = stream.readUint8Array(datasize); + } + }); + + // file:src/parsing/uuid/piff/piffSenc.js + BoxParser.createUUIDBox("a2394f525a9b4f14a2446c427c648df4", true, false /*, function(stream) { + if (this.flags & 0x1) { + this.AlgorithmID = stream.readUint24(); + this.IV_size = stream.readUint8(); + this.KID = BoxParser.parseHex16(stream); + } + var sample_count = stream.readUint32(); + this.samples = []; + for (var i = 0; i < sample_count; i++) { + var sample = {}; + sample.InitializationVector = this.readUint8Array(this.IV_size*8); + if (this.flags & 0x2) { + sample.subsamples = []; + sample.NumberOfEntries = stream.readUint16(); + for (var j = 0; j < sample.NumberOfEntries; j++) { + var subsample = {}; + subsample.BytesOfClearData = stream.readUint16(); + subsample.BytesOfProtectedData = stream.readUint32(); + sample.subsamples.push(subsample); + } + } + this.samples.push(sample); + } + }*/); + // file:src/parsing/uuid/piff/piffTenc.js + BoxParser.createUUIDBox("8974dbce7be74c5184f97148f9882554", true, false, function (stream) { + this.default_AlgorithmID = stream.readUint24(); + this.default_IV_size = stream.readUint8(); + this.default_KID = BoxParser.parseHex16(stream); + }); // file:src/parsing/uuid/piff/piffTfrf.js + BoxParser.createUUIDBox("d4807ef2ca3946958e5426cb9e46a79f", true, false, function (stream) { + this.fragment_count = stream.readUint8(); + this.entries = []; + for (var i = 0; i < this.fragment_count; i++) { + var entry = {}; + var absolute_time = 0; + var absolute_duration = 0; + if (this.version === 1) { + absolute_time = stream.readUint64(); + absolute_duration = stream.readUint64(); + } else { + absolute_time = stream.readUint32(); + absolute_duration = stream.readUint32(); + } + entry.absolute_time = absolute_time; + entry.absolute_duration = absolute_duration; + this.entries.push(entry); + } + }); // file:src/parsing/uuid/piff/piffTfxd.js + BoxParser.createUUIDBox("6d1d9b0542d544e680e2141daff757b2", true, false, function (stream) { + if (this.version === 1) { + this.absolute_time = stream.readUint64(); + this.duration = stream.readUint64(); + } else { + this.absolute_time = stream.readUint32(); + this.duration = stream.readUint32(); + } + }); // file:src/parsing/vmhd.js + BoxParser.createFullBoxCtor("vmhd", function (stream) { + this.graphicsmode = stream.readUint16(); + this.opcolor = stream.readUint16Array(3); + }); + + // file:src/parsing/vpcC.js + BoxParser.createFullBoxCtor("vpcC", function (stream) { + var tmp; + if (this.version === 1) { + this.profile = stream.readUint8(); + this.level = stream.readUint8(); + tmp = stream.readUint8(); + this.bitDepth = tmp >> 4; + this.chromaSubsampling = tmp >> 1 & 0x7; + this.videoFullRangeFlag = tmp & 0x1; + this.colourPrimaries = stream.readUint8(); + this.transferCharacteristics = stream.readUint8(); + this.matrixCoefficients = stream.readUint8(); + this.codecIntializationDataSize = stream.readUint16(); + this.codecIntializationData = stream.readUint8Array(this.codecIntializationDataSize); + } else { + this.profile = stream.readUint8(); + this.level = stream.readUint8(); + tmp = stream.readUint8(); + this.bitDepth = tmp >> 4 & 0xF; + this.colorSpace = tmp & 0xF; + tmp = stream.readUint8(); + this.chromaSubsampling = tmp >> 4 & 0xF; + this.transferFunction = tmp >> 1 & 0x7; + this.videoFullRangeFlag = tmp & 0x1; + this.codecIntializationDataSize = stream.readUint16(); + this.codecIntializationData = stream.readUint8Array(this.codecIntializationDataSize); + } + }); // file:src/parsing/vttC.js + BoxParser.createBoxCtor("vttC", function (stream) { + this.text = stream.readString(this.size - this.hdr_size); + }); + + // file:src/parsing/vvcC.js + BoxParser.createFullBoxCtor("vvcC", function (stream) { + var i, j; + + // helper object to simplify extracting individual bits + var bitReader = { + held_bits: undefined, + num_held_bits: 0, + stream_read_1_bytes: function (strm) { + this.held_bits = strm.readUint8(); + this.num_held_bits = 1 * 8; + }, + stream_read_2_bytes: function (strm) { + this.held_bits = strm.readUint16(); + this.num_held_bits = 2 * 8; + }, + extract_bits: function (num_bits) { + var ret = this.held_bits >> this.num_held_bits - num_bits & (1 << num_bits) - 1; + this.num_held_bits -= num_bits; + return ret; + } + }; + + // VvcDecoderConfigurationRecord + bitReader.stream_read_1_bytes(stream); + bitReader.extract_bits(5); // reserved + this.lengthSizeMinusOne = bitReader.extract_bits(2); + this.ptl_present_flag = bitReader.extract_bits(1); + if (this.ptl_present_flag) { + bitReader.stream_read_2_bytes(stream); + this.ols_idx = bitReader.extract_bits(9); + this.num_sublayers = bitReader.extract_bits(3); + this.constant_frame_rate = bitReader.extract_bits(2); + this.chroma_format_idc = bitReader.extract_bits(2); + bitReader.stream_read_1_bytes(stream); + this.bit_depth_minus8 = bitReader.extract_bits(3); + bitReader.extract_bits(5); // reserved + + // VvcPTLRecord + { + bitReader.stream_read_2_bytes(stream); + bitReader.extract_bits(2); // reserved + this.num_bytes_constraint_info = bitReader.extract_bits(6); + this.general_profile_idc = bitReader.extract_bits(7); + this.general_tier_flag = bitReader.extract_bits(1); + this.general_level_idc = stream.readUint8(); + bitReader.stream_read_1_bytes(stream); + this.ptl_frame_only_constraint_flag = bitReader.extract_bits(1); + this.ptl_multilayer_enabled_flag = bitReader.extract_bits(1); + this.general_constraint_info = new Uint8Array(this.num_bytes_constraint_info); + if (this.num_bytes_constraint_info) { + for (i = 0; i < this.num_bytes_constraint_info - 1; i++) { + var cnstr1 = bitReader.extract_bits(6); + bitReader.stream_read_1_bytes(stream); + var cnstr2 = bitReader.extract_bits(2); + this.general_constraint_info[i] = cnstr1 << 2 | cnstr2; + } + this.general_constraint_info[this.num_bytes_constraint_info - 1] = bitReader.extract_bits(6); + } else { + //forbidden in spec! + bitReader.extract_bits(6); + } + if (this.num_sublayers > 1) { + bitReader.stream_read_1_bytes(stream); + this.ptl_sublayer_present_mask = 0; + for (j = this.num_sublayers - 2; j >= 0; --j) { + var val = bitReader.extract_bits(1); + this.ptl_sublayer_present_mask |= val << j; + } + for (j = this.num_sublayers; j <= 8 && this.num_sublayers > 1; ++j) { + bitReader.extract_bits(1); // ptl_reserved_zero_bit + } + this.sublayer_level_idc = []; + for (j = this.num_sublayers - 2; j >= 0; --j) { + if (this.ptl_sublayer_present_mask & 1 << j) { + this.sublayer_level_idc[j] = stream.readUint8(); + } + } + } + this.ptl_num_sub_profiles = stream.readUint8(); + this.general_sub_profile_idc = []; + if (this.ptl_num_sub_profiles) { + for (i = 0; i < this.ptl_num_sub_profiles; i++) { + this.general_sub_profile_idc.push(stream.readUint32()); + } + } + } // end VvcPTLRecord + + this.max_picture_width = stream.readUint16(); + this.max_picture_height = stream.readUint16(); + this.avg_frame_rate = stream.readUint16(); + } + var VVC_NALU_OPI = 12; + var VVC_NALU_DEC_PARAM = 13; + this.nalu_arrays = []; + var num_of_arrays = stream.readUint8(); + for (i = 0; i < num_of_arrays; i++) { + var nalu_array = []; + this.nalu_arrays.push(nalu_array); + bitReader.stream_read_1_bytes(stream); + nalu_array.completeness = bitReader.extract_bits(1); + bitReader.extract_bits(2); // reserved + nalu_array.nalu_type = bitReader.extract_bits(5); + var numNalus = 1; + if (nalu_array.nalu_type != VVC_NALU_DEC_PARAM && nalu_array.nalu_type != VVC_NALU_OPI) { + numNalus = stream.readUint16(); + } + for (j = 0; j < numNalus; j++) { + var len = stream.readUint16(); + nalu_array.push({ + data: stream.readUint8Array(len), + length: len + }); + } + } + }); + // file:src/parsing/vvnC.js + BoxParser.createFullBoxCtor("vvnC", function (stream) { + // VvcNALUConfigBox + var tmp = strm.readUint8(); + this.lengthSizeMinusOne = tmp & 0x3; + }); + // file:src/box-codecs.js + BoxParser.SampleEntry.prototype.isVideo = function () { + return false; + }; + BoxParser.SampleEntry.prototype.isAudio = function () { + return false; + }; + BoxParser.SampleEntry.prototype.isSubtitle = function () { + return false; + }; + BoxParser.SampleEntry.prototype.isMetadata = function () { + return false; + }; + BoxParser.SampleEntry.prototype.isHint = function () { + return false; + }; + BoxParser.SampleEntry.prototype.getCodec = function () { + return this.type.replace('.', ''); + }; + BoxParser.SampleEntry.prototype.getWidth = function () { + return ""; + }; + BoxParser.SampleEntry.prototype.getHeight = function () { + return ""; + }; + BoxParser.SampleEntry.prototype.getChannelCount = function () { + return ""; + }; + BoxParser.SampleEntry.prototype.getSampleRate = function () { + return ""; + }; + BoxParser.SampleEntry.prototype.getSampleSize = function () { + return ""; + }; + BoxParser.VisualSampleEntry.prototype.isVideo = function () { + return true; + }; + BoxParser.VisualSampleEntry.prototype.getWidth = function () { + return this.width; + }; + BoxParser.VisualSampleEntry.prototype.getHeight = function () { + return this.height; + }; + BoxParser.AudioSampleEntry.prototype.isAudio = function () { + return true; + }; + BoxParser.AudioSampleEntry.prototype.getChannelCount = function () { + return this.channel_count; + }; + BoxParser.AudioSampleEntry.prototype.getSampleRate = function () { + return this.samplerate; + }; + BoxParser.AudioSampleEntry.prototype.getSampleSize = function () { + return this.samplesize; + }; + BoxParser.SubtitleSampleEntry.prototype.isSubtitle = function () { + return true; + }; + BoxParser.MetadataSampleEntry.prototype.isMetadata = function () { + return true; + }; + BoxParser.decimalToHex = function (d, padding) { + var hex = Number(d).toString(16); + padding = typeof padding === "undefined" || padding === null ? padding = 2 : padding; + while (hex.length < padding) { + hex = "0" + hex; + } + return hex; + }; + BoxParser.avc1SampleEntry.prototype.getCodec = BoxParser.avc2SampleEntry.prototype.getCodec = BoxParser.avc3SampleEntry.prototype.getCodec = BoxParser.avc4SampleEntry.prototype.getCodec = function () { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.avcC) { + return baseCodec + "." + BoxParser.decimalToHex(this.avcC.AVCProfileIndication) + "" + BoxParser.decimalToHex(this.avcC.profile_compatibility) + "" + BoxParser.decimalToHex(this.avcC.AVCLevelIndication); + } else { + return baseCodec; + } + }; + BoxParser.hev1SampleEntry.prototype.getCodec = BoxParser.hvc1SampleEntry.prototype.getCodec = function () { + var i; + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.hvcC) { + baseCodec += '.'; + switch (this.hvcC.general_profile_space) { + case 0: + baseCodec += ''; + break; + case 1: + baseCodec += 'A'; + break; + case 2: + baseCodec += 'B'; + break; + case 3: + baseCodec += 'C'; + break; + } + baseCodec += this.hvcC.general_profile_idc; + baseCodec += '.'; + var val = this.hvcC.general_profile_compatibility; + var reversed = 0; + for (i = 0; i < 32; i++) { + reversed |= val & 1; + if (i == 31) break; + reversed <<= 1; + val >>= 1; + } + baseCodec += BoxParser.decimalToHex(reversed, 0); + baseCodec += '.'; + if (this.hvcC.general_tier_flag === 0) { + baseCodec += 'L'; + } else { + baseCodec += 'H'; + } + baseCodec += this.hvcC.general_level_idc; + var hasByte = false; + var constraint_string = ""; + for (i = 5; i >= 0; i--) { + if (this.hvcC.general_constraint_indicator[i] || hasByte) { + constraint_string = "." + BoxParser.decimalToHex(this.hvcC.general_constraint_indicator[i], 0) + constraint_string; + hasByte = true; + } + } + baseCodec += constraint_string; + } + return baseCodec; + }; + BoxParser.vvc1SampleEntry.prototype.getCodec = BoxParser.vvi1SampleEntry.prototype.getCodec = function () { + var i; + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.vvcC) { + baseCodec += '.' + this.vvcC.general_profile_idc; + if (this.vvcC.general_tier_flag) { + baseCodec += '.H'; + } else { + baseCodec += '.L'; + } + baseCodec += this.vvcC.general_level_idc; + var constraint_string = ""; + if (this.vvcC.general_constraint_info) { + var bytes = []; + var byte = 0; + byte |= this.vvcC.ptl_frame_only_constraint << 7; + byte |= this.vvcC.ptl_multilayer_enabled << 6; + var last_nonzero; + for (i = 0; i < this.vvcC.general_constraint_info.length; ++i) { + byte |= this.vvcC.general_constraint_info[i] >> 2 & 0x3f; + bytes.push(byte); + if (byte) { + last_nonzero = i; + } + byte = this.vvcC.general_constraint_info[i] >> 2 & 0x03; + } + if (last_nonzero === undefined) { + constraint_string = ".CA"; + } else { + constraint_string = ".C"; + var base32_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; + var held_bits = 0; + var num_held_bits = 0; + for (i = 0; i <= last_nonzero; ++i) { + held_bits = held_bits << 8 | bytes[i]; + num_held_bits += 8; + while (num_held_bits >= 5) { + var val = held_bits >> num_held_bits - 5 & 0x1f; + constraint_string += base32_chars[val]; + num_held_bits -= 5; + held_bits &= (1 << num_held_bits) - 1; + } + } + if (num_held_bits) { + held_bits <<= 5 - num_held_bits; // right-pad with zeros to 5 bits (is this correct?) + constraint_string += base32_chars[held_bits & 0x1f]; + } + } + } + baseCodec += constraint_string; + } + return baseCodec; + }; + BoxParser.mp4aSampleEntry.prototype.getCodec = function () { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.esds && this.esds.esd) { + var oti = this.esds.esd.getOTI(); + var dsi = this.esds.esd.getAudioConfig(); + return baseCodec + "." + BoxParser.decimalToHex(oti) + (dsi ? "." + dsi : ""); + } else { + return baseCodec; + } + }; + BoxParser.stxtSampleEntry.prototype.getCodec = function () { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + if (this.mime_format) { + return baseCodec + "." + this.mime_format; + } else { + return baseCodec; + } + }; + BoxParser.vp08SampleEntry.prototype.getCodec = BoxParser.vp09SampleEntry.prototype.getCodec = function () { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + var level = this.vpcC.level; + if (level == 0) { + level = "00"; + } + var bitDepth = this.vpcC.bitDepth; + if (bitDepth == 8) { + bitDepth = "08"; + } + return baseCodec + ".0" + this.vpcC.profile + "." + level + "." + bitDepth; + }; + BoxParser.av01SampleEntry.prototype.getCodec = function () { + var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); + var level = this.av1C.seq_level_idx_0; + if (level < 10) { + level = "0" + level; + } + var bitdepth; + if (this.av1C.seq_profile === 2 && this.av1C.high_bitdepth === 1) { + bitdepth = this.av1C.twelve_bit === 1 ? "12" : "10"; + } else if (this.av1C.seq_profile <= 2) { + bitdepth = this.av1C.high_bitdepth === 1 ? "10" : "08"; + } + // TODO need to parse the SH to find color config + return baseCodec + "." + this.av1C.seq_profile + "." + level + (this.av1C.seq_tier_0 ? "H" : "M") + "." + bitdepth; //+"."+this.av1C.monochrome+"."+this.av1C.chroma_subsampling_x+""+this.av1C.chroma_subsampling_y+""+this.av1C.chroma_sample_position; + }; + // file:src/box-write.js + /* + * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + BoxParser.Box.prototype.writeHeader = function (stream, msg) { + this.size += 8; + if (this.size > MAX_SIZE) { + this.size += 8; + } + if (this.type === "uuid") { + this.size += 16; + } + Log.debug("BoxWriter", "Writing box " + this.type + " of size: " + this.size + " at position " + stream.getPosition() + (msg || "")); + if (this.size > MAX_SIZE) { + stream.writeUint32(1); + } else { + this.sizePosition = stream.getPosition(); + stream.writeUint32(this.size); + } + stream.writeString(this.type, null, 4); + if (this.type === "uuid") { + stream.writeUint8Array(this.uuid); + } + if (this.size > MAX_SIZE) { + stream.writeUint64(this.size); + } + }; + BoxParser.FullBox.prototype.writeHeader = function (stream) { + this.size += 4; + BoxParser.Box.prototype.writeHeader.call(this, stream, " v=" + this.version + " f=" + this.flags); + stream.writeUint8(this.version); + stream.writeUint24(this.flags); + }; + BoxParser.Box.prototype.write = function (stream) { + if (this.type === "mdat") { + /* TODO: fix this */ + if (this.data) { + this.size = this.data.length; + this.writeHeader(stream); + stream.writeUint8Array(this.data); + } + } else { + this.size = this.data ? this.data.length : 0; + this.writeHeader(stream); + if (this.data) { + stream.writeUint8Array(this.data); + } + } + }; + BoxParser.ContainerBox.prototype.write = function (stream) { + this.size = 0; + this.writeHeader(stream); + for (var i = 0; i < this.boxes.length; i++) { + if (this.boxes[i]) { + this.boxes[i].write(stream); + this.size += this.boxes[i].size; + } + } + /* adjusting the size, now that all sub-boxes are known */ + Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); + stream.adjustUint32(this.sizePosition, this.size); + }; + BoxParser.TrackReferenceTypeBox.prototype.write = function (stream) { + this.size = this.track_ids.length * 4; + this.writeHeader(stream); + stream.writeUint32Array(this.track_ids); + }; + + // file:src/writing/avcC.js + BoxParser.avcCBox.prototype.write = function (stream) { + var i; + this.size = 7; + for (i = 0; i < this.SPS.length; i++) { + this.size += 2 + this.SPS[i].length; + } + for (i = 0; i < this.PPS.length; i++) { + this.size += 2 + this.PPS[i].length; + } + if (this.ext) { + this.size += this.ext.length; + } + this.writeHeader(stream); + stream.writeUint8(this.configurationVersion); + stream.writeUint8(this.AVCProfileIndication); + stream.writeUint8(this.profile_compatibility); + stream.writeUint8(this.AVCLevelIndication); + stream.writeUint8(this.lengthSizeMinusOne + (63 << 2)); + stream.writeUint8(this.SPS.length + (7 << 5)); + for (i = 0; i < this.SPS.length; i++) { + stream.writeUint16(this.SPS[i].length); + stream.writeUint8Array(this.SPS[i].nalu); + } + stream.writeUint8(this.PPS.length); + for (i = 0; i < this.PPS.length; i++) { + stream.writeUint16(this.PPS[i].length); + stream.writeUint8Array(this.PPS[i].nalu); + } + if (this.ext) { + stream.writeUint8Array(this.ext); + } + }; + + // file:src/writing/co64.js + BoxParser.co64Box.prototype.write = function (stream) { + var i; + this.version = 0; + this.flags = 0; + this.size = 4 + 8 * this.chunk_offsets.length; + this.writeHeader(stream); + stream.writeUint32(this.chunk_offsets.length); + for (i = 0; i < this.chunk_offsets.length; i++) { + stream.writeUint64(this.chunk_offsets[i]); + } + }; + + // file:src/writing/cslg.js + BoxParser.cslgBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4 * 5; + this.writeHeader(stream); + stream.writeInt32(this.compositionToDTSShift); + stream.writeInt32(this.leastDecodeToDisplayDelta); + stream.writeInt32(this.greatestDecodeToDisplayDelta); + stream.writeInt32(this.compositionStartTime); + stream.writeInt32(this.compositionEndTime); + }; + + // file:src/writing/ctts.js + BoxParser.cttsBox.prototype.write = function (stream) { + var i; + this.version = 0; + this.flags = 0; + this.size = 4 + 8 * this.sample_counts.length; + this.writeHeader(stream); + stream.writeUint32(this.sample_counts.length); + for (i = 0; i < this.sample_counts.length; i++) { + stream.writeUint32(this.sample_counts[i]); + if (this.version === 1) { + stream.writeInt32(this.sample_offsets[i]); /* signed */ + } else { + stream.writeUint32(this.sample_offsets[i]); /* unsigned */ + } + } + }; + + // file:src/writing/dref.js + BoxParser.drefBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4; // + this.writeHeader(stream); + stream.writeUint32(this.entries.length); + for (var i = 0; i < this.entries.length; i++) { + this.entries[i].write(stream); + this.size += this.entries[i].size; + } + /* adjusting the size, now that all sub-boxes are known */ + Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); + stream.adjustUint32(this.sizePosition, this.size); + }; + + // file:src/writing/elng.js + BoxParser.elngBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = this.extended_language.length; + this.writeHeader(stream); + stream.writeString(this.extended_language); + }; + + // file:src/writing/elst.js + BoxParser.elstBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4 + 12 * this.entries.length; + this.writeHeader(stream); + stream.writeUint32(this.entries.length); + for (var i = 0; i < this.entries.length; i++) { + var entry = this.entries[i]; + stream.writeUint32(entry.segment_duration); + stream.writeInt32(entry.media_time); + stream.writeInt16(entry.media_rate_integer); + stream.writeInt16(entry.media_rate_fraction); + } + }; + + // file:src/writing/emsg.js + BoxParser.emsgBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4 * 4 + this.message_data.length + (this.scheme_id_uri.length + 1) + (this.value.length + 1); + this.writeHeader(stream); + stream.writeCString(this.scheme_id_uri); + stream.writeCString(this.value); + stream.writeUint32(this.timescale); + stream.writeUint32(this.presentation_time_delta); + stream.writeUint32(this.event_duration); + stream.writeUint32(this.id); + stream.writeUint8Array(this.message_data); + }; + + // file:src/writing/ftyp.js + BoxParser.ftypBox.prototype.write = function (stream) { + this.size = 8 + 4 * this.compatible_brands.length; + this.writeHeader(stream); + stream.writeString(this.major_brand, null, 4); + stream.writeUint32(this.minor_version); + for (var i = 0; i < this.compatible_brands.length; i++) { + stream.writeString(this.compatible_brands[i], null, 4); + } + }; + + // file:src/writing/hdlr.js + BoxParser.hdlrBox.prototype.write = function (stream) { + this.size = 5 * 4 + this.name.length + 1; + this.version = 0; + this.flags = 0; + this.writeHeader(stream); + stream.writeUint32(0); + stream.writeString(this.handler, null, 4); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeCString(this.name); + }; + + // file:src/writing/hvcC.js + BoxParser.hvcCBox.prototype.write = function (stream) { + var i, j; + this.size = 23; + for (i = 0; i < this.nalu_arrays.length; i++) { + this.size += 3; + for (j = 0; j < this.nalu_arrays[i].length; j++) { + this.size += 2 + this.nalu_arrays[i][j].data.length; + } + } + this.writeHeader(stream); + stream.writeUint8(this.configurationVersion); + stream.writeUint8((this.general_profile_space << 6) + (this.general_tier_flag << 5) + this.general_profile_idc); + stream.writeUint32(this.general_profile_compatibility); + stream.writeUint8Array(this.general_constraint_indicator); + stream.writeUint8(this.general_level_idc); + stream.writeUint16(this.min_spatial_segmentation_idc + (15 << 24)); + stream.writeUint8(this.parallelismType + (63 << 2)); + stream.writeUint8(this.chroma_format_idc + (63 << 2)); + stream.writeUint8(this.bit_depth_luma_minus8 + (31 << 3)); + stream.writeUint8(this.bit_depth_chroma_minus8 + (31 << 3)); + stream.writeUint16(this.avgFrameRate); + stream.writeUint8((this.constantFrameRate << 6) + (this.numTemporalLayers << 3) + (this.temporalIdNested << 2) + this.lengthSizeMinusOne); + stream.writeUint8(this.nalu_arrays.length); + for (i = 0; i < this.nalu_arrays.length; i++) { + // bit(1) array_completeness + bit(1) reserved = 0 + bit(6) nal_unit_type + stream.writeUint8((this.nalu_arrays[i].completeness << 7) + this.nalu_arrays[i].nalu_type); + stream.writeUint16(this.nalu_arrays[i].length); + for (j = 0; j < this.nalu_arrays[i].length; j++) { + stream.writeUint16(this.nalu_arrays[i][j].data.length); + stream.writeUint8Array(this.nalu_arrays[i][j].data); + } + } + }; + // file:src/writing/kind.js + BoxParser.kindBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = this.schemeURI.length + 1 + (this.value.length + 1); + this.writeHeader(stream); + stream.writeCString(this.schemeURI); + stream.writeCString(this.value); + }; + + // file:src/writing/mdhd.js + BoxParser.mdhdBox.prototype.write = function (stream) { + this.size = 4 * 4 + 2 * 2; + this.flags = 0; + this.version = 0; + this.writeHeader(stream); + stream.writeUint32(this.creation_time); + stream.writeUint32(this.modification_time); + stream.writeUint32(this.timescale); + stream.writeUint32(this.duration); + stream.writeUint16(this.language); + stream.writeUint16(0); + }; + + // file:src/writing/mehd.js + BoxParser.mehdBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4; + this.writeHeader(stream); + stream.writeUint32(this.fragment_duration); + }; + + // file:src/writing/mfhd.js + BoxParser.mfhdBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4; + this.writeHeader(stream); + stream.writeUint32(this.sequence_number); + }; + + // file:src/writing/mvhd.js + BoxParser.mvhdBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 23 * 4 + 2 * 2; + this.writeHeader(stream); + stream.writeUint32(this.creation_time); + stream.writeUint32(this.modification_time); + stream.writeUint32(this.timescale); + stream.writeUint32(this.duration); + stream.writeUint32(this.rate); + stream.writeUint16(this.volume << 8); + stream.writeUint16(0); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint32Array(this.matrix); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint32(this.next_track_id); + }; + + // file:src/writing/sampleentry.js + BoxParser.SampleEntry.prototype.writeHeader = function (stream) { + this.size = 8; + BoxParser.Box.prototype.writeHeader.call(this, stream); + stream.writeUint8(0); + stream.writeUint8(0); + stream.writeUint8(0); + stream.writeUint8(0); + stream.writeUint8(0); + stream.writeUint8(0); + stream.writeUint16(this.data_reference_index); + }; + BoxParser.SampleEntry.prototype.writeFooter = function (stream) { + for (var i = 0; i < this.boxes.length; i++) { + this.boxes[i].write(stream); + this.size += this.boxes[i].size; + } + Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); + stream.adjustUint32(this.sizePosition, this.size); + }; + BoxParser.SampleEntry.prototype.write = function (stream) { + this.writeHeader(stream); + stream.writeUint8Array(this.data); + this.size += this.data.length; + Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); + stream.adjustUint32(this.sizePosition, this.size); + }; + BoxParser.VisualSampleEntry.prototype.write = function (stream) { + this.writeHeader(stream); + this.size += 2 * 7 + 6 * 4 + 32; + stream.writeUint16(0); + stream.writeUint16(0); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint16(this.width); + stream.writeUint16(this.height); + stream.writeUint32(this.horizresolution); + stream.writeUint32(this.vertresolution); + stream.writeUint32(0); + stream.writeUint16(this.frame_count); + stream.writeUint8(Math.min(31, this.compressorname.length)); + stream.writeString(this.compressorname, null, 31); + stream.writeUint16(this.depth); + stream.writeInt16(-1); + this.writeFooter(stream); + }; + BoxParser.AudioSampleEntry.prototype.write = function (stream) { + this.writeHeader(stream); + this.size += 2 * 4 + 3 * 4; + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeUint16(this.channel_count); + stream.writeUint16(this.samplesize); + stream.writeUint16(0); + stream.writeUint16(0); + stream.writeUint32(this.samplerate << 16); + this.writeFooter(stream); + }; + BoxParser.stppSampleEntry.prototype.write = function (stream) { + this.writeHeader(stream); + this.size += this.namespace.length + 1 + this.schema_location.length + 1 + this.auxiliary_mime_types.length + 1; + stream.writeCString(this.namespace); + stream.writeCString(this.schema_location); + stream.writeCString(this.auxiliary_mime_types); + this.writeFooter(stream); + }; + + // file:src/writing/samplegroups/samplegroup.js + BoxParser.SampleGroupEntry.prototype.write = function (stream) { + stream.writeUint8Array(this.data); + }; + + // file:src/writing/sbgp.js + BoxParser.sbgpBox.prototype.write = function (stream) { + this.version = 1; + this.flags = 0; + this.size = 12 + 8 * this.entries.length; + this.writeHeader(stream); + stream.writeString(this.grouping_type, null, 4); + stream.writeUint32(this.grouping_type_parameter); + stream.writeUint32(this.entries.length); + for (var i = 0; i < this.entries.length; i++) { + var entry = this.entries[i]; + stream.writeInt32(entry.sample_count); + stream.writeInt32(entry.group_description_index); + } + }; + + // file:src/writing/sgpd.js + BoxParser.sgpdBox.prototype.write = function (stream) { + var i; + var entry; + // leave version as read + // this.version; + this.flags = 0; + this.size = 12; + for (i = 0; i < this.entries.length; i++) { + entry = this.entries[i]; + if (this.version === 1) { + if (this.default_length === 0) { + this.size += 4; + } + this.size += entry.data.length; + } + } + this.writeHeader(stream); + stream.writeString(this.grouping_type, null, 4); + if (this.version === 1) { + stream.writeUint32(this.default_length); + } + if (this.version >= 2) { + stream.writeUint32(this.default_sample_description_index); + } + stream.writeUint32(this.entries.length); + for (i = 0; i < this.entries.length; i++) { + entry = this.entries[i]; + if (this.version === 1) { + if (this.default_length === 0) { + stream.writeUint32(entry.description_length); + } + } + entry.write(stream); + } + }; + + // file:src/writing/sidx.js + BoxParser.sidxBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4 * 4 + 2 + 2 + 12 * this.references.length; + this.writeHeader(stream); + stream.writeUint32(this.reference_ID); + stream.writeUint32(this.timescale); + stream.writeUint32(this.earliest_presentation_time); + stream.writeUint32(this.first_offset); + stream.writeUint16(0); + stream.writeUint16(this.references.length); + for (var i = 0; i < this.references.length; i++) { + var ref = this.references[i]; + stream.writeUint32(ref.reference_type << 31 | ref.referenced_size); + stream.writeUint32(ref.subsegment_duration); + stream.writeUint32(ref.starts_with_SAP << 31 | ref.SAP_type << 28 | ref.SAP_delta_time); + } + }; + + // file:src/writing/smhd.js + BoxParser.smhdBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 1; + this.size = 4; + this.writeHeader(stream); + stream.writeUint16(this.balance); + stream.writeUint16(0); + }; + // file:src/writing/stco.js + BoxParser.stcoBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4 + 4 * this.chunk_offsets.length; + this.writeHeader(stream); + stream.writeUint32(this.chunk_offsets.length); + stream.writeUint32Array(this.chunk_offsets); + }; + + // file:src/writing/stsc.js + BoxParser.stscBox.prototype.write = function (stream) { + var i; + this.version = 0; + this.flags = 0; + this.size = 4 + 12 * this.first_chunk.length; + this.writeHeader(stream); + stream.writeUint32(this.first_chunk.length); + for (i = 0; i < this.first_chunk.length; i++) { + stream.writeUint32(this.first_chunk[i]); + stream.writeUint32(this.samples_per_chunk[i]); + stream.writeUint32(this.sample_description_index[i]); + } + }; + + // file:src/writing/stsd.js + BoxParser.stsdBox.prototype.write = function (stream) { + var i; + this.version = 0; + this.flags = 0; + this.size = 0; + this.writeHeader(stream); + stream.writeUint32(this.entries.length); + this.size += 4; + for (i = 0; i < this.entries.length; i++) { + this.entries[i].write(stream); + this.size += this.entries[i].size; + } + /* adjusting the size, now that all sub-boxes are known */ + Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); + stream.adjustUint32(this.sizePosition, this.size); + }; + + // file:src/writing/stsh.js + BoxParser.stshBox.prototype.write = function (stream) { + var i; + this.version = 0; + this.flags = 0; + this.size = 4 + 8 * this.shadowed_sample_numbers.length; + this.writeHeader(stream); + stream.writeUint32(this.shadowed_sample_numbers.length); + for (i = 0; i < this.shadowed_sample_numbers.length; i++) { + stream.writeUint32(this.shadowed_sample_numbers[i]); + stream.writeUint32(this.sync_sample_numbers[i]); + } + }; + + // file:src/writing/stss.js + BoxParser.stssBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4 + 4 * this.sample_numbers.length; + this.writeHeader(stream); + stream.writeUint32(this.sample_numbers.length); + stream.writeUint32Array(this.sample_numbers); + }; + + // file:src/writing/stsz.js + BoxParser.stszBox.prototype.write = function (stream) { + var i; + var constant = true; + this.version = 0; + this.flags = 0; + if (this.sample_sizes.length > 0) { + i = 0; + while (i + 1 < this.sample_sizes.length) { + if (this.sample_sizes[i + 1] !== this.sample_sizes[0]) { + constant = false; + break; + } else { + i++; + } + } + } else { + constant = false; + } + this.size = 8; + if (!constant) { + this.size += 4 * this.sample_sizes.length; + } + this.writeHeader(stream); + if (!constant) { + stream.writeUint32(0); + } else { + stream.writeUint32(this.sample_sizes[0]); + } + stream.writeUint32(this.sample_sizes.length); + if (!constant) { + stream.writeUint32Array(this.sample_sizes); + } + }; + + // file:src/writing/stts.js + BoxParser.sttsBox.prototype.write = function (stream) { + var i; + this.version = 0; + this.flags = 0; + this.size = 4 + 8 * this.sample_counts.length; + this.writeHeader(stream); + stream.writeUint32(this.sample_counts.length); + for (i = 0; i < this.sample_counts.length; i++) { + stream.writeUint32(this.sample_counts[i]); + stream.writeUint32(this.sample_deltas[i]); + } + }; + + // file:src/writing/tfdt.js + BoxParser.tfdtBox.prototype.write = function (stream) { + var UINT32_MAX = Math.pow(2, 32) - 1; + // use version 1 if baseMediaDecodeTime does not fit 32 bits + this.version = this.baseMediaDecodeTime > UINT32_MAX ? 1 : 0; + this.flags = 0; + this.size = 4; + if (this.version === 1) { + this.size += 4; + } + this.writeHeader(stream); + if (this.version === 1) { + stream.writeUint64(this.baseMediaDecodeTime); + } else { + stream.writeUint32(this.baseMediaDecodeTime); + } + }; + + // file:src/writing/tfhd.js + BoxParser.tfhdBox.prototype.write = function (stream) { + this.version = 0; + this.size = 4; + if (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { + this.size += 8; + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { + this.size += 4; + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { + this.size += 4; + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { + this.size += 4; + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { + this.size += 4; + } + this.writeHeader(stream); + stream.writeUint32(this.track_id); + if (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { + stream.writeUint64(this.base_data_offset); + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { + stream.writeUint32(this.default_sample_description_index); + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { + stream.writeUint32(this.default_sample_duration); + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { + stream.writeUint32(this.default_sample_size); + } + if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { + stream.writeUint32(this.default_sample_flags); + } + }; + + // file:src/writing/tkhd.js + BoxParser.tkhdBox.prototype.write = function (stream) { + this.version = 0; + //this.flags = 0; + this.size = 4 * 18 + 2 * 4; + this.writeHeader(stream); + stream.writeUint32(this.creation_time); + stream.writeUint32(this.modification_time); + stream.writeUint32(this.track_id); + stream.writeUint32(0); + stream.writeUint32(this.duration); + stream.writeUint32(0); + stream.writeUint32(0); + stream.writeInt16(this.layer); + stream.writeInt16(this.alternate_group); + stream.writeInt16(this.volume << 8); + stream.writeUint16(0); + stream.writeInt32Array(this.matrix); + stream.writeUint32(this.width); + stream.writeUint32(this.height); + }; + + // file:src/writing/trex.js + BoxParser.trexBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = 4 * 5; + this.writeHeader(stream); + stream.writeUint32(this.track_id); + stream.writeUint32(this.default_sample_description_index); + stream.writeUint32(this.default_sample_duration); + stream.writeUint32(this.default_sample_size); + stream.writeUint32(this.default_sample_flags); + }; + + // file:src/writing/trun.js + BoxParser.trunBox.prototype.write = function (stream) { + this.version = 0; + this.size = 4; + if (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { + this.size += 4; + } + if (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { + this.size += 4; + } + if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { + this.size += 4 * this.sample_duration.length; + } + if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { + this.size += 4 * this.sample_size.length; + } + if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { + this.size += 4 * this.sample_flags.length; + } + if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { + this.size += 4 * this.sample_composition_time_offset.length; + } + this.writeHeader(stream); + stream.writeUint32(this.sample_count); + if (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { + this.data_offset_position = stream.getPosition(); + stream.writeInt32(this.data_offset); //signed + } + if (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { + stream.writeUint32(this.first_sample_flags); + } + for (var i = 0; i < this.sample_count; i++) { + if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { + stream.writeUint32(this.sample_duration[i]); + } + if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { + stream.writeUint32(this.sample_size[i]); + } + if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { + stream.writeUint32(this.sample_flags[i]); + } + if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { + if (this.version === 0) { + stream.writeUint32(this.sample_composition_time_offset[i]); + } else { + stream.writeInt32(this.sample_composition_time_offset[i]); //signed + } + } + } + }; + + // file:src/writing/url.js + BoxParser["url Box"].prototype.write = function (stream) { + this.version = 0; + if (this.location) { + this.flags = 0; + this.size = this.location.length + 1; + } else { + this.flags = 0x000001; + this.size = 0; + } + this.writeHeader(stream); + if (this.location) { + stream.writeCString(this.location); + } + }; + + // file:src/writing/urn.js + BoxParser["urn Box"].prototype.write = function (stream) { + this.version = 0; + this.flags = 0; + this.size = this.name.length + 1 + (this.location ? this.location.length + 1 : 0); + this.writeHeader(stream); + stream.writeCString(this.name); + if (this.location) { + stream.writeCString(this.location); + } + }; + + // file:src/writing/vmhd.js + BoxParser.vmhdBox.prototype.write = function (stream) { + this.version = 0; + this.flags = 1; + this.size = 8; + this.writeHeader(stream); + stream.writeUint16(this.graphicsmode); + stream.writeUint16Array(this.opcolor); + }; + + // file:src/box-unpack.js + /* + * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + BoxParser.cttsBox.prototype.unpack = function (samples) { + var i, j, k; + k = 0; + for (i = 0; i < this.sample_counts.length; i++) { + for (j = 0; j < this.sample_counts[i]; j++) { + samples[k].pts = samples[k].dts + this.sample_offsets[i]; + k++; + } + } + }; + BoxParser.sttsBox.prototype.unpack = function (samples) { + var i, j, k; + k = 0; + for (i = 0; i < this.sample_counts.length; i++) { + for (j = 0; j < this.sample_counts[i]; j++) { + if (k === 0) { + samples[k].dts = 0; + } else { + samples[k].dts = samples[k - 1].dts + this.sample_deltas[i]; + } + k++; + } + } + }; + BoxParser.stcoBox.prototype.unpack = function (samples) { + var i; + for (i = 0; i < this.chunk_offsets.length; i++) { + samples[i].offset = this.chunk_offsets[i]; + } + }; + BoxParser.stscBox.prototype.unpack = function (samples) { + var i, j, k, l, m; + l = 0; + m = 0; + for (i = 0; i < this.first_chunk.length; i++) { + for (j = 0; j < (i + 1 < this.first_chunk.length ? this.first_chunk[i + 1] : Infinity); j++) { + m++; + for (k = 0; k < this.samples_per_chunk[i]; k++) { + if (samples[l]) { + samples[l].description_index = this.sample_description_index[i]; + samples[l].chunk_index = m; + } else { + return; + } + l++; + } + } + } + }; + BoxParser.stszBox.prototype.unpack = function (samples) { + var i; + for (i = 0; i < this.sample_sizes.length; i++) { + samples[i].size = this.sample_sizes[i]; + } + }; + // file:src/box-diff.js + + BoxParser.DIFF_BOXES_PROP_NAMES = ["boxes", "entries", "references", "subsamples", "items", "item_infos", "extents", "associations", "subsegments", "ranges", "seekLists", "seekPoints", "esd", "levels"]; + BoxParser.DIFF_PRIMITIVE_ARRAY_PROP_NAMES = ["compatible_brands", "matrix", "opcolor", "sample_counts", "sample_counts", "sample_deltas", "first_chunk", "samples_per_chunk", "sample_sizes", "chunk_offsets", "sample_offsets", "sample_description_index", "sample_duration"]; + BoxParser.boxEqualFields = function (box_a, box_b) { + if (box_a && !box_b) return false; + var prop; + for (prop in box_a) { + if (BoxParser.DIFF_BOXES_PROP_NAMES.indexOf(prop) > -1) { + continue; + // } else if (excluded_fields && excluded_fields.indexOf(prop) > -1) { + // continue; + } else if (box_a[prop] instanceof BoxParser.Box || box_b[prop] instanceof BoxParser.Box) { + continue; + } else if (typeof box_a[prop] === "undefined" || typeof box_b[prop] === "undefined") { + continue; + } else if (typeof box_a[prop] === "function" || typeof box_b[prop] === "function") { + continue; + } else if (box_a.subBoxNames && box_a.subBoxNames.indexOf(prop.slice(0, 4)) > -1 || box_b.subBoxNames && box_b.subBoxNames.indexOf(prop.slice(0, 4)) > -1) { + continue; + } else { + if (prop === "data" || prop === "start" || prop === "size" || prop === "creation_time" || prop === "modification_time") { + continue; + } else if (BoxParser.DIFF_PRIMITIVE_ARRAY_PROP_NAMES.indexOf(prop) > -1) { + continue; + } else { + if (box_a[prop] !== box_b[prop]) { + return false; + } + } + } + } + return true; + }; + BoxParser.boxEqual = function (box_a, box_b) { + if (!BoxParser.boxEqualFields(box_a, box_b)) { + return false; + } + for (var j = 0; j < BoxParser.DIFF_BOXES_PROP_NAMES.length; j++) { + var name = BoxParser.DIFF_BOXES_PROP_NAMES[j]; + if (box_a[name] && box_b[name]) { + if (!BoxParser.boxEqual(box_a[name], box_b[name])) { + return false; + } + } + } + return true; + }; // file:src/text-mp4.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var VTTin4Parser = function () {}; + VTTin4Parser.prototype.parseSample = function (data) { + var cues, cue; + var stream = new MP4BoxStream(data.buffer); + cues = []; + while (!stream.isEos()) { + cue = BoxParser.parseOneBox(stream, false); + if (cue.code === BoxParser.OK && cue.box.type === "vttc") { + cues.push(cue.box); + } + } + return cues; + }; + VTTin4Parser.prototype.getText = function (startTime, endTime, data) { + function pad(n, width, z) { + z = z || '0'; + n = n + ''; + return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n; + } + function secToTimestamp(insec) { + var h = Math.floor(insec / 3600); + var m = Math.floor((insec - h * 3600) / 60); + var s = Math.floor(insec - h * 3600 - m * 60); + var ms = Math.floor((insec - h * 3600 - m * 60 - s) * 1000); + return "" + pad(h, 2) + ":" + pad(m, 2) + ":" + pad(s, 2) + "." + pad(ms, 3); + } + var cues = this.parseSample(data); + var string = ""; + for (var i = 0; i < cues.length; i++) { + var cueIn4 = cues[i]; + string += secToTimestamp(startTime) + " --> " + secToTimestamp(endTime) + "\r\n"; + string += cueIn4.payl.text; + } + return string; + }; + var XMLSubtitlein4Parser = function () {}; + XMLSubtitlein4Parser.prototype.parseSample = function (sample) { + var res = {}; + var i; + res.resources = []; + var stream = new MP4BoxStream(sample.data.buffer); + if (!sample.subsamples || sample.subsamples.length === 0) { + res.documentString = stream.readString(sample.data.length); + } else { + res.documentString = stream.readString(sample.subsamples[0].size); + if (sample.subsamples.length > 1) { + for (i = 1; i < sample.subsamples.length; i++) { + res.resources[i] = stream.readUint8Array(sample.subsamples[i].size); + } + } + } + if (typeof DOMParser !== "undefined") { + res.document = new DOMParser().parseFromString(res.documentString, "application/xml"); + } + return res; + }; + var Textin4Parser = function () {}; + Textin4Parser.prototype.parseSample = function (sample) { + var textString; + var stream = new MP4BoxStream(sample.data.buffer); + textString = stream.readString(sample.data.length); + return textString; + }; + Textin4Parser.prototype.parseConfig = function (data) { + var textString; + var stream = new MP4BoxStream(data.buffer); + stream.readUint32(); // version & flags + textString = stream.readCString(); + return textString; + }; + { + exports.VTTin4Parser = VTTin4Parser; + exports.XMLSubtitlein4Parser = XMLSubtitlein4Parser; + exports.Textin4Parser = Textin4Parser; + } + // file:src/isofile.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var ISOFile = function (stream) { + /* MutiBufferStream object used to parse boxes */ + this.stream = stream || new MultiBufferStream(); + /* Array of all boxes (in order) found in the file */ + this.boxes = []; + /* Array of all mdats */ + this.mdats = []; + /* Array of all moofs */ + this.moofs = []; + /* Boolean indicating if the file is compatible with progressive parsing (moov first) */ + this.isProgressive = false; + /* Boolean used to fire moov start event only once */ + this.moovStartFound = false; + /* Callback called when the moov parsing starts */ + this.onMoovStart = null; + /* Boolean keeping track of the call to onMoovStart, to avoid double calls */ + this.moovStartSent = false; + /* Callback called when the moov is entirely parsed */ + this.onReady = null; + /* Boolean keeping track of the call to onReady, to avoid double calls */ + this.readySent = false; + /* Callback to call when segments are ready */ + this.onSegment = null; + /* Callback to call when samples are ready */ + this.onSamples = null; + /* Callback to call when there is an error in the parsing or processing of samples */ + this.onError = null; + /* Boolean indicating if the moov box run-length encoded tables of sample information have been processed */ + this.sampleListBuilt = false; + /* Array of Track objects for which fragmentation of samples is requested */ + this.fragmentedTracks = []; + /* Array of Track objects for which extraction of samples is requested */ + this.extractedTracks = []; + /* Boolean indicating that fragmention is ready */ + this.isFragmentationInitialized = false; + /* Boolean indicating that fragmented has started */ + this.sampleProcessingStarted = false; + /* Number of the next 'moof' to generate when fragmenting */ + this.nextMoofNumber = 0; + /* Boolean indicating if the initial list of items has been produced */ + this.itemListBuilt = false; + /* Array of items */ + this.items = []; + /* Array of entity groups */ + this.entity_groups = []; + /* Callback called when the sidx box is entirely parsed */ + this.onSidx = null; + /* Boolean keeping track of the call to onSidx, to avoid double calls */ + this.sidxSent = false; + }; + ISOFile.prototype.setSegmentOptions = function (id, user, options) { + var trak = this.getTrackById(id); + if (trak) { + var fragTrack = {}; + this.fragmentedTracks.push(fragTrack); + fragTrack.id = id; + fragTrack.user = user; + fragTrack.trak = trak; + trak.nextSample = 0; + fragTrack.segmentStream = null; + fragTrack.nb_samples = 1000; + fragTrack.rapAlignement = true; + if (options) { + if (options.nbSamples) fragTrack.nb_samples = options.nbSamples; + if (options.rapAlignement) fragTrack.rapAlignement = options.rapAlignement; + } + } + }; + ISOFile.prototype.unsetSegmentOptions = function (id) { + var index = -1; + for (var i = 0; i < this.fragmentedTracks.length; i++) { + var fragTrack = this.fragmentedTracks[i]; + if (fragTrack.id == id) { + index = i; + } + } + if (index > -1) { + this.fragmentedTracks.splice(index, 1); + } + }; + ISOFile.prototype.setExtractionOptions = function (id, user, options) { + var trak = this.getTrackById(id); + if (trak) { + var extractTrack = {}; + this.extractedTracks.push(extractTrack); + extractTrack.id = id; + extractTrack.user = user; + extractTrack.trak = trak; + trak.nextSample = 0; + extractTrack.nb_samples = 1000; + extractTrack.samples = []; + if (options) { + if (options.nbSamples) extractTrack.nb_samples = options.nbSamples; + } + } + }; + ISOFile.prototype.unsetExtractionOptions = function (id) { + var index = -1; + for (var i = 0; i < this.extractedTracks.length; i++) { + var extractTrack = this.extractedTracks[i]; + if (extractTrack.id == id) { + index = i; + } + } + if (index > -1) { + this.extractedTracks.splice(index, 1); + } + }; + ISOFile.prototype.parse = function () { + var ret; + var box; + var parseBoxHeadersOnly = false; + if (this.restoreParsePosition) { + if (!this.restoreParsePosition()) { + return; + } + } + while (true) { + if (this.hasIncompleteMdat && this.hasIncompleteMdat()) { + if (this.processIncompleteMdat()) { + continue; + } else { + return; + } + } else { + if (this.saveParsePosition) { + this.saveParsePosition(); + } + ret = BoxParser.parseOneBox(this.stream, parseBoxHeadersOnly); + if (ret.code === BoxParser.ERR_NOT_ENOUGH_DATA) { + if (this.processIncompleteBox) { + if (this.processIncompleteBox(ret)) { + continue; + } else { + return; + } + } else { + return; + } + } else { + var box_type; + /* the box is entirely parsed */ + box = ret.box; + box_type = box.type !== "uuid" ? box.type : box.uuid; + /* store the box in the 'boxes' array to preserve box order (for file rewrite if needed) */ + this.boxes.push(box); + /* but also store box in a property for more direct access */ + switch (box_type) { + case "mdat": + this.mdats.push(box); + break; + case "moof": + this.moofs.push(box); + break; + case "moov": + this.moovStartFound = true; + if (this.mdats.length === 0) { + this.isProgressive = true; + } + /* no break */ + /* falls through */ + default: + if (this[box_type] !== undefined) { + Log.warn("ISOFile", "Duplicate Box of type: " + box_type + ", overriding previous occurrence"); + } + this[box_type] = box; + break; + } + if (this.updateUsedBytes) { + this.updateUsedBytes(box, ret); + } + } + } + } + }; + ISOFile.prototype.checkBuffer = function (ab) { + if (ab === null || ab === undefined) { + throw "Buffer must be defined and non empty"; + } + if (ab.fileStart === undefined) { + throw "Buffer must have a fileStart property"; + } + if (ab.byteLength === 0) { + Log.warn("ISOFile", "Ignoring empty buffer (fileStart: " + ab.fileStart + ")"); + this.stream.logBufferLevel(); + return false; + } + Log.info("ISOFile", "Processing buffer (fileStart: " + ab.fileStart + ")"); + + /* mark the bytes in the buffer as not being used yet */ + ab.usedBytes = 0; + this.stream.insertBuffer(ab); + this.stream.logBufferLevel(); + if (!this.stream.initialized()) { + Log.warn("ISOFile", "Not ready to start parsing"); + return false; + } + return true; + }; + + /* Processes a new ArrayBuffer (with a fileStart property) + Returns the next expected file position, or undefined if not ready to parse */ + ISOFile.prototype.appendBuffer = function (ab, last) { + var nextFileStart; + if (!this.checkBuffer(ab)) { + return; + } + + /* Parse whatever is in the existing buffers */ + this.parse(); + + /* Check if the moovStart callback needs to be called */ + if (this.moovStartFound && !this.moovStartSent) { + this.moovStartSent = true; + if (this.onMoovStart) this.onMoovStart(); + } + if (this.moov) { + /* A moov box has been entirely parsed */ + + /* if this is the first call after the moov is found we initialize the list of samples (may be empty in fragmented files) */ + if (!this.sampleListBuilt) { + this.buildSampleLists(); + this.sampleListBuilt = true; + } + + /* We update the sample information if there are any new moof boxes */ + this.updateSampleLists(); + + /* If the application needs to be informed that the 'moov' has been found, + we create the information object and callback the application */ + if (this.onReady && !this.readySent) { + this.readySent = true; + this.onReady(this.getInfo()); + } + + /* See if any sample extraction or segment creation needs to be done with the available samples */ + this.processSamples(last); + + /* Inform about the best range to fetch next */ + if (this.nextSeekPosition) { + nextFileStart = this.nextSeekPosition; + this.nextSeekPosition = undefined; + } else { + nextFileStart = this.nextParsePosition; + } + if (this.stream.getEndFilePositionAfter) { + nextFileStart = this.stream.getEndFilePositionAfter(nextFileStart); + } + } else { + if (this.nextParsePosition) { + /* moov has not been parsed but the first buffer was received, + the next fetch should probably be the next box start */ + nextFileStart = this.nextParsePosition; + } else { + /* No valid buffer has been parsed yet, we cannot know what to parse next */ + nextFileStart = 0; + } + } + if (this.sidx) { + if (this.onSidx && !this.sidxSent) { + this.onSidx(this.sidx); + this.sidxSent = true; + } + } + if (this.meta) { + if (this.flattenItemInfo && !this.itemListBuilt) { + this.flattenItemInfo(); + this.itemListBuilt = true; + } + if (this.processItems) { + this.processItems(this.onItem); + } + } + if (this.stream.cleanBuffers) { + Log.info("ISOFile", "Done processing buffer (fileStart: " + ab.fileStart + ") - next buffer to fetch should have a fileStart position of " + nextFileStart); + this.stream.logBufferLevel(); + this.stream.cleanBuffers(); + this.stream.logBufferLevel(true); + Log.info("ISOFile", "Sample data size in memory: " + this.getAllocatedSampleDataSize()); + } + return nextFileStart; + }; + ISOFile.prototype.getInfo = function () { + var i, j; + var movie = {}; + var trak; + var track; + var ref; + var sample_desc; + var _1904 = new Date('1904-01-01T00:00:00Z').getTime(); + if (this.moov) { + movie.hasMoov = true; + movie.duration = this.moov.mvhd.duration; + movie.timescale = this.moov.mvhd.timescale; + movie.isFragmented = this.moov.mvex != null; + if (movie.isFragmented && this.moov.mvex.mehd) { + movie.fragment_duration = this.moov.mvex.mehd.fragment_duration; + } + movie.isProgressive = this.isProgressive; + movie.hasIOD = this.moov.iods != null; + movie.brands = []; + movie.brands.push(this.ftyp.major_brand); + movie.brands = movie.brands.concat(this.ftyp.compatible_brands); + movie.created = new Date(_1904 + this.moov.mvhd.creation_time * 1000); + movie.modified = new Date(_1904 + this.moov.mvhd.modification_time * 1000); + movie.tracks = []; + movie.audioTracks = []; + movie.videoTracks = []; + movie.subtitleTracks = []; + movie.metadataTracks = []; + movie.hintTracks = []; + movie.otherTracks = []; + for (i = 0; i < this.moov.traks.length; i++) { + trak = this.moov.traks[i]; + sample_desc = trak.mdia.minf.stbl.stsd.entries[0]; + track = {}; + movie.tracks.push(track); + track.id = trak.tkhd.track_id; + track.name = trak.mdia.hdlr.name; + track.references = []; + if (trak.tref) { + for (j = 0; j < trak.tref.boxes.length; j++) { + ref = {}; + track.references.push(ref); + ref.type = trak.tref.boxes[j].type; + ref.track_ids = trak.tref.boxes[j].track_ids; + } + } + if (trak.edts) { + track.edits = trak.edts.elst.entries; + } + track.created = new Date(_1904 + trak.tkhd.creation_time * 1000); + track.modified = new Date(_1904 + trak.tkhd.modification_time * 1000); + track.movie_duration = trak.tkhd.duration; + track.movie_timescale = movie.timescale; + track.layer = trak.tkhd.layer; + track.alternate_group = trak.tkhd.alternate_group; + track.volume = trak.tkhd.volume; + track.matrix = trak.tkhd.matrix; + track.track_width = trak.tkhd.width / (1 << 16); + track.track_height = trak.tkhd.height / (1 << 16); + track.timescale = trak.mdia.mdhd.timescale; + track.cts_shift = trak.mdia.minf.stbl.cslg; + track.duration = trak.mdia.mdhd.duration; + track.samples_duration = trak.samples_duration; + track.codec = sample_desc.getCodec(); + track.kind = trak.udta && trak.udta.kinds.length ? trak.udta.kinds[0] : { + schemeURI: "", + value: "" + }; + track.language = trak.mdia.elng ? trak.mdia.elng.extended_language : trak.mdia.mdhd.languageString; + track.nb_samples = trak.samples.length; + track.size = trak.samples_size; + track.bitrate = track.size * 8 * track.timescale / track.samples_duration; + if (sample_desc.isAudio()) { + track.type = "audio"; + movie.audioTracks.push(track); + track.audio = {}; + track.audio.sample_rate = sample_desc.getSampleRate(); + track.audio.channel_count = sample_desc.getChannelCount(); + track.audio.sample_size = sample_desc.getSampleSize(); + } else if (sample_desc.isVideo()) { + track.type = "video"; + movie.videoTracks.push(track); + track.video = {}; + track.video.width = sample_desc.getWidth(); + track.video.height = sample_desc.getHeight(); + } else if (sample_desc.isSubtitle()) { + track.type = "subtitles"; + movie.subtitleTracks.push(track); + } else if (sample_desc.isHint()) { + track.type = "metadata"; + movie.hintTracks.push(track); + } else if (sample_desc.isMetadata()) { + track.type = "metadata"; + movie.metadataTracks.push(track); + } else { + track.type = "metadata"; + movie.otherTracks.push(track); + } + } + } else { + movie.hasMoov = false; + } + movie.mime = ""; + if (movie.hasMoov && movie.tracks) { + if (movie.videoTracks && movie.videoTracks.length > 0) { + movie.mime += 'video/mp4; codecs=\"'; + } else if (movie.audioTracks && movie.audioTracks.length > 0) { + movie.mime += 'audio/mp4; codecs=\"'; + } else { + movie.mime += 'application/mp4; codecs=\"'; + } + for (i = 0; i < movie.tracks.length; i++) { + if (i !== 0) movie.mime += ','; + movie.mime += movie.tracks[i].codec; + } + movie.mime += '\"; profiles=\"'; + movie.mime += this.ftyp.compatible_brands.join(); + movie.mime += '\"'; + } + return movie; + }; + ISOFile.prototype.setNextSeekPositionFromSample = function (sample) { + if (!sample) { + return; + } + if (this.nextSeekPosition) { + this.nextSeekPosition = Math.min(sample.offset + sample.alreadyRead, this.nextSeekPosition); + } else { + this.nextSeekPosition = sample.offset + sample.alreadyRead; + } + }; + ISOFile.prototype.processSamples = function (last) { + var i; + var trak; + if (!this.sampleProcessingStarted) return; + + /* For each track marked for fragmentation, + check if the next sample is there (i.e. if the sample information is known (i.e. moof has arrived) and if it has been downloaded) + and create a fragment with it */ + if (this.isFragmentationInitialized && this.onSegment !== null) { + for (i = 0; i < this.fragmentedTracks.length; i++) { + var fragTrak = this.fragmentedTracks[i]; + trak = fragTrak.trak; + while (trak.nextSample < trak.samples.length && this.sampleProcessingStarted) { + /* The sample information is there (either because the file is not fragmented and this is not the last sample, + or because the file is fragmented and the moof for that sample has been received */ + Log.debug("ISOFile", "Creating media fragment on track #" + fragTrak.id + " for sample " + trak.nextSample); + var result = this.createFragment(fragTrak.id, trak.nextSample, fragTrak.segmentStream); + if (result) { + fragTrak.segmentStream = result; + trak.nextSample++; + } else { + /* The fragment could not be created because the media data is not there (not downloaded), wait for it */ + break; + } + /* A fragment is created by sample, but the segment is the accumulation in the buffer of these fragments. + It is flushed only as requested by the application (nb_samples) to avoid too many callbacks */ + if (trak.nextSample % fragTrak.nb_samples === 0 || last || trak.nextSample >= trak.samples.length) { + Log.info("ISOFile", "Sending fragmented data on track #" + fragTrak.id + " for samples [" + Math.max(0, trak.nextSample - fragTrak.nb_samples) + "," + (trak.nextSample - 1) + "]"); + Log.info("ISOFile", "Sample data size in memory: " + this.getAllocatedSampleDataSize()); + if (this.onSegment) { + this.onSegment(fragTrak.id, fragTrak.user, fragTrak.segmentStream.buffer, trak.nextSample, last || trak.nextSample >= trak.samples.length); + } + /* force the creation of a new buffer */ + fragTrak.segmentStream = null; + if (fragTrak !== this.fragmentedTracks[i]) { + /* make sure we can stop fragmentation if needed */ + break; + } + } + } + } + } + if (this.onSamples !== null) { + /* For each track marked for data export, + check if the next sample is there (i.e. has been downloaded) and send it */ + for (i = 0; i < this.extractedTracks.length; i++) { + var extractTrak = this.extractedTracks[i]; + trak = extractTrak.trak; + while (trak.nextSample < trak.samples.length && this.sampleProcessingStarted) { + Log.debug("ISOFile", "Exporting on track #" + extractTrak.id + " sample #" + trak.nextSample); + var sample = this.getSample(trak, trak.nextSample); + if (sample) { + trak.nextSample++; + extractTrak.samples.push(sample); + } else { + this.setNextSeekPositionFromSample(trak.samples[trak.nextSample]); + break; + } + if (trak.nextSample % extractTrak.nb_samples === 0 || trak.nextSample >= trak.samples.length) { + Log.debug("ISOFile", "Sending samples on track #" + extractTrak.id + " for sample " + trak.nextSample); + if (this.onSamples) { + this.onSamples(extractTrak.id, extractTrak.user, extractTrak.samples); + } + extractTrak.samples = []; + if (extractTrak !== this.extractedTracks[i]) { + /* check if the extraction needs to be stopped */ + break; + } + } + } + } + } + }; + + /* Find and return specific boxes using recursion and early return */ + ISOFile.prototype.getBox = function (type) { + var result = this.getBoxes(type, true); + return result.length ? result[0] : null; + }; + ISOFile.prototype.getBoxes = function (type, returnEarly) { + var result = []; + ISOFile._sweep.call(this, type, result, returnEarly); + return result; + }; + ISOFile._sweep = function (type, result, returnEarly) { + if (this.type && this.type == type) result.push(this); + for (var box in this.boxes) { + if (result.length && returnEarly) return; + ISOFile._sweep.call(this.boxes[box], type, result, returnEarly); + } + }; + ISOFile.prototype.getTrackSamplesInfo = function (track_id) { + var track = this.getTrackById(track_id); + if (track) { + return track.samples; + } else { + return; + } + }; + ISOFile.prototype.getTrackSample = function (track_id, number) { + var track = this.getTrackById(track_id); + var sample = this.getSample(track, number); + return sample; + }; + + /* Called by the application to release the resources associated to samples already forwarded to the application */ + ISOFile.prototype.releaseUsedSamples = function (id, sampleNum) { + var size = 0; + var trak = this.getTrackById(id); + if (!trak.lastValidSample) trak.lastValidSample = 0; + for (var i = trak.lastValidSample; i < sampleNum; i++) { + size += this.releaseSample(trak, i); + } + Log.info("ISOFile", "Track #" + id + " released samples up to " + sampleNum + " (released size: " + size + ", remaining: " + this.samplesDataSize + ")"); + trak.lastValidSample = sampleNum; + }; + ISOFile.prototype.start = function () { + this.sampleProcessingStarted = true; + this.processSamples(false); + }; + ISOFile.prototype.stop = function () { + this.sampleProcessingStarted = false; + }; + + /* Called by the application to flush the remaining samples (e.g. once the download is finished or when no more samples will be added) */ + ISOFile.prototype.flush = function () { + Log.info("ISOFile", "Flushing remaining samples"); + this.updateSampleLists(); + this.processSamples(true); + this.stream.cleanBuffers(); + this.stream.logBufferLevel(true); + }; + + /* Finds the byte offset for a given time on a given track + also returns the time of the previous rap */ + ISOFile.prototype.seekTrack = function (time, useRap, trak) { + var j; + var sample; + var seek_offset = Infinity; + var rap_seek_sample_num = 0; + var seek_sample_num = 0; + var timescale; + if (trak.samples.length === 0) { + Log.info("ISOFile", "No sample in track, cannot seek! Using time " + Log.getDurationString(0, 1) + " and offset: " + 0); + return { + offset: 0, + time: 0 + }; + } + for (j = 0; j < trak.samples.length; j++) { + sample = trak.samples[j]; + if (j === 0) { + seek_sample_num = 0; + timescale = sample.timescale; + } else if (sample.cts > time * sample.timescale) { + seek_sample_num = j - 1; + break; + } + if (useRap && sample.is_sync) { + rap_seek_sample_num = j; + } + } + if (useRap) { + seek_sample_num = rap_seek_sample_num; + } + time = trak.samples[seek_sample_num].cts; + trak.nextSample = seek_sample_num; + while (trak.samples[seek_sample_num].alreadyRead === trak.samples[seek_sample_num].size) { + // No remaining samples to look for, all are downloaded. + if (!trak.samples[seek_sample_num + 1]) { + break; + } + seek_sample_num++; + } + seek_offset = trak.samples[seek_sample_num].offset + trak.samples[seek_sample_num].alreadyRead; + Log.info("ISOFile", "Seeking to " + (useRap ? "RAP" : "") + " sample #" + trak.nextSample + " on track " + trak.tkhd.track_id + ", time " + Log.getDurationString(time, timescale) + " and offset: " + seek_offset); + return { + offset: seek_offset, + time: time / timescale + }; + }; + ISOFile.prototype.getTrackDuration = function (trak) { + var sample; + if (!trak.samples) { + return Infinity; + } + sample = trak.samples[trak.samples.length - 1]; + return (sample.cts + sample.duration) / sample.timescale; + }; + + /* Finds the byte offset in the file corresponding to the given time or to the time of the previous RAP */ + ISOFile.prototype.seek = function (time, useRap) { + var moov = this.moov; + var trak; + var trak_seek_info; + var i; + var seek_info = { + offset: Infinity, + time: Infinity + }; + if (!this.moov) { + throw "Cannot seek: moov not received!"; + } else { + for (i = 0; i < moov.traks.length; i++) { + trak = moov.traks[i]; + if (time > this.getTrackDuration(trak)) { + // skip tracks that already ended + continue; + } + trak_seek_info = this.seekTrack(time, useRap, trak); + if (trak_seek_info.offset < seek_info.offset) { + seek_info.offset = trak_seek_info.offset; + } + if (trak_seek_info.time < seek_info.time) { + seek_info.time = trak_seek_info.time; + } + } + Log.info("ISOFile", "Seeking at time " + Log.getDurationString(seek_info.time, 1) + " needs a buffer with a fileStart position of " + seek_info.offset); + if (seek_info.offset === Infinity) { + /* No sample info, in all tracks, cannot seek */ + seek_info = { + offset: this.nextParsePosition, + time: 0 + }; + } else { + /* check if the seek position is already in some buffer and + in that case return the end of that buffer (or of the last contiguous buffer) */ + /* TODO: Should wait until append operations are done */ + seek_info.offset = this.stream.getEndFilePositionAfter(seek_info.offset); + } + Log.info("ISOFile", "Adjusted seek position (after checking data already in buffer): " + seek_info.offset); + return seek_info; + } + }; + ISOFile.prototype.equal = function (b) { + var box_index = 0; + while (box_index < this.boxes.length && box_index < b.boxes.length) { + var a_box = this.boxes[box_index]; + var b_box = b.boxes[box_index]; + if (!BoxParser.boxEqual(a_box, b_box)) { + return false; + } + box_index++; + } + return true; + }; + { + exports.ISOFile = ISOFile; + } + // file:src/isofile-advanced-parsing.js + /* position in the current buffer of the beginning of the last box parsed */ + ISOFile.prototype.lastBoxStartPosition = 0; + /* indicator if the parsing is stuck in the middle of an mdat box */ + ISOFile.prototype.parsingMdat = null; + /* next file position that the parser needs: + - 0 until the first buffer (i.e. fileStart ===0) has been received + - otherwise, the next box start until the moov box has been parsed + - otherwise, the position of the next sample to fetch + */ + ISOFile.prototype.nextParsePosition = 0; + /* keep mdat data */ + ISOFile.prototype.discardMdatData = false; + ISOFile.prototype.processIncompleteBox = function (ret) { + var box; + var merged; + var found; + + /* we did not have enough bytes in the current buffer to parse the entire box */ + if (ret.type === "mdat") { + /* we had enough bytes to get its type and size and it's an 'mdat' */ + + /* special handling for mdat boxes, since we don't actually need to parse it linearly + we create the box */ + box = new BoxParser[ret.type + "Box"](ret.size); + this.parsingMdat = box; + this.boxes.push(box); + this.mdats.push(box); + box.start = ret.start; + box.hdr_size = ret.hdr_size; + this.stream.addUsedBytes(box.hdr_size); + + /* indicate that the parsing should start from the end of the box */ + this.lastBoxStartPosition = box.start + box.size; + /* let's see if we have the end of the box in the other buffers */ + found = this.stream.seek(box.start + box.size, false, this.discardMdatData); + if (found) { + /* found the end of the box */ + this.parsingMdat = null; + /* let's see if we can parse more in this buffer */ + return true; + } else { + /* 'mdat' end not found in the existing buffers */ + /* determine the next position in the file to start parsing from */ + if (!this.moovStartFound) { + /* moov not find yet, + the file probably has 'mdat' at the beginning, and 'moov' at the end, + indicate that the downloader should not try to download those bytes now */ + this.nextParsePosition = box.start + box.size; + } else { + /* we have the start of the moov box, + the next bytes should try to complete the current 'mdat' */ + this.nextParsePosition = this.stream.findEndContiguousBuf(); + } + /* not much we can do, wait for more buffers to arrive */ + return false; + } + } else { + /* box is incomplete, we may not even know its type */ + if (ret.type === "moov") { + /* the incomplete box is a 'moov' box */ + this.moovStartFound = true; + if (this.mdats.length === 0) { + this.isProgressive = true; + } + } + /* either it's not an mdat box (and we need to parse it, we cannot skip it) + (TODO: we could skip 'free' boxes ...) + or we did not have enough data to parse the type and size of the box, + we try to concatenate the current buffer with the next buffer to restart parsing */ + merged = this.stream.mergeNextBuffer ? this.stream.mergeNextBuffer() : false; + if (merged) { + /* The next buffer was contiguous, the merging succeeded, + we can now continue parsing, + the next best position to parse is at the end of this new buffer */ + this.nextParsePosition = this.stream.getEndPosition(); + return true; + } else { + /* we cannot concatenate existing buffers because they are not contiguous or because there is no additional buffer */ + /* The next best position to parse is still at the end of this old buffer */ + if (!ret.type) { + /* There were not enough bytes in the buffer to parse the box type and length, + the next fetch should retrieve those missing bytes, i.e. the next bytes after this buffer */ + this.nextParsePosition = this.stream.getEndPosition(); + } else { + /* we had enough bytes to parse size and type of the incomplete box + if we haven't found yet the moov box, skip this one and try the next one + if we have found the moov box, let's continue linear parsing */ + if (this.moovStartFound) { + this.nextParsePosition = this.stream.getEndPosition(); + } else { + this.nextParsePosition = this.stream.getPosition() + ret.size; + } + } + return false; + } + } + }; + ISOFile.prototype.hasIncompleteMdat = function () { + return this.parsingMdat !== null; + }; + ISOFile.prototype.processIncompleteMdat = function () { + var box; + var found; + + /* we are in the parsing of an incomplete mdat box */ + box = this.parsingMdat; + found = this.stream.seek(box.start + box.size, false, this.discardMdatData); + if (found) { + Log.debug("ISOFile", "Found 'mdat' end in buffered data"); + /* the end of the mdat has been found */ + this.parsingMdat = null; + /* we can parse more in this buffer */ + return true; + } else { + /* we don't have the end of this mdat yet, + indicate that the next byte to fetch is the end of the buffers we have so far, + return and wait for more buffer to come */ + this.nextParsePosition = this.stream.findEndContiguousBuf(); + return false; + } + }; + ISOFile.prototype.restoreParsePosition = function () { + /* Reposition at the start position of the previous box not entirely parsed */ + return this.stream.seek(this.lastBoxStartPosition, true, this.discardMdatData); + }; + ISOFile.prototype.saveParsePosition = function () { + /* remember the position of the box start in case we need to roll back (if the box is incomplete) */ + this.lastBoxStartPosition = this.stream.getPosition(); + }; + ISOFile.prototype.updateUsedBytes = function (box, ret) { + if (this.stream.addUsedBytes) { + if (box.type === "mdat") { + /* for an mdat box, only its header is considered used, other bytes will be used when sample data is requested */ + this.stream.addUsedBytes(box.hdr_size); + if (this.discardMdatData) { + this.stream.addUsedBytes(box.size - box.hdr_size); + } + } else { + /* for all other boxes, the entire box data is considered used */ + this.stream.addUsedBytes(box.size); + } + } + }; + // file:src/isofile-advanced-creation.js + ISOFile.prototype.add = BoxParser.Box.prototype.add; + ISOFile.prototype.addBox = BoxParser.Box.prototype.addBox; + ISOFile.prototype.init = function (_options) { + var options = _options || {}; + this.add("ftyp").set("major_brand", options.brands && options.brands[0] || "iso4").set("minor_version", 0).set("compatible_brands", options.brands || ["iso4"]); + var moov = this.add("moov"); + moov.add("mvhd").set("timescale", options.timescale || 600).set("rate", options.rate || 1 << 16).set("creation_time", 0).set("modification_time", 0).set("duration", options.duration || 0).set("volume", options.width ? 0 : 0x0100).set("matrix", [1 << 16, 0, 0, 0, 1 << 16, 0, 0, 0, 0x40000000]).set("next_track_id", 1); + moov.add("mvex"); + return this; + }; + ISOFile.prototype.addTrack = function (_options) { + if (!this.moov) { + this.init(_options); + } + var options = _options || {}; + options.width = options.width || 320; + options.height = options.height || 320; + options.id = options.id || this.moov.mvhd.next_track_id; + options.type = options.type || "avc1"; + var trak = this.moov.add("trak"); + this.moov.mvhd.next_track_id = options.id + 1; + trak.add("tkhd").set("flags", BoxParser.TKHD_FLAG_ENABLED | BoxParser.TKHD_FLAG_IN_MOVIE | BoxParser.TKHD_FLAG_IN_PREVIEW).set("creation_time", 0).set("modification_time", 0).set("track_id", options.id).set("duration", options.duration || 0).set("layer", options.layer || 0).set("alternate_group", 0).set("volume", 1).set("matrix", [0, 0, 0, 0, 0, 0, 0, 0, 0]).set("width", options.width << 16).set("height", options.height << 16); + var mdia = trak.add("mdia"); + mdia.add("mdhd").set("creation_time", 0).set("modification_time", 0).set("timescale", options.timescale || 1).set("duration", options.media_duration || 0).set("language", options.language || "und"); + mdia.add("hdlr").set("handler", options.hdlr || "vide").set("name", options.name || "Track created with MP4Box.js"); + mdia.add("elng").set("extended_language", options.language || "fr-FR"); + var minf = mdia.add("minf"); + if (BoxParser[options.type + "SampleEntry"] === undefined) return; + var sample_description_entry = new BoxParser[options.type + "SampleEntry"](); + sample_description_entry.data_reference_index = 1; + var media_type = ""; + for (var mediaType in BoxParser.sampleEntryCodes) { + var codes = BoxParser.sampleEntryCodes[mediaType]; + for (var i = 0; i < codes.length; i++) { + if (codes.indexOf(options.type) > -1) { + media_type = mediaType; + break; + } + } + } + switch (media_type) { + case "Visual": + minf.add("vmhd").set("graphicsmode", 0).set("opcolor", [0, 0, 0]); + sample_description_entry.set("width", options.width).set("height", options.height).set("horizresolution", 0x48 << 16).set("vertresolution", 0x48 << 16).set("frame_count", 1).set("compressorname", options.type + " Compressor").set("depth", 0x18); + if (options.avcDecoderConfigRecord) { + var avcC = new BoxParser.avcCBox(); + avcC.parse(new MP4BoxStream(options.avcDecoderConfigRecord)); + sample_description_entry.addBox(avcC); + } else if (options.hevcDecoderConfigRecord) { + var hvcC = new BoxParser.hvcCBox(); + hvcC.parse(new MP4BoxStream(options.hevcDecoderConfigRecord)); + sample_description_entry.addBox(hvcC); + } + break; + case "Audio": + minf.add("smhd").set("balance", options.balance || 0); + sample_description_entry.set("channel_count", options.channel_count || 2).set("samplesize", options.samplesize || 16).set("samplerate", options.samplerate || 1 << 16); + break; + case "Hint": + minf.add("hmhd"); // TODO: add properties + break; + case "Subtitle": + minf.add("sthd"); + switch (options.type) { + case "stpp": + sample_description_entry.set("namespace", options.namespace || "nonamespace").set("schema_location", options.schema_location || "").set("auxiliary_mime_types", options.auxiliary_mime_types || ""); + break; + } + break; + case "Metadata": + minf.add("nmhd"); + break; + case "System": + minf.add("nmhd"); + break; + default: + minf.add("nmhd"); + break; + } + if (options.description) { + sample_description_entry.addBox(options.description); + } + if (options.description_boxes) { + options.description_boxes.forEach(function (b) { + sample_description_entry.addBox(b); + }); + } + minf.add("dinf").add("dref").addEntry(new BoxParser["url Box"]().set("flags", 0x1)); + var stbl = minf.add("stbl"); + stbl.add("stsd").addEntry(sample_description_entry); + stbl.add("stts").set("sample_counts", []).set("sample_deltas", []); + stbl.add("stsc").set("first_chunk", []).set("samples_per_chunk", []).set("sample_description_index", []); + stbl.add("stco").set("chunk_offsets", []); + stbl.add("stsz").set("sample_sizes", []); + this.moov.mvex.add("trex").set("track_id", options.id).set("default_sample_description_index", options.default_sample_description_index || 1).set("default_sample_duration", options.default_sample_duration || 0).set("default_sample_size", options.default_sample_size || 0).set("default_sample_flags", options.default_sample_flags || 0); + this.buildTrakSampleLists(trak); + return options.id; + }; + BoxParser.Box.prototype.computeSize = function (stream_) { + var stream = stream_ || new DataStream(); + stream.endianness = DataStream.BIG_ENDIAN; + this.write(stream); + }; + ISOFile.prototype.addSample = function (track_id, data, _options) { + var options = _options || {}; + var sample = {}; + var trak = this.getTrackById(track_id); + if (trak === null) return; + sample.number = trak.samples.length; + sample.track_id = trak.tkhd.track_id; + sample.timescale = trak.mdia.mdhd.timescale; + sample.description_index = options.sample_description_index ? options.sample_description_index - 1 : 0; + sample.description = trak.mdia.minf.stbl.stsd.entries[sample.description_index]; + sample.data = data; + sample.size = data.byteLength; + sample.alreadyRead = sample.size; + sample.duration = options.duration || 1; + sample.cts = options.cts || 0; + sample.dts = options.dts || 0; + sample.is_sync = options.is_sync || false; + sample.is_leading = options.is_leading || 0; + sample.depends_on = options.depends_on || 0; + sample.is_depended_on = options.is_depended_on || 0; + sample.has_redundancy = options.has_redundancy || 0; + sample.degradation_priority = options.degradation_priority || 0; + sample.offset = 0; + sample.subsamples = options.subsamples; + trak.samples.push(sample); + trak.samples_size += sample.size; + trak.samples_duration += sample.duration; + if (trak.first_dts === undefined) { + trak.first_dts = options.dts; + } + this.processSamples(); + var moof = this.createSingleSampleMoof(sample); + this.addBox(moof); + moof.computeSize(); + /* adjusting the data_offset now that the moof size is known*/ + moof.trafs[0].truns[0].data_offset = moof.size + 8; //8 is mdat header + this.add("mdat").data = new Uint8Array(data); + return sample; + }; + ISOFile.prototype.createSingleSampleMoof = function (sample) { + var sample_flags = 0; + if (sample.is_sync) sample_flags = 1 << 25; // sample_depends_on_none (I picture) + else sample_flags = 1 << 16; // non-sync + + var moof = new BoxParser.moofBox(); + moof.add("mfhd").set("sequence_number", this.nextMoofNumber); + this.nextMoofNumber++; + var traf = moof.add("traf"); + var trak = this.getTrackById(sample.track_id); + traf.add("tfhd").set("track_id", sample.track_id).set("flags", BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF); + traf.add("tfdt").set("baseMediaDecodeTime", sample.dts - (trak.first_dts || 0)); + traf.add("trun").set("flags", BoxParser.TRUN_FLAGS_DATA_OFFSET | BoxParser.TRUN_FLAGS_DURATION | BoxParser.TRUN_FLAGS_SIZE | BoxParser.TRUN_FLAGS_FLAGS | BoxParser.TRUN_FLAGS_CTS_OFFSET).set("data_offset", 0).set("first_sample_flags", 0).set("sample_count", 1).set("sample_duration", [sample.duration]).set("sample_size", [sample.size]).set("sample_flags", [sample_flags]).set("sample_composition_time_offset", [sample.cts - sample.dts]); + return moof; + }; + + // file:src/isofile-sample-processing.js + /* Index of the last moof box received */ + ISOFile.prototype.lastMoofIndex = 0; + + /* size of the buffers allocated for samples */ + ISOFile.prototype.samplesDataSize = 0; + + /* Resets all sample tables */ + ISOFile.prototype.resetTables = function () { + var i; + var trak, stco, stsc, stsz, stts, ctts, stss; + this.initial_duration = this.moov.mvhd.duration; + this.moov.mvhd.duration = 0; + for (i = 0; i < this.moov.traks.length; i++) { + trak = this.moov.traks[i]; + trak.tkhd.duration = 0; + trak.mdia.mdhd.duration = 0; + stco = trak.mdia.minf.stbl.stco || trak.mdia.minf.stbl.co64; + stco.chunk_offsets = []; + stsc = trak.mdia.minf.stbl.stsc; + stsc.first_chunk = []; + stsc.samples_per_chunk = []; + stsc.sample_description_index = []; + stsz = trak.mdia.minf.stbl.stsz || trak.mdia.minf.stbl.stz2; + stsz.sample_sizes = []; + stts = trak.mdia.minf.stbl.stts; + stts.sample_counts = []; + stts.sample_deltas = []; + ctts = trak.mdia.minf.stbl.ctts; + if (ctts) { + ctts.sample_counts = []; + ctts.sample_offsets = []; + } + stss = trak.mdia.minf.stbl.stss; + var k = trak.mdia.minf.stbl.boxes.indexOf(stss); + if (k != -1) trak.mdia.minf.stbl.boxes[k] = null; + } + }; + ISOFile.initSampleGroups = function (trak, traf, sbgps, trak_sgpds, traf_sgpds) { + var l; + var k; + var sample_group_info; + var sample_group_key; + function SampleGroupInfo(_type, _parameter, _sbgp) { + this.grouping_type = _type; + this.grouping_type_parameter = _parameter; + this.sbgp = _sbgp; + this.last_sample_in_run = -1; + this.entry_index = -1; + } + if (traf) { + traf.sample_groups_info = []; + } + if (!trak.sample_groups_info) { + trak.sample_groups_info = []; + } + for (k = 0; k < sbgps.length; k++) { + sample_group_key = sbgps[k].grouping_type + "/" + sbgps[k].grouping_type_parameter; + sample_group_info = new SampleGroupInfo(sbgps[k].grouping_type, sbgps[k].grouping_type_parameter, sbgps[k]); + if (traf) { + traf.sample_groups_info[sample_group_key] = sample_group_info; + } + if (!trak.sample_groups_info[sample_group_key]) { + trak.sample_groups_info[sample_group_key] = sample_group_info; + } + for (l = 0; l < trak_sgpds.length; l++) { + if (trak_sgpds[l].grouping_type === sbgps[k].grouping_type) { + sample_group_info.description = trak_sgpds[l]; + sample_group_info.description.used = true; + } + } + if (traf_sgpds) { + for (l = 0; l < traf_sgpds.length; l++) { + if (traf_sgpds[l].grouping_type === sbgps[k].grouping_type) { + sample_group_info.fragment_description = traf_sgpds[l]; + sample_group_info.fragment_description.used = true; + sample_group_info.is_fragment = true; + } + } + } + } + if (!traf) { + for (k = 0; k < trak_sgpds.length; k++) { + if (!trak_sgpds[k].used && trak_sgpds[k].version >= 2) { + sample_group_key = trak_sgpds[k].grouping_type + "/0"; + sample_group_info = new SampleGroupInfo(trak_sgpds[k].grouping_type, 0); + if (!trak.sample_groups_info[sample_group_key]) { + trak.sample_groups_info[sample_group_key] = sample_group_info; + } + } + } + } else { + if (traf_sgpds) { + for (k = 0; k < traf_sgpds.length; k++) { + if (!traf_sgpds[k].used && traf_sgpds[k].version >= 2) { + sample_group_key = traf_sgpds[k].grouping_type + "/0"; + sample_group_info = new SampleGroupInfo(traf_sgpds[k].grouping_type, 0); + sample_group_info.is_fragment = true; + if (!traf.sample_groups_info[sample_group_key]) { + traf.sample_groups_info[sample_group_key] = sample_group_info; + } + } + } + } + } + }; + ISOFile.setSampleGroupProperties = function (trak, sample, sample_number, sample_groups_info) { + var k; + var index; + sample.sample_groups = []; + for (k in sample_groups_info) { + sample.sample_groups[k] = {}; + sample.sample_groups[k].grouping_type = sample_groups_info[k].grouping_type; + sample.sample_groups[k].grouping_type_parameter = sample_groups_info[k].grouping_type_parameter; + if (sample_number >= sample_groups_info[k].last_sample_in_run) { + if (sample_groups_info[k].last_sample_in_run < 0) { + sample_groups_info[k].last_sample_in_run = 0; + } + sample_groups_info[k].entry_index++; + if (sample_groups_info[k].entry_index <= sample_groups_info[k].sbgp.entries.length - 1) { + sample_groups_info[k].last_sample_in_run += sample_groups_info[k].sbgp.entries[sample_groups_info[k].entry_index].sample_count; + } + } + if (sample_groups_info[k].entry_index <= sample_groups_info[k].sbgp.entries.length - 1) { + sample.sample_groups[k].group_description_index = sample_groups_info[k].sbgp.entries[sample_groups_info[k].entry_index].group_description_index; + } else { + sample.sample_groups[k].group_description_index = -1; // special value for not defined + } + if (sample.sample_groups[k].group_description_index !== 0) { + var description; + if (sample_groups_info[k].fragment_description) { + description = sample_groups_info[k].fragment_description; + } else { + description = sample_groups_info[k].description; + } + if (sample.sample_groups[k].group_description_index > 0) { + if (sample.sample_groups[k].group_description_index > 65535) { + index = (sample.sample_groups[k].group_description_index >> 16) - 1; + } else { + index = sample.sample_groups[k].group_description_index - 1; + } + if (description && index >= 0) { + sample.sample_groups[k].description = description.entries[index]; + } + } else { + if (description && description.version >= 2) { + if (description.default_group_description_index > 0) { + sample.sample_groups[k].description = description.entries[description.default_group_description_index - 1]; + } + } + } + } + } + }; + ISOFile.process_sdtp = function (sdtp, sample, number) { + if (!sample) { + return; + } + if (sdtp) { + sample.is_leading = sdtp.is_leading[number]; + sample.depends_on = sdtp.sample_depends_on[number]; + sample.is_depended_on = sdtp.sample_is_depended_on[number]; + sample.has_redundancy = sdtp.sample_has_redundancy[number]; + } else { + sample.is_leading = 0; + sample.depends_on = 0; + sample.is_depended_on = 0; + sample.has_redundancy = 0; + } + }; + + /* Build initial sample list from sample tables */ + ISOFile.prototype.buildSampleLists = function () { + var i; + var trak; + for (i = 0; i < this.moov.traks.length; i++) { + trak = this.moov.traks[i]; + this.buildTrakSampleLists(trak); + } + }; + ISOFile.prototype.buildTrakSampleLists = function (trak) { + var j; + var stco, stsc, stsz, stts, ctts, stss, stsd, subs, sbgps, sgpds, stdp; + var chunk_run_index, chunk_index, last_chunk_in_run, offset_in_chunk, last_sample_in_chunk; + var last_sample_in_stts_run, stts_run_index, last_sample_in_ctts_run, ctts_run_index, last_stss_index, subs_entry_index, last_subs_sample_index; + trak.samples = []; + trak.samples_duration = 0; + trak.samples_size = 0; + stco = trak.mdia.minf.stbl.stco || trak.mdia.minf.stbl.co64; + stsc = trak.mdia.minf.stbl.stsc; + stsz = trak.mdia.minf.stbl.stsz || trak.mdia.minf.stbl.stz2; + stts = trak.mdia.minf.stbl.stts; + ctts = trak.mdia.minf.stbl.ctts; + stss = trak.mdia.minf.stbl.stss; + stsd = trak.mdia.minf.stbl.stsd; + subs = trak.mdia.minf.stbl.subs; + stdp = trak.mdia.minf.stbl.stdp; + sbgps = trak.mdia.minf.stbl.sbgps; + sgpds = trak.mdia.minf.stbl.sgpds; + last_sample_in_stts_run = -1; + stts_run_index = -1; + last_sample_in_ctts_run = -1; + ctts_run_index = -1; + last_stss_index = 0; + subs_entry_index = 0; + last_subs_sample_index = 0; + ISOFile.initSampleGroups(trak, null, sbgps, sgpds); + if (typeof stsz === "undefined") { + return; + } + + /* we build the samples one by one and compute their properties */ + for (j = 0; j < stsz.sample_sizes.length; j++) { + var sample = {}; + sample.number = j; + sample.track_id = trak.tkhd.track_id; + sample.timescale = trak.mdia.mdhd.timescale; + sample.alreadyRead = 0; + trak.samples[j] = sample; + /* size can be known directly */ + sample.size = stsz.sample_sizes[j]; + trak.samples_size += sample.size; + /* computing chunk-based properties (offset, sample description index)*/ + if (j === 0) { + chunk_index = 1; /* the first sample is in the first chunk (chunk indexes are 1-based) */ + chunk_run_index = 0; /* the first chunk is the first entry in the first_chunk table */ + sample.chunk_index = chunk_index; + sample.chunk_run_index = chunk_run_index; + last_sample_in_chunk = stsc.samples_per_chunk[chunk_run_index]; + offset_in_chunk = 0; + + /* Is there another entry in the first_chunk table ? */ + if (chunk_run_index + 1 < stsc.first_chunk.length) { + /* The last chunk in the run is the chunk before the next first chunk */ + last_chunk_in_run = stsc.first_chunk[chunk_run_index + 1] - 1; + } else { + /* There is only one entry in the table, it is valid for all future chunks*/ + last_chunk_in_run = Infinity; + } + } else { + if (j < last_sample_in_chunk) { + /* the sample is still in the current chunk */ + sample.chunk_index = chunk_index; + sample.chunk_run_index = chunk_run_index; + } else { + /* the sample is in the next chunk */ + chunk_index++; + sample.chunk_index = chunk_index; + /* reset the accumulated offset in the chunk */ + offset_in_chunk = 0; + if (chunk_index <= last_chunk_in_run) ; else { + chunk_run_index++; + /* Is there another entry in the first_chunk table ? */ + if (chunk_run_index + 1 < stsc.first_chunk.length) { + /* The last chunk in the run is the chunk before the next first chunk */ + last_chunk_in_run = stsc.first_chunk[chunk_run_index + 1] - 1; + } else { + /* There is only one entry in the table, it is valid for all future chunks*/ + last_chunk_in_run = Infinity; + } + } + sample.chunk_run_index = chunk_run_index; + last_sample_in_chunk += stsc.samples_per_chunk[chunk_run_index]; + } + } + sample.description_index = stsc.sample_description_index[sample.chunk_run_index] - 1; + sample.description = stsd.entries[sample.description_index]; + sample.offset = stco.chunk_offsets[sample.chunk_index - 1] + offset_in_chunk; /* chunk indexes are 1-based */ + offset_in_chunk += sample.size; + + /* setting dts, cts, duration and rap flags */ + if (j > last_sample_in_stts_run) { + stts_run_index++; + if (last_sample_in_stts_run < 0) { + last_sample_in_stts_run = 0; + } + last_sample_in_stts_run += stts.sample_counts[stts_run_index]; + } + if (j > 0) { + trak.samples[j - 1].duration = stts.sample_deltas[stts_run_index]; + trak.samples_duration += trak.samples[j - 1].duration; + sample.dts = trak.samples[j - 1].dts + trak.samples[j - 1].duration; + } else { + sample.dts = 0; + } + if (ctts) { + if (j >= last_sample_in_ctts_run) { + ctts_run_index++; + if (last_sample_in_ctts_run < 0) { + last_sample_in_ctts_run = 0; + } + last_sample_in_ctts_run += ctts.sample_counts[ctts_run_index]; + } + sample.cts = trak.samples[j].dts + ctts.sample_offsets[ctts_run_index]; + } else { + sample.cts = sample.dts; + } + if (stss) { + if (j == stss.sample_numbers[last_stss_index] - 1) { + // sample numbers are 1-based + sample.is_sync = true; + last_stss_index++; + } else { + sample.is_sync = false; + sample.degradation_priority = 0; + } + if (subs) { + if (subs.entries[subs_entry_index].sample_delta + last_subs_sample_index == j + 1) { + sample.subsamples = subs.entries[subs_entry_index].subsamples; + last_subs_sample_index += subs.entries[subs_entry_index].sample_delta; + subs_entry_index++; + } + } + } else { + sample.is_sync = true; + } + ISOFile.process_sdtp(trak.mdia.minf.stbl.sdtp, sample, sample.number); + if (stdp) { + sample.degradation_priority = stdp.priority[j]; + } else { + sample.degradation_priority = 0; + } + if (subs) { + if (subs.entries[subs_entry_index].sample_delta + last_subs_sample_index == j) { + sample.subsamples = subs.entries[subs_entry_index].subsamples; + last_subs_sample_index += subs.entries[subs_entry_index].sample_delta; + } + } + if (sbgps.length > 0 || sgpds.length > 0) { + ISOFile.setSampleGroupProperties(trak, sample, j, trak.sample_groups_info); + } + } + if (j > 0) { + trak.samples[j - 1].duration = Math.max(trak.mdia.mdhd.duration - trak.samples[j - 1].dts, 0); + trak.samples_duration += trak.samples[j - 1].duration; + } + }; + + /* Update sample list when new 'moof' boxes are received */ + ISOFile.prototype.updateSampleLists = function () { + var i, j, k; + var default_sample_description_index, default_sample_duration, default_sample_size, default_sample_flags; + var last_run_position; + var box, moof, traf, trak, trex; + var sample; + var sample_flags; + if (this.moov === undefined) { + return; + } + /* if the input file is fragmented and fetched in multiple downloads, we need to update the list of samples */ + while (this.lastMoofIndex < this.moofs.length) { + box = this.moofs[this.lastMoofIndex]; + this.lastMoofIndex++; + if (box.type == "moof") { + moof = box; + for (i = 0; i < moof.trafs.length; i++) { + traf = moof.trafs[i]; + trak = this.getTrackById(traf.tfhd.track_id); + trex = this.getTrexById(traf.tfhd.track_id); + if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { + default_sample_description_index = traf.tfhd.default_sample_description_index; + } else { + default_sample_description_index = trex ? trex.default_sample_description_index : 1; + } + if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { + default_sample_duration = traf.tfhd.default_sample_duration; + } else { + default_sample_duration = trex ? trex.default_sample_duration : 0; + } + if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { + default_sample_size = traf.tfhd.default_sample_size; + } else { + default_sample_size = trex ? trex.default_sample_size : 0; + } + if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { + default_sample_flags = traf.tfhd.default_sample_flags; + } else { + default_sample_flags = trex ? trex.default_sample_flags : 0; + } + traf.sample_number = 0; + /* process sample groups */ + if (traf.sbgps.length > 0) { + ISOFile.initSampleGroups(trak, traf, traf.sbgps, trak.mdia.minf.stbl.sgpds, traf.sgpds); + } + for (j = 0; j < traf.truns.length; j++) { + var trun = traf.truns[j]; + for (k = 0; k < trun.sample_count; k++) { + sample = {}; + sample.moof_number = this.lastMoofIndex; + sample.number_in_traf = traf.sample_number; + traf.sample_number++; + sample.number = trak.samples.length; + traf.first_sample_index = trak.samples.length; + trak.samples.push(sample); + sample.track_id = trak.tkhd.track_id; + sample.timescale = trak.mdia.mdhd.timescale; + sample.description_index = default_sample_description_index - 1; + sample.description = trak.mdia.minf.stbl.stsd.entries[sample.description_index]; + sample.size = default_sample_size; + if (trun.flags & BoxParser.TRUN_FLAGS_SIZE) { + sample.size = trun.sample_size[k]; + } + trak.samples_size += sample.size; + sample.duration = default_sample_duration; + if (trun.flags & BoxParser.TRUN_FLAGS_DURATION) { + sample.duration = trun.sample_duration[k]; + } + trak.samples_duration += sample.duration; + if (trak.first_traf_merged || k > 0) { + sample.dts = trak.samples[trak.samples.length - 2].dts + trak.samples[trak.samples.length - 2].duration; + } else { + if (traf.tfdt) { + sample.dts = traf.tfdt.baseMediaDecodeTime; + } else { + sample.dts = 0; + } + trak.first_traf_merged = true; + } + sample.cts = sample.dts; + if (trun.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { + sample.cts = sample.dts + trun.sample_composition_time_offset[k]; + } + sample_flags = default_sample_flags; + if (trun.flags & BoxParser.TRUN_FLAGS_FLAGS) { + sample_flags = trun.sample_flags[k]; + } else if (k === 0 && trun.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { + sample_flags = trun.first_sample_flags; + } + sample.is_sync = sample_flags >> 16 & 0x1 ? false : true; + sample.is_leading = sample_flags >> 26 & 0x3; + sample.depends_on = sample_flags >> 24 & 0x3; + sample.is_depended_on = sample_flags >> 22 & 0x3; + sample.has_redundancy = sample_flags >> 20 & 0x3; + sample.degradation_priority = sample_flags & 0xFFFF; + //ISOFile.process_sdtp(traf.sdtp, sample, sample.number_in_traf); + var bdop = traf.tfhd.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET ? true : false; + var dbim = traf.tfhd.flags & BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF ? true : false; + var dop = trun.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET ? true : false; + var bdo = 0; + if (!bdop) { + if (!dbim) { + if (j === 0) { + // the first track in the movie fragment + bdo = moof.start; // the position of the first byte of the enclosing Movie Fragment Box + } else { + bdo = last_run_position; // end of the data defined by the preceding *track* (irrespective of the track id) fragment in the moof + } + } else { + bdo = moof.start; + } + } else { + bdo = traf.tfhd.base_data_offset; + } + if (j === 0 && k === 0) { + if (dop) { + sample.offset = bdo + trun.data_offset; // If the data-offset is present, it is relative to the base-data-offset established in the track fragment header + } else { + sample.offset = bdo; // the data for this run starts the base-data-offset defined by the track fragment header + } + } else { + sample.offset = last_run_position; // this run starts immediately after the data of the previous run + } + last_run_position = sample.offset + sample.size; + if (traf.sbgps.length > 0 || traf.sgpds.length > 0 || trak.mdia.minf.stbl.sbgps.length > 0 || trak.mdia.minf.stbl.sgpds.length > 0) { + ISOFile.setSampleGroupProperties(trak, sample, sample.number_in_traf, traf.sample_groups_info); + } + } + } + if (traf.subs) { + trak.has_fragment_subsamples = true; + var sample_index = traf.first_sample_index; + for (j = 0; j < traf.subs.entries.length; j++) { + sample_index += traf.subs.entries[j].sample_delta; + sample = trak.samples[sample_index - 1]; + sample.subsamples = traf.subs.entries[j].subsamples; + } + } + } + } + } + }; + + /* Try to get sample data for a given sample: + returns null if not found + returns the same sample if already requested + */ + ISOFile.prototype.getSample = function (trak, sampleNum) { + var buffer; + var sample = trak.samples[sampleNum]; + if (!this.moov) { + return null; + } + if (!sample.data) { + /* Not yet fetched */ + sample.data = new Uint8Array(sample.size); + sample.alreadyRead = 0; + this.samplesDataSize += sample.size; + Log.debug("ISOFile", "Allocating sample #" + sampleNum + " on track #" + trak.tkhd.track_id + " of size " + sample.size + " (total: " + this.samplesDataSize + ")"); + } else if (sample.alreadyRead == sample.size) { + /* Already fetched entirely */ + return sample; + } + + /* The sample has only been partially fetched, we need to check in all buffers */ + while (true) { + var index = this.stream.findPosition(true, sample.offset + sample.alreadyRead, false); + if (index > -1) { + buffer = this.stream.buffers[index]; + var lengthAfterStart = buffer.byteLength - (sample.offset + sample.alreadyRead - buffer.fileStart); + if (sample.size - sample.alreadyRead <= lengthAfterStart) { + /* the (rest of the) sample is entirely contained in this buffer */ + + Log.debug("ISOFile", "Getting sample #" + sampleNum + " data (alreadyRead: " + sample.alreadyRead + " offset: " + (sample.offset + sample.alreadyRead - buffer.fileStart) + " read size: " + (sample.size - sample.alreadyRead) + " full size: " + sample.size + ")"); + DataStream.memcpy(sample.data.buffer, sample.alreadyRead, buffer, sample.offset + sample.alreadyRead - buffer.fileStart, sample.size - sample.alreadyRead); + + /* update the number of bytes used in this buffer and check if it needs to be removed */ + buffer.usedBytes += sample.size - sample.alreadyRead; + this.stream.logBufferLevel(); + sample.alreadyRead = sample.size; + return sample; + } else { + /* the sample does not end in this buffer */ + + if (lengthAfterStart === 0) return null; + Log.debug("ISOFile", "Getting sample #" + sampleNum + " partial data (alreadyRead: " + sample.alreadyRead + " offset: " + (sample.offset + sample.alreadyRead - buffer.fileStart) + " read size: " + lengthAfterStart + " full size: " + sample.size + ")"); + DataStream.memcpy(sample.data.buffer, sample.alreadyRead, buffer, sample.offset + sample.alreadyRead - buffer.fileStart, lengthAfterStart); + sample.alreadyRead += lengthAfterStart; + + /* update the number of bytes used in this buffer and check if it needs to be removed */ + buffer.usedBytes += lengthAfterStart; + this.stream.logBufferLevel(); + + /* keep looking in the next buffer */ + } + } else { + return null; + } + } + }; + + /* Release the memory used to store the data of the sample */ + ISOFile.prototype.releaseSample = function (trak, sampleNum) { + var sample = trak.samples[sampleNum]; + if (sample.data) { + this.samplesDataSize -= sample.size; + sample.data = null; + sample.alreadyRead = 0; + return sample.size; + } else { + return 0; + } + }; + ISOFile.prototype.getAllocatedSampleDataSize = function () { + return this.samplesDataSize; + }; + + /* Builds the MIME Type 'codecs' sub-parameters for the whole file */ + ISOFile.prototype.getCodecs = function () { + var i; + var codecs = ""; + for (i = 0; i < this.moov.traks.length; i++) { + var trak = this.moov.traks[i]; + if (i > 0) { + codecs += ","; + } + codecs += trak.mdia.minf.stbl.stsd.entries[0].getCodec(); + } + return codecs; + }; + + /* Helper function */ + ISOFile.prototype.getTrexById = function (id) { + var i; + if (!this.moov || !this.moov.mvex) return null; + for (i = 0; i < this.moov.mvex.trexs.length; i++) { + var trex = this.moov.mvex.trexs[i]; + if (trex.track_id == id) return trex; + } + return null; + }; + + /* Helper function */ + ISOFile.prototype.getTrackById = function (id) { + if (this.moov === undefined) { + return null; + } + for (var j = 0; j < this.moov.traks.length; j++) { + var trak = this.moov.traks[j]; + if (trak.tkhd.track_id == id) return trak; + } + return null; + }; + // file:src/isofile-item-processing.js + /* size of the buffers allocated for samples */ + ISOFile.prototype.itemsDataSize = 0; + ISOFile.prototype.flattenItemInfo = function () { + var items = this.items; + var entity_groups = this.entity_groups; + var i, j; + var item; + var meta = this.meta; + if (meta === null || meta === undefined) return; + if (meta.hdlr === undefined) return; + if (meta.iinf === undefined) return; + for (i = 0; i < meta.iinf.item_infos.length; i++) { + item = {}; + item.id = meta.iinf.item_infos[i].item_ID; + items[item.id] = item; + item.ref_to = []; + item.name = meta.iinf.item_infos[i].item_name; + if (meta.iinf.item_infos[i].protection_index > 0) { + item.protection = meta.ipro.protections[meta.iinf.item_infos[i].protection_index - 1]; + } + if (meta.iinf.item_infos[i].item_type) { + item.type = meta.iinf.item_infos[i].item_type; + } else { + item.type = "mime"; + } + item.content_type = meta.iinf.item_infos[i].content_type; + item.content_encoding = meta.iinf.item_infos[i].content_encoding; + } + if (meta.grpl) { + for (i = 0; i < meta.grpl.boxes.length; i++) { + entity_group = {}; + entity_group.id = meta.grpl.boxes[i].group_id; + entity_group.entity_ids = meta.grpl.boxes[i].entity_ids; + entity_group.type = meta.grpl.boxes[i].type; + entity_groups[entity_group.id] = entity_group; + } + } + if (meta.iloc) { + for (i = 0; i < meta.iloc.items.length; i++) { + var itemloc = meta.iloc.items[i]; + item = items[itemloc.item_ID]; + if (itemloc.data_reference_index !== 0) { + Log.warn("Item storage with reference to other files: not supported"); + item.source = meta.dinf.boxes[itemloc.data_reference_index - 1]; + } + switch (itemloc.construction_method) { + case 0: + // offset into the file referenced by the data reference index + break; + case 1: + // offset into the idat box of this meta box + break; + case 2: + // offset into another item + Log.warn("Item storage with construction_method : not supported"); + break; + } + item.extents = []; + item.size = 0; + for (j = 0; j < itemloc.extents.length; j++) { + item.extents[j] = {}; + item.extents[j].offset = itemloc.extents[j].extent_offset + itemloc.base_offset; + if (itemloc.construction_method == 1) { + item.extents[j].offset += meta.idat.start + meta.idat.hdr_size; + } + item.extents[j].length = itemloc.extents[j].extent_length; + item.extents[j].alreadyRead = 0; + item.size += item.extents[j].length; + } + } + } + if (meta.pitm) { + items[meta.pitm.item_id].primary = true; + } + if (meta.iref) { + for (i = 0; i < meta.iref.references.length; i++) { + var ref = meta.iref.references[i]; + for (j = 0; j < ref.references.length; j++) { + items[ref.from_item_ID].ref_to.push({ + type: ref.type, + id: ref.references[j] + }); + } + } + } + if (meta.iprp) { + for (var k = 0; k < meta.iprp.ipmas.length; k++) { + var ipma = meta.iprp.ipmas[k]; + for (i = 0; i < ipma.associations.length; i++) { + var association = ipma.associations[i]; + item = items[association.id]; + if (!item) { + item = entity_groups[association.id]; + } + if (item) { + if (item.properties === undefined) { + item.properties = {}; + item.properties.boxes = []; + } + for (j = 0; j < association.props.length; j++) { + var propEntry = association.props[j]; + if (propEntry.property_index > 0 && propEntry.property_index - 1 < meta.iprp.ipco.boxes.length) { + var propbox = meta.iprp.ipco.boxes[propEntry.property_index - 1]; + item.properties[propbox.type] = propbox; + item.properties.boxes.push(propbox); + } + } + } + } + } + } + }; + ISOFile.prototype.getItem = function (item_id) { + var buffer; + var item; + if (!this.meta) { + return null; + } + item = this.items[item_id]; + if (!item.data && item.size) { + /* Not yet fetched */ + item.data = new Uint8Array(item.size); + item.alreadyRead = 0; + this.itemsDataSize += item.size; + Log.debug("ISOFile", "Allocating item #" + item_id + " of size " + item.size + " (total: " + this.itemsDataSize + ")"); + } else if (item.alreadyRead === item.size) { + /* Already fetched entirely */ + return item; + } + + /* The item has only been partially fetched, we need to check in all buffers to find the remaining extents*/ + + for (var i = 0; i < item.extents.length; i++) { + var extent = item.extents[i]; + if (extent.alreadyRead === extent.length) { + continue; + } else { + var index = this.stream.findPosition(true, extent.offset + extent.alreadyRead, false); + if (index > -1) { + buffer = this.stream.buffers[index]; + var lengthAfterStart = buffer.byteLength - (extent.offset + extent.alreadyRead - buffer.fileStart); + if (extent.length - extent.alreadyRead <= lengthAfterStart) { + /* the (rest of the) extent is entirely contained in this buffer */ + + Log.debug("ISOFile", "Getting item #" + item_id + " extent #" + i + " data (alreadyRead: " + extent.alreadyRead + " offset: " + (extent.offset + extent.alreadyRead - buffer.fileStart) + " read size: " + (extent.length - extent.alreadyRead) + " full extent size: " + extent.length + " full item size: " + item.size + ")"); + DataStream.memcpy(item.data.buffer, item.alreadyRead, buffer, extent.offset + extent.alreadyRead - buffer.fileStart, extent.length - extent.alreadyRead); + + /* update the number of bytes used in this buffer and check if it needs to be removed */ + buffer.usedBytes += extent.length - extent.alreadyRead; + this.stream.logBufferLevel(); + item.alreadyRead += extent.length - extent.alreadyRead; + extent.alreadyRead = extent.length; + } else { + /* the sample does not end in this buffer */ + + Log.debug("ISOFile", "Getting item #" + item_id + " extent #" + i + " partial data (alreadyRead: " + extent.alreadyRead + " offset: " + (extent.offset + extent.alreadyRead - buffer.fileStart) + " read size: " + lengthAfterStart + " full extent size: " + extent.length + " full item size: " + item.size + ")"); + DataStream.memcpy(item.data.buffer, item.alreadyRead, buffer, extent.offset + extent.alreadyRead - buffer.fileStart, lengthAfterStart); + extent.alreadyRead += lengthAfterStart; + item.alreadyRead += lengthAfterStart; + + /* update the number of bytes used in this buffer and check if it needs to be removed */ + buffer.usedBytes += lengthAfterStart; + this.stream.logBufferLevel(); + return null; + } + } else { + return null; + } + } + } + if (item.alreadyRead === item.size) { + /* fetched entirely */ + return item; + } else { + return null; + } + }; + + /* Release the memory used to store the data of the item */ + ISOFile.prototype.releaseItem = function (item_id) { + var item = this.items[item_id]; + if (item.data) { + this.itemsDataSize -= item.size; + item.data = null; + item.alreadyRead = 0; + for (var i = 0; i < item.extents.length; i++) { + var extent = item.extents[i]; + extent.alreadyRead = 0; + } + return item.size; + } else { + return 0; + } + }; + ISOFile.prototype.processItems = function (callback) { + for (var i in this.items) { + var item = this.items[i]; + this.getItem(item.id); + if (callback && !item.sent) { + callback(item); + item.sent = true; + item.data = null; + } + } + }; + ISOFile.prototype.hasItem = function (name) { + for (var i in this.items) { + var item = this.items[i]; + if (item.name === name) { + return item.id; + } + } + return -1; + }; + ISOFile.prototype.getMetaHandler = function () { + if (!this.meta) { + return null; + } else { + return this.meta.hdlr.handler; + } + }; + ISOFile.prototype.getPrimaryItem = function () { + if (!this.meta || !this.meta.pitm) { + return null; + } else { + return this.getItem(this.meta.pitm.item_id); + } + }; + ISOFile.prototype.itemToFragmentedTrackFile = function (_options) { + var options = _options || {}; + var item = null; + if (options.itemId) { + item = this.getItem(options.itemId); + } else { + item = this.getPrimaryItem(); + } + if (item == null) return null; + var file = new ISOFile(); + file.discardMdatData = false; + // assuming the track type is the same as the item type + var trackOptions = { + type: item.type, + description_boxes: item.properties.boxes + }; + if (item.properties.ispe) { + trackOptions.width = item.properties.ispe.image_width; + trackOptions.height = item.properties.ispe.image_height; + } + var trackId = file.addTrack(trackOptions); + if (trackId) { + file.addSample(trackId, item.data); + return file; + } else { + return null; + } + }; + + // file:src/isofile-write.js + /* Rewrite the entire file */ + ISOFile.prototype.write = function (outstream) { + for (var i = 0; i < this.boxes.length; i++) { + this.boxes[i].write(outstream); + } + }; + ISOFile.prototype.createFragment = function (track_id, sampleNumber, stream_) { + var trak = this.getTrackById(track_id); + var sample = this.getSample(trak, sampleNumber); + if (sample == null) { + this.setNextSeekPositionFromSample(trak.samples[sampleNumber]); + return null; + } + var stream = stream_ || new DataStream(); + stream.endianness = DataStream.BIG_ENDIAN; + var moof = this.createSingleSampleMoof(sample); + moof.write(stream); + + /* adjusting the data_offset now that the moof size is known*/ + moof.trafs[0].truns[0].data_offset = moof.size + 8; //8 is mdat header + Log.debug("MP4Box", "Adjusting data_offset with new value " + moof.trafs[0].truns[0].data_offset); + stream.adjustUint32(moof.trafs[0].truns[0].data_offset_position, moof.trafs[0].truns[0].data_offset); + var mdat = new BoxParser.mdatBox(); + mdat.data = sample.data; + mdat.write(stream); + return stream; + }; + + /* Modify the file and create the initialization segment */ + ISOFile.writeInitializationSegment = function (ftyp, moov, total_duration, sample_duration) { + var i; + Log.debug("ISOFile", "Generating initialization segment"); + var stream = new DataStream(); + stream.endianness = DataStream.BIG_ENDIAN; + ftyp.write(stream); + + /* we can now create the new mvex box */ + var mvex = moov.add("mvex"); + if (total_duration) { + mvex.add("mehd").set("fragment_duration", total_duration); + } + for (i = 0; i < moov.traks.length; i++) { + mvex.add("trex").set("track_id", moov.traks[i].tkhd.track_id).set("default_sample_description_index", 1).set("default_sample_duration", sample_duration).set("default_sample_size", 0).set("default_sample_flags", 1 << 16); + } + moov.write(stream); + return stream.buffer; + }; + ISOFile.prototype.save = function (name) { + var stream = new DataStream(); + stream.endianness = DataStream.BIG_ENDIAN; + this.write(stream); + stream.save(name); + }; + ISOFile.prototype.getBuffer = function () { + var stream = new DataStream(); + stream.endianness = DataStream.BIG_ENDIAN; + this.write(stream); + return stream.buffer; + }; + ISOFile.prototype.initializeSegmentation = function () { + var i; + var initSegs; + var trak; + var seg; + if (this.onSegment === null) { + Log.warn("MP4Box", "No segmentation callback set!"); + } + if (!this.isFragmentationInitialized) { + this.isFragmentationInitialized = true; + this.nextMoofNumber = 0; + this.resetTables(); + } + initSegs = []; + for (i = 0; i < this.fragmentedTracks.length; i++) { + var moov = new BoxParser.moovBox(); + moov.mvhd = this.moov.mvhd; + moov.boxes.push(moov.mvhd); + trak = this.getTrackById(this.fragmentedTracks[i].id); + moov.boxes.push(trak); + moov.traks.push(trak); + seg = {}; + seg.id = trak.tkhd.track_id; + seg.user = this.fragmentedTracks[i].user; + seg.buffer = ISOFile.writeInitializationSegment(this.ftyp, moov, this.moov.mvex && this.moov.mvex.mehd ? this.moov.mvex.mehd.fragment_duration : undefined, this.moov.traks[i].samples.length > 0 ? this.moov.traks[i].samples[0].duration : 0); + initSegs.push(seg); + } + return initSegs; + }; + + // file:src/box-print.js + /* + * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + BoxParser.Box.prototype.printHeader = function (output) { + this.size += 8; + if (this.size > MAX_SIZE) { + this.size += 8; + } + if (this.type === "uuid") { + this.size += 16; + } + output.log(output.indent + "size:" + this.size); + output.log(output.indent + "type:" + this.type); + }; + BoxParser.FullBox.prototype.printHeader = function (output) { + this.size += 4; + BoxParser.Box.prototype.printHeader.call(this, output); + output.log(output.indent + "version:" + this.version); + output.log(output.indent + "flags:" + this.flags); + }; + BoxParser.Box.prototype.print = function (output) { + this.printHeader(output); + }; + BoxParser.ContainerBox.prototype.print = function (output) { + this.printHeader(output); + for (var i = 0; i < this.boxes.length; i++) { + if (this.boxes[i]) { + var prev_indent = output.indent; + output.indent += " "; + this.boxes[i].print(output); + output.indent = prev_indent; + } + } + }; + ISOFile.prototype.print = function (output) { + output.indent = ""; + for (var i = 0; i < this.boxes.length; i++) { + if (this.boxes[i]) { + this.boxes[i].print(output); + } + } + }; + BoxParser.mvhdBox.prototype.print = function (output) { + BoxParser.FullBox.prototype.printHeader.call(this, output); + output.log(output.indent + "creation_time: " + this.creation_time); + output.log(output.indent + "modification_time: " + this.modification_time); + output.log(output.indent + "timescale: " + this.timescale); + output.log(output.indent + "duration: " + this.duration); + output.log(output.indent + "rate: " + this.rate); + output.log(output.indent + "volume: " + (this.volume >> 8)); + output.log(output.indent + "matrix: " + this.matrix.join(", ")); + output.log(output.indent + "next_track_id: " + this.next_track_id); + }; + BoxParser.tkhdBox.prototype.print = function (output) { + BoxParser.FullBox.prototype.printHeader.call(this, output); + output.log(output.indent + "creation_time: " + this.creation_time); + output.log(output.indent + "modification_time: " + this.modification_time); + output.log(output.indent + "track_id: " + this.track_id); + output.log(output.indent + "duration: " + this.duration); + output.log(output.indent + "volume: " + (this.volume >> 8)); + output.log(output.indent + "matrix: " + this.matrix.join(", ")); + output.log(output.indent + "layer: " + this.layer); + output.log(output.indent + "alternate_group: " + this.alternate_group); + output.log(output.indent + "width: " + this.width); + output.log(output.indent + "height: " + this.height); + }; // file:src/mp4box.js + /* + * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato + * License: BSD-3-Clause (see LICENSE file) + */ + var MP4Box = {}; + MP4Box.createFile = function (_keepMdatData, _stream) { + /* Boolean indicating if bytes containing media data should be kept in memory */ + var keepMdatData = _keepMdatData !== undefined ? _keepMdatData : true; + var file = new ISOFile(_stream); + file.discardMdatData = keepMdatData ? false : true; + return file; + }; + { + exports.createFile = MP4Box.createFile; + } + })(mp4box_all); + return mp4box_all; + } + + var mp4box_allExports = requireMp4box_all(); + + // Decode a MP4 container into individual samples. + class Parser { + info; + #mp4 = mp4box_allExports.createFile(); + #offset = 0; + #samples = []; + constructor(init) { + this.#mp4.onError = (err) => { + console.error("MP4 error", err); + }; + this.#mp4.onReady = (info) => { + this.info = info; + // Extract all of the tracks, because we don't know if it's audio or video. + for (const track of info.tracks) { + this.#mp4.setExtractionOptions(track.id, track, { nbSamples: 1 }); + } + }; + this.#mp4.onSamples = (_track_id, track, samples) => { + for (const sample of samples) { + this.#samples.push({ track, sample }); + } + }; + this.#mp4.start(); + // For some reason we need to modify the underlying ArrayBuffer with offset + const copy = new Uint8Array(init); + const buffer = copy.buffer; + buffer.fileStart = this.#offset; + this.#mp4.appendBuffer(buffer); + this.#offset += buffer.byteLength; + this.#mp4.flush(); + if (!this.info) { + throw new Error("could not parse MP4 info"); + } + } + decode(chunk) { + const copy = new Uint8Array(chunk); + // For some reason we need to modify the underlying ArrayBuffer with offset + const buffer = copy.buffer; + buffer.fileStart = this.#offset; + // Parse the data + this.#mp4.appendBuffer(buffer); + this.#mp4.flush(); + this.#offset += buffer.byteLength; + const samples = [...this.#samples]; + this.#samples.length = 0; + return samples; + } + } + + // Rename some stuff so it's on brand. + // We need a separate file so this file can use the rename too. + function isAudioTrack(track) { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + return track.audio !== undefined; + } + function isVideoTrack(track) { + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + return track.video !== undefined; + } + // TODO contribute to mp4box + mp4box_allExports.BoxParser.dOpsBox.prototype.write = function (stream) { + this.size = this.ChannelMappingFamily === 0 ? 11 : 13 + this.ChannelMapping.length; + this.writeHeader(stream); + stream.writeUint8(this.Version); + stream.writeUint8(this.OutputChannelCount); + stream.writeUint16(this.PreSkip); + stream.writeUint32(this.InputSampleRate); + stream.writeInt16(this.OutputGain); + stream.writeUint8(this.ChannelMappingFamily); + if (this.ChannelMappingFamily !== 0) { + stream.writeUint8(this.StreamCount); + stream.writeUint8(this.CoupledCount); + for (const mapping of this.ChannelMapping) { + stream.writeUint8(mapping); + } + } + }; + + // This is run in a worker. + let Renderer$1 = class Renderer { + #ring; + #timeline; + #decoder; + #stream; + constructor(config, timeline) { + this.#timeline = timeline; + this.#ring = new Ring(config.ring); + this.#stream = new TransformStream({ + start: this.#start.bind(this), + transform: this.#transform.bind(this), + }); + this.#run().catch(console.error); + } + #start(controller) { + this.#decoder = new AudioDecoder({ + output: (frame) => { + controller.enqueue(frame); + }, + error: console.warn, + }); + } + #transform(frame) { + if (this.#decoder.state !== "configured") { + const track = frame.track; + if (!isAudioTrack(track)) + throw new Error("expected audio track"); + // We only support OPUS right now which doesn't need a description. + this.#decoder.configure({ + codec: track.codec, + sampleRate: track.audio.sample_rate, + numberOfChannels: track.audio.channel_count, + }); + } + const chunk = new EncodedAudioChunk({ + type: frame.sample.is_sync ? "key" : "delta", + timestamp: frame.sample.dts / frame.track.timescale, + duration: frame.sample.duration, + data: frame.sample.data, + }); + this.#decoder.decode(chunk); + } + async #run() { + const reader = this.#timeline.frames.pipeThrough(this.#stream).getReader(); + for (;;) { + const { value: frame, done } = await reader.read(); + if (done) + break; + // Write audio samples to the ring buffer, dropping when there's no space. + const written = this.#ring.write(frame); + if (written < frame.numberOfFrames) { + console.warn(`droppped ${frame.numberOfFrames - written} audio samples`); + } + } + } + }; + + class Renderer { + #canvas; + #timeline; + #decoder; + #queue; + #decoderConfig; + #waitingForKeyframe = true; + constructor(config, timeline) { + this.#canvas = config.canvas; + this.#timeline = timeline; + this.#queue = new TransformStream({ + start: this.#start.bind(this), + transform: this.#transform.bind(this), + }); + this.#run().catch(console.error); + } + pause() { + console.log("pause"); + this.#waitingForKeyframe = true; + } + async #run() { + const reader = this.#timeline.frames.pipeThrough(this.#queue).getReader(); + for (;;) { + const { value: frame, done } = await reader.read(); + if (done) + break; + self.requestAnimationFrame(() => { + this.#canvas.width = frame.displayWidth; + this.#canvas.height = frame.displayHeight; + const ctx = this.#canvas.getContext("2d"); + if (!ctx) + throw new Error("failed to get canvas context"); + ctx.drawImage(frame, 0, 0, frame.displayWidth, frame.displayHeight); // TODO respect aspect ratio + frame.close(); + }); + } + } + #start(controller) { + this.#decoder = new VideoDecoder({ + output: (frame) => { + controller.enqueue(frame); + }, + error: console.error, + }); + } + #transform(frame) { + if (this.#decoder.state === "closed") { + console.warn("Decoder is closed. Skipping frame."); + return; + } + const { sample, track } = frame; + // Reset the decoder on video track change + if (this.#decoderConfig && this.#decoder.state == "configured") { + if (isVideoTrack(track)) { + const configMismatch = this.#decoderConfig.codec !== track.codec || + this.#decoderConfig.codedWidth !== track.video.width || + this.#decoderConfig.codedHeight !== track.video.height; + if (configMismatch) { + this.#decoder.reset(); + this.#decoderConfig = undefined; + } + } + } + // Configure the decoder with the first frame + if (this.#decoder.state !== "configured") { + const desc = sample.description; + const box = desc.avcC ?? desc.hvcC ?? desc.vpcC ?? desc.av1C; + if (!box) + throw new Error(`unsupported codec: ${track.codec}`); + const buffer = new mp4box_allExports.DataStream(undefined, 0, mp4box_allExports.DataStream.BIG_ENDIAN); + box.write(buffer); + const description = new Uint8Array(buffer.buffer, 8); // Remove the box header. + if (!isVideoTrack(track)) + throw new Error("expected video track"); + this.#decoderConfig = { + codec: track.codec, + codedHeight: track.video.height, + codedWidth: track.video.width, + description, + // optimizeForLatency: true + }; + this.#decoder.configure(this.#decoderConfig); + if (!frame.sample.is_sync) { + this.#waitingForKeyframe = true; + } + else { + this.#waitingForKeyframe = false; + } + } + //At the start of decode , VideoDecoder seems to expect a key frame after configure() or flush() + if (this.#decoder.state == "configured") { + if (this.#waitingForKeyframe && !frame.sample.is_sync) { + console.warn("Skipping non-keyframe until a keyframe is found."); + return; + } + // On arrival of a keyframe, allow decoding and stop waiting for a keyframe. + if (frame.sample.is_sync) { + this.#waitingForKeyframe = false; + } + const chunk = new EncodedVideoChunk({ + type: frame.sample.is_sync ? "key" : "delta", + data: frame.sample.data, + timestamp: frame.sample.dts / frame.track.timescale, + }); + this.#decoder.decode(chunk); + } + } + } + + // I hate javascript + function asError(e) { + if (e instanceof Error) { + return e; + } + else if (typeof e === "string") { + return new Error(e); + } + else { + return new Error(String(e)); + } + } + + class Deferred { + promise; + resolve; + reject; + pending = true; + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = (value) => { + this.pending = false; + resolve(value); + }; + this.reject = (reason) => { + this.pending = false; + reject(reason); + }; + }); + } + } + + const MAX_U53 = Number.MAX_SAFE_INTEGER; + // Reader wraps a stream and provides convience methods for reading pieces from a stream + // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet. + class Reader { + #buffer; + #stream; + #reader; + constructor(buffer, stream) { + this.#buffer = buffer; + this.#stream = stream; + this.#reader = this.#stream.getReader(); + } + // Adds more data to the buffer, returning true if more data was added. + async #fill() { + const result = await this.#reader.read(); + if (result.done) { + return false; + } + const buffer = new Uint8Array(result.value); + if (this.#buffer.byteLength == 0) { + this.#buffer = buffer; + } + else { + const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength); + temp.set(this.#buffer); + temp.set(buffer, this.#buffer.byteLength); + this.#buffer = temp; + } + return true; + } + // Add more data to the buffer until it's at least size bytes. + async #fillTo(size) { + while (this.#buffer.byteLength < size) { + if (!(await this.#fill())) { + throw new Error("unexpected end of stream"); + } + } + } + // Consumes the first size bytes of the buffer. + #slice(size) { + const result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size); + this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size); + return result; + } + async read(size) { + if (size == 0) + return new Uint8Array(); + await this.#fillTo(size); + return this.#slice(size); + } + async readAll() { + // eslint-disable-next-line no-empty + while (await this.#fill()) { } + return this.#slice(this.#buffer.byteLength); + } + async string(maxLength) { + const length = await this.u53(); + if (maxLength !== undefined && length > maxLength) { + throw new Error(`string length ${length} exceeds max length ${maxLength}`); + } + const buffer = await this.read(length); + return new TextDecoder().decode(buffer); + } + async u8() { + await this.#fillTo(1); + return this.#slice(1)[0]; + } + // Returns a Number using 53-bits, the max Javascript can use for integer math + async u53() { + const v = await this.u62(); + if (v > MAX_U53) { + throw new Error("value larger than 53-bits; use v62 instead"); + } + return Number(v); + } + // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits + async u62() { + await this.#fillTo(1); + const size = (this.#buffer[0] & 0xc0) >> 6; + if (size == 0) { + const first = this.#slice(1)[0]; + return BigInt(first) & 0x3fn; + } + else if (size == 1) { + await this.#fillTo(2); + const slice = this.#slice(2); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return BigInt(view.getInt16(0)) & 0x3fffn; + } + else if (size == 2) { + await this.#fillTo(4); + const slice = this.#slice(4); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return BigInt(view.getUint32(0)) & 0x3fffffffn; + } + else if (size == 3) { + await this.#fillTo(8); + const slice = this.#slice(8); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return view.getBigUint64(0) & 0x3fffffffffffffffn; + } + else { + throw new Error("impossible"); + } + } + async done() { + if (this.#buffer.byteLength > 0) + return false; + return !(await this.#fill()); + } + async close() { + this.#reader.releaseLock(); + await this.#stream.cancel(); + } + release() { + this.#reader.releaseLock(); + return [this.#buffer, this.#stream]; + } + } + + var StreamType; + (function (StreamType) { + StreamType[StreamType["Object"] = 0] = "Object"; + StreamType[StreamType["Track"] = 80] = "Track"; + StreamType[StreamType["Group"] = 81] = "Group"; + })(StreamType || (StreamType = {})); + var Status; + (function (Status) { + Status[Status["OBJECT_NULL"] = 1] = "OBJECT_NULL"; + Status[Status["GROUP_NULL"] = 2] = "GROUP_NULL"; + Status[Status["GROUP_END"] = 3] = "GROUP_END"; + Status[Status["TRACK_END"] = 4] = "TRACK_END"; + })(Status || (Status = {})); + class GroupReader { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async read() { + if (await this.stream.done()) { + return; + } + const object = await this.stream.u53(); + const size = await this.stream.u53(); + let payload; + if (size == 0) { + payload = (await this.stream.u53()); + } + else { + payload = await this.stream.read(size); + } + return { + object, + payload, + }; + } + async close() { + await this.stream.close(); + } + } + + class Worker { + // Timeline receives samples, buffering them and choosing the timestamp to render. + #timeline = new Timeline(); + // A map of init tracks. + #inits = new Map(); + // Renderer requests samples, rendering video frames and emitting audio frames. + #audio; + #video; + on(e) { + const msg = e.data; + if (msg.config) { + this.#onConfig(msg.config); + } + else if (msg.init) { + // TODO buffer the init segmnet so we don't hold the stream open. + this.#onInit(msg.init); + } + else if (msg.segment) { + this.#onSegment(msg.segment).catch(console.warn); + } + else if (msg.pause) { + this.#onPause(msg.pause); + } + else { + throw new Error(`unknown message: + ${JSON.stringify(msg)}`); + } + } + #onConfig(msg) { + if (msg.audio) { + this.#audio = new Renderer$1(msg.audio, this.#timeline.audio); + } + if (msg.video) { + this.#video = new Renderer(msg.video, this.#timeline.video); + } + } + #onInit(msg) { + let init = this.#inits.get(msg.name); + if (!init) { + init = new Deferred(); + this.#inits.set(msg.name, init); + } + init.resolve(msg.data); + } + async #onSegment(msg) { + let init = this.#inits.get(msg.init); + if (!init) { + init = new Deferred(); + this.#inits.set(msg.init, init); + } + // Create a new stream that we will use to decode. + const container = new Parser(await init.promise); + const timeline = msg.kind === "audio" ? this.#timeline.audio : this.#timeline.video; + const reader = new GroupReader(msg.header, new Reader(msg.buffer, msg.stream)); + // Create a queue that will contain each MP4 frame. + const queue = new TransformStream({}); + const segment = queue.writable.getWriter(); + // Add the segment to the timeline + const segments = timeline.segments.getWriter(); + await segments.write({ + sequence: msg.header.group, + frames: queue.readable, + }); + segments.releaseLock(); + // Read each chunk, decoding the MP4 frames and adding them to the queue. + for (;;) { + const chunk = await reader.read(); + if (!chunk) { + break; + } + if (!(chunk.payload instanceof Uint8Array)) { + throw new Error(`invalid payload: ${chunk.payload}`); + } + const frames = container.decode(chunk.payload); + for (const frame of frames) { + await segment.write(frame); + } + } + // We done. + await segment.close(); + } + #onPause(pause) { + if (this.#video && pause) { + this.#video.pause(); + } + } + } + // Pass all events to the worker + const worker = new Worker(); + self.addEventListener("message", (msg) => { + try { + worker.on(msg); + } + catch (e) { + const err = asError(e); + console.warn("worker error:", err); + } + }); + + })(); + + }); + /* eslint-enable */ + + // Ring buffer with audio samples. + var STATE; + (function (STATE) { + STATE[STATE["READ_POS"] = 0] = "READ_POS"; + STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; + STATE[STATE["LENGTH"] = 2] = "LENGTH"; + })(STATE || (STATE = {})); + // No prototype to make this easier to send via postMessage + class RingShared { + state; + channels; + capacity; + constructor(channels, capacity) { + // Store the current state in a separate ring buffer. + this.state = new SharedArrayBuffer(STATE.LENGTH * Int32Array.BYTES_PER_ELEMENT); + // Create a buffer for each audio channel + this.channels = []; + for (let i = 0; i < channels; i += 1) { + const buffer = new SharedArrayBuffer(capacity * Float32Array.BYTES_PER_ELEMENT); + this.channels.push(buffer); + } + this.capacity = capacity; + } + } + + // This is a non-standard way of importing worklet/workers. + // Unfortunately, it's the only option because of a Vite bug: https://github.com/vitejs/vite/issues/11823 + // Responsible for sending messages to the worker and worklet. + class Backend { + // General worker + #worker; + // The audio context, which must be created on the main thread. + #audio; + constructor(config) { + // TODO does this block the main thread? If so, make this async + this.#worker = new WorkerFactory(); + this.#worker.addEventListener("message", this.on.bind(this)); + let sampleRate; + let channels; + for (const track of config.catalog.tracks) { + if (isAudioTrack(track)) { + if (sampleRate && track.selectionParams.samplerate !== sampleRate) { + throw new Error(`TODO multiple audio tracks with different sample rates`); + } + sampleRate = track.selectionParams.samplerate; + // TODO properly handle weird channel configs + channels = Math.max(+track.selectionParams.channelConfig, channels ?? 0); + } + } + const msg = {}; + // Only configure audio is we have an audio track + if (sampleRate && channels) { + msg.audio = { + channels: channels, + sampleRate: sampleRate, + ring: new RingShared(2, sampleRate / 10), // 100ms + }; + this.#audio = new Audio(msg.audio); + } + // TODO only send the canvas if we have a video track + msg.video = { + canvas: config.canvas, + }; + this.send({ config: msg }, msg.video.canvas); + } + pause() { + this.send({ pause: true }); + } + async mute() { + await this.#audio?.context.suspend(); + } + async unmute() { + await this.#audio?.context.resume(); + } + init(init) { + this.send({ init }); + } + segment(segment) { + this.send({ segment }, segment.stream); + } + async close() { + this.#worker.terminate(); + await this.#audio?.context.close(); + } + // Enforce we're sending valid types to the worker + send(msg, ...transfer) { + //console.log("sent message from main to worker", msg) + this.#worker.postMessage(msg, transfer); + } + on(e) { + const msg = e.data; + // Don't print the verbose timeline message. + if (!msg.timeline) ; + } + } + + const MAX_U6 = Math.pow(2, 6) - 1; + const MAX_U14 = Math.pow(2, 14) - 1; + const MAX_U30 = Math.pow(2, 30) - 1; + const MAX_U31 = Math.pow(2, 31) - 1; + const MAX_U53 = Number.MAX_SAFE_INTEGER; + const MAX_U62 = 2n ** 62n - 1n; + // Reader wraps a stream and provides convience methods for reading pieces from a stream + // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet. + class Reader { + #buffer; + #stream; + #reader; + constructor(buffer, stream) { + this.#buffer = buffer; + this.#stream = stream; + this.#reader = this.#stream.getReader(); + } + // Adds more data to the buffer, returning true if more data was added. + async #fill() { + const result = await this.#reader.read(); + if (result.done) { + return false; + } + const buffer = new Uint8Array(result.value); + if (this.#buffer.byteLength == 0) { + this.#buffer = buffer; + } + else { + const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength); + temp.set(this.#buffer); + temp.set(buffer, this.#buffer.byteLength); + this.#buffer = temp; + } + return true; + } + // Add more data to the buffer until it's at least size bytes. + async #fillTo(size) { + while (this.#buffer.byteLength < size) { + if (!(await this.#fill())) { + throw new Error("unexpected end of stream"); + } + } + } + // Consumes the first size bytes of the buffer. + #slice(size) { + const result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size); + this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size); + return result; + } + async read(size) { + if (size == 0) + return new Uint8Array(); + await this.#fillTo(size); + return this.#slice(size); + } + async readAll() { + // eslint-disable-next-line no-empty + while (await this.#fill()) { } + return this.#slice(this.#buffer.byteLength); + } + async string(maxLength) { + const length = await this.u53(); + if (maxLength !== undefined && length > maxLength) { + throw new Error(`string length ${length} exceeds max length ${maxLength}`); + } + const buffer = await this.read(length); + return new TextDecoder().decode(buffer); + } + async u8() { + await this.#fillTo(1); + return this.#slice(1)[0]; + } + // Returns a Number using 53-bits, the max Javascript can use for integer math + async u53() { + const v = await this.u62(); + if (v > MAX_U53) { + throw new Error("value larger than 53-bits; use v62 instead"); + } + return Number(v); + } + // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits + async u62() { + await this.#fillTo(1); + const size = (this.#buffer[0] & 0xc0) >> 6; + if (size == 0) { + const first = this.#slice(1)[0]; + return BigInt(first) & 0x3fn; + } + else if (size == 1) { + await this.#fillTo(2); + const slice = this.#slice(2); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return BigInt(view.getInt16(0)) & 0x3fffn; + } + else if (size == 2) { + await this.#fillTo(4); + const slice = this.#slice(4); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return BigInt(view.getUint32(0)) & 0x3fffffffn; + } + else if (size == 3) { + await this.#fillTo(8); + const slice = this.#slice(8); + const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); + return view.getBigUint64(0) & 0x3fffffffffffffffn; + } + else { + throw new Error("impossible"); + } + } + async done() { + if (this.#buffer.byteLength > 0) + return false; + return !(await this.#fill()); + } + async close() { + this.#reader.releaseLock(); + await this.#stream.cancel(); + } + release() { + this.#reader.releaseLock(); + return [this.#buffer, this.#stream]; + } + } + // Writer wraps a stream and writes chunks of data + class Writer { + #scratch; + #writer; + #stream; + constructor(stream) { + this.#stream = stream; + this.#scratch = new Uint8Array(8); + this.#writer = this.#stream.getWriter(); + } + async u8(v) { + await this.write(setUint8(this.#scratch, v)); + } + async i32(v) { + if (Math.abs(v) > MAX_U31) { + throw new Error(`overflow, value larger than 32-bits: ${v}`); + } + // We don't use a VarInt, so it always takes 4 bytes. + // This could be improved but nothing is standardized yet. + await this.write(setInt32(this.#scratch, v)); + } + async u53(v) { + if (v < 0) { + throw new Error(`underflow, value is negative: ${v}`); + } + else if (v > MAX_U53) { + throw new Error(`overflow, value larger than 53-bits: ${v}`); + } + await this.write(setVint53(this.#scratch, v)); + } + async u62(v) { + if (v < 0) { + throw new Error(`underflow, value is negative: ${v}`); + } + else if (v >= MAX_U62) { + throw new Error(`overflow, value larger than 62-bits: ${v}`); + } + await this.write(setVint62(this.#scratch, v)); + } + async write(v) { + await this.#writer.write(v); + } + async string(str) { + const data = new TextEncoder().encode(str); + await this.u53(data.byteLength); + await this.write(data); + } + async close() { + this.#writer.releaseLock(); + await this.#stream.close(); + } + release() { + this.#writer.releaseLock(); + return this.#stream; + } + } + function setUint8(dst, v) { + dst[0] = v; + return dst.slice(0, 1); + } + function setUint16(dst, v) { + const view = new DataView(dst.buffer, dst.byteOffset, 2); + view.setUint16(0, v); + return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); + } + function setInt32(dst, v) { + const view = new DataView(dst.buffer, dst.byteOffset, 4); + view.setInt32(0, v); + return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); + } + function setUint32(dst, v) { + const view = new DataView(dst.buffer, dst.byteOffset, 4); + view.setUint32(0, v); + return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); + } + function setVint53(dst, v) { + if (v <= MAX_U6) { + return setUint8(dst, v); + } + else if (v <= MAX_U14) { + return setUint16(dst, v | 0x4000); + } + else if (v <= MAX_U30) { + return setUint32(dst, v | 0x80000000); + } + else if (v <= MAX_U53) { + return setUint64(dst, BigInt(v) | 0xc000000000000000n); + } + else { + throw new Error(`overflow, value larger than 53-bits: ${v}`); + } + } + function setVint62(dst, v) { + if (v < MAX_U6) { + return setUint8(dst, Number(v)); + } + else if (v < MAX_U14) { + return setUint16(dst, Number(v) | 0x4000); + } + else if (v <= MAX_U30) { + return setUint32(dst, Number(v) | 0x80000000); + } + else if (v <= MAX_U62) { + return setUint64(dst, BigInt(v) | 0xc000000000000000n); + } + else { + throw new Error(`overflow, value larger than 62-bits: ${v}`); + } + } + function setUint64(dst, v) { + const view = new DataView(dst.buffer, dst.byteOffset, 8); + view.setBigUint64(0, v); + return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); + } + + var Version; + (function (Version) { + Version[Version["DRAFT_00"] = 4278190080] = "DRAFT_00"; + Version[Version["DRAFT_01"] = 4278190081] = "DRAFT_01"; + Version[Version["DRAFT_02"] = 4278190082] = "DRAFT_02"; + Version[Version["DRAFT_03"] = 4278190083] = "DRAFT_03"; + Version[Version["DRAFT_04"] = 4278190084] = "DRAFT_04"; + Version[Version["DRAFT_05"] = 4278190085] = "DRAFT_05"; + Version[Version["KIXEL_00"] = 765184] = "KIXEL_00"; + Version[Version["KIXEL_01"] = 765185] = "KIXEL_01"; + })(Version || (Version = {})); + let Stream$1 = class Stream { + recv; + send; + constructor(r, w) { + this.recv = new Decoder$1(r); + this.send = new Encoder$1(w); + } + }; + let Decoder$1 = class Decoder { + r; + constructor(r) { + this.r = r; + } + async client() { + const type = await this.r.u53(); + if (type !== 0x40) + throw new Error(`client SETUP type must be 0x40, got ${type}`); + const count = await this.r.u53(); + const versions = []; + for (let i = 0; i < count; i++) { + const version = await this.r.u53(); + versions.push(version); + } + const params = await this.parameters(); + const role = this.role(params?.get(0n)); + return { + versions, + role, + params, + }; + } + async server() { + const type = await this.r.u53(); + if (type !== 0x41) + throw new Error(`server SETUP type must be 0x41, got ${type}`); + const version = await this.r.u53(); + const params = await this.parameters(); + return { + version, + params, + }; + } + async parameters() { + const count = await this.r.u53(); + if (count == 0) + return undefined; + const params = new Map(); + for (let i = 0; i < count; i++) { + const id = await this.r.u62(); + const size = await this.r.u53(); + const value = await this.r.read(size); + if (params.has(id)) { + throw new Error(`duplicate parameter id: ${id}`); + } + params.set(id, value); + } + return params; + } + role(raw) { + if (!raw) + throw new Error("missing role parameter"); + if (raw.length != 1) + throw new Error("multi-byte varint not supported"); + switch (raw[0]) { + case 1: + return "publisher"; + case 2: + return "subscriber"; + case 3: + return "both"; + default: + throw new Error(`invalid role: ${raw[0]}`); + } + } + }; + let Encoder$1 = class Encoder { + w; + constructor(w) { + this.w = w; + } + async client(c) { + await this.w.u53(0x40); + await this.w.u53(c.versions.length); + for (const v of c.versions) { + await this.w.u53(v); + } + // I hate it + const params = c.params ?? new Map(); + params.set(0n, new Uint8Array([c.role == "publisher" ? 1 : c.role == "subscriber" ? 2 : 3])); + await this.parameters(params); + } + async server(s) { + await this.w.u53(0x41); + await this.w.u53(s.version); + await this.parameters(s.params); + } + async parameters(p) { + if (!p) { + await this.w.u8(0); + return; + } + await this.w.u53(p.size); + for (const [id, value] of p) { + await this.w.u62(id); + await this.w.u53(value.length); + await this.w.write(value); + } + } + }; + + function isPublisher(m) { + return (m.kind == Msg.SubscribeOk || + m.kind == Msg.SubscribeError || + m.kind == Msg.SubscribeDone || + m.kind == Msg.Announce || + m.kind == Msg.Unannounce); + } + // I wish we didn't have to split Msg and Id into separate enums. + // However using the string in the message makes it easier to debug. + // We'll take the tiny performance hit until I'm better at Typescript. + var Msg; + (function (Msg) { + // NOTE: object and setup are in other modules + Msg["Subscribe"] = "subscribe"; + Msg["SubscribeOk"] = "subscribe_ok"; + Msg["SubscribeError"] = "subscribe_error"; + Msg["SubscribeDone"] = "subscribe_done"; + Msg["Unsubscribe"] = "unsubscribe"; + Msg["Announce"] = "announce"; + Msg["AnnounceOk"] = "announce_ok"; + Msg["AnnounceError"] = "announce_error"; + Msg["Unannounce"] = "unannounce"; + Msg["GoAway"] = "go_away"; + })(Msg || (Msg = {})); + var Id; + (function (Id) { + // NOTE: object and setup are in other modules + // Object = 0, + // Setup = 1, + Id[Id["Subscribe"] = 3] = "Subscribe"; + Id[Id["SubscribeOk"] = 4] = "SubscribeOk"; + Id[Id["SubscribeError"] = 5] = "SubscribeError"; + Id[Id["SubscribeDone"] = 11] = "SubscribeDone"; + Id[Id["Unsubscribe"] = 10] = "Unsubscribe"; + Id[Id["Announce"] = 6] = "Announce"; + Id[Id["AnnounceOk"] = 7] = "AnnounceOk"; + Id[Id["AnnounceError"] = 8] = "AnnounceError"; + Id[Id["Unannounce"] = 9] = "Unannounce"; + Id[Id["GoAway"] = 16] = "GoAway"; + })(Id || (Id = {})); + var GroupOrder; + (function (GroupOrder) { + GroupOrder[GroupOrder["Publisher"] = 0] = "Publisher"; + GroupOrder[GroupOrder["Ascending"] = 1] = "Ascending"; + GroupOrder[GroupOrder["Descending"] = 2] = "Descending"; + })(GroupOrder || (GroupOrder = {})); + class Stream { + decoder; + encoder; + #mutex = Promise.resolve(); + constructor(r, w) { + this.decoder = new Decoder(r); + this.encoder = new Encoder(w); + } + // Will error if two messages are read at once. + async recv() { + const msg = await this.decoder.message(); + console.log("received message", msg); + return msg; + } + async send(msg) { + const unlock = await this.#lock(); + try { + console.log("sending message", msg); + await this.encoder.message(msg); + } + finally { + unlock(); + } + } + async #lock() { + // Make a new promise that we can resolve later. + let done; + const p = new Promise((resolve) => { + done = () => resolve(); + }); + // Wait until the previous lock is done, then resolve our our lock. + const lock = this.#mutex.then(() => done); + // Save our lock as the next lock. + this.#mutex = p; + // Return the lock. + return lock; + } + } + class Decoder { + r; + constructor(r) { + this.r = r; + } + async msg() { + const t = await this.r.u53(); + switch (t) { + case Id.Subscribe: + return Msg.Subscribe; + case Id.SubscribeOk: + return Msg.SubscribeOk; + case Id.SubscribeDone: + return Msg.SubscribeDone; + case Id.SubscribeError: + return Msg.SubscribeError; + case Id.Unsubscribe: + return Msg.Unsubscribe; + case Id.Announce: + return Msg.Announce; + case Id.AnnounceOk: + return Msg.AnnounceOk; + case Id.AnnounceError: + return Msg.AnnounceError; + case Id.Unannounce: + return Msg.Unannounce; + case Id.GoAway: + return Msg.GoAway; + } + throw new Error(`unknown control message type: ${t}`); + } + async message() { + const t = await this.msg(); + switch (t) { + case Msg.Subscribe: + return this.subscribe(); + case Msg.SubscribeOk: + return this.subscribe_ok(); + case Msg.SubscribeError: + return this.subscribe_error(); + case Msg.SubscribeDone: + return this.subscribe_done(); + case Msg.Unsubscribe: + return this.unsubscribe(); + case Msg.Announce: + return this.announce(); + case Msg.AnnounceOk: + return this.announce_ok(); + case Msg.Unannounce: + return this.unannounce(); + case Msg.AnnounceError: + return this.announce_error(); + case Msg.GoAway: + throw new Error("TODO: implement go away"); + } + } + async subscribe() { + return { + kind: Msg.Subscribe, + id: await this.r.u62(), + trackId: await this.r.u62(), + namespace: await this.r.string(), + name: await this.r.string(), + subscriber_priority: await this.r.u8(), + group_order: await this.decodeGroupOrder(), + location: await this.location(), + params: await this.parameters(), + }; + } + async decodeGroupOrder() { + const orderCode = await this.r.u8(); + switch (orderCode) { + case 0: + return GroupOrder.Publisher; + case 1: + return GroupOrder.Ascending; + case 2: + return GroupOrder.Descending; + default: + throw new Error(`Invalid GroupOrder value: ${orderCode}`); + } + } + async location() { + const mode = await this.r.u62(); + if (mode == 1n) { + return { + mode: "latest_group", + }; + } + else if (mode == 2n) { + return { + mode: "latest_object", + }; + } + else if (mode == 3n) { + return { + mode: "absolute_start", + start_group: await this.r.u53(), + start_object: await this.r.u53(), + }; + } + else if (mode == 4n) { + return { + mode: "absolute_range", + start_group: await this.r.u53(), + start_object: await this.r.u53(), + end_group: await this.r.u53(), + end_object: await this.r.u53(), + }; + } + else { + throw new Error(`invalid filter type: ${mode}`); + } + } + async parameters() { + const count = await this.r.u53(); + if (count == 0) + return undefined; + const params = new Map(); + for (let i = 0; i < count; i++) { + const id = await this.r.u62(); + const size = await this.r.u53(); + const value = await this.r.read(size); + if (params.has(id)) { + throw new Error(`duplicate parameter id: ${id}`); + } + params.set(id, value); + } + return params; + } + async subscribe_ok() { + const id = await this.r.u62(); + const expires = await this.r.u62(); + const group_order = await this.decodeGroupOrder(); + let latest; + const flag = await this.r.u8(); + if (flag === 1) { + latest = [await this.r.u53(), await this.r.u53()]; + } + else if (flag !== 0) { + throw new Error(`invalid final flag: ${flag}`); + } + return { + kind: Msg.SubscribeOk, + id, + expires, + group_order, + latest, + }; + } + async subscribe_done() { + const id = await this.r.u62(); + const code = await this.r.u62(); + const reason = await this.r.string(); + let final; + const flag = await this.r.u8(); + if (flag === 1) { + final = [await this.r.u53(), await this.r.u53()]; + } + else if (flag !== 0) { + throw new Error(`invalid final flag: ${flag}`); + } + return { + kind: Msg.SubscribeDone, + id, + code, + reason, + final, + }; + } + async subscribe_error() { + return { + kind: Msg.SubscribeError, + id: await this.r.u62(), + code: await this.r.u62(), + reason: await this.r.string(), + }; + } + async unsubscribe() { + return { + kind: Msg.Unsubscribe, + id: await this.r.u62(), + }; + } + async announce() { + const namespace = await this.r.string(); + return { + kind: Msg.Announce, + namespace, + params: await this.parameters(), + }; + } + async announce_ok() { + return { + kind: Msg.AnnounceOk, + namespace: await this.r.string(), + }; + } + async announce_error() { + return { + kind: Msg.AnnounceError, + namespace: await this.r.string(), + code: await this.r.u62(), + reason: await this.r.string(), + }; + } + async unannounce() { + return { + kind: Msg.Unannounce, + namespace: await this.r.string(), + }; + } + } + class Encoder { + w; + constructor(w) { + this.w = w; + } + async message(m) { + switch (m.kind) { + case Msg.Subscribe: + return this.subscribe(m); + case Msg.SubscribeOk: + return this.subscribe_ok(m); + case Msg.SubscribeError: + return this.subscribe_error(m); + case Msg.SubscribeDone: + return this.subscribe_done(m); + case Msg.Unsubscribe: + return this.unsubscribe(m); + case Msg.Announce: + return this.announce(m); + case Msg.AnnounceOk: + return this.announce_ok(m); + case Msg.AnnounceError: + return this.announce_error(m); + case Msg.Unannounce: + return this.unannounce(m); + } + } + async subscribe(s) { + await this.w.u53(Id.Subscribe); + await this.w.u62(s.id); + await this.w.u62(s.trackId); + await this.w.string(s.namespace); + await this.w.string(s.name); + await this.w.u8(s.subscriber_priority ?? 127); + await this.encodeGroupOrder(s.group_order ?? GroupOrder.Publisher); + await this.location(s.location); + await this.parameters(s.params); + } + async encodeGroupOrder(order) { + switch (order) { + case GroupOrder.Publisher: + await this.w.u8(GroupOrder.Publisher); + break; + case GroupOrder.Ascending: + await this.w.u8(GroupOrder.Ascending); + break; + case GroupOrder.Descending: + await this.w.u8(GroupOrder.Descending); + break; + default: + throw new Error("Invalid GroupOrder value"); + } + } + async location(l) { + switch (l.mode) { + case "latest_group": + await this.w.u62(1n); + break; + case "latest_object": + await this.w.u62(2n); + break; + case "absolute_start": + await this.w.u62(3n); + await this.w.u53(l.start_group); + await this.w.u53(l.start_object); + break; + case "absolute_range": + await this.w.u62(3n); + await this.w.u53(l.start_group); + await this.w.u53(l.start_object); + await this.w.u53(l.end_group); + await this.w.u53(l.end_object); + } + } + async parameters(p) { + if (!p) { + await this.w.u8(0); + return; + } + await this.w.u53(p.size); + for (const [id, value] of p) { + await this.w.u62(id); + await this.w.u53(value.length); + await this.w.write(value); + } + } + async subscribe_ok(s) { + await this.w.u53(Id.SubscribeOk); + await this.w.u62(s.id); + await this.w.u62(s.expires); + await this.encodeGroupOrder(s.group_order); + if (s.latest !== undefined) { + await this.w.u8(1); + await this.w.u53(s.latest[0]); + await this.w.u53(s.latest[1]); + } + else { + await this.w.u8(0); + } + } + async subscribe_done(s) { + await this.w.u53(Id.SubscribeDone); + await this.w.u62(s.id); + await this.w.u62(s.code); + await this.w.string(s.reason); + if (s.final !== undefined) { + await this.w.u8(1); + await this.w.u53(s.final[0]); + await this.w.u53(s.final[1]); + } + else { + await this.w.u8(0); + } + } + async subscribe_error(s) { + await this.w.u53(Id.SubscribeError); + await this.w.u62(s.id); + } + async unsubscribe(s) { + await this.w.u53(Id.Unsubscribe); + await this.w.u62(s.id); + } + async announce(a) { + await this.w.u53(Id.Announce); + await this.w.string(a.namespace); + await this.w.u53(0); // parameters + } + async announce_ok(a) { + await this.w.u53(Id.AnnounceOk); + await this.w.string(a.namespace); + } + async announce_error(a) { + await this.w.u53(Id.AnnounceError); + await this.w.string(a.namespace); + await this.w.u62(a.code); + await this.w.string(a.reason); + } + async unannounce(a) { + await this.w.u53(Id.Unannounce); + await this.w.string(a.namespace); + } + } + + var StreamType; + (function (StreamType) { + StreamType[StreamType["Object"] = 0] = "Object"; + StreamType[StreamType["Track"] = 80] = "Track"; + StreamType[StreamType["Group"] = 81] = "Group"; + })(StreamType || (StreamType = {})); + var Status; + (function (Status) { + Status[Status["OBJECT_NULL"] = 1] = "OBJECT_NULL"; + Status[Status["GROUP_NULL"] = 2] = "GROUP_NULL"; + Status[Status["GROUP_END"] = 3] = "GROUP_END"; + Status[Status["TRACK_END"] = 4] = "TRACK_END"; + })(Status || (Status = {})); + class Objects { + quic; + constructor(quic) { + this.quic = quic; + } + async send(h) { + const stream = await this.quic.createUnidirectionalStream(); + const w = new Writer(stream); + await w.u53(h.type); + await w.u62(h.sub); + await w.u62(h.track); + let res; + if (h.type == StreamType.Object) { + await w.u53(h.group); + await w.u53(h.object); + await w.u8(h.publisher_priority); + await w.u53(h.status); + res = new ObjectWriter(h, w); + } + else if (h.type === StreamType.Group) { + await w.u53(h.group); + await w.u8(h.publisher_priority); + res = new GroupWriter(h, w); + } + else if (h.type === StreamType.Track) { + await w.u8(h.publisher_priority); + res = new TrackWriter(h, w); + } + else { + throw new Error("unknown header type"); + } + // console.trace("send object", res.header) + return res; + } + async recv() { + const streams = this.quic.incomingUnidirectionalStreams.getReader(); + const { value, done } = await streams.read(); + streams.releaseLock(); + if (done) + return; + const r = new Reader(new Uint8Array(), value); + const type = (await r.u53()); + let res; + if (type == StreamType.Track) { + const h = { + type, + sub: await r.u62(), + track: await r.u62(), + publisher_priority: await r.u8(), + }; + res = new TrackReader(h, r); + } + else if (type == StreamType.Group) { + const h = { + type, + sub: await r.u62(), + track: await r.u62(), + group: await r.u53(), + publisher_priority: await r.u8(), + }; + res = new GroupReader(h, r); + } + else if (type == StreamType.Object) { + const h = { + type, + sub: await r.u62(), + track: await r.u62(), + group: await r.u53(), + object: await r.u53(), + status: await r.u53(), + publisher_priority: await r.u8(), + }; + res = new ObjectReader(h, r); + } + else { + throw new Error("unknown stream type"); + } + // console.trace("receive object", res.header) + return res; + } + } + class TrackWriter { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async write(c) { + await this.stream.u53(c.group); + await this.stream.u53(c.object); + if (c.payload instanceof Uint8Array) { + await this.stream.u53(c.payload.byteLength); + await this.stream.write(c.payload); + } + else { + // empty payload with status + await this.stream.u53(0); + await this.stream.u53(c.payload); + } + } + async close() { + await this.stream.close(); + } + } + class GroupWriter { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async write(c) { + await this.stream.u53(c.object); + if (c.payload instanceof Uint8Array) { + await this.stream.u53(c.payload.byteLength); + await this.stream.write(c.payload); + } + else { + await this.stream.u53(0); + await this.stream.u53(c.payload); + } + } + async close() { + await this.stream.close(); + } + } + class ObjectWriter { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async write(c) { + await this.stream.write(c.payload); + } + async close() { + await this.stream.close(); + } + } + class TrackReader { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async read() { + if (await this.stream.done()) { + return; + } + const group = await this.stream.u53(); + const object = await this.stream.u53(); + const size = await this.stream.u53(); + let payload; + if (size == 0) { + payload = (await this.stream.u53()); + } + else { + payload = await this.stream.read(size); + } + return { + group, + object, + payload, + }; + } + async close() { + await this.stream.close(); + } + } + class GroupReader { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + async read() { + if (await this.stream.done()) { + return; + } + const object = await this.stream.u53(); + const size = await this.stream.u53(); + let payload; + if (size == 0) { + payload = (await this.stream.u53()); + } + else { + payload = await this.stream.read(size); + } + return { + object, + payload, + }; + } + async close() { + await this.stream.close(); + } + } + class ObjectReader { + header; + stream; + constructor(header, stream) { + this.header = header; + this.stream = stream; + } + // NOTE: Can only be called once. + async read() { + if (await this.stream.done()) { + return; + } + return { + payload: await this.stream.readAll(), + }; + } + async close() { + await this.stream.close(); + } + } + + class Deferred { + promise; + resolve; + reject; + pending = true; + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = (value) => { + this.pending = false; + resolve(value); + }; + this.reject = (reason) => { + this.pending = false; + reject(reason); + }; + }); + } + } + class Watch { + #current; + #next = new Deferred(); + constructor(init) { + this.#next = new Deferred(); + this.#current = [init, this.#next.promise]; + } + value() { + return this.#current; + } + update(v) { + if (!this.#next.pending) { + throw new Error("already closed"); + } + // If we're given a function, call it with the current value + if (v instanceof Function) { + v = v(this.#current[0]); + } + const next = new Deferred(); + this.#current = [v, next.promise]; + this.#next.resolve(this.#current); + this.#next = next; + } + close() { + this.#current[1] = undefined; + this.#next.resolve(this.#current); + } + } + // Allows queuing N values, like a Channel. + class Queue { + #stream; + #closed = false; + constructor(capacity = 1) { + const queue = new CountQueuingStrategy({ highWaterMark: capacity }); + this.#stream = new TransformStream({}, undefined, queue); + } + async push(v) { + const w = this.#stream.writable.getWriter(); + await w.write(v); + w.releaseLock(); + } + async next() { + const r = this.#stream.readable.getReader(); + const { value, done } = await r.read(); + r.releaseLock(); + if (done) + return; + return value; + } + async abort(err) { + if (this.#closed) + return; + await this.#stream.writable.abort(err); + this.#closed = true; + } + async close() { + if (this.#closed) + return; + await this.#stream.writable.close(); + this.#closed = true; + } + closed() { + return this.#closed; + } + } + + class Publisher { + // Used to send control messages + #control; + // Use to send objects. + #objects; + // Our announced tracks. + #announce = new Map(); + // Their subscribed tracks. + #subscribe = new Map(); + #subscribeQueue = new Queue(Number.MAX_SAFE_INTEGER); // Unbounded queue in case there's no receiver + constructor(control, objects) { + this.#control = control; + this.#objects = objects; + } + // Announce a track namespace. + async announce(namespace) { + if (this.#announce.has(namespace)) { + throw new Error(`already announce: ${namespace}`); + } + const announce = new AnnounceSend(this.#control, namespace); + this.#announce.set(namespace, announce); + await this.#control.send({ + kind: Msg.Announce, + namespace, + }); + return announce; + } + // Receive the next new subscription + async subscribed() { + return await this.#subscribeQueue.next(); + } + async recv(msg) { + if (msg.kind == Msg.Subscribe) { + await this.recvSubscribe(msg); + } + else if (msg.kind == Msg.Unsubscribe) { + this.recvUnsubscribe(msg); + } + else if (msg.kind == Msg.AnnounceOk) { + this.recvAnnounceOk(msg); + } + else if (msg.kind == Msg.AnnounceError) { + this.recvAnnounceError(msg); + } + else { + throw new Error(`unknown control message`); // impossible + } + } + recvAnnounceOk(msg) { + const announce = this.#announce.get(msg.namespace); + if (!announce) { + throw new Error(`announce OK for unknown announce: ${msg.namespace}`); + } + announce.onOk(); + } + recvAnnounceError(msg) { + const announce = this.#announce.get(msg.namespace); + if (!announce) { + // TODO debug this + console.warn(`announce error for unknown announce: ${msg.namespace}`); + return; + } + announce.onError(msg.code, msg.reason); + } + async recvSubscribe(msg) { + if (this.#subscribe.has(msg.id)) { + throw new Error(`duplicate subscribe for id: ${msg.id}`); + } + const subscribe = new SubscribeRecv(this.#control, this.#objects, msg); + this.#subscribe.set(msg.id, subscribe); + await this.#subscribeQueue.push(subscribe); + await this.#control.send({ + kind: Msg.SubscribeOk, + id: msg.id, + expires: 0n, + group_order: msg.group_order, + }); + } + recvUnsubscribe(_msg) { + throw new Error("TODO unsubscribe"); + } + } + class AnnounceSend { + #control; + namespace; + // The current state, updated by control messages. + #state = new Watch("init"); + constructor(control, namespace) { + this.#control = control; + this.namespace = namespace; + } + async ok() { + for (;;) { + const [state, next] = this.#state.value(); + if (state === "ack") + return; + if (state instanceof Error) + throw state; + if (!next) + throw new Error("closed"); + await next; + } + } + async active() { + for (;;) { + const [state, next] = this.#state.value(); + if (state instanceof Error) + throw state; + if (!next) + return; + await next; + } + } + async close() { + // TODO implement unsubscribe + // await this.#inner.sendUnsubscribe() + } + closed() { + const [state, next] = this.#state.value(); + return state instanceof Error || next == undefined; + } + onOk() { + if (this.closed()) + return; + this.#state.update("ack"); + } + onError(code, reason) { + if (this.closed()) + return; + const err = new Error(`ANNOUNCE_ERROR (${code})` + reason ? `: ${reason}` : ""); + this.#state.update(err); + } + } + class SubscribeRecv { + #control; + #objects; + #id; + #trackId; + #subscriberPriority; + groupOrder; + namespace; + track; + // The current state of the subscription. + #state = "init"; + constructor(control, objects, msg) { + this.#control = control; // so we can send messages + this.#objects = objects; // so we can send objects + this.#id = msg.id; + this.#trackId = msg.trackId; + this.namespace = msg.namespace; + this.track = msg.name; + this.#subscriberPriority = msg.subscriber_priority; + this.groupOrder = msg.group_order; + } + // Acknowledge the subscription as valid. + async ack() { + if (this.#state !== "init") + return; + this.#state = "ack"; + // Send the control message. + return this.#control.send({ + kind: Msg.SubscribeOk, + id: this.#id, + expires: 0n, + group_order: this.groupOrder, + }); + } + // Close the subscription with an error. + async close(code = 0n, reason = "") { + if (this.#state === "closed") + return; + this.#state = "closed"; + return this.#control.send({ + kind: Msg.SubscribeDone, + id: this.#id, + code, + reason, + }); + } + // Create a writable data stream for the entire track + async serve(props) { + return this.#objects.send({ + type: StreamType.Track, + sub: this.#id, + track: this.#trackId, + publisher_priority: props?.priority ?? 127, + }); + } + // Create a writable data stream for a group within the track + async group(props) { + return this.#objects.send({ + type: StreamType.Group, + sub: this.#id, + track: this.#trackId, + group: props.group, + publisher_priority: props.priority ?? 127, + }); + } + // Create a writable data stream for a single object within the track + async object(props) { + return this.#objects.send({ + type: StreamType.Object, + sub: this.#id, + track: this.#trackId, + group: props.group, + object: props.object, + publisher_priority: props.priority ?? 127, + status: 0, + }); + } + } + + class Subscriber { + // Use to send control messages. + #control; + // Use to send objects. + #objects; + // Announced broadcasts. + #announce = new Map(); + #announceQueue = new Watch([]); + // Our subscribed tracks. + #subscribe = new Map(); + #subscribeNext = 0n; + #trackToIDMap = new Map(); + constructor(control, objects) { + this.#control = control; + this.#objects = objects; + } + announced() { + return this.#announceQueue; + } + async recv(msg) { + if (msg.kind == Msg.Announce) { + await this.recvAnnounce(msg); + } + else if (msg.kind == Msg.Unannounce) { + this.recvUnannounce(msg); + } + else if (msg.kind == Msg.SubscribeOk) { + this.recvSubscribeOk(msg); + } + else if (msg.kind == Msg.SubscribeError) { + await this.recvSubscribeError(msg); + } + else if (msg.kind == Msg.SubscribeDone) { + await this.recvSubscribeDone(msg); + } + else { + throw new Error(`unknown control message`); // impossible + } + } + async recvAnnounce(msg) { + if (this.#announce.has(msg.namespace)) { + throw new Error(`duplicate announce for namespace: ${msg.namespace}`); + } + await this.#control.send({ kind: Msg.AnnounceOk, namespace: msg.namespace }); + const announce = new AnnounceRecv(this.#control, msg.namespace); + this.#announce.set(msg.namespace, announce); + this.#announceQueue.update((queue) => [...queue, announce]); + } + recvUnannounce(_msg) { + throw new Error(`TODO Unannounce`); + } + async subscribe(namespace, track) { + const id = this.#subscribeNext++; + const subscribe = new SubscribeSend(this.#control, id, namespace, track); + this.#subscribe.set(id, subscribe); + this.#trackToIDMap.set(track, id); + await this.#control.send({ + kind: Msg.Subscribe, + id, + trackId: id, + namespace, + name: track, + subscriber_priority: 127, // default to mid value, see: https://github.com/moq-wg/moq-transport/issues/504 + group_order: GroupOrder.Publisher, + location: { + mode: "latest_group", + }, + }); + return subscribe; + } + async unsubscribe(track) { + if (this.#trackToIDMap.has(track)) { + const trackID = this.#trackToIDMap.get(track); + if (trackID === undefined) { + console.warn(`Exception track ${track} not found in trackToIDMap.`); + return; + } + try { + await this.#control.send({ kind: Msg.Unsubscribe, id: trackID }); + this.#trackToIDMap.delete(track); + } + catch (error) { + console.error(`Failed to unsubscribe from track ${track}:`, error); + } + } + else { + console.warn(`During unsubscribe request initiation attempt track ${track} not found in trackToIDMap.`); + } + } + recvSubscribeOk(msg) { + const subscribe = this.#subscribe.get(msg.id); + if (!subscribe) { + throw new Error(`subscribe ok for unknown id: ${msg.id}`); + } + subscribe.onOk(); + } + async recvSubscribeError(msg) { + const subscribe = this.#subscribe.get(msg.id); + if (!subscribe) { + throw new Error(`subscribe error for unknown id: ${msg.id}`); + } + await subscribe.onError(msg.code, msg.reason); + } + async recvSubscribeDone(msg) { + const subscribe = this.#subscribe.get(msg.id); + if (!subscribe) { + throw new Error(`subscribe error for unknown id: ${msg.id}`); + } + await subscribe.onError(msg.code, msg.reason); + } + async recvObject(reader) { + const subscribe = this.#subscribe.get(reader.header.track); + if (!subscribe) { + throw new Error(`data for for unknown track: ${reader.header.track}`); + } + await subscribe.onData(reader); + } + } + class AnnounceRecv { + #control; + namespace; + // The current state of the announce + #state = "init"; + constructor(control, namespace) { + this.#control = control; // so we can send messages + this.namespace = namespace; + } + // Acknowledge the subscription as valid. + async ok() { + if (this.#state !== "init") + return; + this.#state = "ack"; + // Send the control message. + return this.#control.send({ kind: Msg.AnnounceOk, namespace: this.namespace }); + } + async close(code = 0n, reason = "") { + if (this.#state === "closed") + return; + this.#state = "closed"; + return this.#control.send({ kind: Msg.AnnounceError, namespace: this.namespace, code, reason }); + } + } + class SubscribeSend { + #control; + #id; + namespace; + track; + // A queue of received streams for this subscription. + #data = new Queue(); + constructor(control, id, namespace, track) { + this.#control = control; // so we can send messages + this.#id = id; + this.namespace = namespace; + this.track = track; + } + async close(_code = 0n, _reason = "") { + // TODO implement unsubscribe + // await this.#inner.sendReset(code, reason) + } + onOk() { + // noop + } + async onError(code, reason) { + if (code == 0n) { + return await this.#data.close(); + } + if (reason !== "") { + reason = `: ${reason}`; + } + const err = new Error(`SUBSCRIBE_ERROR (${code})${reason}`); + return await this.#data.abort(err); + } + async onData(reader) { + if (!this.#data.closed()) + await this.#data.push(reader); + } + // Receive the next a readable data stream + async data() { + return await this.#data.next(); + } + } + + class Connection { + // The established WebTransport session. + #quic; + // Use to receive/send control messages. + #control; + // Use to receive/send objects. + #objects; + // Module for contributing tracks. + #publisher; + // Module for distributing tracks. + #subscriber; + // Async work running in the background + #running; + constructor(quic, control, objects) { + this.#quic = quic; + this.#control = control; + this.#objects = objects; + this.#publisher = new Publisher(this.#control, this.#objects); + this.#subscriber = new Subscriber(this.#control, this.#objects); + this.#running = this.#run(); + } + close(code = 0, reason = "") { + this.#quic.close({ closeCode: code, reason }); + } + async #run() { + await Promise.all([this.#runControl(), this.#runObjects()]); + } + announce(namespace) { + return this.#publisher.announce(namespace); + } + announced() { + return this.#subscriber.announced(); + } + subscribe(namespace, track) { + return this.#subscriber.subscribe(namespace, track); + } + unsubscribe(track) { + return this.#subscriber.unsubscribe(track); + } + subscribed() { + return this.#publisher.subscribed(); + } + async #runControl() { + // Receive messages until the connection is closed. + for (;;) { + const msg = await this.#control.recv(); + await this.#recv(msg); + } + } + async #runObjects() { + for (;;) { + const obj = await this.#objects.recv(); + if (!obj) + break; + await this.#subscriber.recvObject(obj); + } + } + async #recv(msg) { + if (isPublisher(msg)) { + await this.#subscriber.recv(msg); + } + else { + await this.#publisher.recv(msg); + } + } + async closed() { + try { + await this.#running; + return new Error("closed"); + } + catch (e) { + return asError(e); + } + } + } + + class Client { + #fingerprint; + config; + constructor(config) { + this.config = config; + this.#fingerprint = this.#fetchFingerprint(config.fingerprint).catch((e) => { + console.warn("failed to fetch fingerprint: ", e); + return undefined; + }); + } + async connect() { + // Helper function to make creating a promise easier + const options = {}; + const fingerprint = await this.#fingerprint; + if (fingerprint) + options.serverCertificateHashes = [fingerprint]; + const quic = new WebTransport(this.config.url, options); + await quic.ready; + const stream = await quic.createBidirectionalStream(); + const writer = new Writer(stream.writable); + const reader = new Reader(new Uint8Array(), stream.readable); + const setup = new Stream$1(reader, writer); + // Send the setup message. + await setup.send.client({ versions: [Version.DRAFT_05], role: this.config.role }); + // Receive the setup message. + // TODO verify the SETUP response. + const server = await setup.recv.server(); + if (server.version != Version.DRAFT_05) { + throw new Error(`unsupported server version: ${server.version}`); + } + const control = new Stream(reader, writer); + const objects = new Objects(quic); + return new Connection(quic, control, objects); + } + async #fetchFingerprint(url) { + if (!url) + return; + // TODO remove this fingerprint when Chrome WebTransport accepts the system CA + const response = await fetch(url); + const hexString = await response.text(); + const hexBytes = new Uint8Array(hexString.length / 2); + for (let i = 0; i < hexBytes.length; i += 1) { + hexBytes[i] = parseInt(hexString.slice(2 * i, 2 * i + 2), 16); + } + return { + algorithm: "sha-256", + value: hexBytes, + }; + } + } + + // This class must be created on the main thread due to AudioContext. + class Player { + #backend; + // A periodically updated timeline + //#timeline = new Watch(undefined) + #connection; + #catalog; + #tracksByName; + #tracknum; + #audioTrackName; + #videoTrackName; + #muted; + #paused; + // Running is a promise that resolves when the player is closed. + // #close is called with no error, while #abort is called with an error. + #running; + #close; + #abort; + #trackTasks = new Map(); + constructor(connection, catalog, backend, tracknum) { + this.#connection = connection; + this.#catalog = catalog; + this.#tracksByName = new Map(catalog.tracks.map((track) => [track.name, track])); + this.#backend = backend; + this.#tracknum = tracknum; + this.#audioTrackName = ""; + this.#videoTrackName = ""; + this.#muted = false; + this.#paused = false; + const abort = new Promise((resolve, reject) => { + this.#close = resolve; + this.#abort = reject; + }); + // Async work + this.#running = abort.catch(this.#close); + this.#run().catch((err) => { + console.error("Error in #run():", err); + this.#abort(err); + }); + } + static async create(config, tracknum) { + const client = new Client({ url: config.url, fingerprint: config.fingerprint, role: "subscriber" }); + const connection = await client.connect(); + const catalog = await fetch$1(connection, config.namespace); + console.log("catalog", catalog); + const canvas = config.canvas.transferControlToOffscreen(); + const backend = new Backend({ canvas, catalog }); + return new Player(connection, catalog, backend, tracknum); + } + async #run() { + const inits = new Set(); + const tracks = new Array(); + this.#catalog.tracks.forEach((track, index) => { + if (index == this.#tracknum || isAudioTrack(track)) { + if (!track.namespace) + throw new Error("track has no namespace"); + if (track.initTrack) + inits.add([track.namespace, track.initTrack]); + tracks.push(track); + } + }); + // Call #runInit on each unique init track + // TODO do this in parallel with #runTrack to remove a round trip + await Promise.all(Array.from(inits).map((init) => this.#runInit(...init))); + // Call #runTrack on each track + tracks.forEach((track) => { + this.#runTrack(track); + }); + } + async #runInit(namespace, name) { + const sub = await this.#connection.subscribe(namespace, name); + try { + const init = await Promise.race([sub.data(), this.#running]); + if (!init) + throw new Error("no init data"); + // We don't care what type of reader we get, we just want the payload. + const chunk = await init.read(); + if (!chunk) + throw new Error("no init chunk"); + if (!(chunk.payload instanceof Uint8Array)) + throw new Error("invalid init chunk"); + this.#backend.init({ data: chunk.payload, name }); + } + finally { + await sub.close(); + } + } + async #trackTask(track) { + if (!track.namespace) + throw new Error("track has no namespace"); + if (this.#paused) + return; + const kind = isVideoTrack(track) ? "video" : isAudioTrack(track) ? "audio" : "unknown"; + if (kind == "audio" && this.#muted) + return; + const sub = await this.#connection.subscribe(track.namespace, track.name); + if (kind == "audio") { + // Save ref to last audio track we subscribed to for unmuting + this.#audioTrackName = track.name; + } + if (kind == "video") { + this.#videoTrackName = track.name; + } + try { + for (;;) { + const segment = await Promise.race([sub.data(), this.#running]); + if (!segment) + continue; + if (!(segment instanceof GroupReader)) { + throw new Error(`expected group reader for segment: ${track.name}`); + } + if (kind == "unknown") { + throw new Error(`unknown track kind: ${track.name}`); + } + if (!track.initTrack) { + throw new Error(`no init track for segment: ${track.name}`); + } + const [buffer, stream] = segment.stream.release(); + this.#backend.segment({ + init: track.initTrack, + kind, + header: segment.header, + buffer, + stream, + }); + } + } + catch (error) { + console.error("Error in #runTrack:", error); + } + finally { + await sub.close(); + } + } + #runTrack(track) { + if (this.#trackTasks.has(track.name)) { + console.warn(`Already exist a runTrack task for the track: ${track.name}`); + return; + } + const task = (async () => this.#trackTask(track))(); + this.#trackTasks.set(track.name, task); + task.catch((err) => { + console.error(`Error to subscribe to track ${track.name}`, err); + }).finally(() => { + this.#trackTasks.delete(track.name); + }); + } + getCatalog() { + return this.#catalog; + } + getCurrentTrack() { + if (this.#tracknum >= 0 && this.#tracknum < this.#catalog.tracks.length) { + return this.#catalog.tracks[this.#tracknum]; + } + else { + console.warn("Invalid track number:", this.#tracknum); + return null; + } + } + getVideoTracks() { + return this.#catalog.tracks.filter(isVideoTrack).map((track) => track.name); + } + getAudioTracks() { + return this.#catalog.tracks.filter(isAudioTrack).map((track) => track.name); + } + async switchTrack(trackname) { + const currentTrack = this.getCurrentTrack(); + if (this.#paused) { + this.#videoTrackName = trackname; + return; + } + if (currentTrack) { + console.log(`Unsubscribing from track: ${currentTrack.name} and Subscribing to track: ${trackname}`); + await this.unsubscribeFromTrack(currentTrack.name); + } + else { + console.log(`Subscribing to track: ${trackname}`); + } + this.#tracknum = this.#catalog.tracks.findIndex((track) => track.name === trackname); + const tracksToStream = this.#catalog.tracks.filter((track) => track.name === trackname); + await Promise.all(tracksToStream.map((track) => this.#runTrack(track))); + } + async mute(isMuted) { + this.#muted = isMuted; + if (isMuted) { + console.log("Unsubscribing from audio track: ", this.#audioTrackName); + await this.unsubscribeFromTrack(this.#audioTrackName); + await this.#backend.mute(); + } + else { + console.log("Subscribing to audio track: ", this.#audioTrackName); + this.subscribeFromTrackName(this.#audioTrackName); + await this.#backend.unmute(); + } + } + async unsubscribeFromTrack(trackname) { + console.log(`Unsubscribing from track: ${trackname}`); + await this.#connection.unsubscribe(trackname); + const task = this.#trackTasks.get(trackname); + if (task) { + await task; + } + } + subscribeFromTrackName(trackname) { + console.log(`Subscribing to track: ${trackname}`); + const track = this.#tracksByName.get(trackname); + if (track) { + this.#runTrack(track); + } + else { + console.warn(`Track ${trackname} not in #tracksByName`); + } + } + #onMessage(msg) { + if (msg.timeline) ; + } + async close(err) { + if (err) + this.#abort(err); + else + this.#close(); + if (this.#connection) + this.#connection.close(); + if (this.#backend) + await this.#backend.close(); + } + async closed() { + try { + await this.#running; + } + catch (e) { + return asError(e); + } + } + /* + play() { + this.#backend.play({ minBuffer: 0.5 }) // TODO configurable + } + + seek(timestamp: number) { + this.#backend.seek({ timestamp }) + } + */ + async play() { + if (this.#paused) { + this.#paused = false; + this.subscribeFromTrackName(this.#videoTrackName); + if (!this.#muted) { + this.subscribeFromTrackName(this.#audioTrackName); + await this.#backend.unmute(); + } + } + else { + await this.unsubscribeFromTrack(this.#videoTrackName); + await this.unsubscribeFromTrack(this.#audioTrackName); + await this.#backend.mute(); + this.#backend.pause(); + this.#paused = true; + } + } + } + + return Player; + +})(); +//# sourceMappingURL=moq-player.iife.js.map diff --git a/simple-web/public/moq-player.iife.js.map b/simple-web/public/moq-player.iife.js.map new file mode 100644 index 0000000..575cf0c --- /dev/null +++ b/simple-web/public/moq-player.iife.js.map @@ -0,0 +1 @@ +{"version":3,"file":"moq-player.iife.js","sources":["../../../common/error.ts","../../../media/catalog/index.ts","../../../playback/audio.ts","../../../common/ring.ts","../../../playback/backend.ts","../../../transport/stream.ts","../../../transport/setup.ts","../../../transport/control.ts","../../../transport/objects.ts","../../../common/async.ts","../../../transport/publisher.ts","../../../transport/subscriber.ts","../../../transport/connection.ts","../../../transport/client.ts","../../../playback/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":["fetch","registerMyAudioWorklet","MediaWorker","Decoder","Encoder","Control.Msg","Control.GroupOrder","Control.isPublisher","Stream.Writer","Stream.Reader","Setup.Stream","Setup.Version","Control.Stream","Catalog.fetch","Catalog.isAudioTrack","Catalog.isVideoTrack"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/simple-web/public/moq-player.umd.js b/simple-web/public/moq-player.umd.js deleted file mode 100644 index 9d5c274..0000000 --- a/simple-web/public/moq-player.umd.js +++ /dev/null @@ -1,11800 +0,0 @@ -var moqplayer = (function () { - 'use strict'; - - // I hate javascript - function asError(e) { - if (e instanceof Error) { - return e; - } - else if (typeof e === "string") { - return new Error(e); - } - else { - return new Error(String(e)); - } - } - - function decode(raw) { - const decoder = new TextDecoder(); - const str = decoder.decode(raw); - const catalog = JSON.parse(str); - if (!isRoot(catalog)) { - throw new Error("invalid catalog"); - } - // Merge common track fields into each track. - for (const track of catalog.tracks) { - track.altGroup ??= catalog.commonTrackFields.altGroup; - track.namespace ??= catalog.commonTrackFields.namespace; - track.packaging ??= catalog.commonTrackFields.packaging; - track.renderGroup ??= catalog.commonTrackFields.renderGroup; - } - return catalog; - } - async function fetch$1(connection, namespace) { - const subscribe = await connection.subscribe(namespace, ".catalog"); - try { - const segment = await subscribe.data(); - if (!segment) - throw new Error("no catalog data"); - const chunk = await segment.read(); - if (!chunk) - throw new Error("no catalog chunk"); - await segment.close(); - await subscribe.close(); // we done - if (chunk.payload instanceof Uint8Array) { - return decode(chunk.payload); - } - else { - throw new Error("invalid catalog chunk"); - } - } - catch (e) { - const err = asError(e); - // Close the subscription after we're done. - await subscribe.close(1n, err.message); - throw err; - } - } - function isRoot(catalog) { - if (!isCatalogFieldValid(catalog, "packaging")) - return false; - if (!isCatalogFieldValid(catalog, "namespace")) - return false; - if (!Array.isArray(catalog.tracks)) - return false; - return catalog.tracks.every((track) => isTrack(track)); - } - function isTrack(track) { - if (typeof track.name !== "string") - return false; - return true; - } - function isVideoTrack(track) { - if (!isTrack(track)) - return false; - return isVideoSelectionParams(track.selectionParams); - } - function isVideoSelectionParams(params) { - if (typeof params.width !== "number") - return false; - if (typeof params.height !== "number") - return false; - return true; - } - function isAudioTrack(track) { - if (!isTrack(track)) - return false; - return isAudioSelectionParams(track.selectionParams); - } - function isAudioSelectionParams(params) { - if (typeof params.channelConfig !== "string") - return false; - if (typeof params.samplerate !== "number") - return false; - return true; - } - function isCatalogFieldValid(catalog, field) { - //packaging,namespace if common would be listed in commonTrackFields but if fields - //in commonTrackFields are mentiond in Tracks , the fields in Tracks precedes - function isValidPackaging(packaging) { - return packaging === "cmaf" || packaging === "loc"; - } - function isValidNamespace(namespace) { - return typeof namespace === "string"; - } - let isValidField; - if (field === "packaging") { - isValidField = isValidPackaging; - } - else if (field === "namespace") { - isValidField = isValidNamespace; - } - else { - throw new Error(`Invalid field: ${field}`); - } - if (catalog.commonTrackFields[field] !== undefined && !isValidField(catalog.commonTrackFields[field])) { - return false; - } - for (const track of catalog.tracks) { - if (track[field] !== undefined && !isValidField(track[field])) { - return false; - } - } - return true; - } - - function funcToSource(fn, sourcemapArg) { - var source = fn.toString(); - var lines = source.split('\n'); - lines.pop(); - lines.shift(); - var blankPrefixLength = lines[0].search(/\S/); - var regex = /(['"])__worker_loader_strict__(['"])/g; - for (var i = 0, n = lines.length; i < n; ++i) { - lines[i] = lines[i].substring(blankPrefixLength).replace(regex, '$1use strict$2') + '\n'; - } - return lines; - } - - function createURL$1(fn, sourcemapArg) { - var lines = funcToSource(fn); - var blob = new Blob(lines, { type: 'application/javascript' }); - return URL.createObjectURL(blob); - } - - function createInlineAudioWorkletFactory$1(fn, sourcemapArg) { - var url; - return async function AudioWorkletFactory(audioContext, options) { - url = url || createURL$1(fn); - return await audioContext.audioWorklet.addModule(url, options); - }; - } - - var kIsNodeJS = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'; - - function isNodeJS() { - return kIsNodeJS; - } - - function createInlineAudioWorkletFactory(fn, sourcemapArg) { - if (isNodeJS()) { - throw new Error('rollup-plugin-web-worker-loader does not support Audio Worklet in Node.JS'); - } - return createInlineAudioWorkletFactory$1(fn); - } - - var WorkerFactory$1 = /*#__PURE__*/createInlineAudioWorkletFactory(/* rollup-plugin-web-worker-loader */function () { - (function () { - '__worker_loader_strict__'; - - // Ring buffer with audio samples. - var STATE; - (function (STATE) { - STATE[STATE["READ_POS"] = 0] = "READ_POS"; - STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; - STATE[STATE["LENGTH"] = 2] = "LENGTH"; - })(STATE || (STATE = {})); - class Ring { - state; - channels; - capacity; - constructor(shared) { - this.state = new Int32Array(shared.state); - this.channels = []; - for (const channel of shared.channels) { - this.channels.push(new Float32Array(channel)); - } - this.capacity = shared.capacity; - } - // Write samples for single audio frame, returning the total number written. - write(frame) { - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - const startPos = writePos; - let endPos = writePos + frame.numberOfFrames; - if (endPos > readPos + this.capacity) { - endPos = readPos + this.capacity; - if (endPos <= startPos) { - // No space to write - return 0; - } - } - const startIndex = startPos % this.capacity; - const endIndex = endPos % this.capacity; - // Loop over each channel - for (let i = 0; i < this.channels.length; i += 1) { - const channel = this.channels[i]; - // If the AudioData doesn't have enough channels, duplicate it. - const planeIndex = Math.min(i, frame.numberOfChannels - 1); - if (startIndex < endIndex) { - // One continuous range to copy. - const full = channel.subarray(startIndex, endIndex); - frame.copyTo(full, { - planeIndex, - frameCount: endIndex - startIndex, - }); - } - else { - const first = channel.subarray(startIndex); - const second = channel.subarray(0, endIndex); - frame.copyTo(first, { - planeIndex, - frameCount: first.length, - }); - // We need this conditional when startIndex == 0 and endIndex == 0 - // When capacity=4410 and frameCount=1024, this was happening 52s into the audio. - if (second.length) { - frame.copyTo(second, { - planeIndex, - frameOffset: first.length, - frameCount: second.length, - }); - } - } - } - Atomics.store(this.state, STATE.WRITE_POS, endPos); - return endPos - startPos; - } - read(dst) { - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - const startPos = readPos; - let endPos = startPos + dst[0].length; - if (endPos > writePos) { - endPos = writePos; - if (endPos <= startPos) { - // Nothing to read - return 0; - } - } - const startIndex = startPos % this.capacity; - const endIndex = endPos % this.capacity; - // Loop over each channel - for (let i = 0; i < dst.length; i += 1) { - if (i >= this.channels.length) ; - const input = this.channels[i]; - const output = dst[i]; - if (startIndex < endIndex) { - const full = input.subarray(startIndex, endIndex); - output.set(full); - } - else { - const first = input.subarray(startIndex); - const second = input.subarray(0, endIndex); - output.set(first); - output.set(second, first.length); - } - } - Atomics.store(this.state, STATE.READ_POS, endPos); - return endPos - startPos; - } - clear() { - const pos = Atomics.load(this.state, STATE.WRITE_POS); - Atomics.store(this.state, STATE.READ_POS, pos); - } - size() { - // TODO is this thread safe? - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - return writePos - readPos; - } - } - - // TODO add support for @/ to avoid relative imports - class Renderer extends AudioWorkletProcessor { - ring; - base; - constructor() { - // The super constructor call is required. - super(); - this.base = 0; - this.port.onmessage = this.onMessage.bind(this); - } - onMessage(e) { - const msg = e.data; - if (msg.config) { - this.onConfig(msg.config); - } - } - onConfig(config) { - this.ring = new Ring(config.ring); - } - // Inputs and outputs in groups of 128 samples. - process(inputs, outputs, _parameters) { - if (!this.ring) { - // Paused - return true; - } - if (inputs.length != 1 && outputs.length != 1) { - throw new Error("only a single track is supported"); - } - if (this.ring.size() == this.ring.capacity) { - // This is a hack to clear any latency in the ring buffer. - // The proper solution is to play back slightly faster? - console.warn("resyncing ring buffer"); - this.ring.clear(); - return true; - } - const output = outputs[0]; - const size = this.ring.read(output); - if (size < output.length) ; - return true; - } - } - registerProcessor("renderer", Renderer); - - })(); - - }); - /* eslint-enable */ - - // NOTE: This must be on the main thread - class Audio { - context; - worklet; - constructor(config) { - this.context = new AudioContext({ - latencyHint: "interactive", - sampleRate: config.sampleRate, - }); - this.worklet = this.load(config); - } - async load(config) { - // Load the worklet source code. - await WorkerFactory$1(this.context); - const volume = this.context.createGain(); - volume.gain.value = 2.0; - // Create the worklet - const worklet = new AudioWorkletNode(this.context, "renderer"); - worklet.port.addEventListener("message", this.on.bind(this)); - worklet.onprocessorerror = (e) => { - console.error("Audio worklet error:", e); - }; - // Connect the worklet to the volume node and then to the speakers - worklet.connect(volume); - volume.connect(this.context.destination); - worklet.port.postMessage({ config }); - return worklet; - } - on(_event) { - // TODO - } - } - - var WorkerClass = null; - - try { - var WorkerThreads = - typeof module !== 'undefined' && typeof module.require === 'function' && module.require('worker_threads') || - typeof __non_webpack_require__ === 'function' && __non_webpack_require__('worker_threads') || - typeof require === 'function' && require('worker_threads'); - WorkerClass = WorkerThreads.Worker; - } catch(e) {} // eslint-disable-line - - function createInlineWorkerFactory$2(fn, sourcemapArg) { - var lines = funcToSource(fn); - var concat = lines.join('\n'); - return function WorkerFactory(options) { - return new WorkerClass(concat, Object.assign({}, options, { eval: true })); - }; - } - - function createURL(fn, sourcemapArg) { - var lines = funcToSource(fn); - var blob = new Blob(lines, { type: 'application/javascript' }); - return URL.createObjectURL(blob); - } - - function createInlineWorkerFactory$1(fn, sourcemapArg) { - var url; - return function WorkerFactory(options) { - url = url || createURL(fn); - return new Worker(url, options); - }; - } - - function createInlineWorkerFactory(fn, sourcemapArg) { - if (isNodeJS()) { - return createInlineWorkerFactory$2(fn); - } - return createInlineWorkerFactory$1(fn); - } - - var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-worker-loader */function () { - (function () { - '__worker_loader_strict__'; - - class Timeline { - // Maintain audio and video seprarately - audio; - video; - // Construct a timeline - constructor() { - this.audio = new Component(); - this.video = new Component(); - } - } - class Component { - #current; - frames; - #segments; - constructor() { - this.frames = new ReadableStream({ - pull: this.#pull.bind(this), - cancel: this.#cancel.bind(this), - }); - // This is a hack to have an async channel with 100 items. - this.#segments = new TransformStream({}, { highWaterMark: 100 }); - } - get segments() { - return this.#segments.writable; - } - async #pull(controller) { - for (;;) { - // Get the next segment to render. - const segments = this.#segments.readable.getReader(); - let res; - if (this.#current) { - // Get the next frame to render. - const frames = this.#current.frames.getReader(); - // Wait for either the frames or segments to be ready. - // NOTE: This assume that the first promise gets priority. - res = await Promise.race([frames.read(), segments.read()]); - frames.releaseLock(); - } - else { - res = await segments.read(); - } - segments.releaseLock(); - const { value, done } = res; - if (done) { - // We assume the current segment has been closed - // TODO support the segments stream closing - this.#current = undefined; - continue; - } - if (!isSegment(value)) { - // Return so the reader can decide when to get the next frame. - controller.enqueue(value); - return; - } - // We didn't get any frames, and instead got a new segment. - if (this.#current) { - if (value.sequence < this.#current.sequence) { - // Our segment is older than the current, abandon it. - await value.frames.cancel("skipping segment; too old"); - continue; - } - else { - // Our segment is newer than the current, cancel the old one. - await this.#current.frames.cancel("skipping segment; too slow"); - } - } - this.#current = value; - } - } - async #cancel(reason) { - if (this.#current) { - await this.#current.frames.cancel(reason); - } - const segments = this.#segments.readable.getReader(); - for (;;) { - const { value: segment, done } = await segments.read(); - if (done) - break; - await segment.frames.cancel(reason); - } - } - } - // Return if a type is a segment or frame - // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents - function isSegment(value) { - // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition - return value.frames !== undefined; - } - - // Ring buffer with audio samples. - var STATE; - (function (STATE) { - STATE[STATE["READ_POS"] = 0] = "READ_POS"; - STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; - STATE[STATE["LENGTH"] = 2] = "LENGTH"; - })(STATE || (STATE = {})); - class Ring { - state; - channels; - capacity; - constructor(shared) { - this.state = new Int32Array(shared.state); - this.channels = []; - for (const channel of shared.channels) { - this.channels.push(new Float32Array(channel)); - } - this.capacity = shared.capacity; - } - // Write samples for single audio frame, returning the total number written. - write(frame) { - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - const startPos = writePos; - let endPos = writePos + frame.numberOfFrames; - if (endPos > readPos + this.capacity) { - endPos = readPos + this.capacity; - if (endPos <= startPos) { - // No space to write - return 0; - } - } - const startIndex = startPos % this.capacity; - const endIndex = endPos % this.capacity; - // Loop over each channel - for (let i = 0; i < this.channels.length; i += 1) { - const channel = this.channels[i]; - // If the AudioData doesn't have enough channels, duplicate it. - const planeIndex = Math.min(i, frame.numberOfChannels - 1); - if (startIndex < endIndex) { - // One continuous range to copy. - const full = channel.subarray(startIndex, endIndex); - frame.copyTo(full, { - planeIndex, - frameCount: endIndex - startIndex, - }); - } - else { - const first = channel.subarray(startIndex); - const second = channel.subarray(0, endIndex); - frame.copyTo(first, { - planeIndex, - frameCount: first.length, - }); - // We need this conditional when startIndex == 0 and endIndex == 0 - // When capacity=4410 and frameCount=1024, this was happening 52s into the audio. - if (second.length) { - frame.copyTo(second, { - planeIndex, - frameOffset: first.length, - frameCount: second.length, - }); - } - } - } - Atomics.store(this.state, STATE.WRITE_POS, endPos); - return endPos - startPos; - } - read(dst) { - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - const startPos = readPos; - let endPos = startPos + dst[0].length; - if (endPos > writePos) { - endPos = writePos; - if (endPos <= startPos) { - // Nothing to read - return 0; - } - } - const startIndex = startPos % this.capacity; - const endIndex = endPos % this.capacity; - // Loop over each channel - for (let i = 0; i < dst.length; i += 1) { - if (i >= this.channels.length) ; - const input = this.channels[i]; - const output = dst[i]; - if (startIndex < endIndex) { - const full = input.subarray(startIndex, endIndex); - output.set(full); - } - else { - const first = input.subarray(startIndex); - const second = input.subarray(0, endIndex); - output.set(first); - output.set(second, first.length); - } - } - Atomics.store(this.state, STATE.READ_POS, endPos); - return endPos - startPos; - } - clear() { - const pos = Atomics.load(this.state, STATE.WRITE_POS); - Atomics.store(this.state, STATE.READ_POS, pos); - } - size() { - // TODO is this thread safe? - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - return writePos - readPos; - } - } - - function createCommonjsModule(fn, module) { - return module = { exports: {} }, fn(module, module.exports), module.exports; - } - - var mp4box_all = createCommonjsModule(function (module, exports) { - // file:src/log.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var Log = (function (){ - var start = new Date(); - var LOG_LEVEL_ERROR = 4; - var LOG_LEVEL_WARNING = 3; - var LOG_LEVEL_INFO = 2; - var LOG_LEVEL_DEBUG = 1; - var log_level = LOG_LEVEL_ERROR; - var logObject = { - setLogLevel : function(level) { - if (level == this.debug) log_level = LOG_LEVEL_DEBUG; - else if (level == this.info) log_level = LOG_LEVEL_INFO; - else if (level == this.warn) log_level = LOG_LEVEL_WARNING; - else if (level == this.error) log_level = LOG_LEVEL_ERROR; - else log_level = LOG_LEVEL_ERROR; - }, - debug : function(module, msg) { - if (console.debug === undefined) { - console.debug = console.log; - } - if (LOG_LEVEL_DEBUG >= log_level) { - console.debug("["+Log.getDurationString(new Date()-start,1000)+"]","["+module+"]",msg); - } - }, - log : function(module, msg) { - this.debug(module.msg); - }, - info : function(module, msg) { - if (LOG_LEVEL_INFO >= log_level) { - console.info("["+Log.getDurationString(new Date()-start,1000)+"]","["+module+"]",msg); - } - }, - warn : function(module, msg) { - if (LOG_LEVEL_WARNING >= log_level) { - console.warn("["+Log.getDurationString(new Date()-start,1000)+"]","["+module+"]",msg); - } - }, - error : function(module, msg) { - if (LOG_LEVEL_ERROR >= log_level) { - console.error("["+Log.getDurationString(new Date()-start,1000)+"]","["+module+"]",msg); - } - } - }; - return logObject; - })(); - - /* Helper function to print a duration value in the form H:MM:SS.MS */ - Log.getDurationString = function(duration, _timescale) { - var neg; - /* Helper function to print a number on a fixed number of digits */ - function pad(number, length) { - var str = '' + number; - var a = str.split('.'); - while (a[0].length < length) { - a[0] = '0' + a[0]; - } - return a.join('.'); - } - if (duration < 0) { - neg = true; - duration = -duration; - } else { - neg = false; - } - var timescale = _timescale || 1; - var duration_sec = duration/timescale; - var hours = Math.floor(duration_sec/3600); - duration_sec -= hours * 3600; - var minutes = Math.floor(duration_sec/60); - duration_sec -= minutes * 60; - var msec = duration_sec*1000; - duration_sec = Math.floor(duration_sec); - msec -= duration_sec*1000; - msec = Math.floor(msec); - return (neg ? "-": "")+hours+":"+pad(minutes,2)+":"+pad(duration_sec,2)+"."+pad(msec,3); - }; - - /* Helper function to stringify HTML5 TimeRanges objects */ - Log.printRanges = function(ranges) { - var length = ranges.length; - if (length > 0) { - var str = ""; - for (var i = 0; i < length; i++) { - if (i > 0) str += ","; - str += "["+Log.getDurationString(ranges.start(i))+ ","+Log.getDurationString(ranges.end(i))+"]"; - } - return str; - } else { - return "(empty)"; - } - }; - - { - exports.Log = Log; - } - // file:src/stream.js - var MP4BoxStream = function(arrayBuffer) { - if (arrayBuffer instanceof ArrayBuffer) { - this.buffer = arrayBuffer; - this.dataview = new DataView(arrayBuffer); - } else { - throw ("Needs an array buffer"); - } - this.position = 0; - }; - - /************************************************************************* - Common API between MultiBufferStream and SimpleStream - *************************************************************************/ - MP4BoxStream.prototype.getPosition = function() { - return this.position; - }; - - MP4BoxStream.prototype.getEndPosition = function() { - return this.buffer.byteLength; - }; - - MP4BoxStream.prototype.getLength = function() { - return this.buffer.byteLength; - }; - - MP4BoxStream.prototype.seek = function (pos) { - var npos = Math.max(0, Math.min(this.buffer.byteLength, pos)); - this.position = (isNaN(npos) || !isFinite(npos)) ? 0 : npos; - return true; - }; - - MP4BoxStream.prototype.isEos = function () { - return this.getPosition() >= this.getEndPosition(); - }; - - /************************************************************************* - Read methods, simimar to DataStream but simpler - *************************************************************************/ - MP4BoxStream.prototype.readAnyInt = function(size, signed) { - var res = 0; - if (this.position + size <= this.buffer.byteLength) { - switch (size) { - case 1: - if (signed) { - res = this.dataview.getInt8(this.position); - } else { - res = this.dataview.getUint8(this.position); - } - break; - case 2: - if (signed) { - res = this.dataview.getInt16(this.position); - } else { - res = this.dataview.getUint16(this.position); - } - break; - case 3: - if (signed) { - throw ("No method for reading signed 24 bits values"); - } else { - res = this.dataview.getUint8(this.position) << 16; - res |= this.dataview.getUint8(this.position+1) << 8; - res |= this.dataview.getUint8(this.position+2); - } - break; - case 4: - if (signed) { - res = this.dataview.getInt32(this.position); - } else { - res = this.dataview.getUint32(this.position); - } - break; - case 8: - if (signed) { - throw ("No method for reading signed 64 bits values"); - } else { - res = this.dataview.getUint32(this.position) << 32; - res |= this.dataview.getUint32(this.position+4); - } - break; - default: - throw ("readInt method not implemented for size: "+size); - } - this.position+= size; - return res; - } else { - throw ("Not enough bytes in buffer"); - } - }; - - MP4BoxStream.prototype.readUint8 = function() { - return this.readAnyInt(1, false); - }; - - MP4BoxStream.prototype.readUint16 = function() { - return this.readAnyInt(2, false); - }; - - MP4BoxStream.prototype.readUint24 = function() { - return this.readAnyInt(3, false); - }; - - MP4BoxStream.prototype.readUint32 = function() { - return this.readAnyInt(4, false); - }; - - MP4BoxStream.prototype.readUint64 = function() { - return this.readAnyInt(8, false); - }; - - MP4BoxStream.prototype.readString = function(length) { - if (this.position + length <= this.buffer.byteLength) { - var s = ""; - for (var i = 0; i < length; i++) { - s += String.fromCharCode(this.readUint8()); - } - return s; - } else { - throw ("Not enough bytes in buffer"); - } - }; - - MP4BoxStream.prototype.readCString = function() { - var arr = []; - while(true) { - var b = this.readUint8(); - if (b !== 0) { - arr.push(b); - } else { - break; - } - } - return String.fromCharCode.apply(null, arr); - }; - - MP4BoxStream.prototype.readInt8 = function() { - return this.readAnyInt(1, true); - }; - - MP4BoxStream.prototype.readInt16 = function() { - return this.readAnyInt(2, true); - }; - - MP4BoxStream.prototype.readInt32 = function() { - return this.readAnyInt(4, true); - }; - - MP4BoxStream.prototype.readInt64 = function() { - return this.readAnyInt(8, false); - }; - - MP4BoxStream.prototype.readUint8Array = function(length) { - var arr = new Uint8Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readUint8(); - } - return arr; - }; - - MP4BoxStream.prototype.readInt16Array = function(length) { - var arr = new Int16Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readInt16(); - } - return arr; - }; - - MP4BoxStream.prototype.readUint16Array = function(length) { - var arr = new Int16Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readUint16(); - } - return arr; - }; - - MP4BoxStream.prototype.readUint32Array = function(length) { - var arr = new Uint32Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readUint32(); - } - return arr; - }; - - MP4BoxStream.prototype.readInt32Array = function(length) { - var arr = new Int32Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readInt32(); - } - return arr; - }; - - { - exports.MP4BoxStream = MP4BoxStream; - }// file:src/DataStream.js - /** - DataStream reads scalars, arrays and structs of data from an ArrayBuffer. - It's like a file-like DataView on steroids. - - @param {ArrayBuffer} arrayBuffer ArrayBuffer to read from. - @param {?Number} byteOffset Offset from arrayBuffer beginning for the DataStream. - @param {?Boolean} endianness DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN (the default). - */ - var DataStream = function(arrayBuffer, byteOffset, endianness) { - this._byteOffset = byteOffset || 0; - if (arrayBuffer instanceof ArrayBuffer) { - this.buffer = arrayBuffer; - } else if (typeof arrayBuffer == "object") { - this.dataView = arrayBuffer; - if (byteOffset) { - this._byteOffset += byteOffset; - } - } else { - this.buffer = new ArrayBuffer(arrayBuffer || 0); - } - this.position = 0; - this.endianness = endianness == null ? DataStream.LITTLE_ENDIAN : endianness; - }; - DataStream.prototype = {}; - - DataStream.prototype.getPosition = function() { - return this.position; - }; - - /** - Internal function to resize the DataStream buffer when required. - @param {number} extra Number of bytes to add to the buffer allocation. - @return {null} - */ - DataStream.prototype._realloc = function(extra) { - if (!this._dynamicSize) { - return; - } - var req = this._byteOffset + this.position + extra; - var blen = this._buffer.byteLength; - if (req <= blen) { - if (req > this._byteLength) { - this._byteLength = req; - } - return; - } - if (blen < 1) { - blen = 1; - } - while (req > blen) { - blen *= 2; - } - var buf = new ArrayBuffer(blen); - var src = new Uint8Array(this._buffer); - var dst = new Uint8Array(buf, 0, src.length); - dst.set(src); - this.buffer = buf; - this._byteLength = req; - }; - - /** - Internal function to trim the DataStream buffer when required. - Used for stripping out the extra bytes from the backing buffer when - the virtual byteLength is smaller than the buffer byteLength (happens after - growing the buffer with writes and not filling the extra space completely). - - @return {null} - */ - DataStream.prototype._trimAlloc = function() { - if (this._byteLength == this._buffer.byteLength) { - return; - } - var buf = new ArrayBuffer(this._byteLength); - var dst = new Uint8Array(buf); - var src = new Uint8Array(this._buffer, 0, dst.length); - dst.set(src); - this.buffer = buf; - }; - - - /** - Big-endian const to use as default endianness. - @type {boolean} - */ - DataStream.BIG_ENDIAN = false; - - /** - Little-endian const to use as default endianness. - @type {boolean} - */ - DataStream.LITTLE_ENDIAN = true; - - /** - Virtual byte length of the DataStream backing buffer. - Updated to be max of original buffer size and last written size. - If dynamicSize is false is set to buffer size. - @type {number} - */ - DataStream.prototype._byteLength = 0; - - /** - Returns the byte length of the DataStream object. - @type {number} - */ - Object.defineProperty(DataStream.prototype, 'byteLength', - { get: function() { - return this._byteLength - this._byteOffset; - }}); - - /** - Set/get the backing ArrayBuffer of the DataStream object. - The setter updates the DataView to point to the new buffer. - @type {Object} - */ - Object.defineProperty(DataStream.prototype, 'buffer', - { get: function() { - this._trimAlloc(); - return this._buffer; - }, - set: function(v) { - this._buffer = v; - this._dataView = new DataView(this._buffer, this._byteOffset); - this._byteLength = this._buffer.byteLength; - } }); - - /** - Set/get the byteOffset of the DataStream object. - The setter updates the DataView to point to the new byteOffset. - @type {number} - */ - Object.defineProperty(DataStream.prototype, 'byteOffset', - { get: function() { - return this._byteOffset; - }, - set: function(v) { - this._byteOffset = v; - this._dataView = new DataView(this._buffer, this._byteOffset); - this._byteLength = this._buffer.byteLength; - } }); - - /** - Set/get the backing DataView of the DataStream object. - The setter updates the buffer and byteOffset to point to the DataView values. - @type {Object} - */ - Object.defineProperty(DataStream.prototype, 'dataView', - { get: function() { - return this._dataView; - }, - set: function(v) { - this._byteOffset = v.byteOffset; - this._buffer = v.buffer; - this._dataView = new DataView(this._buffer, this._byteOffset); - this._byteLength = this._byteOffset + v.byteLength; - } }); - - /** - Sets the DataStream read/write position to given position. - Clamps between 0 and DataStream length. - - @param {number} pos Position to seek to. - @return {null} - */ - DataStream.prototype.seek = function(pos) { - var npos = Math.max(0, Math.min(this.byteLength, pos)); - this.position = (isNaN(npos) || !isFinite(npos)) ? 0 : npos; - }; - - /** - Returns true if the DataStream seek pointer is at the end of buffer and - there's no more data to read. - - @return {boolean} True if the seek pointer is at the end of the buffer. - */ - DataStream.prototype.isEof = function() { - return (this.position >= this._byteLength); - }; - - - /** - Maps a Uint8Array into the DataStream buffer. - - Nice for quickly reading in data. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Uint8Array to the DataStream backing buffer. - */ - DataStream.prototype.mapUint8Array = function(length) { - this._realloc(length * 1); - var arr = new Uint8Array(this._buffer, this.byteOffset+this.position, length); - this.position += length * 1; - return arr; - }; - - - /** - Reads an Int32Array of desired length and endianness from the DataStream. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Int32Array. - */ - DataStream.prototype.readInt32Array = function(length, e) { - length = length == null ? (this.byteLength-this.position / 4) : length; - var arr = new Int32Array(length); - DataStream.memcpy(arr.buffer, 0, - this.buffer, this.byteOffset+this.position, - length*arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads an Int16Array of desired length and endianness from the DataStream. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Int16Array. - */ - DataStream.prototype.readInt16Array = function(length, e) { - length = length == null ? (this.byteLength-this.position / 2) : length; - var arr = new Int16Array(length); - DataStream.memcpy(arr.buffer, 0, - this.buffer, this.byteOffset+this.position, - length*arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads an Int8Array of desired length from the DataStream. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Int8Array. - */ - DataStream.prototype.readInt8Array = function(length) { - length = length == null ? (this.byteLength-this.position) : length; - var arr = new Int8Array(length); - DataStream.memcpy(arr.buffer, 0, - this.buffer, this.byteOffset+this.position, - length*arr.BYTES_PER_ELEMENT); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Uint32Array of desired length and endianness from the DataStream. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Uint32Array. - */ - DataStream.prototype.readUint32Array = function(length, e) { - length = length == null ? (this.byteLength-this.position / 4) : length; - var arr = new Uint32Array(length); - DataStream.memcpy(arr.buffer, 0, - this.buffer, this.byteOffset+this.position, - length*arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Uint16Array of desired length and endianness from the DataStream. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Uint16Array. - */ - DataStream.prototype.readUint16Array = function(length, e) { - length = length == null ? (this.byteLength-this.position / 2) : length; - var arr = new Uint16Array(length); - DataStream.memcpy(arr.buffer, 0, - this.buffer, this.byteOffset+this.position, - length*arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Uint8Array of desired length from the DataStream. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Uint8Array. - */ - DataStream.prototype.readUint8Array = function(length) { - length = length == null ? (this.byteLength-this.position) : length; - var arr = new Uint8Array(length); - DataStream.memcpy(arr.buffer, 0, - this.buffer, this.byteOffset+this.position, - length*arr.BYTES_PER_ELEMENT); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Float64Array of desired length and endianness from the DataStream. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Float64Array. - */ - DataStream.prototype.readFloat64Array = function(length, e) { - length = length == null ? (this.byteLength-this.position / 8) : length; - var arr = new Float64Array(length); - DataStream.memcpy(arr.buffer, 0, - this.buffer, this.byteOffset+this.position, - length*arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Float32Array of desired length and endianness from the DataStream. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Float32Array. - */ - DataStream.prototype.readFloat32Array = function(length, e) { - length = length == null ? (this.byteLength-this.position / 4) : length; - var arr = new Float32Array(length); - DataStream.memcpy(arr.buffer, 0, - this.buffer, this.byteOffset+this.position, - length*arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - - /** - Reads a 32-bit int from the DataStream with the desired endianness. - - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readInt32 = function(e) { - var v = this._dataView.getInt32(this.position, e == null ? this.endianness : e); - this.position += 4; - return v; - }; - - /** - Reads a 16-bit int from the DataStream with the desired endianness. - - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readInt16 = function(e) { - var v = this._dataView.getInt16(this.position, e == null ? this.endianness : e); - this.position += 2; - return v; - }; - - /** - Reads an 8-bit int from the DataStream. - - @return {number} The read number. - */ - DataStream.prototype.readInt8 = function() { - var v = this._dataView.getInt8(this.position); - this.position += 1; - return v; - }; - - /** - Reads a 32-bit unsigned int from the DataStream with the desired endianness. - - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readUint32 = function(e) { - var v = this._dataView.getUint32(this.position, e == null ? this.endianness : e); - this.position += 4; - return v; - }; - - /** - Reads a 16-bit unsigned int from the DataStream with the desired endianness. - - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readUint16 = function(e) { - var v = this._dataView.getUint16(this.position, e == null ? this.endianness : e); - this.position += 2; - return v; - }; - - /** - Reads an 8-bit unsigned int from the DataStream. - - @return {number} The read number. - */ - DataStream.prototype.readUint8 = function() { - var v = this._dataView.getUint8(this.position); - this.position += 1; - return v; - }; - - /** - Reads a 32-bit float from the DataStream with the desired endianness. - - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readFloat32 = function(e) { - var v = this._dataView.getFloat32(this.position, e == null ? this.endianness : e); - this.position += 4; - return v; - }; - - /** - Reads a 64-bit float from the DataStream with the desired endianness. - - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readFloat64 = function(e) { - var v = this._dataView.getFloat64(this.position, e == null ? this.endianness : e); - this.position += 8; - return v; - }; - - /** - Native endianness. Either DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN - depending on the platform endianness. - - @type {boolean} - */ - DataStream.endianness = new Int8Array(new Int16Array([1]).buffer)[0] > 0; - - /** - Copies byteLength bytes from the src buffer at srcOffset to the - dst buffer at dstOffset. - - @param {Object} dst Destination ArrayBuffer to write to. - @param {number} dstOffset Offset to the destination ArrayBuffer. - @param {Object} src Source ArrayBuffer to read from. - @param {number} srcOffset Offset to the source ArrayBuffer. - @param {number} byteLength Number of bytes to copy. - */ - DataStream.memcpy = function(dst, dstOffset, src, srcOffset, byteLength) { - var dstU8 = new Uint8Array(dst, dstOffset, byteLength); - var srcU8 = new Uint8Array(src, srcOffset, byteLength); - dstU8.set(srcU8); - }; - - /** - Converts array to native endianness in-place. - - @param {Object} array Typed array to convert. - @param {boolean} arrayIsLittleEndian True if the data in the array is - little-endian. Set false for big-endian. - @return {Object} The converted typed array. - */ - DataStream.arrayToNative = function(array, arrayIsLittleEndian) { - if (arrayIsLittleEndian == this.endianness) { - return array; - } else { - return this.flipArrayEndianness(array); - } - }; - - /** - Converts native endianness array to desired endianness in-place. - - @param {Object} array Typed array to convert. - @param {boolean} littleEndian True if the converted array should be - little-endian. Set false for big-endian. - @return {Object} The converted typed array. - */ - DataStream.nativeToEndian = function(array, littleEndian) { - if (this.endianness == littleEndian) { - return array; - } else { - return this.flipArrayEndianness(array); - } - }; - - /** - Flips typed array endianness in-place. - - @param {Object} array Typed array to flip. - @return {Object} The converted typed array. - */ - DataStream.flipArrayEndianness = function(array) { - var u8 = new Uint8Array(array.buffer, array.byteOffset, array.byteLength); - for (var i=0; ik; j--, k++) { - var tmp = u8[k]; - u8[k] = u8[j]; - u8[j] = tmp; - } - } - return array; - }; - - /** - Seek position where DataStream#readStruct ran into a problem. - Useful for debugging struct parsing. - - @type {number} - */ - DataStream.prototype.failurePosition = 0; - - String.fromCharCodeUint8 = function(uint8arr) { - var arr = []; - for (var i = 0; i < uint8arr.length; i++) { - arr[i] = uint8arr[i]; - } - return String.fromCharCode.apply(null, arr); - }; - /** - Read a string of desired length and encoding from the DataStream. - - @param {number} length The length of the string to read in bytes. - @param {?string} encoding The encoding of the string data in the DataStream. - Defaults to ASCII. - @return {string} The read string. - */ - DataStream.prototype.readString = function(length, encoding) { - if (encoding == null || encoding == "ASCII") { - return String.fromCharCodeUint8.apply(null, [this.mapUint8Array(length == null ? this.byteLength-this.position : length)]); - } else { - return (new TextDecoder(encoding)).decode(this.mapUint8Array(length)); - } - }; - - /** - Read null-terminated string of desired length from the DataStream. Truncates - the returned string so that the null byte is not a part of it. - - @param {?number} length The length of the string to read. - @return {string} The read string. - */ - DataStream.prototype.readCString = function(length) { - var blen = this.byteLength-this.position; - var u8 = new Uint8Array(this._buffer, this._byteOffset + this.position); - var len = blen; - if (length != null) { - len = Math.min(length, blen); - } - for (var i = 0; i < len && u8[i] !== 0; i++); // find first zero byte - var s = String.fromCharCodeUint8.apply(null, [this.mapUint8Array(i)]); - if (length != null) { - this.position += len-i; - } else if (i != blen) { - this.position += 1; // trailing zero if not at end of buffer - } - return s; - }; - - /* - TODO: fix endianness for 24/64-bit fields - TODO: check range/support for 64-bits numbers in JavaScript - */ - var MAX_SIZE = Math.pow(2, 32); - - DataStream.prototype.readInt64 = function () { - return (this.readInt32()*MAX_SIZE)+this.readUint32(); - }; - DataStream.prototype.readUint64 = function () { - return (this.readUint32()*MAX_SIZE)+this.readUint32(); - }; - - DataStream.prototype.readInt64 = function () { - return (this.readUint32()*MAX_SIZE)+this.readUint32(); - }; - - DataStream.prototype.readUint24 = function () { - return (this.readUint8()<<16)+(this.readUint8()<<8)+this.readUint8(); - }; - - { - exports.DataStream = DataStream; - } - // file:src/DataStream-write.js - /** - Saves the DataStream contents to the given filename. - Uses Chrome's anchor download property to initiate download. - - @param {string} filename Filename to save as. - @return {null} - */ - DataStream.prototype.save = function(filename) { - var blob = new Blob([this.buffer]); - if (window.URL && URL.createObjectURL) { - var url = window.URL.createObjectURL(blob); - var a = document.createElement('a'); - // Required in Firefox: - document.body.appendChild(a); - a.setAttribute('href', url); - a.setAttribute('download', filename); - // Required in Firefox: - a.setAttribute('target', '_self'); - a.click(); - window.URL.revokeObjectURL(url); - } else { - throw("DataStream.save: Can't create object URL."); - } - }; - - /** - Whether to extend DataStream buffer when trying to write beyond its size. - If set, the buffer is reallocated to twice its current size until the - requested write fits the buffer. - @type {boolean} - */ - DataStream.prototype._dynamicSize = true; - Object.defineProperty(DataStream.prototype, 'dynamicSize', - { get: function() { - return this._dynamicSize; - }, - set: function(v) { - if (!v) { - this._trimAlloc(); - } - this._dynamicSize = v; - } }); - - /** - Internal function to trim the DataStream buffer when required. - Used for stripping out the first bytes when not needed anymore. - - @return {null} - */ - DataStream.prototype.shift = function(offset) { - var buf = new ArrayBuffer(this._byteLength-offset); - var dst = new Uint8Array(buf); - var src = new Uint8Array(this._buffer, offset, dst.length); - dst.set(src); - this.buffer = buf; - this.position -= offset; - }; - - /** - Writes an Int32Array of specified endianness to the DataStream. - - @param {Object} arr The array to write. - @param {?boolean} e Endianness of the data to write. - */ - DataStream.prototype.writeInt32Array = function(arr, e) { - this._realloc(arr.length * 4); - if (arr instanceof Int32Array && - this.byteOffset+this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset+this.position, - arr.buffer, 0, - arr.byteLength); - this.mapInt32Array(arr.length, e); - } else { - for (var i=0; i>16); - this.writeUint8((v & 0x0000FF00)>>8); - this.writeUint8((v & 0x000000FF)); - }; - - DataStream.prototype.adjustUint32 = function(position, value) { - var pos = this.position; - this.seek(position); - this.writeUint32(value); - this.seek(pos); - }; - // file:src/DataStream-map.js - /** - Maps an Int32Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Int32Array to the DataStream backing buffer. - */ - DataStream.prototype.mapInt32Array = function(length, e) { - this._realloc(length * 4); - var arr = new Int32Array(this._buffer, this.byteOffset+this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 4; - return arr; - }; - - /** - Maps an Int16Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Int16Array to the DataStream backing buffer. - */ - DataStream.prototype.mapInt16Array = function(length, e) { - this._realloc(length * 2); - var arr = new Int16Array(this._buffer, this.byteOffset+this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 2; - return arr; - }; - - /** - Maps an Int8Array into the DataStream buffer. - - Nice for quickly reading in data. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Int8Array to the DataStream backing buffer. - */ - DataStream.prototype.mapInt8Array = function(length) { - this._realloc(length * 1); - var arr = new Int8Array(this._buffer, this.byteOffset+this.position, length); - this.position += length * 1; - return arr; - }; - - /** - Maps a Uint32Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Uint32Array to the DataStream backing buffer. - */ - DataStream.prototype.mapUint32Array = function(length, e) { - this._realloc(length * 4); - var arr = new Uint32Array(this._buffer, this.byteOffset+this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 4; - return arr; - }; - - /** - Maps a Uint16Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Uint16Array to the DataStream backing buffer. - */ - DataStream.prototype.mapUint16Array = function(length, e) { - this._realloc(length * 2); - var arr = new Uint16Array(this._buffer, this.byteOffset+this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 2; - return arr; - }; - - /** - Maps a Float64Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Float64Array to the DataStream backing buffer. - */ - DataStream.prototype.mapFloat64Array = function(length, e) { - this._realloc(length * 8); - var arr = new Float64Array(this._buffer, this.byteOffset+this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 8; - return arr; - }; - - /** - Maps a Float32Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Float32Array to the DataStream backing buffer. - */ - DataStream.prototype.mapFloat32Array = function(length, e) { - this._realloc(length * 4); - var arr = new Float32Array(this._buffer, this.byteOffset+this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 4; - return arr; - }; - // file:src/buffer.js - /** - * MultiBufferStream is a class that acts as a SimpleStream for parsing - * It holds several, possibly non-contiguous ArrayBuffer objects, each with a fileStart property - * containing the offset for the buffer data in an original/virtual file - * - * It inherits also from DataStream for all read/write/alloc operations - */ - - /** - * Constructor - */ - var MultiBufferStream = function(buffer) { - /* List of ArrayBuffers, with a fileStart property, sorted in fileStart order and non overlapping */ - this.buffers = []; - this.bufferIndex = -1; - if (buffer) { - this.insertBuffer(buffer); - this.bufferIndex = 0; - } - }; - MultiBufferStream.prototype = new DataStream(new ArrayBuffer(), 0, DataStream.BIG_ENDIAN); - - /************************************************************************************ - Methods for the managnement of the buffers (insertion, removal, concatenation, ...) - ***********************************************************************************/ - - MultiBufferStream.prototype.initialized = function() { - var firstBuffer; - if (this.bufferIndex > -1) { - return true; - } else if (this.buffers.length > 0) { - firstBuffer = this.buffers[0]; - if (firstBuffer.fileStart === 0) { - this.buffer = firstBuffer; - this.bufferIndex = 0; - Log.debug("MultiBufferStream", "Stream ready for parsing"); - return true; - } else { - Log.warn("MultiBufferStream", "The first buffer should have a fileStart of 0"); - this.logBufferLevel(); - return false; - } - } else { - Log.warn("MultiBufferStream", "No buffer to start parsing from"); - this.logBufferLevel(); - return false; - } - }; - - /** - * helper functions to concatenate two ArrayBuffer objects - * @param {ArrayBuffer} buffer1 - * @param {ArrayBuffer} buffer2 - * @return {ArrayBuffer} the concatenation of buffer1 and buffer2 in that order - */ - ArrayBuffer.concat = function(buffer1, buffer2) { - Log.debug("ArrayBuffer", "Trying to create a new buffer of size: "+(buffer1.byteLength + buffer2.byteLength)); - var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength); - tmp.set(new Uint8Array(buffer1), 0); - tmp.set(new Uint8Array(buffer2), buffer1.byteLength); - return tmp.buffer; - }; - - /** - * Reduces the size of a given buffer, but taking the part between offset and offset+newlength - * @param {ArrayBuffer} buffer - * @param {Number} offset the start of new buffer - * @param {Number} newLength the length of the new buffer - * @return {ArrayBuffer} the new buffer - */ - MultiBufferStream.prototype.reduceBuffer = function(buffer, offset, newLength) { - var smallB; - smallB = new Uint8Array(newLength); - smallB.set(new Uint8Array(buffer, offset, newLength)); - smallB.buffer.fileStart = buffer.fileStart+offset; - smallB.buffer.usedBytes = 0; - return smallB.buffer; - }; - - /** - * Inserts the new buffer in the sorted list of buffers, - * making sure, it is not overlapping with existing ones (possibly reducing its size). - * if the new buffer overrides/replaces the 0-th buffer (for instance because it is bigger), - * updates the DataStream buffer for parsing - */ - MultiBufferStream.prototype.insertBuffer = function(ab) { - var to_add = true; - /* TODO: improve insertion if many buffers */ - for (var i = 0; i < this.buffers.length; i++) { - var b = this.buffers[i]; - if (ab.fileStart <= b.fileStart) { - /* the insertion position is found */ - if (ab.fileStart === b.fileStart) { - /* The new buffer overlaps with an existing buffer */ - if (ab.byteLength > b.byteLength) { - /* the new buffer is bigger than the existing one - remove the existing buffer and try again to insert - the new buffer to check overlap with the next ones */ - this.buffers.splice(i, 1); - i--; - continue; - } else { - /* the new buffer is smaller than the existing one, just drop it */ - Log.warn("MultiBufferStream", "Buffer (fileStart: "+ab.fileStart+" - Length: "+ab.byteLength+") already appended, ignoring"); - } - } else { - /* The beginning of the new buffer is not overlapping with an existing buffer - let's check the end of it */ - if (ab.fileStart + ab.byteLength <= b.fileStart) ; else { - /* There is some overlap, cut the new buffer short, and add it*/ - ab = this.reduceBuffer(ab, 0, b.fileStart - ab.fileStart); - } - Log.debug("MultiBufferStream", "Appending new buffer (fileStart: "+ab.fileStart+" - Length: "+ab.byteLength+")"); - this.buffers.splice(i, 0, ab); - /* if this new buffer is inserted in the first place in the list of the buffer, - and the DataStream is initialized, make it the buffer used for parsing */ - if (i === 0) { - this.buffer = ab; - } - } - to_add = false; - break; - } else if (ab.fileStart < b.fileStart + b.byteLength) { - /* the new buffer overlaps its beginning with the end of the current buffer */ - var offset = b.fileStart + b.byteLength - ab.fileStart; - var newLength = ab.byteLength - offset; - if (newLength > 0) { - /* the new buffer is bigger than the current overlap, drop the overlapping part and try again inserting the remaining buffer */ - ab = this.reduceBuffer(ab, offset, newLength); - } else { - /* the content of the new buffer is entirely contained in the existing buffer, drop it entirely */ - to_add = false; - break; - } - } - } - /* if the buffer has not been added, we can add it at the end */ - if (to_add) { - Log.debug("MultiBufferStream", "Appending new buffer (fileStart: "+ab.fileStart+" - Length: "+ab.byteLength+")"); - this.buffers.push(ab); - /* if this new buffer is inserted in the first place in the list of the buffer, - and the DataStream is initialized, make it the buffer used for parsing */ - if (i === 0) { - this.buffer = ab; - } - } - }; - - /** - * Displays the status of the buffers (number and used bytes) - * @param {Object} info callback method for display - */ - MultiBufferStream.prototype.logBufferLevel = function(info) { - var i; - var buffer; - var used, total; - var ranges = []; - var range; - var bufferedString = ""; - used = 0; - total = 0; - for (i = 0; i < this.buffers.length; i++) { - buffer = this.buffers[i]; - if (i === 0) { - range = {}; - ranges.push(range); - range.start = buffer.fileStart; - range.end = buffer.fileStart+buffer.byteLength; - bufferedString += "["+range.start+"-"; - } else if (range.end === buffer.fileStart) { - range.end = buffer.fileStart+buffer.byteLength; - } else { - range = {}; - range.start = buffer.fileStart; - bufferedString += (ranges[ranges.length-1].end-1)+"], ["+range.start+"-"; - range.end = buffer.fileStart+buffer.byteLength; - ranges.push(range); - } - used += buffer.usedBytes; - total += buffer.byteLength; - } - if (ranges.length > 0) { - bufferedString += (range.end-1)+"]"; - } - var log = (info ? Log.info : Log.debug); - if (this.buffers.length === 0) { - log("MultiBufferStream", "No more buffer in memory"); - } else { - log("MultiBufferStream", ""+this.buffers.length+" stored buffer(s) ("+used+"/"+total+" bytes), continuous ranges: "+bufferedString); - } - }; - - MultiBufferStream.prototype.cleanBuffers = function () { - var i; - var buffer; - for (i = 0; i < this.buffers.length; i++) { - buffer = this.buffers[i]; - if (buffer.usedBytes === buffer.byteLength) { - Log.debug("MultiBufferStream", "Removing buffer #"+i); - this.buffers.splice(i, 1); - i--; - } - } - }; - - MultiBufferStream.prototype.mergeNextBuffer = function() { - var next_buffer; - if (this.bufferIndex+1 < this.buffers.length) { - next_buffer = this.buffers[this.bufferIndex+1]; - if (next_buffer.fileStart === this.buffer.fileStart + this.buffer.byteLength) { - var oldLength = this.buffer.byteLength; - var oldUsedBytes = this.buffer.usedBytes; - var oldFileStart = this.buffer.fileStart; - this.buffers[this.bufferIndex] = ArrayBuffer.concat(this.buffer, next_buffer); - this.buffer = this.buffers[this.bufferIndex]; - this.buffers.splice(this.bufferIndex+1, 1); - this.buffer.usedBytes = oldUsedBytes; /* TODO: should it be += ? */ - this.buffer.fileStart = oldFileStart; - Log.debug("ISOFile", "Concatenating buffer for box parsing (length: "+oldLength+"->"+this.buffer.byteLength+")"); - return true; - } else { - return false; - } - } else { - return false; - } - }; - - - /************************************************************************* - Seek-related functions - *************************************************************************/ - - /** - * Finds the buffer that holds the given file position - * @param {Boolean} fromStart indicates if the search should start from the current buffer (false) - * or from the first buffer (true) - * @param {Number} filePosition position in the file to seek to - * @param {Boolean} markAsUsed indicates if the bytes in between the current position and the seek position - * should be marked as used for garbage collection - * @return {Number} the index of the buffer holding the seeked file position, -1 if not found. - */ - MultiBufferStream.prototype.findPosition = function(fromStart, filePosition, markAsUsed) { - var i; - var abuffer = null; - var index = -1; - - /* find the buffer with the largest position smaller than the given position */ - if (fromStart === true) { - /* the reposition can be in the past, we need to check from the beginning of the list of buffers */ - i = 0; - } else { - i = this.bufferIndex; - } - - while (i < this.buffers.length) { - abuffer = this.buffers[i]; - if (abuffer.fileStart <= filePosition) { - index = i; - if (markAsUsed) { - if (abuffer.fileStart + abuffer.byteLength <= filePosition) { - abuffer.usedBytes = abuffer.byteLength; - } else { - abuffer.usedBytes = filePosition - abuffer.fileStart; - } - this.logBufferLevel(); - } - } else { - break; - } - i++; - } - - if (index !== -1) { - abuffer = this.buffers[index]; - if (abuffer.fileStart + abuffer.byteLength >= filePosition) { - Log.debug("MultiBufferStream", "Found position in existing buffer #"+index); - return index; - } else { - return -1; - } - } else { - return -1; - } - }; - - /** - * Finds the largest file position contained in a buffer or in the next buffers if they are contiguous (no gap) - * starting from the given buffer index or from the current buffer if the index is not given - * - * @param {Number} inputindex Index of the buffer to start from - * @return {Number} The largest file position found in the buffers - */ - MultiBufferStream.prototype.findEndContiguousBuf = function(inputindex) { - var i; - var currentBuf; - var nextBuf; - var index = (inputindex !== undefined ? inputindex : this.bufferIndex); - currentBuf = this.buffers[index]; - /* find the end of the contiguous range of data */ - if (this.buffers.length > index+1) { - for (i = index+1; i < this.buffers.length; i++) { - nextBuf = this.buffers[i]; - if (nextBuf.fileStart === currentBuf.fileStart + currentBuf.byteLength) { - currentBuf = nextBuf; - } else { - break; - } - } - } - /* return the position of last byte in the file that we have */ - return currentBuf.fileStart + currentBuf.byteLength; - }; - - /** - * Returns the largest file position contained in the buffers, larger than the given position - * @param {Number} pos the file position to start from - * @return {Number} the largest position in the current buffer or in the buffer and the next contiguous - * buffer that holds the given position - */ - MultiBufferStream.prototype.getEndFilePositionAfter = function(pos) { - var index = this.findPosition(true, pos, false); - if (index !== -1) { - return this.findEndContiguousBuf(index); - } else { - return pos; - } - }; - - /************************************************************************* - Garbage collection related functions - *************************************************************************/ - - /** - * Marks a given number of bytes as used in the current buffer for garbage collection - * @param {Number} nbBytes - */ - MultiBufferStream.prototype.addUsedBytes = function(nbBytes) { - this.buffer.usedBytes += nbBytes; - this.logBufferLevel(); - }; - - /** - * Marks the entire current buffer as used, ready for garbage collection - */ - MultiBufferStream.prototype.setAllUsedBytes = function() { - this.buffer.usedBytes = this.buffer.byteLength; - this.logBufferLevel(); - }; - - /************************************************************************* - Common API between MultiBufferStream and SimpleStream - *************************************************************************/ - - /** - * Tries to seek to a given file position - * if possible, repositions the parsing from there and returns true - * if not possible, does not change anything and returns false - * @param {Number} filePosition position in the file to seek to - * @param {Boolean} fromStart indicates if the search should start from the current buffer (false) - * or from the first buffer (true) - * @param {Boolean} markAsUsed indicates if the bytes in between the current position and the seek position - * should be marked as used for garbage collection - * @return {Boolean} true if the seek succeeded, false otherwise - */ - MultiBufferStream.prototype.seek = function(filePosition, fromStart, markAsUsed) { - var index; - index = this.findPosition(fromStart, filePosition, markAsUsed); - if (index !== -1) { - this.buffer = this.buffers[index]; - this.bufferIndex = index; - this.position = filePosition - this.buffer.fileStart; - Log.debug("MultiBufferStream", "Repositioning parser at buffer position: "+this.position); - return true; - } else { - Log.debug("MultiBufferStream", "Position "+filePosition+" not found in buffered data"); - return false; - } - }; - - /** - * Returns the current position in the file - * @return {Number} the position in the file - */ - MultiBufferStream.prototype.getPosition = function() { - if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null) { - throw "Error accessing position in the MultiBufferStream"; - } - return this.buffers[this.bufferIndex].fileStart+this.position; - }; - - /** - * Returns the length of the current buffer - * @return {Number} the length of the current buffer - */ - MultiBufferStream.prototype.getLength = function() { - return this.byteLength; - }; - - MultiBufferStream.prototype.getEndPosition = function() { - if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null) { - throw "Error accessing position in the MultiBufferStream"; - } - return this.buffers[this.bufferIndex].fileStart+this.byteLength; - }; - - { - exports.MultiBufferStream = MultiBufferStream; - }// file:src/descriptor.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var MPEG4DescriptorParser = function () { - var ES_DescrTag = 0x03; - var DecoderConfigDescrTag = 0x04; - var DecSpecificInfoTag = 0x05; - var SLConfigDescrTag = 0x06; - - var descTagToName = []; - descTagToName[ES_DescrTag] = "ES_Descriptor"; - descTagToName[DecoderConfigDescrTag] = "DecoderConfigDescriptor"; - descTagToName[DecSpecificInfoTag] = "DecoderSpecificInfo"; - descTagToName[SLConfigDescrTag] = "SLConfigDescriptor"; - - this.getDescriptorName = function(tag) { - return descTagToName[tag]; - }; - - var that = this; - var classes = {}; - - this.parseOneDescriptor = function (stream) { - var size = 0; - var tag; - var desc; - var byteRead; - tag = stream.readUint8(); - byteRead = stream.readUint8(); - while (byteRead & 0x80) { - size = (size << 7) + (byteRead & 0x7F); - byteRead = stream.readUint8(); - } - size = (size << 7) + (byteRead & 0x7F); - Log.debug("MPEG4DescriptorParser", "Found "+(descTagToName[tag] || "Descriptor "+tag)+", size "+size+" at position "+stream.getPosition()); - if (descTagToName[tag]) { - desc = new classes[descTagToName[tag]](size); - } else { - desc = new classes.Descriptor(size); - } - desc.parse(stream); - return desc; - }; - - classes.Descriptor = function(_tag, _size) { - this.tag = _tag; - this.size = _size; - this.descs = []; - }; - - classes.Descriptor.prototype.parse = function (stream) { - this.data = stream.readUint8Array(this.size); - }; - - classes.Descriptor.prototype.findDescriptor = function (tag) { - for (var i = 0; i < this.descs.length; i++) { - if (this.descs[i].tag == tag) { - return this.descs[i]; - } - } - return null; - }; - - classes.Descriptor.prototype.parseRemainingDescriptors = function (stream) { - var start = stream.position; - while (stream.position < start+this.size) { - var desc = that.parseOneDescriptor(stream); - this.descs.push(desc); - } - }; - - classes.ES_Descriptor = function (size) { - classes.Descriptor.call(this, ES_DescrTag, size); - }; - - classes.ES_Descriptor.prototype = new classes.Descriptor(); - - classes.ES_Descriptor.prototype.parse = function(stream) { - this.ES_ID = stream.readUint16(); - this.flags = stream.readUint8(); - this.size -= 3; - if (this.flags & 0x80) { - this.dependsOn_ES_ID = stream.readUint16(); - this.size -= 2; - } else { - this.dependsOn_ES_ID = 0; - } - if (this.flags & 0x40) { - var l = stream.readUint8(); - this.URL = stream.readString(l); - this.size -= l+1; - } else { - this.URL = ""; - } - if (this.flags & 0x20) { - this.OCR_ES_ID = stream.readUint16(); - this.size -= 2; - } else { - this.OCR_ES_ID = 0; - } - this.parseRemainingDescriptors(stream); - }; - - classes.ES_Descriptor.prototype.getOTI = function(stream) { - var dcd = this.findDescriptor(DecoderConfigDescrTag); - if (dcd) { - return dcd.oti; - } else { - return 0; - } - }; - - classes.ES_Descriptor.prototype.getAudioConfig = function(stream) { - var dcd = this.findDescriptor(DecoderConfigDescrTag); - if (!dcd) return null; - var dsi = dcd.findDescriptor(DecSpecificInfoTag); - if (dsi && dsi.data) { - var audioObjectType = (dsi.data[0]& 0xF8) >> 3; - if (audioObjectType === 31 && dsi.data.length >= 2) { - audioObjectType = 32 + ((dsi.data[0] & 0x7) << 3) + ((dsi.data[1] & 0xE0) >> 5); - } - return audioObjectType; - } else { - return null; - } - }; - - classes.DecoderConfigDescriptor = function (size) { - classes.Descriptor.call(this, DecoderConfigDescrTag, size); - }; - classes.DecoderConfigDescriptor.prototype = new classes.Descriptor(); - - classes.DecoderConfigDescriptor.prototype.parse = function(stream) { - this.oti = stream.readUint8(); - this.streamType = stream.readUint8(); - this.upStream = ((this.streamType >> 1) & 1) !== 0; - this.streamType = this.streamType >>> 2; - this.bufferSize = stream.readUint24(); - this.maxBitrate = stream.readUint32(); - this.avgBitrate = stream.readUint32(); - this.size -= 13; - this.parseRemainingDescriptors(stream); - }; - - classes.DecoderSpecificInfo = function (size) { - classes.Descriptor.call(this, DecSpecificInfoTag, size); - }; - classes.DecoderSpecificInfo.prototype = new classes.Descriptor(); - - classes.SLConfigDescriptor = function (size) { - classes.Descriptor.call(this, SLConfigDescrTag, size); - }; - classes.SLConfigDescriptor.prototype = new classes.Descriptor(); - - return this; - }; - - { - exports.MPEG4DescriptorParser = MPEG4DescriptorParser; - } - // file:src/box.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var BoxParser = { - ERR_INVALID_DATA : -1, - ERR_NOT_ENOUGH_DATA : 0, - OK : 1, - - // Boxes to be created with default parsing - BASIC_BOXES: [ "mdat", "idat", "free", "skip", "meco", "strk" ], - FULL_BOXES: [ "hmhd", "nmhd", "iods", "xml ", "bxml", "ipro", "mere" ], - CONTAINER_BOXES: [ - [ "moov", [ "trak", "pssh" ] ], - [ "trak" ], - [ "edts" ], - [ "mdia" ], - [ "minf" ], - [ "dinf" ], - [ "stbl", [ "sgpd", "sbgp" ] ], - [ "mvex", [ "trex" ] ], - [ "moof", [ "traf" ] ], - [ "traf", [ "trun", "sgpd", "sbgp" ] ], - [ "vttc" ], - [ "tref" ], - [ "iref" ], - [ "mfra", [ "tfra" ] ], - [ "meco" ], - [ "hnti" ], - [ "hinf" ], - [ "strk" ], - [ "strd" ], - [ "sinf" ], - [ "rinf" ], - [ "schi" ], - [ "trgr" ], - [ "udta", ["kind"] ], - [ "iprp", ["ipma"] ], - [ "ipco" ], - [ "grpl" ], - [ "j2kH" ], - [ "etyp", [ "tyco"] ] - ], - // Boxes effectively created - boxCodes : [], - fullBoxCodes : [], - containerBoxCodes : [], - sampleEntryCodes : {}, - sampleGroupEntryCodes: [], - trackGroupTypes: [], - UUIDBoxes: {}, - UUIDs: [], - initialize: function() { - BoxParser.FullBox.prototype = new BoxParser.Box(); - BoxParser.ContainerBox.prototype = new BoxParser.Box(); - BoxParser.SampleEntry.prototype = new BoxParser.Box(); - BoxParser.TrackGroupTypeBox.prototype = new BoxParser.FullBox(); - - /* creating constructors for simple boxes */ - BoxParser.BASIC_BOXES.forEach(function(type) { - BoxParser.createBoxCtor(type); - }); - BoxParser.FULL_BOXES.forEach(function(type) { - BoxParser.createFullBoxCtor(type); - }); - BoxParser.CONTAINER_BOXES.forEach(function(types) { - BoxParser.createContainerBoxCtor(types[0], null, types[1]); - }); - }, - Box: function(_type, _size, _uuid) { - this.type = _type; - this.size = _size; - this.uuid = _uuid; - }, - FullBox: function(type, size, uuid) { - BoxParser.Box.call(this, type, size, uuid); - this.flags = 0; - this.version = 0; - }, - ContainerBox: function(type, size, uuid) { - BoxParser.Box.call(this, type, size, uuid); - this.boxes = []; - }, - SampleEntry: function(type, size, hdr_size, start) { - BoxParser.ContainerBox.call(this, type, size); - this.hdr_size = hdr_size; - this.start = start; - }, - SampleGroupEntry: function(type) { - this.grouping_type = type; - }, - TrackGroupTypeBox: function(type, size) { - BoxParser.FullBox.call(this, type, size); - }, - createBoxCtor: function(type, parseMethod){ - BoxParser.boxCodes.push(type); - BoxParser[type+"Box"] = function(size) { - BoxParser.Box.call(this, type, size); - }; - BoxParser[type+"Box"].prototype = new BoxParser.Box(); - if (parseMethod) BoxParser[type+"Box"].prototype.parse = parseMethod; - }, - createFullBoxCtor: function(type, parseMethod) { - //BoxParser.fullBoxCodes.push(type); - BoxParser[type+"Box"] = function(size) { - BoxParser.FullBox.call(this, type, size); - }; - BoxParser[type+"Box"].prototype = new BoxParser.FullBox(); - BoxParser[type+"Box"].prototype.parse = function(stream) { - this.parseFullHeader(stream); - if (parseMethod) { - parseMethod.call(this, stream); - } - }; - }, - addSubBoxArrays: function(subBoxNames) { - if (subBoxNames) { - this.subBoxNames = subBoxNames; - var nbSubBoxes = subBoxNames.length; - for (var k = 0; k parentSize) { - Log.error("BoxParser", "Box of type '"+type+"' has a size "+size+" greater than its container size "+parentSize); - return { code: BoxParser.ERR_NOT_ENOUGH_DATA, type: type, size: size, hdr_size: hdr_size, start: start }; - } - if (size !== 0 && start + size > stream.getEndPosition()) { - stream.seek(start); - Log.info("BoxParser", "Not enough data in stream to parse the entire '"+type+"' box"); - return { code: BoxParser.ERR_NOT_ENOUGH_DATA, type: type, size: size, hdr_size: hdr_size, start: start }; - } - if (headerOnly) { - return { code: BoxParser.OK, type: type, size: size, hdr_size: hdr_size, start: start }; - } else { - if (BoxParser[type+"Box"]) { - box = new BoxParser[type+"Box"](size); - } else { - if (type !== "uuid") { - Log.warn("BoxParser", "Unknown box type: '"+type+"'"); - box = new BoxParser.Box(type, size); - box.has_unparsed_data = true; - } else { - if (BoxParser.UUIDBoxes[uuid]) { - box = new BoxParser.UUIDBoxes[uuid](size); - } else { - Log.warn("BoxParser", "Unknown uuid type: '"+uuid+"'"); - box = new BoxParser.Box(type, size); - box.uuid = uuid; - box.has_unparsed_data = true; - } - } - } - } - box.hdr_size = hdr_size; - /* recording the position of the box in the input stream */ - box.start = start; - if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { - Log.info("BoxParser", "'"+box_type+"' box writing not yet implemented, keeping unparsed data in memory for later write"); - box.parseDataAndRewind(stream); - } - box.parse(stream); - diff = stream.getPosition() - (box.start+box.size); - if (diff < 0) { - Log.warn("BoxParser", "Parsing of box '"+box_type+"' did not read the entire indicated box data size (missing "+(-diff)+" bytes), seeking forward"); - stream.seek(box.start+box.size); - } else if (diff > 0) { - Log.error("BoxParser", "Parsing of box '"+box_type+"' read "+diff+" more bytes than the indicated box data size, seeking backwards"); - if (box.size !== 0) stream.seek(box.start+box.size); - } - return { code: BoxParser.OK, box: box, size: box.size }; - }; - - BoxParser.Box.prototype.parse = function(stream) { - if (this.type != "mdat") { - this.data = stream.readUint8Array(this.size-this.hdr_size); - } else { - if (this.size === 0) { - stream.seek(stream.getEndPosition()); - } else { - stream.seek(this.start+this.size); - } - } - }; - - /* Used to parse a box without consuming its data, to allow detailled parsing - Useful for boxes for which a write method is not yet implemented */ - BoxParser.Box.prototype.parseDataAndRewind = function(stream) { - this.data = stream.readUint8Array(this.size-this.hdr_size); - // rewinding - stream.position -= this.size-this.hdr_size; - }; - - BoxParser.FullBox.prototype.parseDataAndRewind = function(stream) { - this.parseFullHeader(stream); - this.data = stream.readUint8Array(this.size-this.hdr_size); - // restore the header size as if the full header had not been parsed - this.hdr_size -= 4; - // rewinding - stream.position -= this.size-this.hdr_size; - }; - - BoxParser.FullBox.prototype.parseFullHeader = function (stream) { - this.version = stream.readUint8(); - this.flags = stream.readUint24(); - this.hdr_size += 4; - }; - - BoxParser.FullBox.prototype.parse = function (stream) { - this.parseFullHeader(stream); - this.data = stream.readUint8Array(this.size-this.hdr_size); - }; - - BoxParser.ContainerBox.prototype.parse = function(stream) { - var ret; - var box; - while (stream.getPosition() < this.start+this.size) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = ret.box; - /* store the box in the 'boxes' array to preserve box order (for offset) but also store box in a property for more direct access */ - this.boxes.push(box); - if (this.subBoxNames && this.subBoxNames.indexOf(box.type) != -1) { - this[this.subBoxNames[this.subBoxNames.indexOf(box.type)]+"s"].push(box); - } else { - var box_type = box.type !== "uuid" ? box.type : box.uuid; - if (this[box_type]) { - Log.warn("Box of type "+box_type+" already stored in field of this type"); - } else { - this[box_type] = box; - } - } - } else { - return; - } - } - }; - - BoxParser.Box.prototype.parseLanguage = function(stream) { - this.language = stream.readUint16(); - var chars = []; - chars[0] = (this.language>>10)&0x1F; - chars[1] = (this.language>>5)&0x1F; - chars[2] = (this.language)&0x1F; - this.languageString = String.fromCharCode(chars[0]+0x60, chars[1]+0x60, chars[2]+0x60); - }; - - // file:src/parsing/sampleentries/sampleentry.js - BoxParser.SAMPLE_ENTRY_TYPE_VISUAL = "Visual"; - BoxParser.SAMPLE_ENTRY_TYPE_AUDIO = "Audio"; - BoxParser.SAMPLE_ENTRY_TYPE_HINT = "Hint"; - BoxParser.SAMPLE_ENTRY_TYPE_METADATA = "Metadata"; - BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE = "Subtitle"; - BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM = "System"; - BoxParser.SAMPLE_ENTRY_TYPE_TEXT = "Text"; - - BoxParser.SampleEntry.prototype.parseHeader = function(stream) { - stream.readUint8Array(6); - this.data_reference_index = stream.readUint16(); - this.hdr_size += 8; - }; - - BoxParser.SampleEntry.prototype.parse = function(stream) { - this.parseHeader(stream); - this.data = stream.readUint8Array(this.size - this.hdr_size); - }; - - BoxParser.SampleEntry.prototype.parseDataAndRewind = function(stream) { - this.parseHeader(stream); - this.data = stream.readUint8Array(this.size - this.hdr_size); - // restore the header size as if the sample entry header had not been parsed - this.hdr_size -= 8; - // rewinding - stream.position -= this.size-this.hdr_size; - }; - - BoxParser.SampleEntry.prototype.parseFooter = function(stream) { - BoxParser.ContainerBox.prototype.parse.call(this, stream); - }; - - // Base SampleEntry types with default parsing - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_HINT); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_TEXT); - - //Base SampleEntry types for Audio and Video with specific parsing - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, function(stream) { - var compressorname_length; - this.parseHeader(stream); - stream.readUint16(); - stream.readUint16(); - stream.readUint32Array(3); - this.width = stream.readUint16(); - this.height = stream.readUint16(); - this.horizresolution = stream.readUint32(); - this.vertresolution = stream.readUint32(); - stream.readUint32(); - this.frame_count = stream.readUint16(); - compressorname_length = Math.min(31, stream.readUint8()); - this.compressorname = stream.readString(compressorname_length); - if (compressorname_length < 31) { - stream.readString(31 - compressorname_length); - } - this.depth = stream.readUint16(); - stream.readUint16(); - this.parseFooter(stream); - }); - - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, function(stream) { - this.parseHeader(stream); - stream.readUint32Array(2); - this.channel_count = stream.readUint16(); - this.samplesize = stream.readUint16(); - stream.readUint16(); - stream.readUint16(); - this.samplerate = (stream.readUint32()/(1<<16)); - this.parseFooter(stream); - }); - - // Sample entries inheriting from Audio and Video - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc2"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc3"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc4"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "av01"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dav1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hvc1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hev1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hvt1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "lhe1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dvh1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dvhe"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvc1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvi1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvs1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvcN"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vp08"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vp09"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avs3"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "j2ki"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "mjp2"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "mjpg"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "uncv"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mp4a"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ac-3"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ac-4"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ec-3"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "Opus"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mha1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mha2"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mhm1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mhm2"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "fLaC"); - - // Encrypted sample entries - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "encv"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "enca"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "encu"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM, "encs"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_TEXT, "enct"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "encm"); - // file:src/parsing/a1lx.js - BoxParser.createBoxCtor("a1lx", function(stream) { - var large_size = stream.readUint8() & 1; - var FieldLength = ((large_size & 1) + 1) * 16; - this.layer_size = []; - for (var i = 0; i < 3; i++) { - if (FieldLength == 16) { - this.layer_size[i] = stream.readUint16(); - } else { - this.layer_size[i] = stream.readUint32(); - } - } - });// file:src/parsing/a1op.js - BoxParser.createBoxCtor("a1op", function(stream) { - this.op_index = stream.readUint8(); - });// file:src/parsing/auxC.js - BoxParser.createFullBoxCtor("auxC", function(stream) { - this.aux_type = stream.readCString(); - var aux_subtype_length = this.size - this.hdr_size - (this.aux_type.length + 1); - this.aux_subtype = stream.readUint8Array(aux_subtype_length); - });// file:src/parsing/av1C.js - BoxParser.createBoxCtor("av1C", function(stream) { - var tmp = stream.readUint8(); - if ((tmp >> 7) & 0x1 !== 1) { - Log.error("av1C marker problem"); - return; - } - this.version = tmp & 0x7F; - if (this.version !== 1) { - Log.error("av1C version "+this.version+" not supported"); - return; - } - tmp = stream.readUint8(); - this.seq_profile = (tmp >> 5) & 0x7; - this.seq_level_idx_0 = tmp & 0x1F; - tmp = stream.readUint8(); - this.seq_tier_0 = (tmp >> 7) & 0x1; - this.high_bitdepth = (tmp >> 6) & 0x1; - this.twelve_bit = (tmp >> 5) & 0x1; - this.monochrome = (tmp >> 4) & 0x1; - this.chroma_subsampling_x = (tmp >> 3) & 0x1; - this.chroma_subsampling_y = (tmp >> 2) & 0x1; - this.chroma_sample_position = (tmp & 0x3); - tmp = stream.readUint8(); - this.reserved_1 = (tmp >> 5) & 0x7; - if (this.reserved_1 !== 0) { - Log.error("av1C reserved_1 parsing problem"); - return; - } - this.initial_presentation_delay_present = (tmp >> 4) & 0x1; - if (this.initial_presentation_delay_present === 1) { - this.initial_presentation_delay_minus_one = (tmp & 0xF); - } else { - this.reserved_2 = (tmp & 0xF); - if (this.reserved_2 !== 0) { - Log.error("av1C reserved_2 parsing problem"); - return; - } - } - - var configOBUs_length = this.size - this.hdr_size - 4; - this.configOBUs = stream.readUint8Array(configOBUs_length); - }); - - // file:src/parsing/avcC.js - BoxParser.createBoxCtor("avcC", function(stream) { - var i; - var toparse; - this.configurationVersion = stream.readUint8(); - this.AVCProfileIndication = stream.readUint8(); - this.profile_compatibility = stream.readUint8(); - this.AVCLevelIndication = stream.readUint8(); - this.lengthSizeMinusOne = (stream.readUint8() & 0x3); - this.nb_SPS_nalus = (stream.readUint8() & 0x1F); - toparse = this.size - this.hdr_size - 6; - this.SPS = []; - for (i = 0; i < this.nb_SPS_nalus; i++) { - this.SPS[i] = {}; - this.SPS[i].length = stream.readUint16(); - this.SPS[i].nalu = stream.readUint8Array(this.SPS[i].length); - toparse -= 2+this.SPS[i].length; - } - this.nb_PPS_nalus = stream.readUint8(); - toparse--; - this.PPS = []; - for (i = 0; i < this.nb_PPS_nalus; i++) { - this.PPS[i] = {}; - this.PPS[i].length = stream.readUint16(); - this.PPS[i].nalu = stream.readUint8Array(this.PPS[i].length); - toparse -= 2+this.PPS[i].length; - } - if (toparse>0) { - this.ext = stream.readUint8Array(toparse); - } - }); - - // file:src/parsing/btrt.js - BoxParser.createBoxCtor("btrt", function(stream) { - this.bufferSizeDB = stream.readUint32(); - this.maxBitrate = stream.readUint32(); - this.avgBitrate = stream.readUint32(); - }); - - // file:src/parsing/ccst.js - BoxParser.createFullBoxCtor("ccst", function(stream) { - var flags = stream.readUint8(); - this.all_ref_pics_intra = ((flags & 0x80) == 0x80); - this.intra_pred_used = ((flags & 0x40) == 0x40); - this.max_ref_per_pic = ((flags & 0x3f) >> 2); - stream.readUint24(); - }); - - // file:src/parsing/cdef.js - BoxParser.createBoxCtor("cdef", function(stream) { - var i; - this.channel_count = stream.readUint16(); - this.channel_indexes = []; - this.channel_types = []; - this.channel_associations = []; - for (i = 0; i < this.channel_count; i++) { - this.channel_indexes.push(stream.readUint16()); - this.channel_types.push(stream.readUint16()); - this.channel_associations.push(stream.readUint16()); - } - }); - - // file:src/parsing/clap.js - BoxParser.createBoxCtor("clap", function(stream) { - this.cleanApertureWidthN = stream.readUint32(); - this.cleanApertureWidthD = stream.readUint32(); - this.cleanApertureHeightN = stream.readUint32(); - this.cleanApertureHeightD = stream.readUint32(); - this.horizOffN = stream.readUint32(); - this.horizOffD = stream.readUint32(); - this.vertOffN = stream.readUint32(); - this.vertOffD = stream.readUint32(); - });// file:src/parsing/clli.js - BoxParser.createBoxCtor("clli", function(stream) { - this.max_content_light_level = stream.readUint16(); - this.max_pic_average_light_level = stream.readUint16(); - }); - - // file:src/parsing/cmex.js - BoxParser.createFullBoxCtor("cmex", function(stream) { - if (this.flags & 0x1) { - this.pos_x = stream.readInt32(); - } - if (this.flags & 0x2) { - this.pos_y = stream.readInt32(); - } - if (this.flags & 0x4) { - this.pos_z = stream.readInt32(); - } - if (this.flags & 0x8) { - if (this.version == 0) { - if (this.flags & 0x10) { - this.quat_x = stream.readInt32(); - this.quat_y = stream.readInt32(); - this.quat_z = stream.readInt32(); - } else { - this.quat_x = stream.readInt16(); - this.quat_y = stream.readInt16(); - this.quat_z = stream.readInt16(); - } - } else if (this.version == 1) ; - } - if (this.flags & 0x20) { - this.id = stream.readUint32(); - } - }); - // file:src/parsing/cmin.js - BoxParser.createFullBoxCtor("cmin", function(stream) { - this.focal_length_x = stream.readInt32(); - this.principal_point_x = stream.readInt32(); - this.principal_point_y = stream.readInt32(); - if (this.flags & 0x1) { - this.focal_length_y = stream.readInt32(); - this.skew_factor = stream.readInt32(); - } - });// file:src/parsing/cmpd.js - BoxParser.createBoxCtor("cmpd", function(stream) { - this.component_count = stream.readUint32(); - this.component_types = []; - this.component_type_urls = []; - for (i = 0; i < this.component_count; i++) { - var component_type = stream.readUint16(); - this.component_types.push(component_type); - if (component_type >= 0x8000) { - this.component_type_urls.push(stream.readCString()); - } - } - });// file:src/parsing/co64.js - BoxParser.createFullBoxCtor("co64", function(stream) { - var entry_count; - var i; - entry_count = stream.readUint32(); - this.chunk_offsets = []; - if (this.version === 0) { - for(i=0; i> 7; - } else if (this.colour_type === 'rICC') { - this.ICC_profile = stream.readUint8Array(this.size - 4); - } else if (this.colour_type === 'prof') { - this.ICC_profile = stream.readUint8Array(this.size - 4); - } - });// file:src/parsing/cprt.js - BoxParser.createFullBoxCtor("cprt", function (stream) { - this.parseLanguage(stream); - this.notice = stream.readCString(); - }); - - // file:src/parsing/cslg.js - BoxParser.createFullBoxCtor("cslg", function(stream) { - if (this.version === 0) { - this.compositionToDTSShift = stream.readInt32(); /* signed */ - this.leastDecodeToDisplayDelta = stream.readInt32(); /* signed */ - this.greatestDecodeToDisplayDelta = stream.readInt32(); /* signed */ - this.compositionStartTime = stream.readInt32(); /* signed */ - this.compositionEndTime = stream.readInt32(); /* signed */ - } - }); - - // file:src/parsing/ctts.js - BoxParser.createFullBoxCtor("ctts", function(stream) { - var entry_count; - var i; - entry_count = stream.readUint32(); - this.sample_counts = []; - this.sample_offsets = []; - if (this.version === 0) { - for(i=0; i> 6; - this.bsid = ((tmp_byte1 >> 1) & 0x1F); - this.bsmod = ((tmp_byte1 & 0x1) << 2) | ((tmp_byte2 >> 6) & 0x3); - this.acmod = ((tmp_byte2 >> 3) & 0x7); - this.lfeon = ((tmp_byte2 >> 2) & 0x1); - this.bit_rate_code = (tmp_byte2 & 0x3) | ((tmp_byte3 >> 5) & 0x7); - }); - - // file:src/parsing/dec3.js - BoxParser.createBoxCtor("dec3", function(stream) { - var tmp_16 = stream.readUint16(); - this.data_rate = tmp_16 >> 3; - this.num_ind_sub = tmp_16 & 0x7; - this.ind_subs = []; - for (var i = 0; i < this.num_ind_sub+1; i++) { - var ind_sub = {}; - this.ind_subs.push(ind_sub); - var tmp_byte1 = stream.readUint8(); - var tmp_byte2 = stream.readUint8(); - var tmp_byte3 = stream.readUint8(); - ind_sub.fscod = tmp_byte1 >> 6; - ind_sub.bsid = ((tmp_byte1 >> 1) & 0x1F); - ind_sub.bsmod = ((tmp_byte1 & 0x1) << 4) | ((tmp_byte2 >> 4) & 0xF); - ind_sub.acmod = ((tmp_byte2 >> 1) & 0x7); - ind_sub.lfeon = (tmp_byte2 & 0x1); - ind_sub.num_dep_sub = ((tmp_byte3 >> 1) & 0xF); - if (ind_sub.num_dep_sub > 0) { - ind_sub.chan_loc = ((tmp_byte3 & 0x1) << 8) | stream.readUint8(); - } - } - }); - - // file:src/parsing/dfLa.js - BoxParser.createFullBoxCtor("dfLa", function(stream) { - var BLOCKTYPE_MASK = 0x7F; - var LASTMETADATABLOCKFLAG_MASK = 0x80; - - var boxesFound = []; - var knownBlockTypes = [ - "STREAMINFO", - "PADDING", - "APPLICATION", - "SEEKTABLE", - "VORBIS_COMMENT", - "CUESHEET", - "PICTURE", - "RESERVED" - ]; - - // for (i=0; ; i++) { // to end of box - do { - var flagAndType = stream.readUint8(); - - var type = Math.min( - (flagAndType & BLOCKTYPE_MASK), - (knownBlockTypes.length - 1) - ); - - // if this is a STREAMINFO block, read the true samplerate since this - // can be different to the AudioSampleEntry samplerate. - if (!(type)) { - // read past all the other stuff - stream.readUint8Array(13); - - // extract samplerate - this.samplerate = (stream.readUint32() >> 12); - - // read to end of STREAMINFO - stream.readUint8Array(20); - } else { - // not interested in other block types so just discard length bytes - stream.readUint8Array(stream.readUint24()); - } - - boxesFound.push(knownBlockTypes[type]); - - if (!!(flagAndType & LASTMETADATABLOCKFLAG_MASK)) { - break; - } - } while (true); - - this.numMetadataBlocks = - boxesFound.length + " (" + boxesFound.join(", ") + ")"; - }); - // file:src/parsing/dimm.js - BoxParser.createBoxCtor("dimm", function(stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/dmax.js - BoxParser.createBoxCtor("dmax", function(stream) { - this.time = stream.readUint32(); - }); - - // file:src/parsing/dmed.js - BoxParser.createBoxCtor("dmed", function(stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/dOps.js - BoxParser.createBoxCtor("dOps", function(stream) { - this.Version = stream.readUint8(); - this.OutputChannelCount = stream.readUint8(); - this.PreSkip = stream.readUint16(); - this.InputSampleRate = stream.readUint32(); - this.OutputGain = stream.readInt16(); - this.ChannelMappingFamily = stream.readUint8(); - if (this.ChannelMappingFamily !== 0) { - this.StreamCount = stream.readUint8(); - this.CoupledCount = stream.readUint8(); - this.ChannelMapping = []; - for (var i = 0; i < this.OutputChannelCount; i++) { - this.ChannelMapping[i] = stream.readUint8(); - } - } - }); - - // file:src/parsing/dref.js - BoxParser.createFullBoxCtor("dref", function(stream) { - var ret; - var box; - this.entries = []; - var entry_count = stream.readUint32(); - for (var i = 0; i < entry_count; i++) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = ret.box; - this.entries.push(box); - } else { - return; - } - } - }); - - // file:src/parsing/drep.js - BoxParser.createBoxCtor("drep", function(stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/elng.js - BoxParser.createFullBoxCtor("elng", function(stream) { - this.extended_language = stream.readString(this.size-this.hdr_size); - }); - - // file:src/parsing/elst.js - BoxParser.createFullBoxCtor("elst", function(stream) { - this.entries = []; - var entry_count = stream.readUint32(); - for (var i = 0; i < entry_count; i++) { - var entry = {}; - this.entries.push(entry); - if (this.version === 1) { - entry.segment_duration = stream.readUint64(); - entry.media_time = stream.readInt64(); - } else { - entry.segment_duration = stream.readUint32(); - entry.media_time = stream.readInt32(); - } - entry.media_rate_integer = stream.readInt16(); - entry.media_rate_fraction = stream.readInt16(); - } - }); - - // file:src/parsing/emsg.js - BoxParser.createFullBoxCtor("emsg", function(stream) { - if (this.version == 1) { - this.timescale = stream.readUint32(); - this.presentation_time = stream.readUint64(); - this.event_duration = stream.readUint32(); - this.id = stream.readUint32(); - this.scheme_id_uri = stream.readCString(); - this.value = stream.readCString(); - } else { - this.scheme_id_uri = stream.readCString(); - this.value = stream.readCString(); - this.timescale = stream.readUint32(); - this.presentation_time_delta = stream.readUint32(); - this.event_duration = stream.readUint32(); - this.id = stream.readUint32(); - } - var message_size = this.size - this.hdr_size - (4*4 + (this.scheme_id_uri.length+1) + (this.value.length+1)); - if (this.version == 1) { - message_size -= 4; - } - this.message_data = stream.readUint8Array(message_size); - }); - - // file:src/parsing/EntityToGroup.js - // ISO/IEC 14496-12:2022 Section 8.18.3 Entity to group box - BoxParser.createEntityToGroupCtor = function(type, parseMethod) { - BoxParser[type+"Box"] = function(size) { - BoxParser.FullBox.call(this, type, size); - }; - BoxParser[type+"Box"].prototype = new BoxParser.FullBox(); - BoxParser[type+"Box"].prototype.parse = function(stream) { - this.parseFullHeader(stream); - if (parseMethod) { - parseMethod.call(this, stream); - } else { - this.group_id = stream.readUint32(); - this.num_entities_in_group = stream.readUint32(); - this.entity_ids = []; - for (i = 0; i < this.num_entities_in_group; i++) { - var entity_id = stream.readUint32(); - this.entity_ids.push(entity_id); - } - } - }; - }; - - // Auto exposure bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.2.1) - BoxParser.createEntityToGroupCtor("aebr"); - - // Flash exposure bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.5.1) - BoxParser.createEntityToGroupCtor("afbr"); - - // Album collection (ISO/IEC 23008-12:2022 Section 6.8.7.1) - BoxParser.createEntityToGroupCtor("albc"); - - // Alternative entity (ISO/IEC 14496-12:2022 Section 8.18.3.1) - BoxParser.createEntityToGroupCtor("altr"); - - // Burst image entity group (ISO/IEC 23008-12:2022 Section 6.8.2.2) - BoxParser.createEntityToGroupCtor("brst"); - - // Depth of field bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.6.1) - BoxParser.createEntityToGroupCtor("dobr"); - - // Equivalent entity (ISO/IEC 23008-12:2022 Section 6.8.1.1) - BoxParser.createEntityToGroupCtor("eqiv"); - - // Favourites collection (ISO/IEC 23008-12:2022 Section 6.8.7.2) - BoxParser.createEntityToGroupCtor("favc"); - - // Focus bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.4.1) - BoxParser.createEntityToGroupCtor("fobr"); - - // Audio to image entity group (ISO/IEC 23008-12:2022 Section 6.8.4) - BoxParser.createEntityToGroupCtor("iaug"); - - // Panorama (ISO/IEC 23008-12:2022 Section 6.8.8.1) - BoxParser.createEntityToGroupCtor("pano"); - - // Slideshow (ISO/IEC 23008-12:2022 Section 6.8.9.1) - BoxParser.createEntityToGroupCtor("slid"); - - // Stereo pair (ISO/IEC 23008-12:2022 Section 6.8.5) - BoxParser.createEntityToGroupCtor("ster"); - - // Time-synchronised capture entity group (ISO/IEC 23008-12:2022 Section 6.8.3) - BoxParser.createEntityToGroupCtor("tsyn"); - - // White balance bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.3.1) - BoxParser.createEntityToGroupCtor("wbbr"); - - // Alternative entity (ISO/IEC 23008-12:2022 AMD1 Section 6.8.10) - BoxParser.createEntityToGroupCtor("prgr"); - - // Image Pyramid entity group (ISO/IEC 23008-12:20xx Section 6.8.11) - BoxParser.createEntityToGroupCtor("pymd", function(stream) { - this.group_id = stream.readUint32(); - this.num_entities_in_group = stream.readUint32(); - this.entity_ids = []; - for (var i = 0; i < this.num_entities_in_group; i++) { - var entity_id = stream.readUint32(); - this.entity_ids.push(entity_id); - } - - this.tile_size_x = stream.readUint16(); - this.tile_size_y = stream.readUint16(); - this.layer_binning = []; - this.tiles_in_layer_column_minus1 = []; - this.tiles_in_layer_row_minus1 = []; - for (i = 0; i < this.num_entities_in_group; i++) { - this.layer_binning[i] = stream.readUint16(); - this.tiles_in_layer_row_minus1[i] = stream.readUint16(); - this.tiles_in_layer_column_minus1[i] = stream.readUint16(); - } - }); - - // file:src/parsing/esds.js - BoxParser.createFullBoxCtor("esds", function(stream) { - var esd_data = stream.readUint8Array(this.size-this.hdr_size); - if (typeof MPEG4DescriptorParser !== "undefined") { - var esd_parser = new MPEG4DescriptorParser(); - this.esd = esd_parser.parseOneDescriptor(new DataStream(esd_data.buffer, 0, DataStream.BIG_ENDIAN)); - } - }); - - // file:src/parsing/fiel.js - BoxParser.createBoxCtor("fiel", function(stream) { - this.fieldCount = stream.readUint8(); - this.fieldOrdering = stream.readUint8(); - }); - - // file:src/parsing/frma.js - BoxParser.createBoxCtor("frma", function(stream) { - this.data_format = stream.readString(4); - }); - - // file:src/parsing/ftyp.js - BoxParser.createBoxCtor("ftyp", function(stream) { - var toparse = this.size - this.hdr_size; - this.major_brand = stream.readString(4); - this.minor_version = stream.readUint32(); - toparse -= 8; - this.compatible_brands = []; - var i = 0; - while (toparse>=4) { - this.compatible_brands[i] = stream.readString(4); - toparse -= 4; - i++; - } - }); - - // file:src/parsing/hdlr.js - BoxParser.createFullBoxCtor("hdlr", function(stream) { - if (this.version === 0) { - stream.readUint32(); - this.handler = stream.readString(4); - stream.readUint32Array(3); - this.name = stream.readString(this.size-this.hdr_size-20); - if (this.name[this.name.length-1]==='\0') { - this.name = this.name.slice(0,-1); - } - } - }); - - // file:src/parsing/hvcC.js - BoxParser.createBoxCtor("hvcC", function(stream) { - var i, j; - var length; - var tmp_byte; - this.configurationVersion = stream.readUint8(); - tmp_byte = stream.readUint8(); - this.general_profile_space = tmp_byte >> 6; - this.general_tier_flag = (tmp_byte & 0x20) >> 5; - this.general_profile_idc = (tmp_byte & 0x1F); - this.general_profile_compatibility = stream.readUint32(); - this.general_constraint_indicator = stream.readUint8Array(6); - this.general_level_idc = stream.readUint8(); - this.min_spatial_segmentation_idc = stream.readUint16() & 0xFFF; - this.parallelismType = (stream.readUint8() & 0x3); - this.chroma_format_idc = (stream.readUint8() & 0x3); - this.bit_depth_luma_minus8 = (stream.readUint8() & 0x7); - this.bit_depth_chroma_minus8 = (stream.readUint8() & 0x7); - this.avgFrameRate = stream.readUint16(); - tmp_byte = stream.readUint8(); - this.constantFrameRate = (tmp_byte >> 6); - this.numTemporalLayers = (tmp_byte & 0XD) >> 3; - this.temporalIdNested = (tmp_byte & 0X4) >> 2; - this.lengthSizeMinusOne = (tmp_byte & 0X3); - - this.nalu_arrays = []; - var numOfArrays = stream.readUint8(); - for (i = 0; i < numOfArrays; i++) { - var nalu_array = []; - this.nalu_arrays.push(nalu_array); - tmp_byte = stream.readUint8(); - nalu_array.completeness = (tmp_byte & 0x80) >> 7; - nalu_array.nalu_type = tmp_byte & 0x3F; - var numNalus = stream.readUint16(); - for (j = 0; j < numNalus; j++) { - var nalu = {}; - nalu_array.push(nalu); - length = stream.readUint16(); - nalu.data = stream.readUint8Array(length); - } - } - }); - - // file:src/parsing/iinf.js - BoxParser.createFullBoxCtor("iinf", function(stream) { - var ret; - if (this.version === 0) { - this.entry_count = stream.readUint16(); - } else { - this.entry_count = stream.readUint32(); - } - this.item_infos = []; - for (var i = 0; i < this.entry_count; i++) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - if (ret.box.type !== "infe") { - Log.error("BoxParser", "Expected 'infe' box, got "+ret.box.type); - } - this.item_infos[i] = ret.box; - } else { - return; - } - } - }); - - // file:src/parsing/iloc.js - BoxParser.createFullBoxCtor("iloc", function(stream) { - var byte; - byte = stream.readUint8(); - this.offset_size = (byte >> 4) & 0xF; - this.length_size = byte & 0xF; - byte = stream.readUint8(); - this.base_offset_size = (byte >> 4) & 0xF; - if (this.version === 1 || this.version === 2) { - this.index_size = byte & 0xF; - } else { - this.index_size = 0; - // reserved = byte & 0xF; - } - this.items = []; - var item_count = 0; - if (this.version < 2) { - item_count = stream.readUint16(); - } else if (this.version === 2) { - item_count = stream.readUint32(); - } else { - throw "version of iloc box not supported"; - } - for (var i = 0; i < item_count; i++) { - var item = {}; - this.items.push(item); - if (this.version < 2) { - item.item_ID = stream.readUint16(); - } else if (this.version === 2) { - item.item_ID = stream.readUint32(); - } else { - throw "version of iloc box not supported"; - } - if (this.version === 1 || this.version === 2) { - item.construction_method = (stream.readUint16() & 0xF); - } else { - item.construction_method = 0; - } - item.data_reference_index = stream.readUint16(); - switch(this.base_offset_size) { - case 0: - item.base_offset = 0; - break; - case 4: - item.base_offset = stream.readUint32(); - break; - case 8: - item.base_offset = stream.readUint64(); - break; - default: - throw "Error reading base offset size"; - } - var extent_count = stream.readUint16(); - item.extents = []; - for (var j=0; j < extent_count; j++) { - var extent = {}; - item.extents.push(extent); - if (this.version === 1 || this.version === 2) { - switch(this.index_size) { - case 0: - extent.extent_index = 0; - break; - case 4: - extent.extent_index = stream.readUint32(); - break; - case 8: - extent.extent_index = stream.readUint64(); - break; - default: - throw "Error reading extent index"; - } - } - switch(this.offset_size) { - case 0: - extent.extent_offset = 0; - break; - case 4: - extent.extent_offset = stream.readUint32(); - break; - case 8: - extent.extent_offset = stream.readUint64(); - break; - default: - throw "Error reading extent index"; - } - switch(this.length_size) { - case 0: - extent.extent_length = 0; - break; - case 4: - extent.extent_length = stream.readUint32(); - break; - case 8: - extent.extent_length = stream.readUint64(); - break; - default: - throw "Error reading extent index"; - } - } - } - }); - - // file:src/parsing/imir.js - BoxParser.createBoxCtor("imir", function(stream) { - var tmp = stream.readUint8(); - this.reserved = tmp >> 7; - this.axis = tmp & 1; - });// file:src/parsing/infe.js - BoxParser.createFullBoxCtor("infe", function(stream) { - if (this.version === 0 || this.version === 1) { - this.item_ID = stream.readUint16(); - this.item_protection_index = stream.readUint16(); - this.item_name = stream.readCString(); - this.content_type = stream.readCString(); - this.content_encoding = stream.readCString(); - } - if (this.version === 1) { - this.extension_type = stream.readString(4); - Log.warn("BoxParser", "Cannot parse extension type"); - stream.seek(this.start+this.size); - return; - } - if (this.version >= 2) { - if (this.version === 2) { - this.item_ID = stream.readUint16(); - } else if (this.version === 3) { - this.item_ID = stream.readUint32(); - } - this.item_protection_index = stream.readUint16(); - this.item_type = stream.readString(4); - this.item_name = stream.readCString(); - if (this.item_type === "mime") { - this.content_type = stream.readCString(); - this.content_encoding = stream.readCString(); - } else if (this.item_type === "uri ") { - this.item_uri_type = stream.readCString(); - } - } - }); - // file:src/parsing/ipma.js - BoxParser.createFullBoxCtor("ipma", function(stream) { - var i, j; - entry_count = stream.readUint32(); - this.associations = []; - for(i=0; i> 7) === 1; - if (this.flags & 0x1) { - p.property_index = (tmp & 0x7F) << 8 | stream.readUint8(); - } else { - p.property_index = (tmp & 0x7F); - } - } - } - }); - - // file:src/parsing/iref.js - BoxParser.createFullBoxCtor("iref", function(stream) { - var ret; - var box; - this.references = []; - - while (stream.getPosition() < this.start+this.size) { - ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - if (this.version === 0) { - box = new BoxParser.SingleItemTypeReferenceBox(ret.type, ret.size, ret.hdr_size, ret.start); - } else { - box = new BoxParser.SingleItemTypeReferenceBoxLarge(ret.type, ret.size, ret.hdr_size, ret.start); - } - if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { - Log.warn("BoxParser", box.type+" box writing not yet implemented, keeping unparsed data in memory for later write"); - box.parseDataAndRewind(stream); - } - box.parse(stream); - this.references.push(box); - } else { - return; - } - } - }); - // file:src/parsing/irot.js - BoxParser.createBoxCtor("irot", function(stream) { - this.angle = stream.readUint8() & 0x3; - }); - - // file:src/parsing/ispe.js - BoxParser.createFullBoxCtor("ispe", function(stream) { - this.image_width = stream.readUint32(); - this.image_height = stream.readUint32(); - });// file:src/parsing/kind.js - BoxParser.createFullBoxCtor("kind", function(stream) { - this.schemeURI = stream.readCString(); - this.value = stream.readCString(); - }); - // file:src/parsing/leva.js - BoxParser.createFullBoxCtor("leva", function(stream) { - var count = stream.readUint8(); - this.levels = []; - for (var i = 0; i < count; i++) { - var level = {}; - this.levels[i] = level; - level.track_ID = stream.readUint32(); - var tmp_byte = stream.readUint8(); - level.padding_flag = tmp_byte >> 7; - level.assignment_type = tmp_byte & 0x7F; - switch (level.assignment_type) { - case 0: - level.grouping_type = stream.readString(4); - break; - case 1: - level.grouping_type = stream.readString(4); - level.grouping_type_parameter = stream.readUint32(); - break; - case 2: - break; - case 3: - break; - case 4: - level.sub_track_id = stream.readUint32(); - break; - default: - Log.warn("BoxParser", "Unknown leva assignement type"); - } - } - }); - - // file:src/parsing/lhvC.js - BoxParser.createBoxCtor("lhvC", function(stream) { - var i, j; - var tmp_byte; - this.configurationVersion = stream.readUint8(); - this.min_spatial_segmentation_idc = stream.readUint16() & 0xFFF; - this.parallelismType = (stream.readUint8() & 0x3); - tmp_byte = stream.readUint8(); - this.numTemporalLayers = (tmp_byte & 0XD) >> 3; - this.temporalIdNested = (tmp_byte & 0X4) >> 2; - this.lengthSizeMinusOne = (tmp_byte & 0X3); - - this.nalu_arrays = []; - var numOfArrays = stream.readUint8(); - for (i = 0; i < numOfArrays; i++) { - var nalu_array = []; - this.nalu_arrays.push(nalu_array); - tmp_byte = stream.readUint8(); - nalu_array.completeness = (tmp_byte & 0x80) >> 7; - nalu_array.nalu_type = tmp_byte & 0x3F; - var numNalus = stream.readUint16(); - for (j = 0; j < numNalus; j++) { - var nalu = {}; - nalu_array.push(nalu); - var length = stream.readUint16(); - nalu.data = stream.readUint8Array(length); - } - } - }); - - // file:src/parsing/lsel.js - BoxParser.createBoxCtor("lsel", function(stream) { - this.layer_id = stream.readUint16(); - });// file:src/parsing/maxr.js - BoxParser.createBoxCtor("maxr", function(stream) { - this.period = stream.readUint32(); - this.bytes = stream.readUint32(); - }); - - // file:src/parsing/mdcv.js - function ColorPoint(x, y) { - this.x = x; - this.y = y; - } - - ColorPoint.prototype.toString = function() { - return "("+this.x+","+this.y+")"; - }; - - BoxParser.createBoxCtor("mdcv", function(stream) { - this.display_primaries = []; - this.display_primaries[0] = new ColorPoint(stream.readUint16(),stream.readUint16()); - this.display_primaries[1] = new ColorPoint(stream.readUint16(),stream.readUint16()); - this.display_primaries[2] = new ColorPoint(stream.readUint16(),stream.readUint16()); - this.white_point = new ColorPoint(stream.readUint16(),stream.readUint16()); - this.max_display_mastering_luminance = stream.readUint32(); - this.min_display_mastering_luminance = stream.readUint32(); - }); - - // file:src/parsing/mdhd.js - BoxParser.createFullBoxCtor("mdhd", function(stream) { - if (this.version == 1) { - this.creation_time = stream.readUint64(); - this.modification_time = stream.readUint64(); - this.timescale = stream.readUint32(); - this.duration = stream.readUint64(); - } else { - this.creation_time = stream.readUint32(); - this.modification_time = stream.readUint32(); - this.timescale = stream.readUint32(); - this.duration = stream.readUint32(); - } - this.parseLanguage(stream); - stream.readUint16(); - }); - - // file:src/parsing/mehd.js - BoxParser.createFullBoxCtor("mehd", function(stream) { - if (this.flags & 0x1) { - Log.warn("BoxParser", "mehd box incorrectly uses flags set to 1, converting version to 1"); - this.version = 1; - } - if (this.version == 1) { - this.fragment_duration = stream.readUint64(); - } else { - this.fragment_duration = stream.readUint32(); - } - }); - - // file:src/parsing/meta.js - BoxParser.createFullBoxCtor("meta", function(stream) { - this.boxes = []; - BoxParser.ContainerBox.prototype.parse.call(this, stream); - }); - // file:src/parsing/mfhd.js - BoxParser.createFullBoxCtor("mfhd", function(stream) { - this.sequence_number = stream.readUint32(); - }); - - // file:src/parsing/mfro.js - BoxParser.createFullBoxCtor("mfro", function(stream) { - this._size = stream.readUint32(); - }); - - // file:src/parsing/mskC.js - BoxParser.createFullBoxCtor("mskC", function(stream) { - this.bits_per_pixel = stream.readUint8(); - }); - - // file:src/parsing/mvhd.js - BoxParser.createFullBoxCtor("mvhd", function(stream) { - if (this.version == 1) { - this.creation_time = stream.readUint64(); - this.modification_time = stream.readUint64(); - this.timescale = stream.readUint32(); - this.duration = stream.readUint64(); - } else { - this.creation_time = stream.readUint32(); - this.modification_time = stream.readUint32(); - this.timescale = stream.readUint32(); - this.duration = stream.readUint32(); - } - this.rate = stream.readUint32(); - this.volume = stream.readUint16()>>8; - stream.readUint16(); - stream.readUint32Array(2); - this.matrix = stream.readUint32Array(9); - stream.readUint32Array(6); - this.next_track_id = stream.readUint32(); - }); - // file:src/parsing/npck.js - BoxParser.createBoxCtor("npck", function(stream) { - this.packetssent = stream.readUint32(); - }); - - // file:src/parsing/nump.js - BoxParser.createBoxCtor("nump", function(stream) { - this.packetssent = stream.readUint64(); - }); - - // file:src/parsing/padb.js - BoxParser.createFullBoxCtor("padb", function(stream) { - var sample_count = stream.readUint32(); - this.padbits = []; - for (var i = 0; i < Math.floor((sample_count+1)/2); i++) { - this.padbits = stream.readUint8(); - } - }); - - // file:src/parsing/pasp.js - BoxParser.createBoxCtor("pasp", function(stream) { - this.hSpacing = stream.readUint32(); - this.vSpacing = stream.readUint32(); - });// file:src/parsing/payl.js - BoxParser.createBoxCtor("payl", function(stream) { - this.text = stream.readString(this.size - this.hdr_size); - }); - - // file:src/parsing/payt.js - BoxParser.createBoxCtor("payt", function(stream) { - this.payloadID = stream.readUint32(); - var count = stream.readUint8(); - this.rtpmap_string = stream.readString(count); - }); - - // file:src/parsing/pdin.js - BoxParser.createFullBoxCtor("pdin", function(stream) { - var count = (this.size - this.hdr_size)/8; - this.rate = []; - this.initial_delay = []; - for (var i = 0; i < count; i++) { - this.rate[i] = stream.readUint32(); - this.initial_delay[i] = stream.readUint32(); - } - }); - - // file:src/parsing/pitm.js - BoxParser.createFullBoxCtor("pitm", function(stream) { - if (this.version === 0) { - this.item_id = stream.readUint16(); - } else { - this.item_id = stream.readUint32(); - } - }); - - // file:src/parsing/pixi.js - BoxParser.createFullBoxCtor("pixi", function(stream) { - var i; - this.num_channels = stream.readUint8(); - this.bits_per_channels = []; - for (i = 0; i < this.num_channels; i++) { - this.bits_per_channels[i] = stream.readUint8(); - } - }); - - // file:src/parsing/pmax.js - BoxParser.createBoxCtor("pmax", function(stream) { - this.bytes = stream.readUint32(); - }); - - // file:src/parsing/prdi.js - BoxParser.createFullBoxCtor("prdi", function(stream) { - this.step_count = stream.readUint16(); - this.item_count = []; - if (this.flags & 0x2) { - for (var i = 0; i < this.step_count; i++) { - this.item_count[i] = stream.readUint16(); - } - } - });// file:src/parsing/prft.js - BoxParser.createFullBoxCtor("prft", function(stream) { - this.ref_track_id = stream.readUint32(); - this.ntp_timestamp = stream.readUint64(); - if (this.version === 0) { - this.media_time = stream.readUint32(); - } else { - this.media_time = stream.readUint64(); - } - }); - - // file:src/parsing/pssh.js - BoxParser.createFullBoxCtor("pssh", function(stream) { - this.system_id = BoxParser.parseHex16(stream); - if (this.version > 0) { - var count = stream.readUint32(); - this.kid = []; - for (var i = 0; i < count; i++) { - this.kid[i] = BoxParser.parseHex16(stream); - } - } - var datasize = stream.readUint32(); - if (datasize > 0) { - this.data = stream.readUint8Array(datasize); - } - }); - - // file:src/parsing/qt/clef.js - BoxParser.createFullBoxCtor("clef", function(stream) { - this.width = stream.readUint32(); - this.height = stream.readUint32(); - });// file:src/parsing/qt/enof.js - BoxParser.createFullBoxCtor("enof", function(stream) { - this.width = stream.readUint32(); - this.height = stream.readUint32(); - });// file:src/parsing/qt/prof.js - BoxParser.createFullBoxCtor("prof", function(stream) { - this.width = stream.readUint32(); - this.height = stream.readUint32(); - });// file:src/parsing/qt/tapt.js - BoxParser.createContainerBoxCtor("tapt", null, [ "clef", "prof", "enof"]);// file:src/parsing/rtp.js - BoxParser.createBoxCtor("rtp ", function(stream) { - this.descriptionformat = stream.readString(4); - this.sdptext = stream.readString(this.size - this.hdr_size - 4); - }); - - // file:src/parsing/saio.js - BoxParser.createFullBoxCtor("saio", function(stream) { - if (this.flags & 0x1) { - this.aux_info_type = stream.readString(4); - this.aux_info_type_parameter = stream.readUint32(); - } - var count = stream.readUint32(); - this.offset = []; - for (var i = 0; i < count; i++) { - if (this.version === 0) { - this.offset[i] = stream.readUint32(); - } else { - this.offset[i] = stream.readUint64(); - } - } - }); - // file:src/parsing/saiz.js - BoxParser.createFullBoxCtor("saiz", function(stream) { - if (this.flags & 0x1) { - this.aux_info_type = stream.readString(4); - this.aux_info_type_parameter = stream.readUint32(); - } - this.default_sample_info_size = stream.readUint8(); - this.sample_count = stream.readUint32(); - this.sample_info_size = []; - if (this.default_sample_info_size === 0) { - for (var i = 0; i < this.sample_count; i++) { - this.sample_info_size[i] = stream.readUint8(); - } - } - }); - - // file:src/parsing/sampleentries/mett.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "mett", function(stream) { - this.parseHeader(stream); - this.content_encoding = stream.readCString(); - this.mime_format = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/metx.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "metx", function(stream) { - this.parseHeader(stream); - this.content_encoding = stream.readCString(); - this.namespace = stream.readCString(); - this.schema_location = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/sbtt.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "sbtt", function(stream) { - this.parseHeader(stream); - this.content_encoding = stream.readCString(); - this.mime_format = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/stpp.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "stpp", function(stream) { - this.parseHeader(stream); - this.namespace = stream.readCString(); - this.schema_location = stream.readCString(); - this.auxiliary_mime_types = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/stxt.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "stxt", function(stream) { - this.parseHeader(stream); - this.content_encoding = stream.readCString(); - this.mime_format = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/tx3g.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "tx3g", function(stream) { - this.parseHeader(stream); - this.displayFlags = stream.readUint32(); - this.horizontal_justification = stream.readInt8(); - this.vertical_justification = stream.readInt8(); - this.bg_color_rgba = stream.readUint8Array(4); - this.box_record = stream.readInt16Array(4); - this.style_record = stream.readUint8Array(12); - this.parseFooter(stream); - }); - // file:src/parsing/sampleentries/wvtt.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "wvtt", function(stream) { - this.parseHeader(stream); - this.parseFooter(stream); - }); - - // file:src/parsing/samplegroups/alst.js - BoxParser.createSampleGroupCtor("alst", function(stream) { - var i; - var roll_count = stream.readUint16(); - this.first_output_sample = stream.readUint16(); - this.sample_offset = []; - for (i = 0; i < roll_count; i++) { - this.sample_offset[i] = stream.readUint32(); - } - var remaining = this.description_length - 4 - 4*roll_count; - this.num_output_samples = []; - this.num_total_samples = []; - for (i = 0; i < remaining/4; i++) { - this.num_output_samples[i] = stream.readUint16(); - this.num_total_samples[i] = stream.readUint16(); - } - }); - - // file:src/parsing/samplegroups/avll.js - BoxParser.createSampleGroupCtor("avll", function(stream) { - this.layerNumber = stream.readUint8(); - this.accurateStatisticsFlag = stream.readUint8(); - this.avgBitRate = stream.readUint16(); - this.avgFrameRate = stream.readUint16(); - }); - - // file:src/parsing/samplegroups/avss.js - BoxParser.createSampleGroupCtor("avss", function(stream) { - this.subSequenceIdentifier = stream.readUint16(); - this.layerNumber = stream.readUint8(); - var tmp_byte = stream.readUint8(); - this.durationFlag = tmp_byte >> 7; - this.avgRateFlag = (tmp_byte >> 6) & 0x1; - if (this.durationFlag) { - this.duration = stream.readUint32(); - } - if (this.avgRateFlag) { - this.accurateStatisticsFlag = stream.readUint8(); - this.avgBitRate = stream.readUint16(); - this.avgFrameRate = stream.readUint16(); - } - this.dependency = []; - var numReferences = stream.readUint8(); - for (var i = 0; i < numReferences; i++) { - var dependencyInfo = {}; - this.dependency.push(dependencyInfo); - dependencyInfo.subSeqDirectionFlag = stream.readUint8(); - dependencyInfo.layerNumber = stream.readUint8(); - dependencyInfo.subSequenceIdentifier = stream.readUint16(); - } - }); - - // file:src/parsing/samplegroups/dtrt.js - BoxParser.createSampleGroupCtor("dtrt", function(stream) { - Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); - }); - - // file:src/parsing/samplegroups/mvif.js - BoxParser.createSampleGroupCtor("mvif", function(stream) { - Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); - }); - - // file:src/parsing/samplegroups/prol.js - BoxParser.createSampleGroupCtor("prol", function(stream) { - this.roll_distance = stream.readInt16(); - }); - - // file:src/parsing/samplegroups/rap.js - BoxParser.createSampleGroupCtor("rap ", function(stream) { - var tmp_byte = stream.readUint8(); - this.num_leading_samples_known = tmp_byte >> 7; - this.num_leading_samples = tmp_byte & 0x7F; - }); - - // file:src/parsing/samplegroups/rash.js - BoxParser.createSampleGroupCtor("rash", function(stream) { - this.operation_point_count = stream.readUint16(); - if (this.description_length !== 2+(this.operation_point_count === 1?2:this.operation_point_count*6)+9) { - Log.warn("BoxParser", "Mismatch in "+this.grouping_type+" sample group length"); - this.data = stream.readUint8Array(this.description_length-2); - } else { - if (this.operation_point_count === 1) { - this.target_rate_share = stream.readUint16(); - } else { - this.target_rate_share = []; - this.available_bitrate = []; - for (var i = 0; i < this.operation_point_count; i++) { - this.available_bitrate[i] = stream.readUint32(); - this.target_rate_share[i] = stream.readUint16(); - } - } - this.maximum_bitrate = stream.readUint32(); - this.minimum_bitrate = stream.readUint32(); - this.discard_priority = stream.readUint8(); - } - }); - - // file:src/parsing/samplegroups/roll.js - BoxParser.createSampleGroupCtor("roll", function(stream) { - this.roll_distance = stream.readInt16(); - }); - - // file:src/parsing/samplegroups/samplegroup.js - BoxParser.SampleGroupEntry.prototype.parse = function(stream) { - Log.warn("BoxParser", "Unknown Sample Group type: "+this.grouping_type); - this.data = stream.readUint8Array(this.description_length); - }; - - // file:src/parsing/samplegroups/scif.js - BoxParser.createSampleGroupCtor("scif", function(stream) { - Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); - }); - - // file:src/parsing/samplegroups/scnm.js - BoxParser.createSampleGroupCtor("scnm", function(stream) { - Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); - }); - - // file:src/parsing/samplegroups/seig.js - BoxParser.createSampleGroupCtor("seig", function(stream) { - this.reserved = stream.readUint8(); - var tmp = stream.readUint8(); - this.crypt_byte_block = tmp >> 4; - this.skip_byte_block = tmp & 0xF; - this.isProtected = stream.readUint8(); - this.Per_Sample_IV_Size = stream.readUint8(); - this.KID = BoxParser.parseHex16(stream); - this.constant_IV_size = 0; - this.constant_IV = 0; - if (this.isProtected === 1 && this.Per_Sample_IV_Size === 0) { - this.constant_IV_size = stream.readUint8(); - this.constant_IV = stream.readUint8Array(this.constant_IV_size); - } - }); - - // file:src/parsing/samplegroups/stsa.js - BoxParser.createSampleGroupCtor("stsa", function(stream) { - Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); - }); - - // file:src/parsing/samplegroups/sync.js - BoxParser.createSampleGroupCtor("sync", function(stream) { - var tmp_byte = stream.readUint8(); - this.NAL_unit_type = tmp_byte & 0x3F; - }); - - // file:src/parsing/samplegroups/tele.js - BoxParser.createSampleGroupCtor("tele", function(stream) { - var tmp_byte = stream.readUint8(); - this.level_independently_decodable = tmp_byte >> 7; - }); - - // file:src/parsing/samplegroups/tsas.js - BoxParser.createSampleGroupCtor("tsas", function(stream) { - Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); - }); - - // file:src/parsing/samplegroups/tscl.js - BoxParser.createSampleGroupCtor("tscl", function(stream) { - Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); - }); - - // file:src/parsing/samplegroups/vipr.js - BoxParser.createSampleGroupCtor("vipr", function(stream) { - Log.warn("BoxParser", "Sample Group type: "+this.grouping_type+" not fully parsed"); - }); - - // file:src/parsing/sbgp.js - BoxParser.createFullBoxCtor("sbgp", function(stream) { - this.grouping_type = stream.readString(4); - if (this.version === 1) { - this.grouping_type_parameter = stream.readUint32(); - } else { - this.grouping_type_parameter = 0; - } - this.entries = []; - var entry_count = stream.readUint32(); - for (var i = 0; i < entry_count; i++) { - var entry = {}; - this.entries.push(entry); - entry.sample_count = stream.readInt32(); - entry.group_description_index = stream.readInt32(); - } - }); - - // file:src/parsing/sbpm.js - function Pixel(row, col) { - this.bad_pixel_row = row; - this.bad_pixel_column = col; - } - - Pixel.prototype.toString = function pixelToString() { - return "[row: " + this.bad_pixel_row + ", column: " + this.bad_pixel_column + "]"; - }; - - BoxParser.createFullBoxCtor("sbpm", function(stream) { - var i; - this.component_count = stream.readUint16(); - this.component_index = []; - for (i = 0; i < this.component_count; i++) { - this.component_index.push(stream.readUint16()); - } - var flags = stream.readUint8(); - this.correction_applied = (0x80 == (flags & 0x80)); - this.num_bad_rows = stream.readUint32(); - this.num_bad_cols = stream.readUint32(); - this.num_bad_pixels = stream.readUint32(); - this.bad_rows = []; - this.bad_columns = []; - this.bad_pixels = []; - for (i = 0; i < this.num_bad_rows; i++) { - this.bad_rows.push(stream.readUint32()); - } - for (i = 0; i < this.num_bad_cols; i++) { - this.bad_columns.push(stream.readUint32()); - } - for (i = 0; i < this.num_bad_pixels; i++) { - var row = stream.readUint32(); - var col = stream.readUint32(); - this.bad_pixels.push(new Pixel(row, col)); - } - }); - - // file:src/parsing/schm.js - BoxParser.createFullBoxCtor("schm", function(stream) { - this.scheme_type = stream.readString(4); - this.scheme_version = stream.readUint32(); - if (this.flags & 0x000001) { - this.scheme_uri = stream.readString(this.size - this.hdr_size - 8); - } - }); - - // file:src/parsing/sdp.js - BoxParser.createBoxCtor("sdp ", function(stream) { - this.sdptext = stream.readString(this.size - this.hdr_size); - }); - - // file:src/parsing/sdtp.js - BoxParser.createFullBoxCtor("sdtp", function(stream) { - var tmp_byte; - var count = (this.size - this.hdr_size); - this.is_leading = []; - this.sample_depends_on = []; - this.sample_is_depended_on = []; - this.sample_has_redundancy = []; - for (var i = 0; i < count; i++) { - tmp_byte = stream.readUint8(); - this.is_leading[i] = tmp_byte >> 6; - this.sample_depends_on[i] = (tmp_byte >> 4) & 0x3; - this.sample_is_depended_on[i] = (tmp_byte >> 2) & 0x3; - this.sample_has_redundancy[i] = tmp_byte & 0x3; - } - }); - - // file:src/parsing/senc.js - // Cannot be fully parsed because Per_Sample_IV_Size needs to be known - BoxParser.createFullBoxCtor("senc" /*, function(stream) { - this.parseFullHeader(stream); - var sample_count = stream.readUint32(); - this.samples = []; - for (var i = 0; i < sample_count; i++) { - var sample = {}; - // tenc.default_Per_Sample_IV_Size or seig.Per_Sample_IV_Size - sample.InitializationVector = this.readUint8Array(Per_Sample_IV_Size*8); - if (this.flags & 0x2) { - sample.subsamples = []; - subsample_count = stream.readUint16(); - for (var j = 0; j < subsample_count; j++) { - var subsample = {}; - subsample.BytesOfClearData = stream.readUint16(); - subsample.BytesOfProtectedData = stream.readUint32(); - sample.subsamples.push(subsample); - } - } - // TODO - this.samples.push(sample); - } - }*/); - // file:src/parsing/sgpd.js - BoxParser.createFullBoxCtor("sgpd", function(stream) { - this.grouping_type = stream.readString(4); - Log.debug("BoxParser", "Found Sample Groups of type "+this.grouping_type); - if (this.version === 1) { - this.default_length = stream.readUint32(); - } else { - this.default_length = 0; - } - if (this.version >= 2) { - this.default_group_description_index = stream.readUint32(); - } - this.entries = []; - var entry_count = stream.readUint32(); - for (var i = 0; i < entry_count; i++) { - var entry; - if (BoxParser[this.grouping_type+"SampleGroupEntry"]) { - entry = new BoxParser[this.grouping_type+"SampleGroupEntry"](this.grouping_type); - } else { - entry = new BoxParser.SampleGroupEntry(this.grouping_type); - } - this.entries.push(entry); - if (this.version === 1) { - if (this.default_length === 0) { - entry.description_length = stream.readUint32(); - } else { - entry.description_length = this.default_length; - } - } else { - entry.description_length = this.default_length; - } - if (entry.write === BoxParser.SampleGroupEntry.prototype.write) { - Log.info("BoxParser", "SampleGroup for type "+this.grouping_type+" writing not yet implemented, keeping unparsed data in memory for later write"); - // storing data - entry.data = stream.readUint8Array(entry.description_length); - // rewinding - stream.position -= entry.description_length; - } - entry.parse(stream); - } - }); - - // file:src/parsing/sidx.js - BoxParser.createFullBoxCtor("sidx", function(stream) { - this.reference_ID = stream.readUint32(); - this.timescale = stream.readUint32(); - if (this.version === 0) { - this.earliest_presentation_time = stream.readUint32(); - this.first_offset = stream.readUint32(); - } else { - this.earliest_presentation_time = stream.readUint64(); - this.first_offset = stream.readUint64(); - } - stream.readUint16(); - this.references = []; - var count = stream.readUint16(); - for (var i = 0; i < count; i++) { - var ref = {}; - this.references.push(ref); - var tmp_32 = stream.readUint32(); - ref.reference_type = (tmp_32 >> 31) & 0x1; - ref.referenced_size = tmp_32 & 0x7FFFFFFF; - ref.subsegment_duration = stream.readUint32(); - tmp_32 = stream.readUint32(); - ref.starts_with_SAP = (tmp_32 >> 31) & 0x1; - ref.SAP_type = (tmp_32 >> 28) & 0x7; - ref.SAP_delta_time = tmp_32 & 0xFFFFFFF; - } - }); - - // file:src/parsing/singleitemtypereference.js - BoxParser.SingleItemTypeReferenceBox = function(type, size, hdr_size, start) { - BoxParser.Box.call(this, type, size); - this.hdr_size = hdr_size; - this.start = start; - }; - BoxParser.SingleItemTypeReferenceBox.prototype = new BoxParser.Box(); - BoxParser.SingleItemTypeReferenceBox.prototype.parse = function(stream) { - this.from_item_ID = stream.readUint16(); - var count = stream.readUint16(); - this.references = []; - for(var i = 0; i < count; i++) { - this.references[i] = {}; - this.references[i].to_item_ID = stream.readUint16(); - } - }; - - // file:src/parsing/singleitemtypereferencelarge.js - BoxParser.SingleItemTypeReferenceBoxLarge = function(type, size, hdr_size, start) { - BoxParser.Box.call(this, type, size); - this.hdr_size = hdr_size; - this.start = start; - }; - BoxParser.SingleItemTypeReferenceBoxLarge.prototype = new BoxParser.Box(); - BoxParser.SingleItemTypeReferenceBoxLarge.prototype.parse = function(stream) { - this.from_item_ID = stream.readUint32(); - var count = stream.readUint16(); - this.references = []; - for(var i = 0; i < count; i++) { - this.references[i] = {}; - this.references[i].to_item_ID = stream.readUint32(); - } - }; - - // file:src/parsing/SmDm.js - BoxParser.createFullBoxCtor("SmDm", function(stream) { - this.primaryRChromaticity_x = stream.readUint16(); - this.primaryRChromaticity_y = stream.readUint16(); - this.primaryGChromaticity_x = stream.readUint16(); - this.primaryGChromaticity_y = stream.readUint16(); - this.primaryBChromaticity_x = stream.readUint16(); - this.primaryBChromaticity_y = stream.readUint16(); - this.whitePointChromaticity_x = stream.readUint16(); - this.whitePointChromaticity_y = stream.readUint16(); - this.luminanceMax = stream.readUint32(); - this.luminanceMin = stream.readUint32(); - }); - - // file:src/parsing/smhd.js - BoxParser.createFullBoxCtor("smhd", function(stream) { - this.balance = stream.readUint16(); - stream.readUint16(); - }); - - // file:src/parsing/ssix.js - BoxParser.createFullBoxCtor("ssix", function(stream) { - this.subsegments = []; - var subsegment_count = stream.readUint32(); - for (var i = 0; i < subsegment_count; i++) { - var subsegment = {}; - this.subsegments.push(subsegment); - subsegment.ranges = []; - var range_count = stream.readUint32(); - for (var j = 0; j < range_count; j++) { - var range = {}; - subsegment.ranges.push(range); - range.level = stream.readUint8(); - range.range_size = stream.readUint24(); - } - } - }); - - // file:src/parsing/stco.js - BoxParser.createFullBoxCtor("stco", function(stream) { - var entry_count; - entry_count = stream.readUint32(); - this.chunk_offsets = []; - if (this.version === 0) { - for (var i = 0; i < entry_count; i++) { - this.chunk_offsets.push(stream.readUint32()); - } - } - }); - - // file:src/parsing/stdp.js - BoxParser.createFullBoxCtor("stdp", function(stream) { - var count = (this.size - this.hdr_size)/2; - this.priority = []; - for (var i = 0; i < count; i++) { - this.priority[i] = stream.readUint16(); - } - }); - - // file:src/parsing/sthd.js - BoxParser.createFullBoxCtor("sthd"); - - // file:src/parsing/stri.js - BoxParser.createFullBoxCtor("stri", function(stream) { - this.switch_group = stream.readUint16(); - this.alternate_group = stream.readUint16(); - this.sub_track_id = stream.readUint32(); - var count = (this.size - this.hdr_size - 8)/4; - this.attribute_list = []; - for (var i = 0; i < count; i++) { - this.attribute_list[i] = stream.readUint32(); - } - }); - - // file:src/parsing/stsc.js - BoxParser.createFullBoxCtor("stsc", function(stream) { - var entry_count; - var i; - entry_count = stream.readUint32(); - this.first_chunk = []; - this.samples_per_chunk = []; - this.sample_description_index = []; - if (this.version === 0) { - for(i=0; i> 4) & 0xF; - this.sample_sizes[i+1] = tmp & 0xF; - } - } else if (this.field_size === 8) { - for (i = 0; i < sample_count; i++) { - this.sample_sizes[i] = stream.readUint8(); - } - } else if (this.field_size === 16) { - for (i = 0; i < sample_count; i++) { - this.sample_sizes[i] = stream.readUint16(); - } - } else { - Log.error("BoxParser", "Error in length field in stz2 box"); - } - } - }); - - // file:src/parsing/subs.js - BoxParser.createFullBoxCtor("subs", function(stream) { - var i,j; - var entry_count; - var subsample_count; - entry_count = stream.readUint32(); - this.entries = []; - for (i = 0; i < entry_count; i++) { - var sampleInfo = {}; - this.entries[i] = sampleInfo; - sampleInfo.sample_delta = stream.readUint32(); - sampleInfo.subsamples = []; - subsample_count = stream.readUint16(); - if (subsample_count>0) { - for (j = 0; j < subsample_count; j++) { - var subsample = {}; - sampleInfo.subsamples.push(subsample); - if (this.version == 1) { - subsample.size = stream.readUint32(); - } else { - subsample.size = stream.readUint16(); - } - subsample.priority = stream.readUint8(); - subsample.discardable = stream.readUint8(); - subsample.codec_specific_parameters = stream.readUint32(); - } - } - } - }); - - // file:src/parsing/tenc.js - BoxParser.createFullBoxCtor("tenc", function(stream) { - stream.readUint8(); // reserved - if (this.version === 0) { - stream.readUint8(); - } else { - var tmp = stream.readUint8(); - this.default_crypt_byte_block = (tmp >> 4) & 0xF; - this.default_skip_byte_block = tmp & 0xF; - } - this.default_isProtected = stream.readUint8(); - this.default_Per_Sample_IV_Size = stream.readUint8(); - this.default_KID = BoxParser.parseHex16(stream); - if (this.default_isProtected === 1 && this.default_Per_Sample_IV_Size === 0) { - this.default_constant_IV_size = stream.readUint8(); - this.default_constant_IV = stream.readUint8Array(this.default_constant_IV_size); - } - });// file:src/parsing/tfdt.js - BoxParser.createFullBoxCtor("tfdt", function(stream) { - if (this.version == 1) { - this.baseMediaDecodeTime = stream.readUint64(); - } else { - this.baseMediaDecodeTime = stream.readUint32(); - } - }); - - // file:src/parsing/tfhd.js - BoxParser.createFullBoxCtor("tfhd", function(stream) { - var readBytes = 0; - this.track_id = stream.readUint32(); - if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET)) { - this.base_data_offset = stream.readUint64(); - readBytes += 8; - } else { - this.base_data_offset = 0; - } - if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC)) { - this.default_sample_description_index = stream.readUint32(); - readBytes += 4; - } else { - this.default_sample_description_index = 0; - } - if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR)) { - this.default_sample_duration = stream.readUint32(); - readBytes += 4; - } else { - this.default_sample_duration = 0; - } - if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE)) { - this.default_sample_size = stream.readUint32(); - readBytes += 4; - } else { - this.default_sample_size = 0; - } - if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS)) { - this.default_sample_flags = stream.readUint32(); - readBytes += 4; - } else { - this.default_sample_flags = 0; - } - }); - - // file:src/parsing/tfra.js - BoxParser.createFullBoxCtor("tfra", function(stream) { - this.track_ID = stream.readUint32(); - stream.readUint24(); - var tmp_byte = stream.readUint8(); - this.length_size_of_traf_num = (tmp_byte >> 4) & 0x3; - this.length_size_of_trun_num = (tmp_byte >> 2) & 0x3; - this.length_size_of_sample_num = (tmp_byte) & 0x3; - this.entries = []; - var number_of_entries = stream.readUint32(); - for (var i = 0; i < number_of_entries; i++) { - if (this.version === 1) { - this.time = stream.readUint64(); - this.moof_offset = stream.readUint64(); - } else { - this.time = stream.readUint32(); - this.moof_offset = stream.readUint32(); - } - this.traf_number = stream["readUint"+(8*(this.length_size_of_traf_num+1))](); - this.trun_number = stream["readUint"+(8*(this.length_size_of_trun_num+1))](); - this.sample_number = stream["readUint"+(8*(this.length_size_of_sample_num+1))](); - } - }); - - // file:src/parsing/tkhd.js - BoxParser.createFullBoxCtor("tkhd", function(stream) { - if (this.version == 1) { - this.creation_time = stream.readUint64(); - this.modification_time = stream.readUint64(); - this.track_id = stream.readUint32(); - stream.readUint32(); - this.duration = stream.readUint64(); - } else { - this.creation_time = stream.readUint32(); - this.modification_time = stream.readUint32(); - this.track_id = stream.readUint32(); - stream.readUint32(); - this.duration = stream.readUint32(); - } - stream.readUint32Array(2); - this.layer = stream.readInt16(); - this.alternate_group = stream.readInt16(); - this.volume = stream.readInt16()>>8; - stream.readUint16(); - this.matrix = stream.readInt32Array(9); - this.width = stream.readUint32(); - this.height = stream.readUint32(); - }); - - // file:src/parsing/tmax.js - BoxParser.createBoxCtor("tmax", function(stream) { - this.time = stream.readUint32(); - }); - - // file:src/parsing/tmin.js - BoxParser.createBoxCtor("tmin", function(stream) { - this.time = stream.readUint32(); - }); - - // file:src/parsing/totl.js - BoxParser.createBoxCtor("totl",function(stream) { - this.bytessent = stream.readUint32(); - }); - - // file:src/parsing/tpay.js - BoxParser.createBoxCtor("tpay", function(stream) { - this.bytessent = stream.readUint32(); - }); - - // file:src/parsing/tpyl.js - BoxParser.createBoxCtor("tpyl", function(stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/TrackGroup.js - BoxParser.TrackGroupTypeBox.prototype.parse = function(stream) { - this.parseFullHeader(stream); - this.track_group_id = stream.readUint32(); - }; - - // file:src/parsing/trackgroups/msrc.js - BoxParser.createTrackGroupCtor("msrc");// file:src/parsing/TrakReference.js - BoxParser.TrackReferenceTypeBox = function(type, size, hdr_size, start) { - BoxParser.Box.call(this, type, size); - this.hdr_size = hdr_size; - this.start = start; - }; - BoxParser.TrackReferenceTypeBox.prototype = new BoxParser.Box(); - BoxParser.TrackReferenceTypeBox.prototype.parse = function(stream) { - this.track_ids = stream.readUint32Array((this.size-this.hdr_size)/4); - }; - - // file:src/parsing/tref.js - BoxParser.trefBox.prototype.parse = function(stream) { - var ret; - var box; - while (stream.getPosition() < this.start+this.size) { - ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = new BoxParser.TrackReferenceTypeBox(ret.type, ret.size, ret.hdr_size, ret.start); - if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { - Log.info("BoxParser", "TrackReference "+box.type+" box writing not yet implemented, keeping unparsed data in memory for later write"); - box.parseDataAndRewind(stream); - } - box.parse(stream); - this.boxes.push(box); - } else { - return; - } - } - }; - - // file:src/parsing/trep.js - BoxParser.createFullBoxCtor("trep", function(stream) { - this.track_ID = stream.readUint32(); - this.boxes = []; - while (stream.getPosition() < this.start+this.size) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = ret.box; - this.boxes.push(box); - } else { - return; - } - } - }); - - // file:src/parsing/trex.js - BoxParser.createFullBoxCtor("trex", function(stream) { - this.track_id = stream.readUint32(); - this.default_sample_description_index = stream.readUint32(); - this.default_sample_duration = stream.readUint32(); - this.default_sample_size = stream.readUint32(); - this.default_sample_flags = stream.readUint32(); - }); - - // file:src/parsing/trpy.js - BoxParser.createBoxCtor("trpy", function(stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/trun.js - BoxParser.createFullBoxCtor("trun", function(stream) { - var readBytes = 0; - this.sample_count = stream.readUint32(); - readBytes+= 4; - if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) ) { - this.data_offset = stream.readInt32(); //signed - readBytes += 4; - } else { - this.data_offset = 0; - } - if (this.size - this.hdr_size > readBytes && (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) ) { - this.first_sample_flags = stream.readUint32(); - readBytes += 4; - } else { - this.first_sample_flags = 0; - } - this.sample_duration = []; - this.sample_size = []; - this.sample_flags = []; - this.sample_composition_time_offset = []; - if (this.size - this.hdr_size > readBytes) { - for (var i = 0; i < this.sample_count; i++) { - if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { - this.sample_duration[i] = stream.readUint32(); - } - if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { - this.sample_size[i] = stream.readUint32(); - } - if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { - this.sample_flags[i] = stream.readUint32(); - } - if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { - if (this.version === 0) { - this.sample_composition_time_offset[i] = stream.readUint32(); - } else { - this.sample_composition_time_offset[i] = stream.readInt32(); //signed - } - } - } - } - }); - - // file:src/parsing/tsel.js - BoxParser.createFullBoxCtor("tsel", function(stream) { - this.switch_group = stream.readUint32(); - var count = (this.size - this.hdr_size - 4)/4; - this.attribute_list = []; - for (var i = 0; i < count; i++) { - this.attribute_list[i] = stream.readUint32(); - } - }); - - // file:src/parsing/txtC.js - BoxParser.createFullBoxCtor("txtC", function(stream) { - this.config = stream.readCString(); - }); - - // file:src/parsing/tyco.js - BoxParser.createBoxCtor("tyco", function(stream) { - var count = (this.size - this.hdr_size) / 4; - this.compatible_brands = []; - for (var i = 0; i < count; i++) { - this.compatible_brands[i] = stream.readString(4); - } - }); - - // file:src/parsing/udes.js - BoxParser.createFullBoxCtor("udes", function(stream) { - this.lang = stream.readCString(); - this.name = stream.readCString(); - this.description = stream.readCString(); - this.tags = stream.readCString(); - }); - - // file:src/parsing/uncC.js - BoxParser.createFullBoxCtor("uncC", function(stream) { - var i; - this.profile = stream.readUint32(); - if (this.version == 1) ; else if (this.version == 0) { - this.component_count = stream.readUint32(); - this.component_index = []; - this.component_bit_depth_minus_one = []; - this.component_format = []; - this.component_align_size = []; - for (i = 0; i < this.component_count; i++) { - this.component_index.push(stream.readUint16()); - this.component_bit_depth_minus_one.push(stream.readUint8()); - this.component_format.push(stream.readUint8()); - this.component_align_size.push(stream.readUint8()); - } - this.sampling_type = stream.readUint8(); - this.interleave_type = stream.readUint8(); - this.block_size = stream.readUint8(); - var flags = stream.readUint8(); - this.component_little_endian = (flags >> 7) & 0x1; - this.block_pad_lsb = (flags >> 6) & 0x1; - this.block_little_endian = (flags >> 5) & 0x1; - this.block_reversed = (flags >> 4) & 0x1; - this.pad_unknown = (flags >> 3) & 0x1; - this.pixel_size = stream.readUint32(); - this.row_align_size = stream.readUint32(); - this.tile_align_size = stream.readUint32(); - this.num_tile_cols_minus_one = stream.readUint32(); - this.num_tile_rows_minus_one = stream.readUint32(); - } - }); - - // file:src/parsing/url.js - BoxParser.createFullBoxCtor("url ", function(stream) { - if (this.flags !== 0x000001) { - this.location = stream.readCString(); - } - }); - - // file:src/parsing/urn.js - BoxParser.createFullBoxCtor("urn ", function(stream) { - this.name = stream.readCString(); - if (this.size - this.hdr_size - this.name.length - 1 > 0) { - this.location = stream.readCString(); - } - }); - - // file:src/parsing/uuid/piff/piffLsm.js - BoxParser.createUUIDBox("a5d40b30e81411ddba2f0800200c9a66", true, false, function(stream) { - this.LiveServerManifest = stream.readString(this.size - this.hdr_size) - .replace(/&/g, "&") - .replace(//g, ">") - .replace(/"/g, """) - .replace(/'/g, "'"); - });// file:src/parsing/uuid/piff/piffPssh.js - BoxParser.createUUIDBox("d08a4f1810f34a82b6c832d8aba183d3", true, false, function(stream) { - this.system_id = BoxParser.parseHex16(stream); - var datasize = stream.readUint32(); - if (datasize > 0) { - this.data = stream.readUint8Array(datasize); - } - }); - - // file:src/parsing/uuid/piff/piffSenc.js - BoxParser.createUUIDBox("a2394f525a9b4f14a2446c427c648df4", true, false /*, function(stream) { - if (this.flags & 0x1) { - this.AlgorithmID = stream.readUint24(); - this.IV_size = stream.readUint8(); - this.KID = BoxParser.parseHex16(stream); - } - var sample_count = stream.readUint32(); - this.samples = []; - for (var i = 0; i < sample_count; i++) { - var sample = {}; - sample.InitializationVector = this.readUint8Array(this.IV_size*8); - if (this.flags & 0x2) { - sample.subsamples = []; - sample.NumberOfEntries = stream.readUint16(); - for (var j = 0; j < sample.NumberOfEntries; j++) { - var subsample = {}; - subsample.BytesOfClearData = stream.readUint16(); - subsample.BytesOfProtectedData = stream.readUint32(); - sample.subsamples.push(subsample); - } - } - this.samples.push(sample); - } - }*/); - // file:src/parsing/uuid/piff/piffTenc.js - BoxParser.createUUIDBox("8974dbce7be74c5184f97148f9882554", true, false, function(stream) { - this.default_AlgorithmID = stream.readUint24(); - this.default_IV_size = stream.readUint8(); - this.default_KID = BoxParser.parseHex16(stream); - });// file:src/parsing/uuid/piff/piffTfrf.js - BoxParser.createUUIDBox("d4807ef2ca3946958e5426cb9e46a79f", true, false, function(stream) { - this.fragment_count = stream.readUint8(); - this.entries = []; - - for (var i = 0; i < this.fragment_count; i++) { - var entry = {}; - var absolute_time = 0; - var absolute_duration = 0; - - if (this.version === 1) { - absolute_time = stream.readUint64(); - absolute_duration = stream.readUint64(); - } else { - absolute_time = stream.readUint32(); - absolute_duration = stream.readUint32(); - } - - entry.absolute_time = absolute_time; - entry.absolute_duration = absolute_duration; - - this.entries.push(entry); - } - });// file:src/parsing/uuid/piff/piffTfxd.js - BoxParser.createUUIDBox("6d1d9b0542d544e680e2141daff757b2", true, false, function(stream) { - if (this.version === 1) { - this.absolute_time = stream.readUint64(); - this.duration = stream.readUint64(); - } else { - this.absolute_time = stream.readUint32(); - this.duration = stream.readUint32(); - } - });// file:src/parsing/vmhd.js - BoxParser.createFullBoxCtor("vmhd", function(stream) { - this.graphicsmode = stream.readUint16(); - this.opcolor = stream.readUint16Array(3); - }); - - // file:src/parsing/vpcC.js - BoxParser.createFullBoxCtor("vpcC", function (stream) { - var tmp; - if (this.version === 1) { - this.profile = stream.readUint8(); - this.level = stream.readUint8(); - tmp = stream.readUint8(); - this.bitDepth = tmp >> 4; - this.chromaSubsampling = (tmp >> 1) & 0x7; - this.videoFullRangeFlag = tmp & 0x1; - this.colourPrimaries = stream.readUint8(); - this.transferCharacteristics = stream.readUint8(); - this.matrixCoefficients = stream.readUint8(); - this.codecIntializationDataSize = stream.readUint16(); - this.codecIntializationData = stream.readUint8Array(this.codecIntializationDataSize); - } else { - this.profile = stream.readUint8(); - this.level = stream.readUint8(); - tmp = stream.readUint8(); - this.bitDepth = (tmp >> 4) & 0xF; - this.colorSpace = tmp & 0xF; - tmp = stream.readUint8(); - this.chromaSubsampling = (tmp >> 4) & 0xF; - this.transferFunction = (tmp >> 1) & 0x7; - this.videoFullRangeFlag = tmp & 0x1; - this.codecIntializationDataSize = stream.readUint16(); - this.codecIntializationData = stream.readUint8Array(this.codecIntializationDataSize); - } - });// file:src/parsing/vttC.js - BoxParser.createBoxCtor("vttC", function(stream) { - this.text = stream.readString(this.size - this.hdr_size); - }); - - // file:src/parsing/vvcC.js - BoxParser.createFullBoxCtor("vvcC", function (stream) { - var i, j; - - // helper object to simplify extracting individual bits - var bitReader = { - held_bits: undefined, - num_held_bits: 0, - - stream_read_1_bytes: function (strm) { - this.held_bits = strm.readUint8(); - this.num_held_bits = 1 * 8; - }, - stream_read_2_bytes: function (strm) { - this.held_bits = strm.readUint16(); - this.num_held_bits = 2 * 8; - }, - - extract_bits: function (num_bits) { - var ret = (this.held_bits >> (this.num_held_bits - num_bits)) & ((1 << num_bits) - 1); - this.num_held_bits -= num_bits; - return ret; - } - }; - - // VvcDecoderConfigurationRecord - bitReader.stream_read_1_bytes(stream); - bitReader.extract_bits(5); // reserved - this.lengthSizeMinusOne = bitReader.extract_bits(2); - this.ptl_present_flag = bitReader.extract_bits(1); - - if (this.ptl_present_flag) { - bitReader.stream_read_2_bytes(stream); - this.ols_idx = bitReader.extract_bits(9); - this.num_sublayers = bitReader.extract_bits(3); - this.constant_frame_rate = bitReader.extract_bits(2); - this.chroma_format_idc = bitReader.extract_bits(2); - - bitReader.stream_read_1_bytes(stream); - this.bit_depth_minus8 = bitReader.extract_bits(3); - bitReader.extract_bits(5); // reserved - - // VvcPTLRecord - { - bitReader.stream_read_2_bytes(stream); - bitReader.extract_bits(2); // reserved - this.num_bytes_constraint_info = bitReader.extract_bits(6); - this.general_profile_idc = bitReader.extract_bits(7); - this.general_tier_flag = bitReader.extract_bits(1); - - this.general_level_idc = stream.readUint8(); - - bitReader.stream_read_1_bytes(stream); - this.ptl_frame_only_constraint_flag = bitReader.extract_bits(1); - this.ptl_multilayer_enabled_flag = bitReader.extract_bits(1); - - this.general_constraint_info = new Uint8Array(this.num_bytes_constraint_info); - if (this.num_bytes_constraint_info) { - for (i = 0; i < this.num_bytes_constraint_info - 1; i++) { - var cnstr1 = bitReader.extract_bits(6); - bitReader.stream_read_1_bytes(stream); - var cnstr2 = bitReader.extract_bits(2); - - this.general_constraint_info[i] = ((cnstr1 << 2) | cnstr2); - } - this.general_constraint_info[this.num_bytes_constraint_info - 1] = bitReader.extract_bits(6); - } else { - //forbidden in spec! - bitReader.extract_bits(6); - } - - if (this.num_sublayers > 1) { - bitReader.stream_read_1_bytes(stream); - this.ptl_sublayer_present_mask = 0; - for (j = this.num_sublayers - 2; j >= 0; --j) { - var val = bitReader.extract_bits(1); - this.ptl_sublayer_present_mask |= val << j; - } - for (j = this.num_sublayers; j <= 8 && this.num_sublayers > 1; ++j) { - bitReader.extract_bits(1); // ptl_reserved_zero_bit - } - - this.sublayer_level_idc = []; - for (j = this.num_sublayers - 2; j >= 0; --j) { - if (this.ptl_sublayer_present_mask & (1 << j)) { - this.sublayer_level_idc[j] = stream.readUint8(); - } - } - } - - this.ptl_num_sub_profiles = stream.readUint8(); - this.general_sub_profile_idc = []; - if (this.ptl_num_sub_profiles) { - for (i = 0; i < this.ptl_num_sub_profiles; i++) { - this.general_sub_profile_idc.push(stream.readUint32()); - } - } - } // end VvcPTLRecord - - this.max_picture_width = stream.readUint16(); - this.max_picture_height = stream.readUint16(); - this.avg_frame_rate = stream.readUint16(); - } - - var VVC_NALU_OPI = 12; - var VVC_NALU_DEC_PARAM = 13; - - this.nalu_arrays = []; - var num_of_arrays = stream.readUint8(); - for (i = 0; i < num_of_arrays; i++) { - var nalu_array = []; - this.nalu_arrays.push(nalu_array); - - bitReader.stream_read_1_bytes(stream); - nalu_array.completeness = bitReader.extract_bits(1); - bitReader.extract_bits(2); // reserved - nalu_array.nalu_type = bitReader.extract_bits(5); - - var numNalus = 1; - if (nalu_array.nalu_type != VVC_NALU_DEC_PARAM && nalu_array.nalu_type != VVC_NALU_OPI) { - numNalus = stream.readUint16(); - } - - for (j = 0; j < numNalus; j++) { - var len = stream.readUint16(); - nalu_array.push({ - data: stream.readUint8Array(len), - length: len - }); - } - } - }); - // file:src/parsing/vvnC.js - BoxParser.createFullBoxCtor("vvnC", function (stream) { - // VvcNALUConfigBox - var tmp = strm.readUint8(); - this.lengthSizeMinusOne = (tmp & 0x3); - }); - // file:src/box-codecs.js - BoxParser.SampleEntry.prototype.isVideo = function() { - return false; - }; - - BoxParser.SampleEntry.prototype.isAudio = function() { - return false; - }; - - BoxParser.SampleEntry.prototype.isSubtitle = function() { - return false; - }; - - BoxParser.SampleEntry.prototype.isMetadata = function() { - return false; - }; - - BoxParser.SampleEntry.prototype.isHint = function() { - return false; - }; - - BoxParser.SampleEntry.prototype.getCodec = function() { - return this.type.replace('.',''); - }; - - BoxParser.SampleEntry.prototype.getWidth = function() { - return ""; - }; - - BoxParser.SampleEntry.prototype.getHeight = function() { - return ""; - }; - - BoxParser.SampleEntry.prototype.getChannelCount = function() { - return ""; - }; - - BoxParser.SampleEntry.prototype.getSampleRate = function() { - return ""; - }; - - BoxParser.SampleEntry.prototype.getSampleSize = function() { - return ""; - }; - - BoxParser.VisualSampleEntry.prototype.isVideo = function() { - return true; - }; - - BoxParser.VisualSampleEntry.prototype.getWidth = function() { - return this.width; - }; - - BoxParser.VisualSampleEntry.prototype.getHeight = function() { - return this.height; - }; - - BoxParser.AudioSampleEntry.prototype.isAudio = function() { - return true; - }; - - BoxParser.AudioSampleEntry.prototype.getChannelCount = function() { - return this.channel_count; - }; - - BoxParser.AudioSampleEntry.prototype.getSampleRate = function() { - return this.samplerate; - }; - - BoxParser.AudioSampleEntry.prototype.getSampleSize = function() { - return this.samplesize; - }; - - BoxParser.SubtitleSampleEntry.prototype.isSubtitle = function() { - return true; - }; - - BoxParser.MetadataSampleEntry.prototype.isMetadata = function() { - return true; - }; - - - BoxParser.decimalToHex = function(d, padding) { - var hex = Number(d).toString(16); - padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding; - while (hex.length < padding) { - hex = "0" + hex; - } - return hex; - }; - - BoxParser.avc1SampleEntry.prototype.getCodec = - BoxParser.avc2SampleEntry.prototype.getCodec = - BoxParser.avc3SampleEntry.prototype.getCodec = - BoxParser.avc4SampleEntry.prototype.getCodec = function() { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.avcC) { - return baseCodec+"."+BoxParser.decimalToHex(this.avcC.AVCProfileIndication)+ - ""+BoxParser.decimalToHex(this.avcC.profile_compatibility)+ - ""+BoxParser.decimalToHex(this.avcC.AVCLevelIndication); - } else { - return baseCodec; - } - }; - - BoxParser.hev1SampleEntry.prototype.getCodec = - BoxParser.hvc1SampleEntry.prototype.getCodec = function() { - var i; - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.hvcC) { - baseCodec += '.'; - switch (this.hvcC.general_profile_space) { - case 0: - baseCodec += ''; - break; - case 1: - baseCodec += 'A'; - break; - case 2: - baseCodec += 'B'; - break; - case 3: - baseCodec += 'C'; - break; - } - baseCodec += this.hvcC.general_profile_idc; - baseCodec += '.'; - var val = this.hvcC.general_profile_compatibility; - var reversed = 0; - for (i=0; i<32; i++) { - reversed |= val & 1; - if (i==31) break; - reversed <<= 1; - val >>=1; - } - baseCodec += BoxParser.decimalToHex(reversed, 0); - baseCodec += '.'; - if (this.hvcC.general_tier_flag === 0) { - baseCodec += 'L'; - } else { - baseCodec += 'H'; - } - baseCodec += this.hvcC.general_level_idc; - var hasByte = false; - var constraint_string = ""; - for (i = 5; i >= 0; i--) { - if (this.hvcC.general_constraint_indicator[i] || hasByte) { - constraint_string = "."+BoxParser.decimalToHex(this.hvcC.general_constraint_indicator[i], 0)+constraint_string; - hasByte = true; - } - } - baseCodec += constraint_string; - } - return baseCodec; - }; - - BoxParser.vvc1SampleEntry.prototype.getCodec = - BoxParser.vvi1SampleEntry.prototype.getCodec = function () { - var i; - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.vvcC) { - baseCodec += '.' + this.vvcC.general_profile_idc; - if (this.vvcC.general_tier_flag) { - baseCodec += '.H'; - } else { - baseCodec += '.L'; - } - baseCodec += this.vvcC.general_level_idc; - - var constraint_string = ""; - if (this.vvcC.general_constraint_info) { - var bytes = []; - var byte = 0; - byte |= this.vvcC.ptl_frame_only_constraint << 7; - byte |= this.vvcC.ptl_multilayer_enabled << 6; - var last_nonzero; - for (i = 0; i < this.vvcC.general_constraint_info.length; ++i) { - byte |= (this.vvcC.general_constraint_info[i] >> 2) & 0x3f; - bytes.push(byte); - if (byte) { - last_nonzero = i; - } - - byte = (this.vvcC.general_constraint_info[i] >> 2) & 0x03; - } - - if (last_nonzero === undefined) { - constraint_string = ".CA"; - } - else { - constraint_string = ".C"; - var base32_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; - var held_bits = 0; - var num_held_bits = 0; - for (i = 0; i <= last_nonzero; ++i) { - held_bits = (held_bits << 8) | bytes[i]; - num_held_bits += 8; - - while (num_held_bits >= 5) { - var val = (held_bits >> (num_held_bits - 5)) & 0x1f; - constraint_string += base32_chars[val]; - - num_held_bits -= 5; - held_bits &= (1 << num_held_bits) - 1; - } - } - if (num_held_bits) { - held_bits <<= (5 - num_held_bits); // right-pad with zeros to 5 bits (is this correct?) - constraint_string += base32_chars[held_bits & 0x1f]; - } - } - } - baseCodec += constraint_string; - } - return baseCodec; - }; - - BoxParser.mp4aSampleEntry.prototype.getCodec = function() { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.esds && this.esds.esd) { - var oti = this.esds.esd.getOTI(); - var dsi = this.esds.esd.getAudioConfig(); - return baseCodec+"."+BoxParser.decimalToHex(oti)+(dsi ? "."+dsi: ""); - } else { - return baseCodec; - } - }; - - BoxParser.stxtSampleEntry.prototype.getCodec = function() { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if(this.mime_format) { - return baseCodec + "." + this.mime_format; - } else { - return baseCodec - } - }; - - BoxParser.vp08SampleEntry.prototype.getCodec = - BoxParser.vp09SampleEntry.prototype.getCodec = function() { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - var level = this.vpcC.level; - if (level == 0) { - level = "00"; - } - var bitDepth = this.vpcC.bitDepth; - if (bitDepth == 8) { - bitDepth = "08"; - } - return baseCodec + ".0" + this.vpcC.profile + "." + level + "." + bitDepth; - }; - - BoxParser.av01SampleEntry.prototype.getCodec = function() { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - var level = this.av1C.seq_level_idx_0; - if (level < 10) { - level = "0" + level; - } - var bitdepth; - if (this.av1C.seq_profile === 2 && this.av1C.high_bitdepth === 1) { - bitdepth = (this.av1C.twelve_bit === 1) ? "12" : "10"; - } else if ( this.av1C.seq_profile <= 2 ) { - bitdepth = (this.av1C.high_bitdepth === 1) ? "10" : "08"; - } - // TODO need to parse the SH to find color config - return baseCodec+"."+this.av1C.seq_profile+"."+level+(this.av1C.seq_tier_0?"H":"M")+"."+bitdepth;//+"."+this.av1C.monochrome+"."+this.av1C.chroma_subsampling_x+""+this.av1C.chroma_subsampling_y+""+this.av1C.chroma_sample_position; - }; - // file:src/box-write.js - /* - * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - BoxParser.Box.prototype.writeHeader = function(stream, msg) { - this.size += 8; - if (this.size > MAX_SIZE) { - this.size += 8; - } - if (this.type === "uuid") { - this.size += 16; - } - Log.debug("BoxWriter", "Writing box "+this.type+" of size: "+this.size+" at position "+stream.getPosition()+(msg || "")); - if (this.size > MAX_SIZE) { - stream.writeUint32(1); - } else { - this.sizePosition = stream.getPosition(); - stream.writeUint32(this.size); - } - stream.writeString(this.type, null, 4); - if (this.type === "uuid") { - stream.writeUint8Array(this.uuid); - } - if (this.size > MAX_SIZE) { - stream.writeUint64(this.size); - } - }; - - BoxParser.FullBox.prototype.writeHeader = function(stream) { - this.size += 4; - BoxParser.Box.prototype.writeHeader.call(this, stream, " v="+this.version+" f="+this.flags); - stream.writeUint8(this.version); - stream.writeUint24(this.flags); - }; - - BoxParser.Box.prototype.write = function(stream) { - if (this.type === "mdat") { - /* TODO: fix this */ - if (this.data) { - this.size = this.data.length; - this.writeHeader(stream); - stream.writeUint8Array(this.data); - } - } else { - this.size = (this.data ? this.data.length : 0); - this.writeHeader(stream); - if (this.data) { - stream.writeUint8Array(this.data); - } - } - }; - - BoxParser.ContainerBox.prototype.write = function(stream) { - this.size = 0; - this.writeHeader(stream); - for (var i=0; i= 2) { - stream.writeUint32(this.default_sample_description_index); - } - stream.writeUint32(this.entries.length); - for (i = 0; i < this.entries.length; i++) { - entry = this.entries[i]; - if (this.version === 1) { - if (this.default_length === 0) { - stream.writeUint32(entry.description_length); - } - } - entry.write(stream); - } - }; - - - // file:src/writing/sidx.js - BoxParser.sidxBox.prototype.write = function(stream) { - this.version = 0; - this.flags = 0; - this.size = 4*4+2+2+12*this.references.length; - this.writeHeader(stream); - stream.writeUint32(this.reference_ID); - stream.writeUint32(this.timescale); - stream.writeUint32(this.earliest_presentation_time); - stream.writeUint32(this.first_offset); - stream.writeUint16(0); - stream.writeUint16(this.references.length); - for (var i = 0; i < this.references.length; i++) { - var ref = this.references[i]; - stream.writeUint32(ref.reference_type << 31 | ref.referenced_size); - stream.writeUint32(ref.subsegment_duration); - stream.writeUint32(ref.starts_with_SAP << 31 | ref.SAP_type << 28 | ref.SAP_delta_time); - } - }; - - // file:src/writing/smhd.js - BoxParser.smhdBox.prototype.write = function(stream) { - this.version = 0; - this.flags = 1; - this.size = 4; - this.writeHeader(stream); - stream.writeUint16(this.balance); - stream.writeUint16(0); - }; - // file:src/writing/stco.js - BoxParser.stcoBox.prototype.write = function(stream) { - this.version = 0; - this.flags = 0; - this.size = 4+4*this.chunk_offsets.length; - this.writeHeader(stream); - stream.writeUint32(this.chunk_offsets.length); - stream.writeUint32Array(this.chunk_offsets); - }; - - // file:src/writing/stsc.js - BoxParser.stscBox.prototype.write = function(stream) { - var i; - this.version = 0; - this.flags = 0; - this.size = 4+12*this.first_chunk.length; - this.writeHeader(stream); - stream.writeUint32(this.first_chunk.length); - for(i=0; i 0) { - i = 0; - while (i+1 < this.sample_sizes.length) { - if (this.sample_sizes[i+1] !== this.sample_sizes[0]) { - constant = false; - break; - } else { - i++; - } - } - } else { - constant = false; - } - this.size = 8; - if (!constant) { - this.size += 4*this.sample_sizes.length; - } - this.writeHeader(stream); - if (!constant) { - stream.writeUint32(0); - } else { - stream.writeUint32(this.sample_sizes[0]); - } - stream.writeUint32(this.sample_sizes.length); - if (!constant) { - stream.writeUint32Array(this.sample_sizes); - } - }; - - // file:src/writing/stts.js - BoxParser.sttsBox.prototype.write = function(stream) { - var i; - this.version = 0; - this.flags = 0; - this.size = 4+8*this.sample_counts.length; - this.writeHeader(stream); - stream.writeUint32(this.sample_counts.length); - for(i=0; i UINT32_MAX ? 1 : 0; - this.flags = 0; - this.size = 4; - if (this.version === 1) { - this.size += 4; - } - this.writeHeader(stream); - if (this.version === 1) { - stream.writeUint64(this.baseMediaDecodeTime); - } else { - stream.writeUint32(this.baseMediaDecodeTime); - } - }; - - // file:src/writing/tfhd.js - BoxParser.tfhdBox.prototype.write = function(stream) { - this.version = 0; - this.size = 4; - if (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { - this.size += 8; - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { - this.size += 4; - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { - this.size += 4; - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { - this.size += 4; - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { - this.size += 4; - } - this.writeHeader(stream); - stream.writeUint32(this.track_id); - if (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { - stream.writeUint64(this.base_data_offset); - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { - stream.writeUint32(this.default_sample_description_index); - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { - stream.writeUint32(this.default_sample_duration); - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { - stream.writeUint32(this.default_sample_size); - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { - stream.writeUint32(this.default_sample_flags); - } - }; - - // file:src/writing/tkhd.js - BoxParser.tkhdBox.prototype.write = function(stream) { - this.version = 0; - //this.flags = 0; - this.size = 4*18+2*4; - this.writeHeader(stream); - stream.writeUint32(this.creation_time); - stream.writeUint32(this.modification_time); - stream.writeUint32(this.track_id); - stream.writeUint32(0); - stream.writeUint32(this.duration); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeInt16(this.layer); - stream.writeInt16(this.alternate_group); - stream.writeInt16(this.volume<<8); - stream.writeUint16(0); - stream.writeInt32Array(this.matrix); - stream.writeUint32(this.width); - stream.writeUint32(this.height); - }; - - // file:src/writing/trex.js - BoxParser.trexBox.prototype.write = function(stream) { - this.version = 0; - this.flags = 0; - this.size = 4*5; - this.writeHeader(stream); - stream.writeUint32(this.track_id); - stream.writeUint32(this.default_sample_description_index); - stream.writeUint32(this.default_sample_duration); - stream.writeUint32(this.default_sample_size); - stream.writeUint32(this.default_sample_flags); - }; - - // file:src/writing/trun.js - BoxParser.trunBox.prototype.write = function(stream) { - this.version = 0; - this.size = 4; - if (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { - this.size += 4; - } - if (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { - this.size += 4; - } - if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { - this.size += 4*this.sample_duration.length; - } - if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { - this.size += 4*this.sample_size.length; - } - if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { - this.size += 4*this.sample_flags.length; - } - if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { - this.size += 4*this.sample_composition_time_offset.length; - } - this.writeHeader(stream); - stream.writeUint32(this.sample_count); - if (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { - this.data_offset_position = stream.getPosition(); - stream.writeInt32(this.data_offset); //signed - } - if (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { - stream.writeUint32(this.first_sample_flags); - } - for (var i = 0; i < this.sample_count; i++) { - if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { - stream.writeUint32(this.sample_duration[i]); - } - if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { - stream.writeUint32(this.sample_size[i]); - } - if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { - stream.writeUint32(this.sample_flags[i]); - } - if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { - if (this.version === 0) { - stream.writeUint32(this.sample_composition_time_offset[i]); - } else { - stream.writeInt32(this.sample_composition_time_offset[i]); //signed - } - } - } - }; - - // file:src/writing/url.js - BoxParser["url Box"].prototype.write = function(stream) { - this.version = 0; - if (this.location) { - this.flags = 0; - this.size = this.location.length+1; - } else { - this.flags = 0x000001; - this.size = 0; - } - this.writeHeader(stream); - if (this.location) { - stream.writeCString(this.location); - } - }; - - // file:src/writing/urn.js - BoxParser["urn Box"].prototype.write = function(stream) { - this.version = 0; - this.flags = 0; - this.size = this.name.length+1+(this.location ? this.location.length+1 : 0); - this.writeHeader(stream); - stream.writeCString(this.name); - if (this.location) { - stream.writeCString(this.location); - } - }; - - // file:src/writing/vmhd.js - BoxParser.vmhdBox.prototype.write = function(stream) { - this.version = 0; - this.flags = 1; - this.size = 8; - this.writeHeader(stream); - stream.writeUint16(this.graphicsmode); - stream.writeUint16Array(this.opcolor); - }; - - // file:src/box-unpack.js - /* - * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - BoxParser.cttsBox.prototype.unpack = function(samples) { - var i, j, k; - k = 0; - for (i = 0; i < this.sample_counts.length; i++) { - for (j = 0; j < this.sample_counts[i]; j++) { - samples[k].pts = samples[k].dts + this.sample_offsets[i]; - k++; - } - } - }; - - BoxParser.sttsBox.prototype.unpack = function(samples) { - var i, j, k; - k = 0; - for (i = 0; i < this.sample_counts.length; i++) { - for (j = 0; j < this.sample_counts[i]; j++) { - if (k === 0) { - samples[k].dts = 0; - } else { - samples[k].dts = samples[k-1].dts + this.sample_deltas[i]; - } - k++; - } - } - }; - - BoxParser.stcoBox.prototype.unpack = function(samples) { - var i; - for (i = 0; i < this.chunk_offsets.length; i++) { - samples[i].offset = this.chunk_offsets[i]; - } - }; - - BoxParser.stscBox.prototype.unpack = function(samples) { - var i, j, k, l, m; - l = 0; - m = 0; - for (i = 0; i < this.first_chunk.length; i++) { - for (j = 0; j < (i+1 < this.first_chunk.length ? this.first_chunk[i+1] : Infinity); j++) { - m++; - for (k = 0; k < this.samples_per_chunk[i]; k++) { - if (samples[l]) { - samples[l].description_index = this.sample_description_index[i]; - samples[l].chunk_index = m; - } else { - return; - } - l++; - } - } - } - }; - - BoxParser.stszBox.prototype.unpack = function(samples) { - var i; - for (i = 0; i < this.sample_sizes.length; i++) { - samples[i].size = this.sample_sizes[i]; - } - }; - // file:src/box-diff.js - - BoxParser.DIFF_BOXES_PROP_NAMES = [ "boxes", "entries", "references", "subsamples", - "items", "item_infos", "extents", "associations", - "subsegments", "ranges", "seekLists", "seekPoints", - "esd", "levels"]; - - BoxParser.DIFF_PRIMITIVE_ARRAY_PROP_NAMES = [ "compatible_brands", "matrix", "opcolor", "sample_counts", "sample_counts", "sample_deltas", - "first_chunk", "samples_per_chunk", "sample_sizes", "chunk_offsets", "sample_offsets", "sample_description_index", "sample_duration" ]; - - BoxParser.boxEqualFields = function(box_a, box_b) { - if (box_a && !box_b) return false; - var prop; - for (prop in box_a) { - if (BoxParser.DIFF_BOXES_PROP_NAMES.indexOf(prop) > -1) { - continue; - // } else if (excluded_fields && excluded_fields.indexOf(prop) > -1) { - // continue; - } else if (box_a[prop] instanceof BoxParser.Box || box_b[prop] instanceof BoxParser.Box) { - continue; - } else if (typeof box_a[prop] === "undefined" || typeof box_b[prop] === "undefined") { - continue; - } else if (typeof box_a[prop] === "function" || typeof box_b[prop] === "function") { - continue; - } else if ( - (box_a.subBoxNames && box_a.subBoxNames.indexOf(prop.slice(0,4)) > -1) || - (box_b.subBoxNames && box_b.subBoxNames.indexOf(prop.slice(0,4)) > -1)) { - continue; - } else { - if (prop === "data" || prop === "start" || prop === "size" || prop === "creation_time" || prop === "modification_time") { - continue; - } else if (BoxParser.DIFF_PRIMITIVE_ARRAY_PROP_NAMES.indexOf(prop) > -1) { - continue; - } else { - if (box_a[prop] !== box_b[prop]) { - return false; - } - } - } - } - return true; - }; - - BoxParser.boxEqual = function(box_a, box_b) { - if (!BoxParser.boxEqualFields(box_a, box_b)) { - return false; - } - for (var j = 0; j < BoxParser.DIFF_BOXES_PROP_NAMES.length; j++) { - var name = BoxParser.DIFF_BOXES_PROP_NAMES[j]; - if (box_a[name] && box_b[name]) { - if (!BoxParser.boxEqual(box_a[name], box_b[name])) { - return false; - } - } - } - return true; - };// file:src/text-mp4.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var VTTin4Parser = function() { - }; - - VTTin4Parser.prototype.parseSample = function(data) { - var cues, cue; - var stream = new MP4BoxStream(data.buffer); - cues = []; - while (!stream.isEos()) { - cue = BoxParser.parseOneBox(stream, false); - if (cue.code === BoxParser.OK && cue.box.type === "vttc") { - cues.push(cue.box); - } - } - return cues; - }; - - VTTin4Parser.prototype.getText = function (startTime, endTime, data) { - function pad(n, width, z) { - z = z || '0'; - n = n + ''; - return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n; - } - function secToTimestamp(insec) { - var h = Math.floor(insec/3600); - var m = Math.floor((insec - h*3600)/60); - var s = Math.floor(insec - h*3600 - m*60); - var ms = Math.floor((insec - h*3600 - m*60 - s)*1000); - return ""+pad(h, 2)+":"+pad(m,2)+":"+pad(s, 2)+"."+pad(ms, 3); - } - var cues = this.parseSample(data); - var string = ""; - for (var i = 0; i < cues.length; i++) { - var cueIn4 = cues[i]; - string += secToTimestamp(startTime)+" --> "+secToTimestamp(endTime)+"\r\n"; - string += cueIn4.payl.text; - } - return string; - }; - - var XMLSubtitlein4Parser = function() { - }; - - XMLSubtitlein4Parser.prototype.parseSample = function(sample) { - var res = {}; - var i; - res.resources = []; - var stream = new MP4BoxStream(sample.data.buffer); - if (!sample.subsamples || sample.subsamples.length === 0) { - res.documentString = stream.readString(sample.data.length); - } else { - res.documentString = stream.readString(sample.subsamples[0].size); - if (sample.subsamples.length > 1) { - for (i = 1; i < sample.subsamples.length; i++) { - res.resources[i] = stream.readUint8Array(sample.subsamples[i].size); - } - } - } - if (typeof (DOMParser) !== "undefined") { - res.document = (new DOMParser()).parseFromString(res.documentString, "application/xml"); - } - return res; - }; - - var Textin4Parser = function() { - }; - - Textin4Parser.prototype.parseSample = function(sample) { - var textString; - var stream = new MP4BoxStream(sample.data.buffer); - textString = stream.readString(sample.data.length); - return textString; - }; - - Textin4Parser.prototype.parseConfig = function(data) { - var textString; - var stream = new MP4BoxStream(data.buffer); - stream.readUint32(); // version & flags - textString = stream.readCString(); - return textString; - }; - - { - exports.VTTin4Parser = VTTin4Parser; - exports.XMLSubtitlein4Parser = XMLSubtitlein4Parser; - exports.Textin4Parser = Textin4Parser; - } - // file:src/isofile.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var ISOFile = function (stream) { - /* MutiBufferStream object used to parse boxes */ - this.stream = stream || new MultiBufferStream(); - /* Array of all boxes (in order) found in the file */ - this.boxes = []; - /* Array of all mdats */ - this.mdats = []; - /* Array of all moofs */ - this.moofs = []; - /* Boolean indicating if the file is compatible with progressive parsing (moov first) */ - this.isProgressive = false; - /* Boolean used to fire moov start event only once */ - this.moovStartFound = false; - /* Callback called when the moov parsing starts */ - this.onMoovStart = null; - /* Boolean keeping track of the call to onMoovStart, to avoid double calls */ - this.moovStartSent = false; - /* Callback called when the moov is entirely parsed */ - this.onReady = null; - /* Boolean keeping track of the call to onReady, to avoid double calls */ - this.readySent = false; - /* Callback to call when segments are ready */ - this.onSegment = null; - /* Callback to call when samples are ready */ - this.onSamples = null; - /* Callback to call when there is an error in the parsing or processing of samples */ - this.onError = null; - /* Boolean indicating if the moov box run-length encoded tables of sample information have been processed */ - this.sampleListBuilt = false; - /* Array of Track objects for which fragmentation of samples is requested */ - this.fragmentedTracks = []; - /* Array of Track objects for which extraction of samples is requested */ - this.extractedTracks = []; - /* Boolean indicating that fragmention is ready */ - this.isFragmentationInitialized = false; - /* Boolean indicating that fragmented has started */ - this.sampleProcessingStarted = false; - /* Number of the next 'moof' to generate when fragmenting */ - this.nextMoofNumber = 0; - /* Boolean indicating if the initial list of items has been produced */ - this.itemListBuilt = false; - /* Array of items */ - this.items = []; - /* Array of entity groups */ - this.entity_groups = []; - /* Callback called when the sidx box is entirely parsed */ - this.onSidx = null; - /* Boolean keeping track of the call to onSidx, to avoid double calls */ - this.sidxSent = false; - }; - - ISOFile.prototype.setSegmentOptions = function(id, user, options) { - var trak = this.getTrackById(id); - if (trak) { - var fragTrack = {}; - this.fragmentedTracks.push(fragTrack); - fragTrack.id = id; - fragTrack.user = user; - fragTrack.trak = trak; - trak.nextSample = 0; - fragTrack.segmentStream = null; - fragTrack.nb_samples = 1000; - fragTrack.rapAlignement = true; - if (options) { - if (options.nbSamples) fragTrack.nb_samples = options.nbSamples; - if (options.rapAlignement) fragTrack.rapAlignement = options.rapAlignement; - } - } - }; - - ISOFile.prototype.unsetSegmentOptions = function(id) { - var index = -1; - for (var i = 0; i < this.fragmentedTracks.length; i++) { - var fragTrack = this.fragmentedTracks[i]; - if (fragTrack.id == id) { - index = i; - } - } - if (index > -1) { - this.fragmentedTracks.splice(index, 1); - } - }; - - ISOFile.prototype.setExtractionOptions = function(id, user, options) { - var trak = this.getTrackById(id); - if (trak) { - var extractTrack = {}; - this.extractedTracks.push(extractTrack); - extractTrack.id = id; - extractTrack.user = user; - extractTrack.trak = trak; - trak.nextSample = 0; - extractTrack.nb_samples = 1000; - extractTrack.samples = []; - if (options) { - if (options.nbSamples) extractTrack.nb_samples = options.nbSamples; - } - } - }; - - ISOFile.prototype.unsetExtractionOptions = function(id) { - var index = -1; - for (var i = 0; i < this.extractedTracks.length; i++) { - var extractTrack = this.extractedTracks[i]; - if (extractTrack.id == id) { - index = i; - } - } - if (index > -1) { - this.extractedTracks.splice(index, 1); - } - }; - - ISOFile.prototype.parse = function() { - var ret; - var box; - var parseBoxHeadersOnly = false; - - if (this.restoreParsePosition) { - if (!this.restoreParsePosition()) { - return; - } - } - - while (true) { - - if (this.hasIncompleteMdat && this.hasIncompleteMdat()) { - if (this.processIncompleteMdat()) { - continue; - } else { - return; - } - } else { - if (this.saveParsePosition) { - this.saveParsePosition(); - } - ret = BoxParser.parseOneBox(this.stream, parseBoxHeadersOnly); - if (ret.code === BoxParser.ERR_NOT_ENOUGH_DATA) { - if (this.processIncompleteBox) { - if (this.processIncompleteBox(ret)) { - continue; - } else { - return; - } - } else { - return; - } - } else { - var box_type; - /* the box is entirely parsed */ - box = ret.box; - box_type = (box.type !== "uuid" ? box.type : box.uuid); - /* store the box in the 'boxes' array to preserve box order (for file rewrite if needed) */ - this.boxes.push(box); - /* but also store box in a property for more direct access */ - switch (box_type) { - case "mdat": - this.mdats.push(box); - break; - case "moof": - this.moofs.push(box); - break; - case "moov": - this.moovStartFound = true; - if (this.mdats.length === 0) { - this.isProgressive = true; - } - /* no break */ - /* falls through */ - default: - if (this[box_type] !== undefined) { - Log.warn("ISOFile", "Duplicate Box of type: "+box_type+", overriding previous occurrence"); - } - this[box_type] = box; - break; - } - if (this.updateUsedBytes) { - this.updateUsedBytes(box, ret); - } - } - } - } - }; - - ISOFile.prototype.checkBuffer = function (ab) { - if (ab === null || ab === undefined) { - throw("Buffer must be defined and non empty"); - } - if (ab.fileStart === undefined) { - throw("Buffer must have a fileStart property"); - } - if (ab.byteLength === 0) { - Log.warn("ISOFile", "Ignoring empty buffer (fileStart: "+ab.fileStart+")"); - this.stream.logBufferLevel(); - return false; - } - Log.info("ISOFile", "Processing buffer (fileStart: "+ab.fileStart+")"); - - /* mark the bytes in the buffer as not being used yet */ - ab.usedBytes = 0; - this.stream.insertBuffer(ab); - this.stream.logBufferLevel(); - - if (!this.stream.initialized()) { - Log.warn("ISOFile", "Not ready to start parsing"); - return false; - } - return true; - }; - - /* Processes a new ArrayBuffer (with a fileStart property) - Returns the next expected file position, or undefined if not ready to parse */ - ISOFile.prototype.appendBuffer = function(ab, last) { - var nextFileStart; - if (!this.checkBuffer(ab)) { - return; - } - - /* Parse whatever is in the existing buffers */ - this.parse(); - - /* Check if the moovStart callback needs to be called */ - if (this.moovStartFound && !this.moovStartSent) { - this.moovStartSent = true; - if (this.onMoovStart) this.onMoovStart(); - } - - if (this.moov) { - /* A moov box has been entirely parsed */ - - /* if this is the first call after the moov is found we initialize the list of samples (may be empty in fragmented files) */ - if (!this.sampleListBuilt) { - this.buildSampleLists(); - this.sampleListBuilt = true; - } - - /* We update the sample information if there are any new moof boxes */ - this.updateSampleLists(); - - /* If the application needs to be informed that the 'moov' has been found, - we create the information object and callback the application */ - if (this.onReady && !this.readySent) { - this.readySent = true; - this.onReady(this.getInfo()); - } - - /* See if any sample extraction or segment creation needs to be done with the available samples */ - this.processSamples(last); - - /* Inform about the best range to fetch next */ - if (this.nextSeekPosition) { - nextFileStart = this.nextSeekPosition; - this.nextSeekPosition = undefined; - } else { - nextFileStart = this.nextParsePosition; - } - if (this.stream.getEndFilePositionAfter) { - nextFileStart = this.stream.getEndFilePositionAfter(nextFileStart); - } - } else { - if (this.nextParsePosition) { - /* moov has not been parsed but the first buffer was received, - the next fetch should probably be the next box start */ - nextFileStart = this.nextParsePosition; - } else { - /* No valid buffer has been parsed yet, we cannot know what to parse next */ - nextFileStart = 0; - } - } - if (this.sidx) { - if (this.onSidx && !this.sidxSent) { - this.onSidx(this.sidx); - this.sidxSent = true; - } - } - if (this.meta) { - if (this.flattenItemInfo && !this.itemListBuilt) { - this.flattenItemInfo(); - this.itemListBuilt = true; - } - if (this.processItems) { - this.processItems(this.onItem); - } - } - - if (this.stream.cleanBuffers) { - Log.info("ISOFile", "Done processing buffer (fileStart: "+ab.fileStart+") - next buffer to fetch should have a fileStart position of "+nextFileStart); - this.stream.logBufferLevel(); - this.stream.cleanBuffers(); - this.stream.logBufferLevel(true); - Log.info("ISOFile", "Sample data size in memory: "+this.getAllocatedSampleDataSize()); - } - return nextFileStart; - }; - - ISOFile.prototype.getInfo = function() { - var i, j; - var movie = {}; - var trak; - var track; - var ref; - var sample_desc; - var _1904 = (new Date('1904-01-01T00:00:00Z').getTime()); - - if (this.moov) { - movie.hasMoov = true; - movie.duration = this.moov.mvhd.duration; - movie.timescale = this.moov.mvhd.timescale; - movie.isFragmented = (this.moov.mvex != null); - if (movie.isFragmented && this.moov.mvex.mehd) { - movie.fragment_duration = this.moov.mvex.mehd.fragment_duration; - } - movie.isProgressive = this.isProgressive; - movie.hasIOD = (this.moov.iods != null); - movie.brands = []; - movie.brands.push(this.ftyp.major_brand); - movie.brands = movie.brands.concat(this.ftyp.compatible_brands); - movie.created = new Date(_1904+this.moov.mvhd.creation_time*1000); - movie.modified = new Date(_1904+this.moov.mvhd.modification_time*1000); - movie.tracks = []; - movie.audioTracks = []; - movie.videoTracks = []; - movie.subtitleTracks = []; - movie.metadataTracks = []; - movie.hintTracks = []; - movie.otherTracks = []; - for (i = 0; i < this.moov.traks.length; i++) { - trak = this.moov.traks[i]; - sample_desc = trak.mdia.minf.stbl.stsd.entries[0]; - track = {}; - movie.tracks.push(track); - track.id = trak.tkhd.track_id; - track.name = trak.mdia.hdlr.name; - track.references = []; - if (trak.tref) { - for (j = 0; j < trak.tref.boxes.length; j++) { - ref = {}; - track.references.push(ref); - ref.type = trak.tref.boxes[j].type; - ref.track_ids = trak.tref.boxes[j].track_ids; - } - } - if (trak.edts) { - track.edits = trak.edts.elst.entries; - } - track.created = new Date(_1904+trak.tkhd.creation_time*1000); - track.modified = new Date(_1904+trak.tkhd.modification_time*1000); - track.movie_duration = trak.tkhd.duration; - track.movie_timescale = movie.timescale; - track.layer = trak.tkhd.layer; - track.alternate_group = trak.tkhd.alternate_group; - track.volume = trak.tkhd.volume; - track.matrix = trak.tkhd.matrix; - track.track_width = trak.tkhd.width/(1<<16); - track.track_height = trak.tkhd.height/(1<<16); - track.timescale = trak.mdia.mdhd.timescale; - track.cts_shift = trak.mdia.minf.stbl.cslg; - track.duration = trak.mdia.mdhd.duration; - track.samples_duration = trak.samples_duration; - track.codec = sample_desc.getCodec(); - track.kind = (trak.udta && trak.udta.kinds.length ? trak.udta.kinds[0] : { schemeURI: "", value: ""}); - track.language = (trak.mdia.elng ? trak.mdia.elng.extended_language : trak.mdia.mdhd.languageString); - track.nb_samples = trak.samples.length; - track.size = trak.samples_size; - track.bitrate = (track.size*8*track.timescale)/track.samples_duration; - if (sample_desc.isAudio()) { - track.type = "audio"; - movie.audioTracks.push(track); - track.audio = {}; - track.audio.sample_rate = sample_desc.getSampleRate(); - track.audio.channel_count = sample_desc.getChannelCount(); - track.audio.sample_size = sample_desc.getSampleSize(); - } else if (sample_desc.isVideo()) { - track.type = "video"; - movie.videoTracks.push(track); - track.video = {}; - track.video.width = sample_desc.getWidth(); - track.video.height = sample_desc.getHeight(); - } else if (sample_desc.isSubtitle()) { - track.type = "subtitles"; - movie.subtitleTracks.push(track); - } else if (sample_desc.isHint()) { - track.type = "metadata"; - movie.hintTracks.push(track); - } else if (sample_desc.isMetadata()) { - track.type = "metadata"; - movie.metadataTracks.push(track); - } else { - track.type = "metadata"; - movie.otherTracks.push(track); - } - } - } else { - movie.hasMoov = false; - } - movie.mime = ""; - if (movie.hasMoov && movie.tracks) { - if (movie.videoTracks && movie.videoTracks.length > 0) { - movie.mime += 'video/mp4; codecs=\"'; - } else if (movie.audioTracks && movie.audioTracks.length > 0) { - movie.mime += 'audio/mp4; codecs=\"'; - } else { - movie.mime += 'application/mp4; codecs=\"'; - } - for (i = 0; i < movie.tracks.length; i++) { - if (i !== 0) movie.mime += ','; - movie.mime+= movie.tracks[i].codec; - } - movie.mime += '\"; profiles=\"'; - movie.mime += this.ftyp.compatible_brands.join(); - movie.mime += '\"'; - } - return movie; - }; - - ISOFile.prototype.setNextSeekPositionFromSample = function (sample) { - if (!sample) { - return; - } - if (this.nextSeekPosition) { - this.nextSeekPosition = Math.min(sample.offset+sample.alreadyRead,this.nextSeekPosition); - } else { - this.nextSeekPosition = sample.offset+sample.alreadyRead; - } - }; - - ISOFile.prototype.processSamples = function(last) { - var i; - var trak; - if (!this.sampleProcessingStarted) return; - - /* For each track marked for fragmentation, - check if the next sample is there (i.e. if the sample information is known (i.e. moof has arrived) and if it has been downloaded) - and create a fragment with it */ - if (this.isFragmentationInitialized && this.onSegment !== null) { - for (i = 0; i < this.fragmentedTracks.length; i++) { - var fragTrak = this.fragmentedTracks[i]; - trak = fragTrak.trak; - while (trak.nextSample < trak.samples.length && this.sampleProcessingStarted) { - /* The sample information is there (either because the file is not fragmented and this is not the last sample, - or because the file is fragmented and the moof for that sample has been received */ - Log.debug("ISOFile", "Creating media fragment on track #"+fragTrak.id +" for sample "+trak.nextSample); - var result = this.createFragment(fragTrak.id, trak.nextSample, fragTrak.segmentStream); - if (result) { - fragTrak.segmentStream = result; - trak.nextSample++; - } else { - /* The fragment could not be created because the media data is not there (not downloaded), wait for it */ - break; - } - /* A fragment is created by sample, but the segment is the accumulation in the buffer of these fragments. - It is flushed only as requested by the application (nb_samples) to avoid too many callbacks */ - if (trak.nextSample % fragTrak.nb_samples === 0 || (last || trak.nextSample >= trak.samples.length)) { - Log.info("ISOFile", "Sending fragmented data on track #"+fragTrak.id+" for samples ["+Math.max(0,trak.nextSample-fragTrak.nb_samples)+","+(trak.nextSample-1)+"]"); - Log.info("ISOFile", "Sample data size in memory: "+this.getAllocatedSampleDataSize()); - if (this.onSegment) { - this.onSegment(fragTrak.id, fragTrak.user, fragTrak.segmentStream.buffer, trak.nextSample, (last || trak.nextSample >= trak.samples.length)); - } - /* force the creation of a new buffer */ - fragTrak.segmentStream = null; - if (fragTrak !== this.fragmentedTracks[i]) { - /* make sure we can stop fragmentation if needed */ - break; - } - } - } - } - } - - if (this.onSamples !== null) { - /* For each track marked for data export, - check if the next sample is there (i.e. has been downloaded) and send it */ - for (i = 0; i < this.extractedTracks.length; i++) { - var extractTrak = this.extractedTracks[i]; - trak = extractTrak.trak; - while (trak.nextSample < trak.samples.length && this.sampleProcessingStarted) { - Log.debug("ISOFile", "Exporting on track #"+extractTrak.id +" sample #"+trak.nextSample); - var sample = this.getSample(trak, trak.nextSample); - if (sample) { - trak.nextSample++; - extractTrak.samples.push(sample); - } else { - this.setNextSeekPositionFromSample(trak.samples[trak.nextSample]); - break; - } - if (trak.nextSample % extractTrak.nb_samples === 0 || trak.nextSample >= trak.samples.length) { - Log.debug("ISOFile", "Sending samples on track #"+extractTrak.id+" for sample "+trak.nextSample); - if (this.onSamples) { - this.onSamples(extractTrak.id, extractTrak.user, extractTrak.samples); - } - extractTrak.samples = []; - if (extractTrak !== this.extractedTracks[i]) { - /* check if the extraction needs to be stopped */ - break; - } - } - } - } - } - }; - - /* Find and return specific boxes using recursion and early return */ - ISOFile.prototype.getBox = function(type) { - var result = this.getBoxes(type, true); - return (result.length ? result[0] : null); - }; - - ISOFile.prototype.getBoxes = function(type, returnEarly) { - var result = []; - ISOFile._sweep.call(this, type, result, returnEarly); - return result; - }; - - ISOFile._sweep = function(type, result, returnEarly) { - if (this.type && this.type == type) result.push(this); - for (var box in this.boxes) { - if (result.length && returnEarly) return; - ISOFile._sweep.call(this.boxes[box], type, result, returnEarly); - } - }; - - ISOFile.prototype.getTrackSamplesInfo = function(track_id) { - var track = this.getTrackById(track_id); - if (track) { - return track.samples; - } else { - return; - } - }; - - ISOFile.prototype.getTrackSample = function(track_id, number) { - var track = this.getTrackById(track_id); - var sample = this.getSample(track, number); - return sample; - }; - - /* Called by the application to release the resources associated to samples already forwarded to the application */ - ISOFile.prototype.releaseUsedSamples = function (id, sampleNum) { - var size = 0; - var trak = this.getTrackById(id); - if (!trak.lastValidSample) trak.lastValidSample = 0; - for (var i = trak.lastValidSample; i < sampleNum; i++) { - size+=this.releaseSample(trak, i); - } - Log.info("ISOFile", "Track #"+id+" released samples up to "+sampleNum+" (released size: "+size+", remaining: "+this.samplesDataSize+")"); - trak.lastValidSample = sampleNum; - }; - - ISOFile.prototype.start = function() { - this.sampleProcessingStarted = true; - this.processSamples(false); - }; - - ISOFile.prototype.stop = function() { - this.sampleProcessingStarted = false; - }; - - /* Called by the application to flush the remaining samples (e.g. once the download is finished or when no more samples will be added) */ - ISOFile.prototype.flush = function() { - Log.info("ISOFile", "Flushing remaining samples"); - this.updateSampleLists(); - this.processSamples(true); - this.stream.cleanBuffers(); - this.stream.logBufferLevel(true); - }; - - /* Finds the byte offset for a given time on a given track - also returns the time of the previous rap */ - ISOFile.prototype.seekTrack = function(time, useRap, trak) { - var j; - var sample; - var seek_offset = Infinity; - var rap_seek_sample_num = 0; - var seek_sample_num = 0; - var timescale; - - if (trak.samples.length === 0) { - Log.info("ISOFile", "No sample in track, cannot seek! Using time "+Log.getDurationString(0, 1) +" and offset: "+0); - return { offset: 0, time: 0 }; - } - - for (j = 0; j < trak.samples.length; j++) { - sample = trak.samples[j]; - if (j === 0) { - seek_sample_num = 0; - timescale = sample.timescale; - } else if (sample.cts > time * sample.timescale) { - seek_sample_num = j-1; - break; - } - if (useRap && sample.is_sync) { - rap_seek_sample_num = j; - } - } - if (useRap) { - seek_sample_num = rap_seek_sample_num; - } - time = trak.samples[seek_sample_num].cts; - trak.nextSample = seek_sample_num; - while (trak.samples[seek_sample_num].alreadyRead === trak.samples[seek_sample_num].size) { - // No remaining samples to look for, all are downloaded. - if (!trak.samples[seek_sample_num + 1]) { - break; - } - seek_sample_num++; - } - seek_offset = trak.samples[seek_sample_num].offset+trak.samples[seek_sample_num].alreadyRead; - Log.info("ISOFile", "Seeking to "+(useRap ? "RAP": "")+" sample #"+trak.nextSample+" on track "+trak.tkhd.track_id+", time "+Log.getDurationString(time, timescale) +" and offset: "+seek_offset); - return { offset: seek_offset, time: time/timescale }; - }; - - ISOFile.prototype.getTrackDuration = function (trak) { - var sample; - - if (!trak.samples) { - return Infinity; - } - sample = trak.samples[trak.samples.length - 1]; - return (sample.cts + sample.duration) / sample.timescale; - }; - - /* Finds the byte offset in the file corresponding to the given time or to the time of the previous RAP */ - ISOFile.prototype.seek = function(time, useRap) { - var moov = this.moov; - var trak; - var trak_seek_info; - var i; - var seek_info = { offset: Infinity, time: Infinity }; - if (!this.moov) { - throw "Cannot seek: moov not received!"; - } else { - for (i = 0; i this.getTrackDuration(trak)) { // skip tracks that already ended - continue; - } - trak_seek_info = this.seekTrack(time, useRap, trak); - if (trak_seek_info.offset < seek_info.offset) { - seek_info.offset = trak_seek_info.offset; - } - if (trak_seek_info.time < seek_info.time) { - seek_info.time = trak_seek_info.time; - } - } - Log.info("ISOFile", "Seeking at time "+Log.getDurationString(seek_info.time, 1)+" needs a buffer with a fileStart position of "+seek_info.offset); - if (seek_info.offset === Infinity) { - /* No sample info, in all tracks, cannot seek */ - seek_info = { offset: this.nextParsePosition, time: 0 }; - } else { - /* check if the seek position is already in some buffer and - in that case return the end of that buffer (or of the last contiguous buffer) */ - /* TODO: Should wait until append operations are done */ - seek_info.offset = this.stream.getEndFilePositionAfter(seek_info.offset); - } - Log.info("ISOFile", "Adjusted seek position (after checking data already in buffer): "+seek_info.offset); - return seek_info; - } - }; - - ISOFile.prototype.equal = function(b) { - var box_index = 0; - while (box_index < this.boxes.length && box_index < b.boxes.length) { - var a_box = this.boxes[box_index]; - var b_box = b.boxes[box_index]; - if (!BoxParser.boxEqual(a_box, b_box)) { - return false; - } - box_index++; - } - return true; - }; - - { - exports.ISOFile = ISOFile; - } - // file:src/isofile-advanced-parsing.js - /* position in the current buffer of the beginning of the last box parsed */ - ISOFile.prototype.lastBoxStartPosition = 0; - /* indicator if the parsing is stuck in the middle of an mdat box */ - ISOFile.prototype.parsingMdat = null; - /* next file position that the parser needs: - - 0 until the first buffer (i.e. fileStart ===0) has been received - - otherwise, the next box start until the moov box has been parsed - - otherwise, the position of the next sample to fetch - */ - ISOFile.prototype.nextParsePosition = 0; - /* keep mdat data */ - ISOFile.prototype.discardMdatData = false; - - ISOFile.prototype.processIncompleteBox = function(ret) { - var box; - var merged; - var found; - - /* we did not have enough bytes in the current buffer to parse the entire box */ - if (ret.type === "mdat") { - /* we had enough bytes to get its type and size and it's an 'mdat' */ - - /* special handling for mdat boxes, since we don't actually need to parse it linearly - we create the box */ - box = new BoxParser[ret.type+"Box"](ret.size); - this.parsingMdat = box; - this.boxes.push(box); - this.mdats.push(box); - box.start = ret.start; - box.hdr_size = ret.hdr_size; - this.stream.addUsedBytes(box.hdr_size); - - /* indicate that the parsing should start from the end of the box */ - this.lastBoxStartPosition = box.start + box.size; - /* let's see if we have the end of the box in the other buffers */ - found = this.stream.seek(box.start + box.size, false, this.discardMdatData); - if (found) { - /* found the end of the box */ - this.parsingMdat = null; - /* let's see if we can parse more in this buffer */ - return true; - } else { - /* 'mdat' end not found in the existing buffers */ - /* determine the next position in the file to start parsing from */ - if (!this.moovStartFound) { - /* moov not find yet, - the file probably has 'mdat' at the beginning, and 'moov' at the end, - indicate that the downloader should not try to download those bytes now */ - this.nextParsePosition = box.start + box.size; - } else { - /* we have the start of the moov box, - the next bytes should try to complete the current 'mdat' */ - this.nextParsePosition = this.stream.findEndContiguousBuf(); - } - /* not much we can do, wait for more buffers to arrive */ - return false; - } - } else { - /* box is incomplete, we may not even know its type */ - if (ret.type === "moov") { - /* the incomplete box is a 'moov' box */ - this.moovStartFound = true; - if (this.mdats.length === 0) { - this.isProgressive = true; - } - } - /* either it's not an mdat box (and we need to parse it, we cannot skip it) - (TODO: we could skip 'free' boxes ...) - or we did not have enough data to parse the type and size of the box, - we try to concatenate the current buffer with the next buffer to restart parsing */ - merged = (this.stream.mergeNextBuffer ? this.stream.mergeNextBuffer() : false); - if (merged) { - /* The next buffer was contiguous, the merging succeeded, - we can now continue parsing, - the next best position to parse is at the end of this new buffer */ - this.nextParsePosition = this.stream.getEndPosition(); - return true; - } else { - /* we cannot concatenate existing buffers because they are not contiguous or because there is no additional buffer */ - /* The next best position to parse is still at the end of this old buffer */ - if (!ret.type) { - /* There were not enough bytes in the buffer to parse the box type and length, - the next fetch should retrieve those missing bytes, i.e. the next bytes after this buffer */ - this.nextParsePosition = this.stream.getEndPosition(); - } else { - /* we had enough bytes to parse size and type of the incomplete box - if we haven't found yet the moov box, skip this one and try the next one - if we have found the moov box, let's continue linear parsing */ - if (this.moovStartFound) { - this.nextParsePosition = this.stream.getEndPosition(); - } else { - this.nextParsePosition = this.stream.getPosition() + ret.size; - } - } - return false; - } - } - }; - - ISOFile.prototype.hasIncompleteMdat = function () { - return (this.parsingMdat !== null); - }; - - ISOFile.prototype.processIncompleteMdat = function () { - var box; - var found; - - /* we are in the parsing of an incomplete mdat box */ - box = this.parsingMdat; - - found = this.stream.seek(box.start + box.size, false, this.discardMdatData); - if (found) { - Log.debug("ISOFile", "Found 'mdat' end in buffered data"); - /* the end of the mdat has been found */ - this.parsingMdat = null; - /* we can parse more in this buffer */ - return true; - } else { - /* we don't have the end of this mdat yet, - indicate that the next byte to fetch is the end of the buffers we have so far, - return and wait for more buffer to come */ - this.nextParsePosition = this.stream.findEndContiguousBuf(); - return false; - } - }; - - ISOFile.prototype.restoreParsePosition = function() { - /* Reposition at the start position of the previous box not entirely parsed */ - return this.stream.seek(this.lastBoxStartPosition, true, this.discardMdatData); - }; - - ISOFile.prototype.saveParsePosition = function() { - /* remember the position of the box start in case we need to roll back (if the box is incomplete) */ - this.lastBoxStartPosition = this.stream.getPosition(); - }; - - ISOFile.prototype.updateUsedBytes = function(box, ret) { - if (this.stream.addUsedBytes) { - if (box.type === "mdat") { - /* for an mdat box, only its header is considered used, other bytes will be used when sample data is requested */ - this.stream.addUsedBytes(box.hdr_size); - if (this.discardMdatData) { - this.stream.addUsedBytes(box.size-box.hdr_size); - } - } else { - /* for all other boxes, the entire box data is considered used */ - this.stream.addUsedBytes(box.size); - } - } - }; - // file:src/isofile-advanced-creation.js - ISOFile.prototype.add = BoxParser.Box.prototype.add; - ISOFile.prototype.addBox = BoxParser.Box.prototype.addBox; - - ISOFile.prototype.init = function (_options) { - var options = _options || {}; - this.add("ftyp").set("major_brand", (options.brands && options.brands[0]) || "iso4") - .set("minor_version", 0) - .set("compatible_brands", options.brands || ["iso4"]); - var moov = this.add("moov"); - moov.add("mvhd").set("timescale", options.timescale || 600) - .set("rate", options.rate || 1<<16) - .set("creation_time", 0) - .set("modification_time", 0) - .set("duration", options.duration || 0) - .set("volume", (options.width) ? 0 : 0x0100) - .set("matrix", [ 1<<16, 0, 0, 0, 1<<16, 0, 0, 0, 0x40000000]) - .set("next_track_id", 1); - moov.add("mvex"); - return this; - }; - - ISOFile.prototype.addTrack = function (_options) { - if (!this.moov) { - this.init(_options); - } - - var options = _options || {}; - options.width = options.width || 320; - options.height = options.height || 320; - options.id = options.id || this.moov.mvhd.next_track_id; - options.type = options.type || "avc1"; - - var trak = this.moov.add("trak"); - this.moov.mvhd.next_track_id = options.id+1; - trak.add("tkhd").set("flags",BoxParser.TKHD_FLAG_ENABLED | - BoxParser.TKHD_FLAG_IN_MOVIE | - BoxParser.TKHD_FLAG_IN_PREVIEW) - .set("creation_time",0) - .set("modification_time", 0) - .set("track_id", options.id) - .set("duration", options.duration || 0) - .set("layer", options.layer || 0) - .set("alternate_group", 0) - .set("volume", 1) - .set("matrix", [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) - .set("width", options.width << 16) - .set("height", options.height << 16); - - var mdia = trak.add("mdia"); - mdia.add("mdhd").set("creation_time", 0) - .set("modification_time", 0) - .set("timescale", options.timescale || 1) - .set("duration", options.media_duration || 0) - .set("language", options.language || "und"); - - mdia.add("hdlr").set("handler", options.hdlr || "vide") - .set("name", options.name || "Track created with MP4Box.js"); - - mdia.add("elng").set("extended_language", options.language || "fr-FR"); - - var minf = mdia.add("minf"); - if (BoxParser[options.type+"SampleEntry"] === undefined) return; - var sample_description_entry = new BoxParser[options.type+"SampleEntry"](); - sample_description_entry.data_reference_index = 1; - var media_type = ""; - for (var mediaType in BoxParser.sampleEntryCodes) { - var codes = BoxParser.sampleEntryCodes[mediaType]; - for (var i = 0; i < codes.length; i++) { - if (codes.indexOf(options.type) > -1) { - media_type = mediaType; - break; - } - } - } - switch(media_type) { - case "Visual": - minf.add("vmhd").set("graphicsmode",0).set("opcolor", [ 0, 0, 0 ]); - sample_description_entry.set("width", options.width) - .set("height", options.height) - .set("horizresolution", 0x48<<16) - .set("vertresolution", 0x48<<16) - .set("frame_count", 1) - .set("compressorname", options.type+" Compressor") - .set("depth", 0x18); - if (options.avcDecoderConfigRecord) { - var avcC = new BoxParser.avcCBox(); - avcC.parse(new MP4BoxStream(options.avcDecoderConfigRecord)); - sample_description_entry.addBox(avcC); - } else if (options.hevcDecoderConfigRecord) { - var hvcC = new BoxParser.hvcCBox(); - hvcC.parse(new MP4BoxStream(options.hevcDecoderConfigRecord)); - sample_description_entry.addBox(hvcC); - } - break; - case "Audio": - minf.add("smhd").set("balance", options.balance || 0); - sample_description_entry.set("channel_count", options.channel_count || 2) - .set("samplesize", options.samplesize || 16) - .set("samplerate", options.samplerate || 1<<16); - break; - case "Hint": - minf.add("hmhd"); // TODO: add properties - break; - case "Subtitle": - minf.add("sthd"); - switch (options.type) { - case "stpp": - sample_description_entry.set("namespace", options.namespace || "nonamespace") - .set("schema_location", options.schema_location || "") - .set("auxiliary_mime_types", options.auxiliary_mime_types || ""); - break; - } - break; - case "Metadata": - minf.add("nmhd"); - break; - case "System": - minf.add("nmhd"); - break; - default: - minf.add("nmhd"); - break; - } - if (options.description) { - sample_description_entry.addBox(options.description); - } - if (options.description_boxes) { - options.description_boxes.forEach(function (b) { - sample_description_entry.addBox(b); - }); - } - minf.add("dinf").add("dref").addEntry((new BoxParser["url Box"]()).set("flags", 0x1)); - var stbl = minf.add("stbl"); - stbl.add("stsd").addEntry(sample_description_entry); - stbl.add("stts").set("sample_counts", []) - .set("sample_deltas", []); - stbl.add("stsc").set("first_chunk", []) - .set("samples_per_chunk", []) - .set("sample_description_index", []); - stbl.add("stco").set("chunk_offsets", []); - stbl.add("stsz").set("sample_sizes", []); - - this.moov.mvex.add("trex").set("track_id", options.id) - .set("default_sample_description_index", options.default_sample_description_index || 1) - .set("default_sample_duration", options.default_sample_duration || 0) - .set("default_sample_size", options.default_sample_size || 0) - .set("default_sample_flags", options.default_sample_flags || 0); - this.buildTrakSampleLists(trak); - return options.id; - }; - - BoxParser.Box.prototype.computeSize = function(stream_) { - var stream = stream_ || new DataStream(); - stream.endianness = DataStream.BIG_ENDIAN; - this.write(stream); - }; - - ISOFile.prototype.addSample = function (track_id, data, _options) { - var options = _options || {}; - var sample = {}; - var trak = this.getTrackById(track_id); - if (trak === null) return; - sample.number = trak.samples.length; - sample.track_id = trak.tkhd.track_id; - sample.timescale = trak.mdia.mdhd.timescale; - sample.description_index = (options.sample_description_index ? options.sample_description_index - 1: 0); - sample.description = trak.mdia.minf.stbl.stsd.entries[sample.description_index]; - sample.data = data; - sample.size = data.byteLength; - sample.alreadyRead = sample.size; - sample.duration = options.duration || 1; - sample.cts = options.cts || 0; - sample.dts = options.dts || 0; - sample.is_sync = options.is_sync || false; - sample.is_leading = options.is_leading || 0; - sample.depends_on = options.depends_on || 0; - sample.is_depended_on = options.is_depended_on || 0; - sample.has_redundancy = options.has_redundancy || 0; - sample.degradation_priority = options.degradation_priority || 0; - sample.offset = 0; - sample.subsamples = options.subsamples; - trak.samples.push(sample); - trak.samples_size += sample.size; - trak.samples_duration += sample.duration; - if (trak.first_dts === undefined) { - trak.first_dts = options.dts; - } - - this.processSamples(); - - var moof = this.createSingleSampleMoof(sample); - this.addBox(moof); - moof.computeSize(); - /* adjusting the data_offset now that the moof size is known*/ - moof.trafs[0].truns[0].data_offset = moof.size+8; //8 is mdat header - this.add("mdat").data = new Uint8Array(data); - return sample; - }; - - ISOFile.prototype.createSingleSampleMoof = function(sample) { - var sample_flags = 0; - if (sample.is_sync) - sample_flags = (1 << 25); // sample_depends_on_none (I picture) - else - sample_flags = (1 << 16); // non-sync - - var moof = new BoxParser.moofBox(); - moof.add("mfhd").set("sequence_number", this.nextMoofNumber); - this.nextMoofNumber++; - var traf = moof.add("traf"); - var trak = this.getTrackById(sample.track_id); - traf.add("tfhd").set("track_id", sample.track_id) - .set("flags", BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF); - traf.add("tfdt").set("baseMediaDecodeTime", (sample.dts - (trak.first_dts || 0))); - traf.add("trun").set("flags", BoxParser.TRUN_FLAGS_DATA_OFFSET | BoxParser.TRUN_FLAGS_DURATION | - BoxParser.TRUN_FLAGS_SIZE | BoxParser.TRUN_FLAGS_FLAGS | - BoxParser.TRUN_FLAGS_CTS_OFFSET) - .set("data_offset",0) - .set("first_sample_flags",0) - .set("sample_count",1) - .set("sample_duration",[sample.duration]) - .set("sample_size",[sample.size]) - .set("sample_flags",[sample_flags]) - .set("sample_composition_time_offset", [sample.cts - sample.dts]); - return moof; - }; - - // file:src/isofile-sample-processing.js - /* Index of the last moof box received */ - ISOFile.prototype.lastMoofIndex = 0; - - /* size of the buffers allocated for samples */ - ISOFile.prototype.samplesDataSize = 0; - - /* Resets all sample tables */ - ISOFile.prototype.resetTables = function () { - var i; - var trak, stco, stsc, stsz, stts, ctts, stss; - this.initial_duration = this.moov.mvhd.duration; - this.moov.mvhd.duration = 0; - for (i = 0; i < this.moov.traks.length; i++) { - trak = this.moov.traks[i]; - trak.tkhd.duration = 0; - trak.mdia.mdhd.duration = 0; - stco = trak.mdia.minf.stbl.stco || trak.mdia.minf.stbl.co64; - stco.chunk_offsets = []; - stsc = trak.mdia.minf.stbl.stsc; - stsc.first_chunk = []; - stsc.samples_per_chunk = []; - stsc.sample_description_index = []; - stsz = trak.mdia.minf.stbl.stsz || trak.mdia.minf.stbl.stz2; - stsz.sample_sizes = []; - stts = trak.mdia.minf.stbl.stts; - stts.sample_counts = []; - stts.sample_deltas = []; - ctts = trak.mdia.minf.stbl.ctts; - if (ctts) { - ctts.sample_counts = []; - ctts.sample_offsets = []; - } - stss = trak.mdia.minf.stbl.stss; - var k = trak.mdia.minf.stbl.boxes.indexOf(stss); - if (k != -1) trak.mdia.minf.stbl.boxes[k] = null; - } - }; - - ISOFile.initSampleGroups = function(trak, traf, sbgps, trak_sgpds, traf_sgpds) { - var l; - var k; - var sample_group_info; - var sample_group_key; - function SampleGroupInfo(_type, _parameter, _sbgp) { - this.grouping_type = _type; - this.grouping_type_parameter = _parameter; - this.sbgp = _sbgp; - this.last_sample_in_run = -1; - this.entry_index = -1; - } - if (traf) { - traf.sample_groups_info = []; - } - if (!trak.sample_groups_info) { - trak.sample_groups_info = []; - } - for (k = 0; k < sbgps.length; k++) { - sample_group_key = sbgps[k].grouping_type +"/"+ sbgps[k].grouping_type_parameter; - sample_group_info = new SampleGroupInfo(sbgps[k].grouping_type, sbgps[k].grouping_type_parameter, sbgps[k]); - if (traf) { - traf.sample_groups_info[sample_group_key] = sample_group_info; - } - if (!trak.sample_groups_info[sample_group_key]) { - trak.sample_groups_info[sample_group_key] = sample_group_info; - } - for (l=0; l = 2) { - sample_group_key = trak_sgpds[k].grouping_type +"/0"; - sample_group_info = new SampleGroupInfo(trak_sgpds[k].grouping_type, 0); - if (!trak.sample_groups_info[sample_group_key]) { - trak.sample_groups_info[sample_group_key] = sample_group_info; - } - } - } - } else { - if (traf_sgpds) { - for (k = 0; k < traf_sgpds.length; k++) { - if (!traf_sgpds[k].used && traf_sgpds[k].version >= 2) { - sample_group_key = traf_sgpds[k].grouping_type +"/0"; - sample_group_info = new SampleGroupInfo(traf_sgpds[k].grouping_type, 0); - sample_group_info.is_fragment = true; - if (!traf.sample_groups_info[sample_group_key]) { - traf.sample_groups_info[sample_group_key] = sample_group_info; - } - } - } - } - } - }; - - ISOFile.setSampleGroupProperties = function(trak, sample, sample_number, sample_groups_info) { - var k; - var index; - sample.sample_groups = []; - for (k in sample_groups_info) { - sample.sample_groups[k] = {}; - sample.sample_groups[k].grouping_type = sample_groups_info[k].grouping_type; - sample.sample_groups[k].grouping_type_parameter = sample_groups_info[k].grouping_type_parameter; - if (sample_number >= sample_groups_info[k].last_sample_in_run) { - if (sample_groups_info[k].last_sample_in_run < 0) { - sample_groups_info[k].last_sample_in_run = 0; - } - sample_groups_info[k].entry_index++; - if (sample_groups_info[k].entry_index <= sample_groups_info[k].sbgp.entries.length - 1) { - sample_groups_info[k].last_sample_in_run += sample_groups_info[k].sbgp.entries[sample_groups_info[k].entry_index].sample_count; - } - } - if (sample_groups_info[k].entry_index <= sample_groups_info[k].sbgp.entries.length - 1) { - sample.sample_groups[k].group_description_index = sample_groups_info[k].sbgp.entries[sample_groups_info[k].entry_index].group_description_index; - } else { - sample.sample_groups[k].group_description_index = -1; // special value for not defined - } - if (sample.sample_groups[k].group_description_index !== 0) { - var description; - if (sample_groups_info[k].fragment_description) { - description = sample_groups_info[k].fragment_description; - } else { - description = sample_groups_info[k].description; - } - if (sample.sample_groups[k].group_description_index > 0) { - if (sample.sample_groups[k].group_description_index > 65535) { - index = (sample.sample_groups[k].group_description_index >> 16)-1; - } else { - index = sample.sample_groups[k].group_description_index-1; - } - if (description && index >= 0) { - sample.sample_groups[k].description = description.entries[index]; - } - } else { - if (description && description.version >= 2) { - if (description.default_group_description_index > 0) { - sample.sample_groups[k].description = description.entries[description.default_group_description_index-1]; - } - } - } - } - } - }; - - ISOFile.process_sdtp = function (sdtp, sample, number) { - if (!sample) { - return; - } - if (sdtp) { - sample.is_leading = sdtp.is_leading[number]; - sample.depends_on = sdtp.sample_depends_on[number]; - sample.is_depended_on = sdtp.sample_is_depended_on[number]; - sample.has_redundancy = sdtp.sample_has_redundancy[number]; - } else { - sample.is_leading = 0; - sample.depends_on = 0; - sample.is_depended_on = 0; - sample.has_redundancy = 0; - } - }; - - /* Build initial sample list from sample tables */ - ISOFile.prototype.buildSampleLists = function() { - var i; - var trak; - for (i = 0; i < this.moov.traks.length; i++) { - trak = this.moov.traks[i]; - this.buildTrakSampleLists(trak); - } - }; - - ISOFile.prototype.buildTrakSampleLists = function(trak) { - var j; - var stco, stsc, stsz, stts, ctts, stss, stsd, subs, sbgps, sgpds, stdp; - var chunk_run_index, chunk_index, last_chunk_in_run, offset_in_chunk, last_sample_in_chunk; - var last_sample_in_stts_run, stts_run_index, last_sample_in_ctts_run, ctts_run_index, last_stss_index, subs_entry_index, last_subs_sample_index; - - trak.samples = []; - trak.samples_duration = 0; - trak.samples_size = 0; - stco = trak.mdia.minf.stbl.stco || trak.mdia.minf.stbl.co64; - stsc = trak.mdia.minf.stbl.stsc; - stsz = trak.mdia.minf.stbl.stsz || trak.mdia.minf.stbl.stz2; - stts = trak.mdia.minf.stbl.stts; - ctts = trak.mdia.minf.stbl.ctts; - stss = trak.mdia.minf.stbl.stss; - stsd = trak.mdia.minf.stbl.stsd; - subs = trak.mdia.minf.stbl.subs; - stdp = trak.mdia.minf.stbl.stdp; - sbgps = trak.mdia.minf.stbl.sbgps; - sgpds = trak.mdia.minf.stbl.sgpds; - - last_sample_in_stts_run = -1; - stts_run_index = -1; - last_sample_in_ctts_run = -1; - ctts_run_index = -1; - last_stss_index = 0; - subs_entry_index = 0; - last_subs_sample_index = 0; - - ISOFile.initSampleGroups(trak, null, sbgps, sgpds); - - if (typeof stsz === "undefined") { - return; - } - - /* we build the samples one by one and compute their properties */ - for (j = 0; j < stsz.sample_sizes.length; j++) { - var sample = {}; - sample.number = j; - sample.track_id = trak.tkhd.track_id; - sample.timescale = trak.mdia.mdhd.timescale; - sample.alreadyRead = 0; - trak.samples[j] = sample; - /* size can be known directly */ - sample.size = stsz.sample_sizes[j]; - trak.samples_size += sample.size; - /* computing chunk-based properties (offset, sample description index)*/ - if (j === 0) { - chunk_index = 1; /* the first sample is in the first chunk (chunk indexes are 1-based) */ - chunk_run_index = 0; /* the first chunk is the first entry in the first_chunk table */ - sample.chunk_index = chunk_index; - sample.chunk_run_index = chunk_run_index; - last_sample_in_chunk = stsc.samples_per_chunk[chunk_run_index]; - offset_in_chunk = 0; - - /* Is there another entry in the first_chunk table ? */ - if (chunk_run_index + 1 < stsc.first_chunk.length) { - /* The last chunk in the run is the chunk before the next first chunk */ - last_chunk_in_run = stsc.first_chunk[chunk_run_index+1]-1; - } else { - /* There is only one entry in the table, it is valid for all future chunks*/ - last_chunk_in_run = Infinity; - } - } else { - if (j < last_sample_in_chunk) { - /* the sample is still in the current chunk */ - sample.chunk_index = chunk_index; - sample.chunk_run_index = chunk_run_index; - } else { - /* the sample is in the next chunk */ - chunk_index++; - sample.chunk_index = chunk_index; - /* reset the accumulated offset in the chunk */ - offset_in_chunk = 0; - if (chunk_index <= last_chunk_in_run) ; else { - chunk_run_index++; - /* Is there another entry in the first_chunk table ? */ - if (chunk_run_index + 1 < stsc.first_chunk.length) { - /* The last chunk in the run is the chunk before the next first chunk */ - last_chunk_in_run = stsc.first_chunk[chunk_run_index+1]-1; - } else { - /* There is only one entry in the table, it is valid for all future chunks*/ - last_chunk_in_run = Infinity; - } - - } - sample.chunk_run_index = chunk_run_index; - last_sample_in_chunk += stsc.samples_per_chunk[chunk_run_index]; - } - } - - sample.description_index = stsc.sample_description_index[sample.chunk_run_index]-1; - sample.description = stsd.entries[sample.description_index]; - sample.offset = stco.chunk_offsets[sample.chunk_index-1] + offset_in_chunk; /* chunk indexes are 1-based */ - offset_in_chunk += sample.size; - - /* setting dts, cts, duration and rap flags */ - if (j > last_sample_in_stts_run) { - stts_run_index++; - if (last_sample_in_stts_run < 0) { - last_sample_in_stts_run = 0; - } - last_sample_in_stts_run += stts.sample_counts[stts_run_index]; - } - if (j > 0) { - trak.samples[j-1].duration = stts.sample_deltas[stts_run_index]; - trak.samples_duration += trak.samples[j-1].duration; - sample.dts = trak.samples[j-1].dts + trak.samples[j-1].duration; - } else { - sample.dts = 0; - } - if (ctts) { - if (j >= last_sample_in_ctts_run) { - ctts_run_index++; - if (last_sample_in_ctts_run < 0) { - last_sample_in_ctts_run = 0; - } - last_sample_in_ctts_run += ctts.sample_counts[ctts_run_index]; - } - sample.cts = trak.samples[j].dts + ctts.sample_offsets[ctts_run_index]; - } else { - sample.cts = sample.dts; - } - if (stss) { - if (j == stss.sample_numbers[last_stss_index] - 1) { // sample numbers are 1-based - sample.is_sync = true; - last_stss_index++; - } else { - sample.is_sync = false; - sample.degradation_priority = 0; - } - if (subs) { - if (subs.entries[subs_entry_index].sample_delta + last_subs_sample_index == j+1) { - sample.subsamples = subs.entries[subs_entry_index].subsamples; - last_subs_sample_index += subs.entries[subs_entry_index].sample_delta; - subs_entry_index++; - } - } - } else { - sample.is_sync = true; - } - ISOFile.process_sdtp(trak.mdia.minf.stbl.sdtp, sample, sample.number); - if (stdp) { - sample.degradation_priority = stdp.priority[j]; - } else { - sample.degradation_priority = 0; - } - if (subs) { - if (subs.entries[subs_entry_index].sample_delta + last_subs_sample_index == j) { - sample.subsamples = subs.entries[subs_entry_index].subsamples; - last_subs_sample_index += subs.entries[subs_entry_index].sample_delta; - } - } - if (sbgps.length > 0 || sgpds.length > 0) { - ISOFile.setSampleGroupProperties(trak, sample, j, trak.sample_groups_info); - } - } - if (j>0) { - trak.samples[j-1].duration = Math.max(trak.mdia.mdhd.duration - trak.samples[j-1].dts, 0); - trak.samples_duration += trak.samples[j-1].duration; - } - }; - - /* Update sample list when new 'moof' boxes are received */ - ISOFile.prototype.updateSampleLists = function() { - var i, j, k; - var default_sample_description_index, default_sample_duration, default_sample_size, default_sample_flags; - var last_run_position; - var box, moof, traf, trak, trex; - var sample; - var sample_flags; - - if (this.moov === undefined) { - return; - } - /* if the input file is fragmented and fetched in multiple downloads, we need to update the list of samples */ - while (this.lastMoofIndex < this.moofs.length) { - box = this.moofs[this.lastMoofIndex]; - this.lastMoofIndex++; - if (box.type == "moof") { - moof = box; - for (i = 0; i < moof.trafs.length; i++) { - traf = moof.trafs[i]; - trak = this.getTrackById(traf.tfhd.track_id); - trex = this.getTrexById(traf.tfhd.track_id); - if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { - default_sample_description_index = traf.tfhd.default_sample_description_index; - } else { - default_sample_description_index = (trex ? trex.default_sample_description_index: 1); - } - if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { - default_sample_duration = traf.tfhd.default_sample_duration; - } else { - default_sample_duration = (trex ? trex.default_sample_duration : 0); - } - if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { - default_sample_size = traf.tfhd.default_sample_size; - } else { - default_sample_size = (trex ? trex.default_sample_size : 0); - } - if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { - default_sample_flags = traf.tfhd.default_sample_flags; - } else { - default_sample_flags = (trex ? trex.default_sample_flags : 0); - } - traf.sample_number = 0; - /* process sample groups */ - if (traf.sbgps.length > 0) { - ISOFile.initSampleGroups(trak, traf, traf.sbgps, trak.mdia.minf.stbl.sgpds, traf.sgpds); - } - for (j = 0; j < traf.truns.length; j++) { - var trun = traf.truns[j]; - for (k = 0; k < trun.sample_count; k++) { - sample = {}; - sample.moof_number = this.lastMoofIndex; - sample.number_in_traf = traf.sample_number; - traf.sample_number++; - sample.number = trak.samples.length; - traf.first_sample_index = trak.samples.length; - trak.samples.push(sample); - sample.track_id = trak.tkhd.track_id; - sample.timescale = trak.mdia.mdhd.timescale; - sample.description_index = default_sample_description_index-1; - sample.description = trak.mdia.minf.stbl.stsd.entries[sample.description_index]; - sample.size = default_sample_size; - if (trun.flags & BoxParser.TRUN_FLAGS_SIZE) { - sample.size = trun.sample_size[k]; - } - trak.samples_size += sample.size; - sample.duration = default_sample_duration; - if (trun.flags & BoxParser.TRUN_FLAGS_DURATION) { - sample.duration = trun.sample_duration[k]; - } - trak.samples_duration += sample.duration; - if (trak.first_traf_merged || k > 0) { - sample.dts = trak.samples[trak.samples.length-2].dts+trak.samples[trak.samples.length-2].duration; - } else { - if (traf.tfdt) { - sample.dts = traf.tfdt.baseMediaDecodeTime; - } else { - sample.dts = 0; - } - trak.first_traf_merged = true; - } - sample.cts = sample.dts; - if (trun.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { - sample.cts = sample.dts + trun.sample_composition_time_offset[k]; - } - sample_flags = default_sample_flags; - if (trun.flags & BoxParser.TRUN_FLAGS_FLAGS) { - sample_flags = trun.sample_flags[k]; - } else if (k === 0 && (trun.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG)) { - sample_flags = trun.first_sample_flags; - } - sample.is_sync = ((sample_flags >> 16 & 0x1) ? false : true); - sample.is_leading = (sample_flags >> 26 & 0x3); - sample.depends_on = (sample_flags >> 24 & 0x3); - sample.is_depended_on = (sample_flags >> 22 & 0x3); - sample.has_redundancy = (sample_flags >> 20 & 0x3); - sample.degradation_priority = (sample_flags & 0xFFFF); - //ISOFile.process_sdtp(traf.sdtp, sample, sample.number_in_traf); - var bdop = (traf.tfhd.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) ? true : false; - var dbim = (traf.tfhd.flags & BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF) ? true : false; - var dop = (trun.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) ? true : false; - var bdo = 0; - if (!bdop) { - if (!dbim) { - if (j === 0) { // the first track in the movie fragment - bdo = moof.start; // the position of the first byte of the enclosing Movie Fragment Box - } else { - bdo = last_run_position; // end of the data defined by the preceding *track* (irrespective of the track id) fragment in the moof - } - } else { - bdo = moof.start; - } - } else { - bdo = traf.tfhd.base_data_offset; - } - if (j === 0 && k === 0) { - if (dop) { - sample.offset = bdo + trun.data_offset; // If the data-offset is present, it is relative to the base-data-offset established in the track fragment header - } else { - sample.offset = bdo; // the data for this run starts the base-data-offset defined by the track fragment header - } - } else { - sample.offset = last_run_position; // this run starts immediately after the data of the previous run - } - last_run_position = sample.offset + sample.size; - if (traf.sbgps.length > 0 || traf.sgpds.length > 0 || - trak.mdia.minf.stbl.sbgps.length > 0 || trak.mdia.minf.stbl.sgpds.length > 0) { - ISOFile.setSampleGroupProperties(trak, sample, sample.number_in_traf, traf.sample_groups_info); - } - } - } - if (traf.subs) { - trak.has_fragment_subsamples = true; - var sample_index = traf.first_sample_index; - for (j = 0; j < traf.subs.entries.length; j++) { - sample_index += traf.subs.entries[j].sample_delta; - sample = trak.samples[sample_index-1]; - sample.subsamples = traf.subs.entries[j].subsamples; - } - } - } - } - } - }; - - /* Try to get sample data for a given sample: - returns null if not found - returns the same sample if already requested - */ - ISOFile.prototype.getSample = function(trak, sampleNum) { - var buffer; - var sample = trak.samples[sampleNum]; - - if (!this.moov) { - return null; - } - - if (!sample.data) { - /* Not yet fetched */ - sample.data = new Uint8Array(sample.size); - sample.alreadyRead = 0; - this.samplesDataSize += sample.size; - Log.debug("ISOFile", "Allocating sample #"+sampleNum+" on track #"+trak.tkhd.track_id+" of size "+sample.size+" (total: "+this.samplesDataSize+")"); - } else if (sample.alreadyRead == sample.size) { - /* Already fetched entirely */ - return sample; - } - - /* The sample has only been partially fetched, we need to check in all buffers */ - while(true) { - var index = this.stream.findPosition(true, sample.offset + sample.alreadyRead, false); - if (index > -1) { - buffer = this.stream.buffers[index]; - var lengthAfterStart = buffer.byteLength - (sample.offset + sample.alreadyRead - buffer.fileStart); - if (sample.size - sample.alreadyRead <= lengthAfterStart) { - /* the (rest of the) sample is entirely contained in this buffer */ - - Log.debug("ISOFile","Getting sample #"+sampleNum+" data (alreadyRead: "+sample.alreadyRead+" offset: "+ - (sample.offset+sample.alreadyRead - buffer.fileStart)+" read size: "+(sample.size - sample.alreadyRead)+" full size: "+sample.size+")"); - - DataStream.memcpy(sample.data.buffer, sample.alreadyRead, - buffer, sample.offset+sample.alreadyRead - buffer.fileStart, sample.size - sample.alreadyRead); - - /* update the number of bytes used in this buffer and check if it needs to be removed */ - buffer.usedBytes += sample.size - sample.alreadyRead; - this.stream.logBufferLevel(); - - sample.alreadyRead = sample.size; - - return sample; - } else { - /* the sample does not end in this buffer */ - - if (lengthAfterStart === 0) return null; - - Log.debug("ISOFile","Getting sample #"+sampleNum+" partial data (alreadyRead: "+sample.alreadyRead+" offset: "+ - (sample.offset+sample.alreadyRead - buffer.fileStart)+" read size: "+lengthAfterStart+" full size: "+sample.size+")"); - - DataStream.memcpy(sample.data.buffer, sample.alreadyRead, - buffer, sample.offset+sample.alreadyRead - buffer.fileStart, lengthAfterStart); - sample.alreadyRead += lengthAfterStart; - - /* update the number of bytes used in this buffer and check if it needs to be removed */ - buffer.usedBytes += lengthAfterStart; - this.stream.logBufferLevel(); - - /* keep looking in the next buffer */ - } - } else { - return null; - } - } - }; - - /* Release the memory used to store the data of the sample */ - ISOFile.prototype.releaseSample = function(trak, sampleNum) { - var sample = trak.samples[sampleNum]; - if (sample.data) { - this.samplesDataSize -= sample.size; - sample.data = null; - sample.alreadyRead = 0; - return sample.size; - } else { - return 0; - } - }; - - ISOFile.prototype.getAllocatedSampleDataSize = function() { - return this.samplesDataSize; - }; - - /* Builds the MIME Type 'codecs' sub-parameters for the whole file */ - ISOFile.prototype.getCodecs = function() { - var i; - var codecs = ""; - for (i = 0; i < this.moov.traks.length; i++) { - var trak = this.moov.traks[i]; - if (i>0) { - codecs+=","; - } - codecs += trak.mdia.minf.stbl.stsd.entries[0].getCodec(); - } - return codecs; - }; - - /* Helper function */ - ISOFile.prototype.getTrexById = function(id) { - var i; - if (!this.moov || !this.moov.mvex) return null; - for (i = 0; i < this.moov.mvex.trexs.length; i++) { - var trex = this.moov.mvex.trexs[i]; - if (trex.track_id == id) return trex; - } - return null; - }; - - /* Helper function */ - ISOFile.prototype.getTrackById = function(id) { - if (this.moov === undefined) { - return null; - } - for (var j = 0; j < this.moov.traks.length; j++) { - var trak = this.moov.traks[j]; - if (trak.tkhd.track_id == id) return trak; - } - return null; - }; - // file:src/isofile-item-processing.js - /* size of the buffers allocated for samples */ - ISOFile.prototype.itemsDataSize = 0; - - ISOFile.prototype.flattenItemInfo = function() { - var items = this.items; - var entity_groups = this.entity_groups; - var i, j; - var item; - var meta = this.meta; - if (meta === null || meta === undefined) return; - if (meta.hdlr === undefined) return; - if (meta.iinf === undefined) return; - for (i = 0; i < meta.iinf.item_infos.length; i++) { - item = {}; - item.id = meta.iinf.item_infos[i].item_ID; - items[item.id] = item; - item.ref_to = []; - item.name = meta.iinf.item_infos[i].item_name; - if (meta.iinf.item_infos[i].protection_index > 0) { - item.protection = meta.ipro.protections[meta.iinf.item_infos[i].protection_index-1]; - } - if (meta.iinf.item_infos[i].item_type) { - item.type = meta.iinf.item_infos[i].item_type; - } else { - item.type = "mime"; - } - item.content_type = meta.iinf.item_infos[i].content_type; - item.content_encoding = meta.iinf.item_infos[i].content_encoding; - } - if (meta.grpl) { - for (i = 0; i < meta.grpl.boxes.length; i++) { - entity_group = {}; - entity_group.id = meta.grpl.boxes[i].group_id; - entity_group.entity_ids = meta.grpl.boxes[i].entity_ids; - entity_group.type = meta.grpl.boxes[i].type; - entity_groups[entity_group.id] = entity_group; - } - } - if (meta.iloc) { - for(i = 0; i < meta.iloc.items.length; i++) { - var itemloc = meta.iloc.items[i]; - item = items[itemloc.item_ID]; - if (itemloc.data_reference_index !== 0) { - Log.warn("Item storage with reference to other files: not supported"); - item.source = meta.dinf.boxes[itemloc.data_reference_index-1]; - } - switch(itemloc.construction_method) { - case 0: // offset into the file referenced by the data reference index - break; - case 1: // offset into the idat box of this meta box - break; - case 2: // offset into another item - Log.warn("Item storage with construction_method : not supported"); - break; - } - item.extents = []; - item.size = 0; - for (j = 0; j < itemloc.extents.length; j++) { - item.extents[j] = {}; - item.extents[j].offset = itemloc.extents[j].extent_offset + itemloc.base_offset; - if (itemloc.construction_method == 1) { - item.extents[j].offset += meta.idat.start + meta.idat.hdr_size; - } - item.extents[j].length = itemloc.extents[j].extent_length; - item.extents[j].alreadyRead = 0; - item.size += item.extents[j].length; - } - } - } - if (meta.pitm) { - items[meta.pitm.item_id].primary = true; - } - if (meta.iref) { - for (i=0; i 0 && propEntry.property_index-1 < meta.iprp.ipco.boxes.length) { - var propbox = meta.iprp.ipco.boxes[propEntry.property_index-1]; - item.properties[propbox.type] = propbox; - item.properties.boxes.push(propbox); - } - } - } - } - } - } - }; - - ISOFile.prototype.getItem = function(item_id) { - var buffer; - var item; - - if (!this.meta) { - return null; - } - - item = this.items[item_id]; - if (!item.data && item.size) { - /* Not yet fetched */ - item.data = new Uint8Array(item.size); - item.alreadyRead = 0; - this.itemsDataSize += item.size; - Log.debug("ISOFile", "Allocating item #"+item_id+" of size "+item.size+" (total: "+this.itemsDataSize+")"); - } else if (item.alreadyRead === item.size) { - /* Already fetched entirely */ - return item; - } - - /* The item has only been partially fetched, we need to check in all buffers to find the remaining extents*/ - - for (var i = 0; i < item.extents.length; i++) { - var extent = item.extents[i]; - if (extent.alreadyRead === extent.length) { - continue; - } else { - var index = this.stream.findPosition(true, extent.offset + extent.alreadyRead, false); - if (index > -1) { - buffer = this.stream.buffers[index]; - var lengthAfterStart = buffer.byteLength - (extent.offset + extent.alreadyRead - buffer.fileStart); - if (extent.length - extent.alreadyRead <= lengthAfterStart) { - /* the (rest of the) extent is entirely contained in this buffer */ - - Log.debug("ISOFile","Getting item #"+item_id+" extent #"+i+" data (alreadyRead: "+extent.alreadyRead+ - " offset: "+(extent.offset+extent.alreadyRead - buffer.fileStart)+" read size: "+(extent.length - extent.alreadyRead)+ - " full extent size: "+extent.length+" full item size: "+item.size+")"); - - DataStream.memcpy(item.data.buffer, item.alreadyRead, - buffer, extent.offset+extent.alreadyRead - buffer.fileStart, extent.length - extent.alreadyRead); - - /* update the number of bytes used in this buffer and check if it needs to be removed */ - buffer.usedBytes += extent.length - extent.alreadyRead; - this.stream.logBufferLevel(); - - item.alreadyRead += (extent.length - extent.alreadyRead); - extent.alreadyRead = extent.length; - } else { - /* the sample does not end in this buffer */ - - Log.debug("ISOFile","Getting item #"+item_id+" extent #"+i+" partial data (alreadyRead: "+extent.alreadyRead+" offset: "+ - (extent.offset+extent.alreadyRead - buffer.fileStart)+" read size: "+lengthAfterStart+ - " full extent size: "+extent.length+" full item size: "+item.size+")"); - - DataStream.memcpy(item.data.buffer, item.alreadyRead, - buffer, extent.offset+extent.alreadyRead - buffer.fileStart, lengthAfterStart); - extent.alreadyRead += lengthAfterStart; - item.alreadyRead += lengthAfterStart; - - /* update the number of bytes used in this buffer and check if it needs to be removed */ - buffer.usedBytes += lengthAfterStart; - this.stream.logBufferLevel(); - return null; - } - } else { - return null; - } - } - } - if (item.alreadyRead === item.size) { - /* fetched entirely */ - return item; - } else { - return null; - } - }; - - /* Release the memory used to store the data of the item */ - ISOFile.prototype.releaseItem = function(item_id) { - var item = this.items[item_id]; - if (item.data) { - this.itemsDataSize -= item.size; - item.data = null; - item.alreadyRead = 0; - for (var i = 0; i < item.extents.length; i++) { - var extent = item.extents[i]; - extent.alreadyRead = 0; - } - return item.size; - } else { - return 0; - } - }; - - - ISOFile.prototype.processItems = function(callback) { - for(var i in this.items) { - var item = this.items[i]; - this.getItem(item.id); - if (callback && !item.sent) { - callback(item); - item.sent = true; - item.data = null; - } - } - }; - - ISOFile.prototype.hasItem = function(name) { - for(var i in this.items) { - var item = this.items[i]; - if (item.name === name) { - return item.id; - } - } - return -1; - }; - - ISOFile.prototype.getMetaHandler = function() { - if (!this.meta) { - return null; - } else { - return this.meta.hdlr.handler; - } - }; - - ISOFile.prototype.getPrimaryItem = function() { - if (!this.meta || !this.meta.pitm) { - return null; - } else { - return this.getItem(this.meta.pitm.item_id); - } - }; - - ISOFile.prototype.itemToFragmentedTrackFile = function(_options) { - var options = _options || {}; - var item = null; - if (options.itemId) { - item = this.getItem(options.itemId); - } else { - item = this.getPrimaryItem(); - } - if (item == null) return null; - - var file = new ISOFile(); - file.discardMdatData = false; - // assuming the track type is the same as the item type - var trackOptions = { type: item.type, description_boxes: item.properties.boxes}; - if (item.properties.ispe) { - trackOptions.width = item.properties.ispe.image_width; - trackOptions.height = item.properties.ispe.image_height; - } - var trackId = file.addTrack(trackOptions); - if (trackId) { - file.addSample(trackId, item.data); - return file; - } else { - return null; - } - }; - - // file:src/isofile-write.js - /* Rewrite the entire file */ - ISOFile.prototype.write = function(outstream) { - for (var i=0; i0 ? this.moov.traks[i].samples[0].duration: 0)); - initSegs.push(seg); - } - return initSegs; - }; - - // file:src/box-print.js - /* - * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - BoxParser.Box.prototype.printHeader = function(output) { - this.size += 8; - if (this.size > MAX_SIZE) { - this.size += 8; - } - if (this.type === "uuid") { - this.size += 16; - } - output.log(output.indent+"size:"+this.size); - output.log(output.indent+"type:"+this.type); - }; - - BoxParser.FullBox.prototype.printHeader = function(output) { - this.size += 4; - BoxParser.Box.prototype.printHeader.call(this, output); - output.log(output.indent+"version:"+this.version); - output.log(output.indent+"flags:"+this.flags); - }; - - BoxParser.Box.prototype.print = function(output) { - this.printHeader(output); - }; - - BoxParser.ContainerBox.prototype.print = function(output) { - this.printHeader(output); - for (var i=0; i>8)); - output.log(output.indent+"matrix: "+this.matrix.join(", ")); - output.log(output.indent+"next_track_id: "+this.next_track_id); - }; - - BoxParser.tkhdBox.prototype.print = function(output) { - BoxParser.FullBox.prototype.printHeader.call(this, output); - output.log(output.indent+"creation_time: "+this.creation_time); - output.log(output.indent+"modification_time: "+this.modification_time); - output.log(output.indent+"track_id: "+this.track_id); - output.log(output.indent+"duration: "+this.duration); - output.log(output.indent+"volume: "+(this.volume>>8)); - output.log(output.indent+"matrix: "+this.matrix.join(", ")); - output.log(output.indent+"layer: "+this.layer); - output.log(output.indent+"alternate_group: "+this.alternate_group); - output.log(output.indent+"width: "+this.width); - output.log(output.indent+"height: "+this.height); - };// file:src/mp4box.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var MP4Box = {}; - - MP4Box.createFile = function (_keepMdatData, _stream) { - /* Boolean indicating if bytes containing media data should be kept in memory */ - var keepMdatData = (_keepMdatData !== undefined ? _keepMdatData : true); - var file = new ISOFile(_stream); - file.discardMdatData = (keepMdatData ? false : true); - return file; - }; - - { - exports.createFile = MP4Box.createFile; - } - }); - mp4box_all.Log; - mp4box_all.MP4BoxStream; - var mp4box_all_3 = mp4box_all.DataStream; - mp4box_all.MultiBufferStream; - mp4box_all.MPEG4DescriptorParser; - var mp4box_all_6 = mp4box_all.BoxParser; - mp4box_all.VTTin4Parser; - mp4box_all.XMLSubtitlein4Parser; - mp4box_all.Textin4Parser; - mp4box_all.ISOFile; - var mp4box_all_11 = mp4box_all.createFile; - - // Decode a MP4 container into individual samples. - class Parser { - info; - #mp4 = mp4box_all_11(); - #offset = 0; - #samples = []; - constructor(init) { - this.#mp4.onError = (err) => { - console.error("MP4 error", err); - }; - this.#mp4.onReady = (info) => { - this.info = info; - // Extract all of the tracks, because we don't know if it's audio or video. - for (const track of info.tracks) { - this.#mp4.setExtractionOptions(track.id, track, { nbSamples: 1 }); - } - }; - this.#mp4.onSamples = (_track_id, track, samples) => { - for (const sample of samples) { - this.#samples.push({ track, sample }); - } - }; - this.#mp4.start(); - // For some reason we need to modify the underlying ArrayBuffer with offset - const copy = new Uint8Array(init); - const buffer = copy.buffer; - buffer.fileStart = this.#offset; - this.#mp4.appendBuffer(buffer); - this.#offset += buffer.byteLength; - this.#mp4.flush(); - if (!this.info) { - throw new Error("could not parse MP4 info"); - } - } - decode(chunk) { - const copy = new Uint8Array(chunk); - // For some reason we need to modify the underlying ArrayBuffer with offset - const buffer = copy.buffer; - buffer.fileStart = this.#offset; - // Parse the data - this.#mp4.appendBuffer(buffer); - this.#mp4.flush(); - this.#offset += buffer.byteLength; - const samples = [...this.#samples]; - this.#samples.length = 0; - return samples; - } - } - - // Rename some stuff so it's on brand. - // We need a separate file so this file can use the rename too. - function isAudioTrack(track) { - // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition - return track.audio !== undefined; - } - function isVideoTrack(track) { - // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition - return track.video !== undefined; - } - // TODO contribute to mp4box - mp4box_all_6.dOpsBox.prototype.write = function (stream) { - this.size = this.ChannelMappingFamily === 0 ? 11 : 13 + this.ChannelMapping.length; - this.writeHeader(stream); - stream.writeUint8(this.Version); - stream.writeUint8(this.OutputChannelCount); - stream.writeUint16(this.PreSkip); - stream.writeUint32(this.InputSampleRate); - stream.writeInt16(this.OutputGain); - stream.writeUint8(this.ChannelMappingFamily); - if (this.ChannelMappingFamily !== 0) { - stream.writeUint8(this.StreamCount); - stream.writeUint8(this.CoupledCount); - for (const mapping of this.ChannelMapping) { - stream.writeUint8(mapping); - } - } - }; - - // This is run in a worker. - let Renderer$1 = class Renderer { - #ring; - #timeline; - #decoder; - #stream; - constructor(config, timeline) { - this.#timeline = timeline; - this.#ring = new Ring(config.ring); - this.#stream = new TransformStream({ - start: this.#start.bind(this), - transform: this.#transform.bind(this), - }); - this.#run().catch(console.error); - } - #start(controller) { - this.#decoder = new AudioDecoder({ - output: (frame) => { - controller.enqueue(frame); - }, - error: console.warn, - }); - } - #transform(frame) { - if (this.#decoder.state !== "configured") { - const track = frame.track; - if (!isAudioTrack(track)) - throw new Error("expected audio track"); - // We only support OPUS right now which doesn't need a description. - this.#decoder.configure({ - codec: track.codec, - sampleRate: track.audio.sample_rate, - numberOfChannels: track.audio.channel_count, - }); - } - const chunk = new EncodedAudioChunk({ - type: frame.sample.is_sync ? "key" : "delta", - timestamp: frame.sample.dts / frame.track.timescale, - duration: frame.sample.duration, - data: frame.sample.data, - }); - this.#decoder.decode(chunk); - } - async #run() { - const reader = this.#timeline.frames.pipeThrough(this.#stream).getReader(); - for (;;) { - const { value: frame, done } = await reader.read(); - if (done) - break; - // Write audio samples to the ring buffer, dropping when there's no space. - const written = this.#ring.write(frame); - if (written < frame.numberOfFrames) { - console.warn(`droppped ${frame.numberOfFrames - written} audio samples`); - } - } - } - }; - - class Renderer { - #canvas; - #timeline; - #decoder; - #queue; - #decoderConfig; - #waitingForKeyframe = true; - constructor(config, timeline) { - this.#canvas = config.canvas; - this.#timeline = timeline; - this.#queue = new TransformStream({ - start: this.#start.bind(this), - transform: this.#transform.bind(this), - }); - this.#run().catch(console.error); - } - pause() { - console.log("pause"); - this.#waitingForKeyframe = true; - } - async #run() { - const reader = this.#timeline.frames.pipeThrough(this.#queue).getReader(); - for (;;) { - const { value: frame, done } = await reader.read(); - if (done) - break; - self.requestAnimationFrame(() => { - this.#canvas.width = frame.displayWidth; - this.#canvas.height = frame.displayHeight; - const ctx = this.#canvas.getContext("2d"); - if (!ctx) - throw new Error("failed to get canvas context"); - ctx.drawImage(frame, 0, 0, frame.displayWidth, frame.displayHeight); // TODO respect aspect ratio - frame.close(); - }); - } - } - #start(controller) { - this.#decoder = new VideoDecoder({ - output: (frame) => { - controller.enqueue(frame); - }, - error: console.error, - }); - } - #transform(frame) { - if (this.#decoder.state === "closed") { - console.warn("Decoder is closed. Skipping frame."); - return; - } - const { sample, track } = frame; - // Reset the decoder on video track change - if (this.#decoderConfig && this.#decoder.state == "configured") { - if (isVideoTrack(track)) { - const configMismatch = this.#decoderConfig.codec !== track.codec || - this.#decoderConfig.codedWidth !== track.video.width || - this.#decoderConfig.codedHeight !== track.video.height; - if (configMismatch) { - this.#decoder.reset(); - this.#decoderConfig = undefined; - } - } - } - // Configure the decoder with the first frame - if (this.#decoder.state !== "configured") { - const desc = sample.description; - const box = desc.avcC ?? desc.hvcC ?? desc.vpcC ?? desc.av1C; - if (!box) - throw new Error(`unsupported codec: ${track.codec}`); - const buffer = new mp4box_all_3(undefined, 0, mp4box_all_3.BIG_ENDIAN); - box.write(buffer); - const description = new Uint8Array(buffer.buffer, 8); // Remove the box header. - if (!isVideoTrack(track)) - throw new Error("expected video track"); - this.#decoderConfig = { - codec: track.codec, - codedHeight: track.video.height, - codedWidth: track.video.width, - description, - // optimizeForLatency: true - }; - this.#decoder.configure(this.#decoderConfig); - if (!frame.sample.is_sync) { - this.#waitingForKeyframe = true; - } - else { - this.#waitingForKeyframe = false; - } - } - //At the start of decode , VideoDecoder seems to expect a key frame after configure() or flush() - if (this.#decoder.state == "configured") { - if (this.#waitingForKeyframe && !frame.sample.is_sync) { - console.warn("Skipping non-keyframe until a keyframe is found."); - return; - } - // On arrival of a keyframe, allow decoding and stop waiting for a keyframe. - if (frame.sample.is_sync) { - this.#waitingForKeyframe = false; - } - const chunk = new EncodedVideoChunk({ - type: frame.sample.is_sync ? "key" : "delta", - data: frame.sample.data, - timestamp: frame.sample.dts / frame.track.timescale, - }); - this.#decoder.decode(chunk); - } - } - } - - // I hate javascript - function asError(e) { - if (e instanceof Error) { - return e; - } - else if (typeof e === "string") { - return new Error(e); - } - else { - return new Error(String(e)); - } - } - - class Deferred { - promise; - resolve; - reject; - pending = true; - constructor() { - this.promise = new Promise((resolve, reject) => { - this.resolve = (value) => { - this.pending = false; - resolve(value); - }; - this.reject = (reason) => { - this.pending = false; - reject(reason); - }; - }); - } - } - - const MAX_U53 = Number.MAX_SAFE_INTEGER; - // Reader wraps a stream and provides convience methods for reading pieces from a stream - // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet. - class Reader { - #buffer; - #stream; - #reader; - constructor(buffer, stream) { - this.#buffer = buffer; - this.#stream = stream; - this.#reader = this.#stream.getReader(); - } - // Adds more data to the buffer, returning true if more data was added. - async #fill() { - const result = await this.#reader.read(); - if (result.done) { - return false; - } - const buffer = new Uint8Array(result.value); - if (this.#buffer.byteLength == 0) { - this.#buffer = buffer; - } - else { - const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength); - temp.set(this.#buffer); - temp.set(buffer, this.#buffer.byteLength); - this.#buffer = temp; - } - return true; - } - // Add more data to the buffer until it's at least size bytes. - async #fillTo(size) { - while (this.#buffer.byteLength < size) { - if (!(await this.#fill())) { - throw new Error("unexpected end of stream"); - } - } - } - // Consumes the first size bytes of the buffer. - #slice(size) { - const result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size); - this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size); - return result; - } - async read(size) { - if (size == 0) - return new Uint8Array(); - await this.#fillTo(size); - return this.#slice(size); - } - async readAll() { - // eslint-disable-next-line no-empty - while (await this.#fill()) { } - return this.#slice(this.#buffer.byteLength); - } - async string(maxLength) { - const length = await this.u53(); - if (maxLength !== undefined && length > maxLength) { - throw new Error(`string length ${length} exceeds max length ${maxLength}`); - } - const buffer = await this.read(length); - return new TextDecoder().decode(buffer); - } - async u8() { - await this.#fillTo(1); - return this.#slice(1)[0]; - } - // Returns a Number using 53-bits, the max Javascript can use for integer math - async u53() { - const v = await this.u62(); - if (v > MAX_U53) { - throw new Error("value larger than 53-bits; use v62 instead"); - } - return Number(v); - } - // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits - async u62() { - await this.#fillTo(1); - const size = (this.#buffer[0] & 0xc0) >> 6; - if (size == 0) { - const first = this.#slice(1)[0]; - return BigInt(first) & 0x3fn; - } - else if (size == 1) { - await this.#fillTo(2); - const slice = this.#slice(2); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return BigInt(view.getInt16(0)) & 0x3fffn; - } - else if (size == 2) { - await this.#fillTo(4); - const slice = this.#slice(4); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return BigInt(view.getUint32(0)) & 0x3fffffffn; - } - else if (size == 3) { - await this.#fillTo(8); - const slice = this.#slice(8); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return view.getBigUint64(0) & 0x3fffffffffffffffn; - } - else { - throw new Error("impossible"); - } - } - async done() { - if (this.#buffer.byteLength > 0) - return false; - return !(await this.#fill()); - } - async close() { - this.#reader.releaseLock(); - await this.#stream.cancel(); - } - release() { - this.#reader.releaseLock(); - return [this.#buffer, this.#stream]; - } - } - - var StreamType; - (function (StreamType) { - StreamType[StreamType["Object"] = 0] = "Object"; - StreamType[StreamType["Track"] = 80] = "Track"; - StreamType[StreamType["Group"] = 81] = "Group"; - })(StreamType || (StreamType = {})); - var Status; - (function (Status) { - Status[Status["OBJECT_NULL"] = 1] = "OBJECT_NULL"; - Status[Status["GROUP_NULL"] = 2] = "GROUP_NULL"; - Status[Status["GROUP_END"] = 3] = "GROUP_END"; - Status[Status["TRACK_END"] = 4] = "TRACK_END"; - })(Status || (Status = {})); - class GroupReader { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async read() { - if (await this.stream.done()) { - return; - } - const object = await this.stream.u53(); - const size = await this.stream.u53(); - let payload; - if (size == 0) { - payload = (await this.stream.u53()); - } - else { - payload = await this.stream.read(size); - } - return { - object, - payload, - }; - } - async close() { - await this.stream.close(); - } - } - - class Worker { - // Timeline receives samples, buffering them and choosing the timestamp to render. - #timeline = new Timeline(); - // A map of init tracks. - #inits = new Map(); - // Renderer requests samples, rendering video frames and emitting audio frames. - #audio; - #video; - on(e) { - const msg = e.data; - if (msg.config) { - this.#onConfig(msg.config); - } - else if (msg.init) { - // TODO buffer the init segmnet so we don't hold the stream open. - this.#onInit(msg.init); - } - else if (msg.segment) { - this.#onSegment(msg.segment).catch(console.warn); - } - else if (msg.pause) { - this.#onPause(msg.pause); - } - else { - throw new Error(`unknown message: + ${JSON.stringify(msg)}`); - } - } - #onConfig(msg) { - if (msg.audio) { - this.#audio = new Renderer$1(msg.audio, this.#timeline.audio); - } - if (msg.video) { - this.#video = new Renderer(msg.video, this.#timeline.video); - } - } - #onInit(msg) { - let init = this.#inits.get(msg.name); - if (!init) { - init = new Deferred(); - this.#inits.set(msg.name, init); - } - init.resolve(msg.data); - } - async #onSegment(msg) { - let init = this.#inits.get(msg.init); - if (!init) { - init = new Deferred(); - this.#inits.set(msg.init, init); - } - // Create a new stream that we will use to decode. - const container = new Parser(await init.promise); - const timeline = msg.kind === "audio" ? this.#timeline.audio : this.#timeline.video; - const reader = new GroupReader(msg.header, new Reader(msg.buffer, msg.stream)); - // Create a queue that will contain each MP4 frame. - const queue = new TransformStream({}); - const segment = queue.writable.getWriter(); - // Add the segment to the timeline - const segments = timeline.segments.getWriter(); - await segments.write({ - sequence: msg.header.group, - frames: queue.readable, - }); - segments.releaseLock(); - // Read each chunk, decoding the MP4 frames and adding them to the queue. - for (;;) { - const chunk = await reader.read(); - if (!chunk) { - break; - } - if (!(chunk.payload instanceof Uint8Array)) { - throw new Error(`invalid payload: ${chunk.payload}`); - } - const frames = container.decode(chunk.payload); - for (const frame of frames) { - await segment.write(frame); - } - } - // We done. - await segment.close(); - } - #onPause(pause) { - if (this.#video && pause) { - this.#video.pause(); - } - } - } - // Pass all events to the worker - const worker = new Worker(); - self.addEventListener("message", (msg) => { - try { - worker.on(msg); - } - catch (e) { - const err = asError(e); - console.warn("worker error:", err); - } - }); - - })(); - - }); - /* eslint-enable */ - - // Ring buffer with audio samples. - var STATE; - (function (STATE) { - STATE[STATE["READ_POS"] = 0] = "READ_POS"; - STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; - STATE[STATE["LENGTH"] = 2] = "LENGTH"; - })(STATE || (STATE = {})); - // No prototype to make this easier to send via postMessage - class RingShared { - state; - channels; - capacity; - constructor(channels, capacity) { - // Store the current state in a separate ring buffer. - this.state = new SharedArrayBuffer(STATE.LENGTH * Int32Array.BYTES_PER_ELEMENT); - // Create a buffer for each audio channel - this.channels = []; - for (let i = 0; i < channels; i += 1) { - const buffer = new SharedArrayBuffer(capacity * Float32Array.BYTES_PER_ELEMENT); - this.channels.push(buffer); - } - this.capacity = capacity; - } - } - - // This is a non-standard way of importing worklet/workers. - // Unfortunately, it's the only option because of a Vite bug: https://github.com/vitejs/vite/issues/11823 - // Responsible for sending messages to the worker and worklet. - class Backend { - // General worker - #worker; - // The audio context, which must be created on the main thread. - #audio; - constructor(config) { - // TODO does this block the main thread? If so, make this async - this.#worker = new WorkerFactory(); - this.#worker.addEventListener("message", this.on.bind(this)); - let sampleRate; - let channels; - for (const track of config.catalog.tracks) { - if (isAudioTrack(track)) { - if (sampleRate && track.selectionParams.samplerate !== sampleRate) { - throw new Error(`TODO multiple audio tracks with different sample rates`); - } - sampleRate = track.selectionParams.samplerate; - // TODO properly handle weird channel configs - channels = Math.max(+track.selectionParams.channelConfig, channels ?? 0); - } - } - const msg = {}; - // Only configure audio is we have an audio track - if (sampleRate && channels) { - msg.audio = { - channels: channels, - sampleRate: sampleRate, - ring: new RingShared(2, sampleRate / 10), // 100ms - }; - this.#audio = new Audio(msg.audio); - } - // TODO only send the canvas if we have a video track - msg.video = { - canvas: config.canvas, - }; - this.send({ config: msg }, msg.video.canvas); - } - pause() { - this.send({ pause: true }); - } - async mute() { - await this.#audio?.context.suspend(); - } - async unmute() { - await this.#audio?.context.resume(); - } - init(init) { - this.send({ init }); - } - segment(segment) { - this.send({ segment }, segment.stream); - } - async close() { - this.#worker.terminate(); - await this.#audio?.context.close(); - } - // Enforce we're sending valid types to the worker - send(msg, ...transfer) { - //console.log("sent message from main to worker", msg) - this.#worker.postMessage(msg, transfer); - } - on(e) { - const msg = e.data; - // Don't print the verbose timeline message. - if (!msg.timeline) ; - } - } - - const MAX_U6 = Math.pow(2, 6) - 1; - const MAX_U14 = Math.pow(2, 14) - 1; - const MAX_U30 = Math.pow(2, 30) - 1; - const MAX_U31 = Math.pow(2, 31) - 1; - const MAX_U53 = Number.MAX_SAFE_INTEGER; - const MAX_U62 = 2n ** 62n - 1n; - // Reader wraps a stream and provides convience methods for reading pieces from a stream - // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet. - class Reader { - #buffer; - #stream; - #reader; - constructor(buffer, stream) { - this.#buffer = buffer; - this.#stream = stream; - this.#reader = this.#stream.getReader(); - } - // Adds more data to the buffer, returning true if more data was added. - async #fill() { - const result = await this.#reader.read(); - if (result.done) { - return false; - } - const buffer = new Uint8Array(result.value); - if (this.#buffer.byteLength == 0) { - this.#buffer = buffer; - } - else { - const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength); - temp.set(this.#buffer); - temp.set(buffer, this.#buffer.byteLength); - this.#buffer = temp; - } - return true; - } - // Add more data to the buffer until it's at least size bytes. - async #fillTo(size) { - while (this.#buffer.byteLength < size) { - if (!(await this.#fill())) { - throw new Error("unexpected end of stream"); - } - } - } - // Consumes the first size bytes of the buffer. - #slice(size) { - const result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size); - this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size); - return result; - } - async read(size) { - if (size == 0) - return new Uint8Array(); - await this.#fillTo(size); - return this.#slice(size); - } - async readAll() { - // eslint-disable-next-line no-empty - while (await this.#fill()) { } - return this.#slice(this.#buffer.byteLength); - } - async string(maxLength) { - const length = await this.u53(); - if (maxLength !== undefined && length > maxLength) { - throw new Error(`string length ${length} exceeds max length ${maxLength}`); - } - const buffer = await this.read(length); - return new TextDecoder().decode(buffer); - } - async u8() { - await this.#fillTo(1); - return this.#slice(1)[0]; - } - // Returns a Number using 53-bits, the max Javascript can use for integer math - async u53() { - const v = await this.u62(); - if (v > MAX_U53) { - throw new Error("value larger than 53-bits; use v62 instead"); - } - return Number(v); - } - // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits - async u62() { - await this.#fillTo(1); - const size = (this.#buffer[0] & 0xc0) >> 6; - if (size == 0) { - const first = this.#slice(1)[0]; - return BigInt(first) & 0x3fn; - } - else if (size == 1) { - await this.#fillTo(2); - const slice = this.#slice(2); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return BigInt(view.getInt16(0)) & 0x3fffn; - } - else if (size == 2) { - await this.#fillTo(4); - const slice = this.#slice(4); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return BigInt(view.getUint32(0)) & 0x3fffffffn; - } - else if (size == 3) { - await this.#fillTo(8); - const slice = this.#slice(8); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return view.getBigUint64(0) & 0x3fffffffffffffffn; - } - else { - throw new Error("impossible"); - } - } - async done() { - if (this.#buffer.byteLength > 0) - return false; - return !(await this.#fill()); - } - async close() { - this.#reader.releaseLock(); - await this.#stream.cancel(); - } - release() { - this.#reader.releaseLock(); - return [this.#buffer, this.#stream]; - } - } - // Writer wraps a stream and writes chunks of data - class Writer { - #scratch; - #writer; - #stream; - constructor(stream) { - this.#stream = stream; - this.#scratch = new Uint8Array(8); - this.#writer = this.#stream.getWriter(); - } - async u8(v) { - await this.write(setUint8(this.#scratch, v)); - } - async i32(v) { - if (Math.abs(v) > MAX_U31) { - throw new Error(`overflow, value larger than 32-bits: ${v}`); - } - // We don't use a VarInt, so it always takes 4 bytes. - // This could be improved but nothing is standardized yet. - await this.write(setInt32(this.#scratch, v)); - } - async u53(v) { - if (v < 0) { - throw new Error(`underflow, value is negative: ${v}`); - } - else if (v > MAX_U53) { - throw new Error(`overflow, value larger than 53-bits: ${v}`); - } - await this.write(setVint53(this.#scratch, v)); - } - async u62(v) { - if (v < 0) { - throw new Error(`underflow, value is negative: ${v}`); - } - else if (v >= MAX_U62) { - throw new Error(`overflow, value larger than 62-bits: ${v}`); - } - await this.write(setVint62(this.#scratch, v)); - } - async write(v) { - await this.#writer.write(v); - } - async string(str) { - const data = new TextEncoder().encode(str); - await this.u53(data.byteLength); - await this.write(data); - } - async close() { - this.#writer.releaseLock(); - await this.#stream.close(); - } - release() { - this.#writer.releaseLock(); - return this.#stream; - } - } - function setUint8(dst, v) { - dst[0] = v; - return dst.slice(0, 1); - } - function setUint16(dst, v) { - const view = new DataView(dst.buffer, dst.byteOffset, 2); - view.setUint16(0, v); - return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); - } - function setInt32(dst, v) { - const view = new DataView(dst.buffer, dst.byteOffset, 4); - view.setInt32(0, v); - return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); - } - function setUint32(dst, v) { - const view = new DataView(dst.buffer, dst.byteOffset, 4); - view.setUint32(0, v); - return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); - } - function setVint53(dst, v) { - if (v <= MAX_U6) { - return setUint8(dst, v); - } - else if (v <= MAX_U14) { - return setUint16(dst, v | 0x4000); - } - else if (v <= MAX_U30) { - return setUint32(dst, v | 0x80000000); - } - else if (v <= MAX_U53) { - return setUint64(dst, BigInt(v) | 0xc000000000000000n); - } - else { - throw new Error(`overflow, value larger than 53-bits: ${v}`); - } - } - function setVint62(dst, v) { - if (v < MAX_U6) { - return setUint8(dst, Number(v)); - } - else if (v < MAX_U14) { - return setUint16(dst, Number(v) | 0x4000); - } - else if (v <= MAX_U30) { - return setUint32(dst, Number(v) | 0x80000000); - } - else if (v <= MAX_U62) { - return setUint64(dst, BigInt(v) | 0xc000000000000000n); - } - else { - throw new Error(`overflow, value larger than 62-bits: ${v}`); - } - } - function setUint64(dst, v) { - const view = new DataView(dst.buffer, dst.byteOffset, 8); - view.setBigUint64(0, v); - return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); - } - - var Version; - (function (Version) { - Version[Version["DRAFT_00"] = 4278190080] = "DRAFT_00"; - Version[Version["DRAFT_01"] = 4278190081] = "DRAFT_01"; - Version[Version["DRAFT_02"] = 4278190082] = "DRAFT_02"; - Version[Version["DRAFT_03"] = 4278190083] = "DRAFT_03"; - Version[Version["DRAFT_04"] = 4278190084] = "DRAFT_04"; - Version[Version["DRAFT_05"] = 4278190085] = "DRAFT_05"; - Version[Version["KIXEL_00"] = 765184] = "KIXEL_00"; - Version[Version["KIXEL_01"] = 765185] = "KIXEL_01"; - })(Version || (Version = {})); - let Stream$1 = class Stream { - recv; - send; - constructor(r, w) { - this.recv = new Decoder$1(r); - this.send = new Encoder$1(w); - } - }; - let Decoder$1 = class Decoder { - r; - constructor(r) { - this.r = r; - } - async client() { - const type = await this.r.u53(); - if (type !== 0x40) - throw new Error(`client SETUP type must be 0x40, got ${type}`); - const count = await this.r.u53(); - const versions = []; - for (let i = 0; i < count; i++) { - const version = await this.r.u53(); - versions.push(version); - } - const params = await this.parameters(); - const role = this.role(params?.get(0n)); - return { - versions, - role, - params, - }; - } - async server() { - const type = await this.r.u53(); - if (type !== 0x41) - throw new Error(`server SETUP type must be 0x41, got ${type}`); - const version = await this.r.u53(); - const params = await this.parameters(); - return { - version, - params, - }; - } - async parameters() { - const count = await this.r.u53(); - if (count == 0) - return undefined; - const params = new Map(); - for (let i = 0; i < count; i++) { - const id = await this.r.u62(); - const size = await this.r.u53(); - const value = await this.r.read(size); - if (params.has(id)) { - throw new Error(`duplicate parameter id: ${id}`); - } - params.set(id, value); - } - return params; - } - role(raw) { - if (!raw) - throw new Error("missing role parameter"); - if (raw.length != 1) - throw new Error("multi-byte varint not supported"); - switch (raw[0]) { - case 1: - return "publisher"; - case 2: - return "subscriber"; - case 3: - return "both"; - default: - throw new Error(`invalid role: ${raw[0]}`); - } - } - }; - let Encoder$1 = class Encoder { - w; - constructor(w) { - this.w = w; - } - async client(c) { - await this.w.u53(0x40); - await this.w.u53(c.versions.length); - for (const v of c.versions) { - await this.w.u53(v); - } - // I hate it - const params = c.params ?? new Map(); - params.set(0n, new Uint8Array([c.role == "publisher" ? 1 : c.role == "subscriber" ? 2 : 3])); - await this.parameters(params); - } - async server(s) { - await this.w.u53(0x41); - await this.w.u53(s.version); - await this.parameters(s.params); - } - async parameters(p) { - if (!p) { - await this.w.u8(0); - return; - } - await this.w.u53(p.size); - for (const [id, value] of p) { - await this.w.u62(id); - await this.w.u53(value.length); - await this.w.write(value); - } - } - }; - - function isPublisher(m) { - return (m.kind == Msg.SubscribeOk || - m.kind == Msg.SubscribeError || - m.kind == Msg.SubscribeDone || - m.kind == Msg.Announce || - m.kind == Msg.Unannounce); - } - // I wish we didn't have to split Msg and Id into separate enums. - // However using the string in the message makes it easier to debug. - // We'll take the tiny performance hit until I'm better at Typescript. - var Msg; - (function (Msg) { - // NOTE: object and setup are in other modules - Msg["Subscribe"] = "subscribe"; - Msg["SubscribeOk"] = "subscribe_ok"; - Msg["SubscribeError"] = "subscribe_error"; - Msg["SubscribeDone"] = "subscribe_done"; - Msg["Unsubscribe"] = "unsubscribe"; - Msg["Announce"] = "announce"; - Msg["AnnounceOk"] = "announce_ok"; - Msg["AnnounceError"] = "announce_error"; - Msg["Unannounce"] = "unannounce"; - Msg["GoAway"] = "go_away"; - })(Msg || (Msg = {})); - var Id; - (function (Id) { - // NOTE: object and setup are in other modules - // Object = 0, - // Setup = 1, - Id[Id["Subscribe"] = 3] = "Subscribe"; - Id[Id["SubscribeOk"] = 4] = "SubscribeOk"; - Id[Id["SubscribeError"] = 5] = "SubscribeError"; - Id[Id["SubscribeDone"] = 11] = "SubscribeDone"; - Id[Id["Unsubscribe"] = 10] = "Unsubscribe"; - Id[Id["Announce"] = 6] = "Announce"; - Id[Id["AnnounceOk"] = 7] = "AnnounceOk"; - Id[Id["AnnounceError"] = 8] = "AnnounceError"; - Id[Id["Unannounce"] = 9] = "Unannounce"; - Id[Id["GoAway"] = 16] = "GoAway"; - })(Id || (Id = {})); - var GroupOrder; - (function (GroupOrder) { - GroupOrder[GroupOrder["Publisher"] = 0] = "Publisher"; - GroupOrder[GroupOrder["Ascending"] = 1] = "Ascending"; - GroupOrder[GroupOrder["Descending"] = 2] = "Descending"; - })(GroupOrder || (GroupOrder = {})); - class Stream { - decoder; - encoder; - #mutex = Promise.resolve(); - constructor(r, w) { - this.decoder = new Decoder(r); - this.encoder = new Encoder(w); - } - // Will error if two messages are read at once. - async recv() { - const msg = await this.decoder.message(); - console.log("received message", msg); - return msg; - } - async send(msg) { - const unlock = await this.#lock(); - try { - console.log("sending message", msg); - await this.encoder.message(msg); - } - finally { - unlock(); - } - } - async #lock() { - // Make a new promise that we can resolve later. - let done; - const p = new Promise((resolve) => { - done = () => resolve(); - }); - // Wait until the previous lock is done, then resolve our our lock. - const lock = this.#mutex.then(() => done); - // Save our lock as the next lock. - this.#mutex = p; - // Return the lock. - return lock; - } - } - class Decoder { - r; - constructor(r) { - this.r = r; - } - async msg() { - const t = await this.r.u53(); - switch (t) { - case Id.Subscribe: - return Msg.Subscribe; - case Id.SubscribeOk: - return Msg.SubscribeOk; - case Id.SubscribeDone: - return Msg.SubscribeDone; - case Id.SubscribeError: - return Msg.SubscribeError; - case Id.Unsubscribe: - return Msg.Unsubscribe; - case Id.Announce: - return Msg.Announce; - case Id.AnnounceOk: - return Msg.AnnounceOk; - case Id.AnnounceError: - return Msg.AnnounceError; - case Id.Unannounce: - return Msg.Unannounce; - case Id.GoAway: - return Msg.GoAway; - } - throw new Error(`unknown control message type: ${t}`); - } - async message() { - const t = await this.msg(); - switch (t) { - case Msg.Subscribe: - return this.subscribe(); - case Msg.SubscribeOk: - return this.subscribe_ok(); - case Msg.SubscribeError: - return this.subscribe_error(); - case Msg.SubscribeDone: - return this.subscribe_done(); - case Msg.Unsubscribe: - return this.unsubscribe(); - case Msg.Announce: - return this.announce(); - case Msg.AnnounceOk: - return this.announce_ok(); - case Msg.Unannounce: - return this.unannounce(); - case Msg.AnnounceError: - return this.announce_error(); - case Msg.GoAway: - throw new Error("TODO: implement go away"); - } - } - async subscribe() { - return { - kind: Msg.Subscribe, - id: await this.r.u62(), - trackId: await this.r.u62(), - namespace: await this.r.string(), - name: await this.r.string(), - subscriber_priority: await this.r.u8(), - group_order: await this.decodeGroupOrder(), - location: await this.location(), - params: await this.parameters(), - }; - } - async decodeGroupOrder() { - const orderCode = await this.r.u8(); - switch (orderCode) { - case 0: - return GroupOrder.Publisher; - case 1: - return GroupOrder.Ascending; - case 2: - return GroupOrder.Descending; - default: - throw new Error(`Invalid GroupOrder value: ${orderCode}`); - } - } - async location() { - const mode = await this.r.u62(); - if (mode == 1n) { - return { - mode: "latest_group", - }; - } - else if (mode == 2n) { - return { - mode: "latest_object", - }; - } - else if (mode == 3n) { - return { - mode: "absolute_start", - start_group: await this.r.u53(), - start_object: await this.r.u53(), - }; - } - else if (mode == 4n) { - return { - mode: "absolute_range", - start_group: await this.r.u53(), - start_object: await this.r.u53(), - end_group: await this.r.u53(), - end_object: await this.r.u53(), - }; - } - else { - throw new Error(`invalid filter type: ${mode}`); - } - } - async parameters() { - const count = await this.r.u53(); - if (count == 0) - return undefined; - const params = new Map(); - for (let i = 0; i < count; i++) { - const id = await this.r.u62(); - const size = await this.r.u53(); - const value = await this.r.read(size); - if (params.has(id)) { - throw new Error(`duplicate parameter id: ${id}`); - } - params.set(id, value); - } - return params; - } - async subscribe_ok() { - const id = await this.r.u62(); - const expires = await this.r.u62(); - const group_order = await this.decodeGroupOrder(); - let latest; - const flag = await this.r.u8(); - if (flag === 1) { - latest = [await this.r.u53(), await this.r.u53()]; - } - else if (flag !== 0) { - throw new Error(`invalid final flag: ${flag}`); - } - return { - kind: Msg.SubscribeOk, - id, - expires, - group_order, - latest, - }; - } - async subscribe_done() { - const id = await this.r.u62(); - const code = await this.r.u62(); - const reason = await this.r.string(); - let final; - const flag = await this.r.u8(); - if (flag === 1) { - final = [await this.r.u53(), await this.r.u53()]; - } - else if (flag !== 0) { - throw new Error(`invalid final flag: ${flag}`); - } - return { - kind: Msg.SubscribeDone, - id, - code, - reason, - final, - }; - } - async subscribe_error() { - return { - kind: Msg.SubscribeError, - id: await this.r.u62(), - code: await this.r.u62(), - reason: await this.r.string(), - }; - } - async unsubscribe() { - return { - kind: Msg.Unsubscribe, - id: await this.r.u62(), - }; - } - async announce() { - const namespace = await this.r.string(); - return { - kind: Msg.Announce, - namespace, - params: await this.parameters(), - }; - } - async announce_ok() { - return { - kind: Msg.AnnounceOk, - namespace: await this.r.string(), - }; - } - async announce_error() { - return { - kind: Msg.AnnounceError, - namespace: await this.r.string(), - code: await this.r.u62(), - reason: await this.r.string(), - }; - } - async unannounce() { - return { - kind: Msg.Unannounce, - namespace: await this.r.string(), - }; - } - } - class Encoder { - w; - constructor(w) { - this.w = w; - } - async message(m) { - switch (m.kind) { - case Msg.Subscribe: - return this.subscribe(m); - case Msg.SubscribeOk: - return this.subscribe_ok(m); - case Msg.SubscribeError: - return this.subscribe_error(m); - case Msg.SubscribeDone: - return this.subscribe_done(m); - case Msg.Unsubscribe: - return this.unsubscribe(m); - case Msg.Announce: - return this.announce(m); - case Msg.AnnounceOk: - return this.announce_ok(m); - case Msg.AnnounceError: - return this.announce_error(m); - case Msg.Unannounce: - return this.unannounce(m); - } - } - async subscribe(s) { - await this.w.u53(Id.Subscribe); - await this.w.u62(s.id); - await this.w.u62(s.trackId); - await this.w.string(s.namespace); - await this.w.string(s.name); - await this.w.u8(s.subscriber_priority ?? 127); - await this.encodeGroupOrder(s.group_order ?? GroupOrder.Publisher); - await this.location(s.location); - await this.parameters(s.params); - } - async encodeGroupOrder(order) { - switch (order) { - case GroupOrder.Publisher: - await this.w.u8(GroupOrder.Publisher); - break; - case GroupOrder.Ascending: - await this.w.u8(GroupOrder.Ascending); - break; - case GroupOrder.Descending: - await this.w.u8(GroupOrder.Descending); - break; - default: - throw new Error("Invalid GroupOrder value"); - } - } - async location(l) { - switch (l.mode) { - case "latest_group": - await this.w.u62(1n); - break; - case "latest_object": - await this.w.u62(2n); - break; - case "absolute_start": - await this.w.u62(3n); - await this.w.u53(l.start_group); - await this.w.u53(l.start_object); - break; - case "absolute_range": - await this.w.u62(3n); - await this.w.u53(l.start_group); - await this.w.u53(l.start_object); - await this.w.u53(l.end_group); - await this.w.u53(l.end_object); - } - } - async parameters(p) { - if (!p) { - await this.w.u8(0); - return; - } - await this.w.u53(p.size); - for (const [id, value] of p) { - await this.w.u62(id); - await this.w.u53(value.length); - await this.w.write(value); - } - } - async subscribe_ok(s) { - await this.w.u53(Id.SubscribeOk); - await this.w.u62(s.id); - await this.w.u62(s.expires); - await this.encodeGroupOrder(s.group_order); - if (s.latest !== undefined) { - await this.w.u8(1); - await this.w.u53(s.latest[0]); - await this.w.u53(s.latest[1]); - } - else { - await this.w.u8(0); - } - } - async subscribe_done(s) { - await this.w.u53(Id.SubscribeDone); - await this.w.u62(s.id); - await this.w.u62(s.code); - await this.w.string(s.reason); - if (s.final !== undefined) { - await this.w.u8(1); - await this.w.u53(s.final[0]); - await this.w.u53(s.final[1]); - } - else { - await this.w.u8(0); - } - } - async subscribe_error(s) { - await this.w.u53(Id.SubscribeError); - await this.w.u62(s.id); - } - async unsubscribe(s) { - await this.w.u53(Id.Unsubscribe); - await this.w.u62(s.id); - } - async announce(a) { - await this.w.u53(Id.Announce); - await this.w.string(a.namespace); - await this.w.u53(0); // parameters - } - async announce_ok(a) { - await this.w.u53(Id.AnnounceOk); - await this.w.string(a.namespace); - } - async announce_error(a) { - await this.w.u53(Id.AnnounceError); - await this.w.string(a.namespace); - await this.w.u62(a.code); - await this.w.string(a.reason); - } - async unannounce(a) { - await this.w.u53(Id.Unannounce); - await this.w.string(a.namespace); - } - } - - var StreamType; - (function (StreamType) { - StreamType[StreamType["Object"] = 0] = "Object"; - StreamType[StreamType["Track"] = 80] = "Track"; - StreamType[StreamType["Group"] = 81] = "Group"; - })(StreamType || (StreamType = {})); - var Status; - (function (Status) { - Status[Status["OBJECT_NULL"] = 1] = "OBJECT_NULL"; - Status[Status["GROUP_NULL"] = 2] = "GROUP_NULL"; - Status[Status["GROUP_END"] = 3] = "GROUP_END"; - Status[Status["TRACK_END"] = 4] = "TRACK_END"; - })(Status || (Status = {})); - class Objects { - quic; - constructor(quic) { - this.quic = quic; - } - async send(h) { - const stream = await this.quic.createUnidirectionalStream(); - const w = new Writer(stream); - await w.u53(h.type); - await w.u62(h.sub); - await w.u62(h.track); - let res; - if (h.type == StreamType.Object) { - await w.u53(h.group); - await w.u53(h.object); - await w.u8(h.publisher_priority); - await w.u53(h.status); - res = new ObjectWriter(h, w); - } - else if (h.type === StreamType.Group) { - await w.u53(h.group); - await w.u8(h.publisher_priority); - res = new GroupWriter(h, w); - } - else if (h.type === StreamType.Track) { - await w.u8(h.publisher_priority); - res = new TrackWriter(h, w); - } - else { - throw new Error("unknown header type"); - } - // console.trace("send object", res.header) - return res; - } - async recv() { - const streams = this.quic.incomingUnidirectionalStreams.getReader(); - const { value, done } = await streams.read(); - streams.releaseLock(); - if (done) - return; - const r = new Reader(new Uint8Array(), value); - const type = (await r.u53()); - let res; - if (type == StreamType.Track) { - const h = { - type, - sub: await r.u62(), - track: await r.u62(), - publisher_priority: await r.u8(), - }; - res = new TrackReader(h, r); - } - else if (type == StreamType.Group) { - const h = { - type, - sub: await r.u62(), - track: await r.u62(), - group: await r.u53(), - publisher_priority: await r.u8(), - }; - res = new GroupReader(h, r); - } - else if (type == StreamType.Object) { - const h = { - type, - sub: await r.u62(), - track: await r.u62(), - group: await r.u53(), - object: await r.u53(), - status: await r.u53(), - publisher_priority: await r.u8(), - }; - res = new ObjectReader(h, r); - } - else { - throw new Error("unknown stream type"); - } - // console.trace("receive object", res.header) - return res; - } - } - class TrackWriter { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async write(c) { - await this.stream.u53(c.group); - await this.stream.u53(c.object); - if (c.payload instanceof Uint8Array) { - await this.stream.u53(c.payload.byteLength); - await this.stream.write(c.payload); - } - else { - // empty payload with status - await this.stream.u53(0); - await this.stream.u53(c.payload); - } - } - async close() { - await this.stream.close(); - } - } - class GroupWriter { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async write(c) { - await this.stream.u53(c.object); - if (c.payload instanceof Uint8Array) { - await this.stream.u53(c.payload.byteLength); - await this.stream.write(c.payload); - } - else { - await this.stream.u53(0); - await this.stream.u53(c.payload); - } - } - async close() { - await this.stream.close(); - } - } - class ObjectWriter { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async write(c) { - await this.stream.write(c.payload); - } - async close() { - await this.stream.close(); - } - } - class TrackReader { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async read() { - if (await this.stream.done()) { - return; - } - const group = await this.stream.u53(); - const object = await this.stream.u53(); - const size = await this.stream.u53(); - let payload; - if (size == 0) { - payload = (await this.stream.u53()); - } - else { - payload = await this.stream.read(size); - } - return { - group, - object, - payload, - }; - } - async close() { - await this.stream.close(); - } - } - class GroupReader { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async read() { - if (await this.stream.done()) { - return; - } - const object = await this.stream.u53(); - const size = await this.stream.u53(); - let payload; - if (size == 0) { - payload = (await this.stream.u53()); - } - else { - payload = await this.stream.read(size); - } - return { - object, - payload, - }; - } - async close() { - await this.stream.close(); - } - } - class ObjectReader { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - // NOTE: Can only be called once. - async read() { - if (await this.stream.done()) { - return; - } - return { - payload: await this.stream.readAll(), - }; - } - async close() { - await this.stream.close(); - } - } - - class Deferred { - promise; - resolve; - reject; - pending = true; - constructor() { - this.promise = new Promise((resolve, reject) => { - this.resolve = (value) => { - this.pending = false; - resolve(value); - }; - this.reject = (reason) => { - this.pending = false; - reject(reason); - }; - }); - } - } - class Watch { - #current; - #next = new Deferred(); - constructor(init) { - this.#next = new Deferred(); - this.#current = [init, this.#next.promise]; - } - value() { - return this.#current; - } - update(v) { - if (!this.#next.pending) { - throw new Error("already closed"); - } - // If we're given a function, call it with the current value - if (v instanceof Function) { - v = v(this.#current[0]); - } - const next = new Deferred(); - this.#current = [v, next.promise]; - this.#next.resolve(this.#current); - this.#next = next; - } - close() { - this.#current[1] = undefined; - this.#next.resolve(this.#current); - } - } - // Allows queuing N values, like a Channel. - class Queue { - #stream; - #closed = false; - constructor(capacity = 1) { - const queue = new CountQueuingStrategy({ highWaterMark: capacity }); - this.#stream = new TransformStream({}, undefined, queue); - } - async push(v) { - const w = this.#stream.writable.getWriter(); - await w.write(v); - w.releaseLock(); - } - async next() { - const r = this.#stream.readable.getReader(); - const { value, done } = await r.read(); - r.releaseLock(); - if (done) - return; - return value; - } - async abort(err) { - if (this.#closed) - return; - await this.#stream.writable.abort(err); - this.#closed = true; - } - async close() { - if (this.#closed) - return; - await this.#stream.writable.close(); - this.#closed = true; - } - closed() { - return this.#closed; - } - } - - class Publisher { - // Used to send control messages - #control; - // Use to send objects. - #objects; - // Our announced tracks. - #announce = new Map(); - // Their subscribed tracks. - #subscribe = new Map(); - #subscribeQueue = new Queue(Number.MAX_SAFE_INTEGER); // Unbounded queue in case there's no receiver - constructor(control, objects) { - this.#control = control; - this.#objects = objects; - } - // Announce a track namespace. - async announce(namespace) { - if (this.#announce.has(namespace)) { - throw new Error(`already announce: ${namespace}`); - } - const announce = new AnnounceSend(this.#control, namespace); - this.#announce.set(namespace, announce); - await this.#control.send({ - kind: Msg.Announce, - namespace, - }); - return announce; - } - // Receive the next new subscription - async subscribed() { - return await this.#subscribeQueue.next(); - } - async recv(msg) { - if (msg.kind == Msg.Subscribe) { - await this.recvSubscribe(msg); - } - else if (msg.kind == Msg.Unsubscribe) { - this.recvUnsubscribe(msg); - } - else if (msg.kind == Msg.AnnounceOk) { - this.recvAnnounceOk(msg); - } - else if (msg.kind == Msg.AnnounceError) { - this.recvAnnounceError(msg); - } - else { - throw new Error(`unknown control message`); // impossible - } - } - recvAnnounceOk(msg) { - const announce = this.#announce.get(msg.namespace); - if (!announce) { - throw new Error(`announce OK for unknown announce: ${msg.namespace}`); - } - announce.onOk(); - } - recvAnnounceError(msg) { - const announce = this.#announce.get(msg.namespace); - if (!announce) { - // TODO debug this - console.warn(`announce error for unknown announce: ${msg.namespace}`); - return; - } - announce.onError(msg.code, msg.reason); - } - async recvSubscribe(msg) { - if (this.#subscribe.has(msg.id)) { - throw new Error(`duplicate subscribe for id: ${msg.id}`); - } - const subscribe = new SubscribeRecv(this.#control, this.#objects, msg); - this.#subscribe.set(msg.id, subscribe); - await this.#subscribeQueue.push(subscribe); - await this.#control.send({ - kind: Msg.SubscribeOk, - id: msg.id, - expires: 0n, - group_order: msg.group_order, - }); - } - recvUnsubscribe(_msg) { - throw new Error("TODO unsubscribe"); - } - } - class AnnounceSend { - #control; - namespace; - // The current state, updated by control messages. - #state = new Watch("init"); - constructor(control, namespace) { - this.#control = control; - this.namespace = namespace; - } - async ok() { - for (;;) { - const [state, next] = this.#state.value(); - if (state === "ack") - return; - if (state instanceof Error) - throw state; - if (!next) - throw new Error("closed"); - await next; - } - } - async active() { - for (;;) { - const [state, next] = this.#state.value(); - if (state instanceof Error) - throw state; - if (!next) - return; - await next; - } - } - async close() { - // TODO implement unsubscribe - // await this.#inner.sendUnsubscribe() - } - closed() { - const [state, next] = this.#state.value(); - return state instanceof Error || next == undefined; - } - onOk() { - if (this.closed()) - return; - this.#state.update("ack"); - } - onError(code, reason) { - if (this.closed()) - return; - const err = new Error(`ANNOUNCE_ERROR (${code})` + reason ? `: ${reason}` : ""); - this.#state.update(err); - } - } - class SubscribeRecv { - #control; - #objects; - #id; - #trackId; - #subscriberPriority; - groupOrder; - namespace; - track; - // The current state of the subscription. - #state = "init"; - constructor(control, objects, msg) { - this.#control = control; // so we can send messages - this.#objects = objects; // so we can send objects - this.#id = msg.id; - this.#trackId = msg.trackId; - this.namespace = msg.namespace; - this.track = msg.name; - this.#subscriberPriority = msg.subscriber_priority; - this.groupOrder = msg.group_order; - } - // Acknowledge the subscription as valid. - async ack() { - if (this.#state !== "init") - return; - this.#state = "ack"; - // Send the control message. - return this.#control.send({ - kind: Msg.SubscribeOk, - id: this.#id, - expires: 0n, - group_order: this.groupOrder, - }); - } - // Close the subscription with an error. - async close(code = 0n, reason = "") { - if (this.#state === "closed") - return; - this.#state = "closed"; - return this.#control.send({ - kind: Msg.SubscribeDone, - id: this.#id, - code, - reason, - }); - } - // Create a writable data stream for the entire track - async serve(props) { - return this.#objects.send({ - type: StreamType.Track, - sub: this.#id, - track: this.#trackId, - publisher_priority: props?.priority ?? 127, - }); - } - // Create a writable data stream for a group within the track - async group(props) { - return this.#objects.send({ - type: StreamType.Group, - sub: this.#id, - track: this.#trackId, - group: props.group, - publisher_priority: props.priority ?? 127, - }); - } - // Create a writable data stream for a single object within the track - async object(props) { - return this.#objects.send({ - type: StreamType.Object, - sub: this.#id, - track: this.#trackId, - group: props.group, - object: props.object, - publisher_priority: props.priority ?? 127, - status: 0, - }); - } - } - - class Subscriber { - // Use to send control messages. - #control; - // Use to send objects. - #objects; - // Announced broadcasts. - #announce = new Map(); - #announceQueue = new Watch([]); - // Our subscribed tracks. - #subscribe = new Map(); - #subscribeNext = 0n; - #trackToIDMap = new Map(); - constructor(control, objects) { - this.#control = control; - this.#objects = objects; - } - announced() { - return this.#announceQueue; - } - async recv(msg) { - if (msg.kind == Msg.Announce) { - await this.recvAnnounce(msg); - } - else if (msg.kind == Msg.Unannounce) { - this.recvUnannounce(msg); - } - else if (msg.kind == Msg.SubscribeOk) { - this.recvSubscribeOk(msg); - } - else if (msg.kind == Msg.SubscribeError) { - await this.recvSubscribeError(msg); - } - else if (msg.kind == Msg.SubscribeDone) { - await this.recvSubscribeDone(msg); - } - else { - throw new Error(`unknown control message`); // impossible - } - } - async recvAnnounce(msg) { - if (this.#announce.has(msg.namespace)) { - throw new Error(`duplicate announce for namespace: ${msg.namespace}`); - } - await this.#control.send({ kind: Msg.AnnounceOk, namespace: msg.namespace }); - const announce = new AnnounceRecv(this.#control, msg.namespace); - this.#announce.set(msg.namespace, announce); - this.#announceQueue.update((queue) => [...queue, announce]); - } - recvUnannounce(_msg) { - throw new Error(`TODO Unannounce`); - } - async subscribe(namespace, track) { - const id = this.#subscribeNext++; - const subscribe = new SubscribeSend(this.#control, id, namespace, track); - this.#subscribe.set(id, subscribe); - this.#trackToIDMap.set(track, id); - await this.#control.send({ - kind: Msg.Subscribe, - id, - trackId: id, - namespace, - name: track, - subscriber_priority: 127, // default to mid value, see: https://github.com/moq-wg/moq-transport/issues/504 - group_order: GroupOrder.Publisher, - location: { - mode: "latest_group", - }, - }); - return subscribe; - } - async unsubscribe(track) { - if (this.#trackToIDMap.has(track)) { - const trackID = this.#trackToIDMap.get(track); - if (trackID === undefined) { - console.warn(`Exception track ${track} not found in trackToIDMap.`); - return; - } - try { - await this.#control.send({ kind: Msg.Unsubscribe, id: trackID }); - this.#trackToIDMap.delete(track); - } - catch (error) { - console.error(`Failed to unsubscribe from track ${track}:`, error); - } - } - else { - console.warn(`During unsubscribe request initiation attempt track ${track} not found in trackToIDMap.`); - } - } - recvSubscribeOk(msg) { - const subscribe = this.#subscribe.get(msg.id); - if (!subscribe) { - throw new Error(`subscribe ok for unknown id: ${msg.id}`); - } - subscribe.onOk(); - } - async recvSubscribeError(msg) { - const subscribe = this.#subscribe.get(msg.id); - if (!subscribe) { - throw new Error(`subscribe error for unknown id: ${msg.id}`); - } - await subscribe.onError(msg.code, msg.reason); - } - async recvSubscribeDone(msg) { - const subscribe = this.#subscribe.get(msg.id); - if (!subscribe) { - throw new Error(`subscribe error for unknown id: ${msg.id}`); - } - await subscribe.onError(msg.code, msg.reason); - } - async recvObject(reader) { - const subscribe = this.#subscribe.get(reader.header.track); - if (!subscribe) { - throw new Error(`data for for unknown track: ${reader.header.track}`); - } - await subscribe.onData(reader); - } - } - class AnnounceRecv { - #control; - namespace; - // The current state of the announce - #state = "init"; - constructor(control, namespace) { - this.#control = control; // so we can send messages - this.namespace = namespace; - } - // Acknowledge the subscription as valid. - async ok() { - if (this.#state !== "init") - return; - this.#state = "ack"; - // Send the control message. - return this.#control.send({ kind: Msg.AnnounceOk, namespace: this.namespace }); - } - async close(code = 0n, reason = "") { - if (this.#state === "closed") - return; - this.#state = "closed"; - return this.#control.send({ kind: Msg.AnnounceError, namespace: this.namespace, code, reason }); - } - } - class SubscribeSend { - #control; - #id; - namespace; - track; - // A queue of received streams for this subscription. - #data = new Queue(); - constructor(control, id, namespace, track) { - this.#control = control; // so we can send messages - this.#id = id; - this.namespace = namespace; - this.track = track; - } - async close(_code = 0n, _reason = "") { - // TODO implement unsubscribe - // await this.#inner.sendReset(code, reason) - } - onOk() { - // noop - } - async onError(code, reason) { - if (code == 0n) { - return await this.#data.close(); - } - if (reason !== "") { - reason = `: ${reason}`; - } - const err = new Error(`SUBSCRIBE_ERROR (${code})${reason}`); - return await this.#data.abort(err); - } - async onData(reader) { - if (!this.#data.closed()) - await this.#data.push(reader); - } - // Receive the next a readable data stream - async data() { - return await this.#data.next(); - } - } - - class Connection { - // The established WebTransport session. - #quic; - // Use to receive/send control messages. - #control; - // Use to receive/send objects. - #objects; - // Module for contributing tracks. - #publisher; - // Module for distributing tracks. - #subscriber; - // Async work running in the background - #running; - constructor(quic, control, objects) { - this.#quic = quic; - this.#control = control; - this.#objects = objects; - this.#publisher = new Publisher(this.#control, this.#objects); - this.#subscriber = new Subscriber(this.#control, this.#objects); - this.#running = this.#run(); - } - close(code = 0, reason = "") { - this.#quic.close({ closeCode: code, reason }); - } - async #run() { - await Promise.all([this.#runControl(), this.#runObjects()]); - } - announce(namespace) { - return this.#publisher.announce(namespace); - } - announced() { - return this.#subscriber.announced(); - } - subscribe(namespace, track) { - return this.#subscriber.subscribe(namespace, track); - } - unsubscribe(track) { - return this.#subscriber.unsubscribe(track); - } - subscribed() { - return this.#publisher.subscribed(); - } - async #runControl() { - // Receive messages until the connection is closed. - for (;;) { - const msg = await this.#control.recv(); - await this.#recv(msg); - } - } - async #runObjects() { - for (;;) { - const obj = await this.#objects.recv(); - if (!obj) - break; - await this.#subscriber.recvObject(obj); - } - } - async #recv(msg) { - if (isPublisher(msg)) { - await this.#subscriber.recv(msg); - } - else { - await this.#publisher.recv(msg); - } - } - async closed() { - try { - await this.#running; - return new Error("closed"); - } - catch (e) { - return asError(e); - } - } - } - - class Client { - #fingerprint; - config; - constructor(config) { - this.config = config; - this.#fingerprint = this.#fetchFingerprint(config.fingerprint).catch((e) => { - console.warn("failed to fetch fingerprint: ", e); - return undefined; - }); - } - async connect() { - // Helper function to make creating a promise easier - const options = {}; - const fingerprint = await this.#fingerprint; - if (fingerprint) - options.serverCertificateHashes = [fingerprint]; - const quic = new WebTransport(this.config.url, options); - await quic.ready; - const stream = await quic.createBidirectionalStream(); - const writer = new Writer(stream.writable); - const reader = new Reader(new Uint8Array(), stream.readable); - const setup = new Stream$1(reader, writer); - // Send the setup message. - await setup.send.client({ versions: [Version.DRAFT_05], role: this.config.role }); - // Receive the setup message. - // TODO verify the SETUP response. - const server = await setup.recv.server(); - if (server.version != Version.DRAFT_05) { - throw new Error(`unsupported server version: ${server.version}`); - } - const control = new Stream(reader, writer); - const objects = new Objects(quic); - return new Connection(quic, control, objects); - } - async #fetchFingerprint(url) { - if (!url) - return; - // TODO remove this fingerprint when Chrome WebTransport accepts the system CA - const response = await fetch(url); - const hexString = await response.text(); - const hexBytes = new Uint8Array(hexString.length / 2); - for (let i = 0; i < hexBytes.length; i += 1) { - hexBytes[i] = parseInt(hexString.slice(2 * i, 2 * i + 2), 16); - } - return { - algorithm: "sha-256", - value: hexBytes, - }; - } - } - - // This class must be created on the main thread due to AudioContext. - class Player { - #backend; - // A periodically updated timeline - //#timeline = new Watch(undefined) - #connection; - #catalog; - #tracksByName; - #tracknum; - #audioTrackName; - #videoTrackName; - #muted; - #paused; - // Running is a promise that resolves when the player is closed. - // #close is called with no error, while #abort is called with an error. - #running; - #close; - #abort; - #trackTasks = new Map(); - constructor(connection, catalog, backend, tracknum) { - this.#connection = connection; - this.#catalog = catalog; - this.#tracksByName = new Map(catalog.tracks.map((track) => [track.name, track])); - this.#backend = backend; - this.#tracknum = tracknum; - this.#audioTrackName = ""; - this.#videoTrackName = ""; - this.#muted = false; - this.#paused = false; - const abort = new Promise((resolve, reject) => { - this.#close = resolve; - this.#abort = reject; - }); - // Async work - this.#running = abort.catch(this.#close); - this.#run().catch((err) => { - console.error("Error in #run():", err); - this.#abort(err); - }); - } - static async create(config, tracknum) { - const client = new Client({ url: config.url, fingerprint: config.fingerprint, role: "subscriber" }); - const connection = await client.connect(); - const catalog = await fetch$1(connection, config.namespace); - console.log("catalog", catalog); - const canvas = config.canvas.transferControlToOffscreen(); - const backend = new Backend({ canvas, catalog }); - return new Player(connection, catalog, backend, tracknum); - } - async #run() { - const inits = new Set(); - const tracks = new Array(); - this.#catalog.tracks.forEach((track, index) => { - if (index == this.#tracknum || isAudioTrack(track)) { - if (!track.namespace) - throw new Error("track has no namespace"); - if (track.initTrack) - inits.add([track.namespace, track.initTrack]); - tracks.push(track); - } - }); - // Call #runInit on each unique init track - // TODO do this in parallel with #runTrack to remove a round trip - await Promise.all(Array.from(inits).map((init) => this.#runInit(...init))); - // Call #runTrack on each track - tracks.forEach((track) => { - this.#runTrack(track); - }); - } - async #runInit(namespace, name) { - const sub = await this.#connection.subscribe(namespace, name); - try { - const init = await Promise.race([sub.data(), this.#running]); - if (!init) - throw new Error("no init data"); - // We don't care what type of reader we get, we just want the payload. - const chunk = await init.read(); - if (!chunk) - throw new Error("no init chunk"); - if (!(chunk.payload instanceof Uint8Array)) - throw new Error("invalid init chunk"); - this.#backend.init({ data: chunk.payload, name }); - } - finally { - await sub.close(); - } - } - async #trackTask(track) { - if (!track.namespace) - throw new Error("track has no namespace"); - if (this.#paused) - return; - const kind = isVideoTrack(track) ? "video" : isAudioTrack(track) ? "audio" : "unknown"; - if (kind == "audio" && this.#muted) - return; - const sub = await this.#connection.subscribe(track.namespace, track.name); - if (kind == "audio") { - // Save ref to last audio track we subscribed to for unmuting - this.#audioTrackName = track.name; - } - if (kind == "video") { - this.#videoTrackName = track.name; - } - try { - for (;;) { - const segment = await Promise.race([sub.data(), this.#running]); - if (!segment) - continue; - if (!(segment instanceof GroupReader)) { - throw new Error(`expected group reader for segment: ${track.name}`); - } - if (kind == "unknown") { - throw new Error(`unknown track kind: ${track.name}`); - } - if (!track.initTrack) { - throw new Error(`no init track for segment: ${track.name}`); - } - const [buffer, stream] = segment.stream.release(); - this.#backend.segment({ - init: track.initTrack, - kind, - header: segment.header, - buffer, - stream, - }); - } - } - catch (error) { - console.error("Error in #runTrack:", error); - } - finally { - await sub.close(); - } - } - #runTrack(track) { - if (this.#trackTasks.has(track.name)) { - console.warn(`Already exist a runTrack task for the track: ${track.name}`); - return; - } - const task = (async () => this.#trackTask(track))(); - this.#trackTasks.set(track.name, task); - task.catch((err) => { - console.error(`Error to subscribe to track ${track.name}`, err); - }).finally(() => { - this.#trackTasks.delete(track.name); - }); - } - getCatalog() { - return this.#catalog; - } - getCurrentTrack() { - if (this.#tracknum >= 0 && this.#tracknum < this.#catalog.tracks.length) { - return this.#catalog.tracks[this.#tracknum]; - } - else { - console.warn("Invalid track number:", this.#tracknum); - return null; - } - } - getVideoTracks() { - return this.#catalog.tracks.filter(isVideoTrack).map((track) => track.name); - } - getAudioTracks() { - return this.#catalog.tracks.filter(isAudioTrack).map((track) => track.name); - } - async switchTrack(trackname) { - const currentTrack = this.getCurrentTrack(); - if (this.#paused) { - this.#videoTrackName = trackname; - return; - } - if (currentTrack) { - console.log(`Unsubscribing from track: ${currentTrack.name} and Subscribing to track: ${trackname}`); - await this.unsubscribeFromTrack(currentTrack.name); - } - else { - console.log(`Subscribing to track: ${trackname}`); - } - this.#tracknum = this.#catalog.tracks.findIndex((track) => track.name === trackname); - const tracksToStream = this.#catalog.tracks.filter((track) => track.name === trackname); - await Promise.all(tracksToStream.map((track) => this.#runTrack(track))); - } - async mute(isMuted) { - this.#muted = isMuted; - if (isMuted) { - console.log("Unsubscribing from audio track: ", this.#audioTrackName); - await this.unsubscribeFromTrack(this.#audioTrackName); - await this.#backend.mute(); - } - else { - console.log("Subscribing to audio track: ", this.#audioTrackName); - this.subscribeFromTrackName(this.#audioTrackName); - await this.#backend.unmute(); - } - } - async unsubscribeFromTrack(trackname) { - console.log(`Unsubscribing from track: ${trackname}`); - await this.#connection.unsubscribe(trackname); - const task = this.#trackTasks.get(trackname); - if (task) { - await task; - } - } - subscribeFromTrackName(trackname) { - console.log(`Subscribing to track: ${trackname}`); - const track = this.#tracksByName.get(trackname); - if (track) { - this.#runTrack(track); - } - else { - console.warn(`Track ${trackname} not in #tracksByName`); - } - } - #onMessage(msg) { - if (msg.timeline) ; - } - async close(err) { - if (err) - this.#abort(err); - else - this.#close(); - if (this.#connection) - this.#connection.close(); - if (this.#backend) - await this.#backend.close(); - } - async closed() { - try { - await this.#running; - } - catch (e) { - return asError(e); - } - } - /* - play() { - this.#backend.play({ minBuffer: 0.5 }) // TODO configurable - } - - seek(timestamp: number) { - this.#backend.seek({ timestamp }) - } - */ - async play() { - if (this.#paused) { - this.#paused = false; - this.subscribeFromTrackName(this.#videoTrackName); - if (!this.#muted) { - this.subscribeFromTrackName(this.#audioTrackName); - await this.#backend.unmute(); - } - } - else { - await this.unsubscribeFromTrack(this.#videoTrackName); - await this.unsubscribeFromTrack(this.#audioTrackName); - await this.#backend.mute(); - this.#backend.pause(); - this.#paused = true; - } - } - } - - return Player; - -})(); -//# sourceMappingURL=moq-player.umd.js.map diff --git a/simple-web/public/moq-player.umd.js.map b/simple-web/public/moq-player.umd.js.map deleted file mode 100644 index 93f5f7c..0000000 --- a/simple-web/public/moq-player.umd.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"moq-player.umd.js","sources":["../../common/error.ts","../../media/catalog/index.ts","../../playback/audio.ts","../../common/ring.ts","../../playback/backend.ts","../../transport/stream.ts","../../transport/setup.ts","../../transport/control.ts","../../transport/objects.ts","../../common/async.ts","../../transport/publisher.ts","../../transport/subscriber.ts","../../transport/connection.ts","../../transport/client.ts","../../playback/index.ts"],"sourcesContent":["// I hate javascript\nexport function asError(e: any): Error {\n\tif (e instanceof Error) {\n\t\treturn e\n\t} else if (typeof e === \"string\") {\n\t\treturn new Error(e)\n\t} else {\n\t\treturn new Error(String(e))\n\t}\n}\n\nexport function isError(e: any): e is Error {\n\treturn e instanceof Error\n}\n","import { Connection } from \"../../transport\"\nimport { asError } from \"../../common/error\"\n\nexport interface CommonTrackFields {\n\tnamespace?: string\n\tpackaging?: string\n\trenderGroup?: number\n\taltGroup?: number\n}\n\nexport interface Root {\n\tversion: number\n\tstreamingFormat: number\n\tstreamingFormatVersion: string\n\tsupportsDeltaUpdates: boolean\n\tcommonTrackFields: CommonTrackFields\n\ttracks: Track[]\n}\n\nexport function encode(catalog: Root): Uint8Array {\n\tconst encoder = new TextEncoder()\n\tconst str = JSON.stringify(catalog)\n\treturn encoder.encode(str)\n}\n\nexport function decode(raw: Uint8Array): Root {\n\tconst decoder = new TextDecoder()\n\tconst str = decoder.decode(raw)\n\n\tconst catalog = JSON.parse(str)\n\tif (!isRoot(catalog)) {\n\t\tthrow new Error(\"invalid catalog\")\n\t}\n\n\t// Merge common track fields into each track.\n\tfor (const track of catalog.tracks) {\n\t\ttrack.altGroup ??= catalog.commonTrackFields.altGroup\n\t\ttrack.namespace ??= catalog.commonTrackFields.namespace\n\t\ttrack.packaging ??= catalog.commonTrackFields.packaging\n\t\ttrack.renderGroup ??= catalog.commonTrackFields.renderGroup\n\t}\n\n\treturn catalog\n}\n\nexport async function fetch(connection: Connection, namespace: string): Promise {\n\tconst subscribe = await connection.subscribe(namespace, \".catalog\")\n\ttry {\n\t\tconst segment = await subscribe.data()\n\t\tif (!segment) throw new Error(\"no catalog data\")\n\n\t\tconst chunk = await segment.read()\n\t\tif (!chunk) throw new Error(\"no catalog chunk\")\n\n\t\tawait segment.close()\n\t\tawait subscribe.close() // we done\n\n\t\tif (chunk.payload instanceof Uint8Array) {\n\t\t\treturn decode(chunk.payload)\n\t\t} else {\n\t\t\tthrow new Error(\"invalid catalog chunk\")\n\t\t}\n\t} catch (e) {\n\t\tconst err = asError(e)\n\n\t\t// Close the subscription after we're done.\n\t\tawait subscribe.close(1n, err.message)\n\n\t\tthrow err\n\t}\n}\n\nexport function isRoot(catalog: any): catalog is Root {\n\tif (!isCatalogFieldValid(catalog, \"packaging\")) return false\n\tif (!isCatalogFieldValid(catalog, \"namespace\")) return false\n\tif (!Array.isArray(catalog.tracks)) return false\n\treturn catalog.tracks.every((track: any) => isTrack(track))\n}\n\nexport interface Track {\n\tnamespace?: string\n\tname: string\n\tdepends?: any[]\n\tpackaging?: string\n\trenderGroup?: number\n\tselectionParams: SelectionParams // technically optional but not really\n\taltGroup?: number\n\tinitTrack?: string\n\tinitData?: string\n}\n\nexport interface Mp4Track extends Track {\n\tinitTrack?: string\n\tinitData?: string\n\tselectionParams: Mp4SelectionParams\n}\n\nexport interface SelectionParams {\n\tcodec?: string\n\tmimeType?: string\n\tbitrate?: number\n\tlang?: string\n}\n\nexport interface Mp4SelectionParams extends SelectionParams {\n\tmimeType: \"video/mp4\"\n}\n\nexport interface AudioTrack extends Track {\n\tname: string\n\tselectionParams: AudioSelectionParams\n}\n\nexport interface AudioSelectionParams extends SelectionParams {\n\tsamplerate: number\n\tchannelConfig: string\n}\n\nexport interface VideoTrack extends Track {\n\tname: string\n\tselectionParams: VideoSelectionParams\n\ttemporalId?: number\n\tspatialId?: number\n}\n\nexport interface VideoSelectionParams extends SelectionParams {\n\twidth: number\n\theight: number\n\tdisplayWidth?: number\n\tdisplayHeight?: number\n\tframerate?: number\n}\n\nexport function isTrack(track: any): track is Track {\n\tif (typeof track.name !== \"string\") return false\n\treturn true\n}\n\nexport function isMp4Track(track: any): track is Mp4Track {\n\tif (!isTrack(track)) return false\n\tif (typeof track.initTrack !== \"string\" && typeof track.initData !== \"string\") return false\n\tif (typeof track.selectionParams.mimeType !== \"string\") return false\n\treturn true\n}\n\nexport function isVideoTrack(track: any): track is VideoTrack {\n\tif (!isTrack(track)) return false\n\treturn isVideoSelectionParams(track.selectionParams)\n}\n\nexport function isVideoSelectionParams(params: any): params is VideoSelectionParams {\n\tif (typeof params.width !== \"number\") return false\n\tif (typeof params.height !== \"number\") return false\n\treturn true\n}\n\nexport function isAudioTrack(track: any): track is AudioTrack {\n\tif (!isTrack(track)) return false\n\treturn isAudioSelectionParams(track.selectionParams)\n}\n\nexport function isAudioSelectionParams(params: any): params is AudioSelectionParams {\n\tif (typeof params.channelConfig !== \"string\") return false\n\tif (typeof params.samplerate !== \"number\") return false\n\treturn true\n}\n\nfunction isCatalogFieldValid(catalog: any, field: string): boolean {\n\t//packaging,namespace if common would be listed in commonTrackFields but if fields\n\t//in commonTrackFields are mentiond in Tracks , the fields in Tracks precedes\n\n\tfunction isValidPackaging(packaging: any): boolean {\n\t\treturn packaging === \"cmaf\" || packaging === \"loc\"\n\t}\n\n\tfunction isValidNamespace(namespace: any): boolean {\n\t\treturn typeof namespace === \"string\"\n\t}\n\n\tlet isValidField: (value: any) => boolean\n\tif (field === \"packaging\") {\n\t\tisValidField = isValidPackaging\n\t} else if (field === \"namespace\") {\n\t\tisValidField = isValidNamespace\n\t} else {\n\t\tthrow new Error(`Invalid field: ${field}`)\n\t}\n\n\tif (catalog.commonTrackFields[field] !== undefined && !isValidField(catalog.commonTrackFields[field])) {\n\t\treturn false\n\t}\n\n\tfor (const track of catalog.tracks) {\n\t\tif (track[field] !== undefined && !isValidField(track[field])) {\n\t\t\treturn false\n\t\t}\n\t}\n\n\treturn true\n}\n\nexport function isMediaTrack(track: any): track is Track {\n\tif (track.name.toLowerCase().includes(\"audio\") || track.name.toLowerCase().includes(\"video\")) {\n\t\treturn true\n\t}\n\n\tif (track.selectionParams && track.selectionParams.codec) {\n\t\tconst codec = track.selectionParams.codec.toLowerCase()\n\t\tconst acceptedCodecs = [\"mp4a\", \"avc1\"]\n\n\t\tfor (const acceptedCodec of acceptedCodecs) {\n\t\t\tif (codec.includes(acceptedCodec)) {\n\t\t\t\treturn true\n\t\t\t}\n\t\t}\n\t}\n\treturn false\n}\n","import * as Message from \"./worker/message\"\n\nimport registerMyAudioWorklet from \"audio-worklet:./worklet/index.ts\"\n\n// NOTE: This must be on the main thread\nexport class Audio {\n\tcontext: AudioContext\n\tworklet: Promise\n\n\tconstructor(config: Message.ConfigAudio) {\n\t\tthis.context = new AudioContext({\n\t\t\tlatencyHint: \"interactive\",\n\t\t\tsampleRate: config.sampleRate,\n\t\t})\n\n\t\tthis.worklet = this.load(config)\n\t}\n\n\tprivate async load(config: Message.ConfigAudio): Promise {\n\t\t// Load the worklet source code.\n\t\tawait registerMyAudioWorklet(this.context)\n\t\tconst volume = this.context.createGain()\n\t\tvolume.gain.value = 2.0\n\n\t\t// Create the worklet\n\t\tconst worklet = new AudioWorkletNode(this.context, \"renderer\")\n\n\t\tworklet.port.addEventListener(\"message\", this.on.bind(this))\n\t\tworklet.onprocessorerror = (e: Event) => {\n\t\t\tconsole.error(\"Audio worklet error:\", e)\n\t\t}\n\n\t\t// Connect the worklet to the volume node and then to the speakers\n\t\tworklet.connect(volume)\n\t\tvolume.connect(this.context.destination)\n\n\t\tworklet.port.postMessage({ config })\n\n\t\treturn worklet\n\t}\n\n\tprivate on(_event: MessageEvent) {\n\t\t// TODO\n\t}\n}\n","// Ring buffer with audio samples.\n\nenum STATE {\n\tREAD_POS = 0, // The current read position\n\tWRITE_POS, // The current write position\n\tLENGTH, // Clever way of saving the total number of enums values.\n}\n\ninterface FrameCopyToOptions {\n\tframeCount?: number\n\tframeOffset?: number\n\tplaneIndex: number\n}\n\n// This is implemented by AudioData in WebCodecs, but we don't import it because it's a DOM type.\ninterface Frame {\n\tnumberOfFrames: number\n\tnumberOfChannels: number\n\tcopyTo(dst: Float32Array, options: FrameCopyToOptions): void\n}\n\n// No prototype to make this easier to send via postMessage\nexport class RingShared {\n\tstate: SharedArrayBuffer\n\n\tchannels: SharedArrayBuffer[]\n\tcapacity: number\n\n\tconstructor(channels: number, capacity: number) {\n\t\t// Store the current state in a separate ring buffer.\n\t\tthis.state = new SharedArrayBuffer(STATE.LENGTH * Int32Array.BYTES_PER_ELEMENT)\n\n\t\t// Create a buffer for each audio channel\n\t\tthis.channels = []\n\t\tfor (let i = 0; i < channels; i += 1) {\n\t\t\tconst buffer = new SharedArrayBuffer(capacity * Float32Array.BYTES_PER_ELEMENT)\n\t\t\tthis.channels.push(buffer)\n\t\t}\n\n\t\tthis.capacity = capacity\n\t}\n}\n\nexport class Ring {\n\tstate: Int32Array\n\tchannels: Float32Array[]\n\tcapacity: number\n\n\tconstructor(shared: RingShared) {\n\t\tthis.state = new Int32Array(shared.state)\n\n\t\tthis.channels = []\n\t\tfor (const channel of shared.channels) {\n\t\t\tthis.channels.push(new Float32Array(channel))\n\t\t}\n\n\t\tthis.capacity = shared.capacity\n\t}\n\n\t// Write samples for single audio frame, returning the total number written.\n\twrite(frame: Frame): number {\n\t\tconst readPos = Atomics.load(this.state, STATE.READ_POS)\n\t\tconst writePos = Atomics.load(this.state, STATE.WRITE_POS)\n\n\t\tconst startPos = writePos\n\t\tlet endPos = writePos + frame.numberOfFrames\n\n\t\tif (endPos > readPos + this.capacity) {\n\t\t\tendPos = readPos + this.capacity\n\t\t\tif (endPos <= startPos) {\n\t\t\t\t// No space to write\n\t\t\t\treturn 0\n\t\t\t}\n\t\t}\n\n\t\tconst startIndex = startPos % this.capacity\n\t\tconst endIndex = endPos % this.capacity\n\n\t\t// Loop over each channel\n\t\tfor (let i = 0; i < this.channels.length; i += 1) {\n\t\t\tconst channel = this.channels[i]\n\n\t\t\t// If the AudioData doesn't have enough channels, duplicate it.\n\t\t\tconst planeIndex = Math.min(i, frame.numberOfChannels - 1)\n\n\t\t\tif (startIndex < endIndex) {\n\t\t\t\t// One continuous range to copy.\n\t\t\t\tconst full = channel.subarray(startIndex, endIndex)\n\n\t\t\t\tframe.copyTo(full, {\n\t\t\t\t\tplaneIndex,\n\t\t\t\t\tframeCount: endIndex - startIndex,\n\t\t\t\t})\n\t\t\t} else {\n\t\t\t\tconst first = channel.subarray(startIndex)\n\t\t\t\tconst second = channel.subarray(0, endIndex)\n\n\t\t\t\tframe.copyTo(first, {\n\t\t\t\t\tplaneIndex,\n\t\t\t\t\tframeCount: first.length,\n\t\t\t\t})\n\n\t\t\t\t// We need this conditional when startIndex == 0 and endIndex == 0\n\t\t\t\t// When capacity=4410 and frameCount=1024, this was happening 52s into the audio.\n\t\t\t\tif (second.length) {\n\t\t\t\t\tframe.copyTo(second, {\n\t\t\t\t\t\tplaneIndex,\n\t\t\t\t\t\tframeOffset: first.length,\n\t\t\t\t\t\tframeCount: second.length,\n\t\t\t\t\t})\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tAtomics.store(this.state, STATE.WRITE_POS, endPos)\n\n\t\treturn endPos - startPos\n\t}\n\n\tread(dst: Float32Array[]): number {\n\t\tconst readPos = Atomics.load(this.state, STATE.READ_POS)\n\t\tconst writePos = Atomics.load(this.state, STATE.WRITE_POS)\n\n\t\tconst startPos = readPos\n\t\tlet endPos = startPos + dst[0].length\n\n\t\tif (endPos > writePos) {\n\t\t\tendPos = writePos\n\t\t\tif (endPos <= startPos) {\n\t\t\t\t// Nothing to read\n\t\t\t\treturn 0\n\t\t\t}\n\t\t}\n\n\t\tconst startIndex = startPos % this.capacity\n\t\tconst endIndex = endPos % this.capacity\n\n\t\t// Loop over each channel\n\t\tfor (let i = 0; i < dst.length; i += 1) {\n\t\t\tif (i >= this.channels.length) {\n\t\t\t\t// ignore excess channels\n\t\t\t}\n\n\t\t\tconst input = this.channels[i]\n\t\t\tconst output = dst[i]\n\n\t\t\tif (startIndex < endIndex) {\n\t\t\t\tconst full = input.subarray(startIndex, endIndex)\n\t\t\t\toutput.set(full)\n\t\t\t} else {\n\t\t\t\tconst first = input.subarray(startIndex)\n\t\t\t\tconst second = input.subarray(0, endIndex)\n\n\t\t\t\toutput.set(first)\n\t\t\t\toutput.set(second, first.length)\n\t\t\t}\n\t\t}\n\n\t\tAtomics.store(this.state, STATE.READ_POS, endPos)\n\n\t\treturn endPos - startPos\n\t}\n\n\tclear() {\n\t\tconst pos = Atomics.load(this.state, STATE.WRITE_POS)\n\t\tAtomics.store(this.state, STATE.READ_POS, pos)\n\t}\n\n\tsize() {\n\t\t// TODO is this thread safe?\n\t\tconst readPos = Atomics.load(this.state, STATE.READ_POS)\n\t\tconst writePos = Atomics.load(this.state, STATE.WRITE_POS)\n\n\t\treturn writePos - readPos\n\t}\n}\n","import * as Message from \"./worker/message\"\nimport { Audio } from \"./audio\"\n\n// import WebWorker from 'web-worker:./Worker.ts';\nimport MediaWorker from \"web-worker:./worker/index.ts\"\n\nimport { RingShared } from \"../common/ring\"\nimport { Root, isAudioTrack } from \"../media/catalog\"\nimport { GroupHeader } from \"../transport/objects\"\n\nexport interface PlayerConfig {\n\tcanvas: OffscreenCanvas\n\tcatalog: Root\n}\n\n// This is a non-standard way of importing worklet/workers.\n// Unfortunately, it's the only option because of a Vite bug: https://github.com/vitejs/vite/issues/11823\n\n// Responsible for sending messages to the worker and worklet.\nexport default class Backend {\n\t// General worker\n\t#worker: Worker\n\n\t// The audio context, which must be created on the main thread.\n\t#audio?: Audio\n\n\tconstructor(config: PlayerConfig) {\n\t\t// TODO does this block the main thread? If so, make this async\n\t\tthis.#worker = new MediaWorker()\n\t\tthis.#worker.addEventListener(\"message\", this.on.bind(this))\n\n\t\tlet sampleRate: number | undefined\n\t\tlet channels: number | undefined\n\n\t\tfor (const track of config.catalog.tracks) {\n\t\t\tif (isAudioTrack(track)) {\n\t\t\t\tif (sampleRate && track.selectionParams.samplerate !== sampleRate) {\n\t\t\t\t\tthrow new Error(`TODO multiple audio tracks with different sample rates`)\n\t\t\t\t}\n\n\t\t\t\tsampleRate = track.selectionParams.samplerate\n\n\t\t\t\t// TODO properly handle weird channel configs\n\t\t\t\tchannels = Math.max(+track.selectionParams.channelConfig, channels ?? 0)\n\t\t\t}\n\t\t}\n\n\t\tconst msg: Message.Config = {}\n\n\t\t// Only configure audio is we have an audio track\n\t\tif (sampleRate && channels) {\n\t\t\tmsg.audio = {\n\t\t\t\tchannels: channels,\n\t\t\t\tsampleRate: sampleRate,\n\t\t\t\tring: new RingShared(2, sampleRate / 10), // 100ms\n\t\t\t}\n\n\t\t\tthis.#audio = new Audio(msg.audio)\n\t\t}\n\n\t\t// TODO only send the canvas if we have a video track\n\t\tmsg.video = {\n\t\t\tcanvas: config.canvas,\n\t\t}\n\n\t\tthis.send({ config: msg }, msg.video.canvas)\n\t}\n\n\tpause() {\n\t\tthis.send({ pause: true })\n\t}\n\n\tasync mute() {\n\t\tawait this.#audio?.context.suspend()\n\t}\n\n\tasync unmute() {\n\t\tawait this.#audio?.context.resume()\n\t}\n\n\tinit(init: Init) {\n\t\tthis.send({ init })\n\t}\n\n\tsegment(segment: Segment) {\n\t\tthis.send({ segment }, segment.stream)\n\t}\n\n\tasync close() {\n\t\tthis.#worker.terminate()\n\t\tawait this.#audio?.context.close()\n\t}\n\n\t// Enforce we're sending valid types to the worker\n\tprivate send(msg: Message.ToWorker, ...transfer: Transferable[]) {\n\t\t//console.log(\"sent message from main to worker\", msg)\n\t\tthis.#worker.postMessage(msg, transfer)\n\t}\n\n\tprivate on(e: MessageEvent) {\n\t\tconst msg = e.data as Message.FromWorker\n\n\t\t// Don't print the verbose timeline message.\n\t\tif (!msg.timeline) {\n\t\t\t//console.log(\"received message from worker to main\", msg)\n\t\t}\n\t}\n}\n\nexport interface Init {\n\tname: string // name of the init track\n\tdata: Uint8Array\n}\n\nexport interface Segment {\n\tinit: string // name of the init track\n\tkind: \"audio\" | \"video\"\n\theader: GroupHeader\n\tbuffer: Uint8Array\n\tstream: ReadableStream\n}\n","const MAX_U6 = Math.pow(2, 6) - 1\nconst MAX_U14 = Math.pow(2, 14) - 1\nconst MAX_U30 = Math.pow(2, 30) - 1\nconst MAX_U31 = Math.pow(2, 31) - 1\nconst MAX_U53 = Number.MAX_SAFE_INTEGER\nconst MAX_U62: bigint = 2n ** 62n - 1n\n\n// Reader wraps a stream and provides convience methods for reading pieces from a stream\n// Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet.\nexport class Reader {\n\t#buffer: Uint8Array\n\t#stream: ReadableStream\n\t#reader: ReadableStreamDefaultReader\n\n\tconstructor(buffer: Uint8Array, stream: ReadableStream) {\n\t\tthis.#buffer = buffer\n\t\tthis.#stream = stream\n\t\tthis.#reader = this.#stream.getReader()\n\t}\n\n\t// Adds more data to the buffer, returning true if more data was added.\n\tasync #fill(): Promise {\n\t\tconst result = await this.#reader.read()\n\t\tif (result.done) {\n\t\t\treturn false\n\t\t}\n\n\t\tconst buffer = new Uint8Array(result.value)\n\n\t\tif (this.#buffer.byteLength == 0) {\n\t\t\tthis.#buffer = buffer\n\t\t} else {\n\t\t\tconst temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength)\n\t\t\ttemp.set(this.#buffer)\n\t\t\ttemp.set(buffer, this.#buffer.byteLength)\n\t\t\tthis.#buffer = temp\n\t\t}\n\n\t\treturn true\n\t}\n\n\t// Add more data to the buffer until it's at least size bytes.\n\tasync #fillTo(size: number) {\n\t\twhile (this.#buffer.byteLength < size) {\n\t\t\tif (!(await this.#fill())) {\n\t\t\t\tthrow new Error(\"unexpected end of stream\")\n\t\t\t}\n\t\t}\n\t}\n\n\t// Consumes the first size bytes of the buffer.\n\t#slice(size: number): Uint8Array {\n\t\tconst result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size)\n\t\tthis.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size)\n\n\t\treturn result\n\t}\n\n\tasync read(size: number): Promise {\n\t\tif (size == 0) return new Uint8Array()\n\n\t\tawait this.#fillTo(size)\n\t\treturn this.#slice(size)\n\t}\n\n\tasync readAll(): Promise {\n\t\t// eslint-disable-next-line no-empty\n\t\twhile (await this.#fill()) {}\n\t\treturn this.#slice(this.#buffer.byteLength)\n\t}\n\n\tasync string(maxLength?: number): Promise {\n\t\tconst length = await this.u53()\n\t\tif (maxLength !== undefined && length > maxLength) {\n\t\t\tthrow new Error(`string length ${length} exceeds max length ${maxLength}`)\n\t\t}\n\n\t\tconst buffer = await this.read(length)\n\t\treturn new TextDecoder().decode(buffer)\n\t}\n\n\tasync u8(): Promise {\n\t\tawait this.#fillTo(1)\n\t\treturn this.#slice(1)[0]\n\t}\n\n\t// Returns a Number using 53-bits, the max Javascript can use for integer math\n\tasync u53(): Promise {\n\t\tconst v = await this.u62()\n\t\tif (v > MAX_U53) {\n\t\t\tthrow new Error(\"value larger than 53-bits; use v62 instead\")\n\t\t}\n\n\t\treturn Number(v)\n\t}\n\n\t// NOTE: Returns a bigint instead of a number since it may be larger than 53-bits\n\tasync u62(): Promise {\n\t\tawait this.#fillTo(1)\n\t\tconst size = (this.#buffer[0] & 0xc0) >> 6\n\n\t\tif (size == 0) {\n\t\t\tconst first = this.#slice(1)[0]\n\t\t\treturn BigInt(first) & 0x3fn\n\t\t} else if (size == 1) {\n\t\t\tawait this.#fillTo(2)\n\t\t\tconst slice = this.#slice(2)\n\t\t\tconst view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength)\n\n\t\t\treturn BigInt(view.getInt16(0)) & 0x3fffn\n\t\t} else if (size == 2) {\n\t\t\tawait this.#fillTo(4)\n\t\t\tconst slice = this.#slice(4)\n\t\t\tconst view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength)\n\n\t\t\treturn BigInt(view.getUint32(0)) & 0x3fffffffn\n\t\t} else if (size == 3) {\n\t\t\tawait this.#fillTo(8)\n\t\t\tconst slice = this.#slice(8)\n\t\t\tconst view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength)\n\n\t\t\treturn view.getBigUint64(0) & 0x3fffffffffffffffn\n\t\t} else {\n\t\t\tthrow new Error(\"impossible\")\n\t\t}\n\t}\n\n\tasync done(): Promise {\n\t\tif (this.#buffer.byteLength > 0) return false\n\t\treturn !(await this.#fill())\n\t}\n\n\tasync close() {\n\t\tthis.#reader.releaseLock()\n\t\tawait this.#stream.cancel()\n\t}\n\n\trelease(): [Uint8Array, ReadableStream] {\n\t\tthis.#reader.releaseLock()\n\t\treturn [this.#buffer, this.#stream]\n\t}\n}\n\n// Writer wraps a stream and writes chunks of data\nexport class Writer {\n\t#scratch: Uint8Array\n\t#writer: WritableStreamDefaultWriter\n\t#stream: WritableStream\n\n\tconstructor(stream: WritableStream) {\n\t\tthis.#stream = stream\n\t\tthis.#scratch = new Uint8Array(8)\n\t\tthis.#writer = this.#stream.getWriter()\n\t}\n\n\tasync u8(v: number) {\n\t\tawait this.write(setUint8(this.#scratch, v))\n\t}\n\n\tasync i32(v: number) {\n\t\tif (Math.abs(v) > MAX_U31) {\n\t\t\tthrow new Error(`overflow, value larger than 32-bits: ${v}`)\n\t\t}\n\n\t\t// We don't use a VarInt, so it always takes 4 bytes.\n\t\t// This could be improved but nothing is standardized yet.\n\t\tawait this.write(setInt32(this.#scratch, v))\n\t}\n\n\tasync u53(v: number) {\n\t\tif (v < 0) {\n\t\t\tthrow new Error(`underflow, value is negative: ${v}`)\n\t\t} else if (v > MAX_U53) {\n\t\t\tthrow new Error(`overflow, value larger than 53-bits: ${v}`)\n\t\t}\n\n\t\tawait this.write(setVint53(this.#scratch, v))\n\t}\n\n\tasync u62(v: bigint) {\n\t\tif (v < 0) {\n\t\t\tthrow new Error(`underflow, value is negative: ${v}`)\n\t\t} else if (v >= MAX_U62) {\n\t\t\tthrow new Error(`overflow, value larger than 62-bits: ${v}`)\n\t\t}\n\n\t\tawait this.write(setVint62(this.#scratch, v))\n\t}\n\n\tasync write(v: Uint8Array) {\n\t\tawait this.#writer.write(v)\n\t}\n\n\tasync string(str: string) {\n\t\tconst data = new TextEncoder().encode(str)\n\t\tawait this.u53(data.byteLength)\n\t\tawait this.write(data)\n\t}\n\n\tasync close() {\n\t\tthis.#writer.releaseLock()\n\t\tawait this.#stream.close()\n\t}\n\n\trelease(): WritableStream {\n\t\tthis.#writer.releaseLock()\n\t\treturn this.#stream\n\t}\n}\n\nfunction setUint8(dst: Uint8Array, v: number): Uint8Array {\n\tdst[0] = v\n\treturn dst.slice(0, 1)\n}\n\nfunction setUint16(dst: Uint8Array, v: number): Uint8Array {\n\tconst view = new DataView(dst.buffer, dst.byteOffset, 2)\n\tview.setUint16(0, v)\n\n\treturn new Uint8Array(view.buffer, view.byteOffset, view.byteLength)\n}\n\nfunction setInt32(dst: Uint8Array, v: number): Uint8Array {\n\tconst view = new DataView(dst.buffer, dst.byteOffset, 4)\n\tview.setInt32(0, v)\n\n\treturn new Uint8Array(view.buffer, view.byteOffset, view.byteLength)\n}\n\nfunction setUint32(dst: Uint8Array, v: number): Uint8Array {\n\tconst view = new DataView(dst.buffer, dst.byteOffset, 4)\n\tview.setUint32(0, v)\n\n\treturn new Uint8Array(view.buffer, view.byteOffset, view.byteLength)\n}\n\nfunction setVint53(dst: Uint8Array, v: number): Uint8Array {\n\tif (v <= MAX_U6) {\n\t\treturn setUint8(dst, v)\n\t} else if (v <= MAX_U14) {\n\t\treturn setUint16(dst, v | 0x4000)\n\t} else if (v <= MAX_U30) {\n\t\treturn setUint32(dst, v | 0x80000000)\n\t} else if (v <= MAX_U53) {\n\t\treturn setUint64(dst, BigInt(v) | 0xc000000000000000n)\n\t} else {\n\t\tthrow new Error(`overflow, value larger than 53-bits: ${v}`)\n\t}\n}\n\nfunction setVint62(dst: Uint8Array, v: bigint): Uint8Array {\n\tif (v < MAX_U6) {\n\t\treturn setUint8(dst, Number(v))\n\t} else if (v < MAX_U14) {\n\t\treturn setUint16(dst, Number(v) | 0x4000)\n\t} else if (v <= MAX_U30) {\n\t\treturn setUint32(dst, Number(v) | 0x80000000)\n\t} else if (v <= MAX_U62) {\n\t\treturn setUint64(dst, BigInt(v) | 0xc000000000000000n)\n\t} else {\n\t\tthrow new Error(`overflow, value larger than 62-bits: ${v}`)\n\t}\n}\n\nfunction setUint64(dst: Uint8Array, v: bigint): Uint8Array {\n\tconst view = new DataView(dst.buffer, dst.byteOffset, 8)\n\tview.setBigUint64(0, v)\n\n\treturn new Uint8Array(view.buffer, view.byteOffset, view.byteLength)\n}\n","import { Reader, Writer } from \"./stream\"\n\nexport type Message = Client | Server\nexport type Role = \"publisher\" | \"subscriber\" | \"both\"\n\nexport enum Version {\n\tDRAFT_00 = 0xff000000,\n\tDRAFT_01 = 0xff000001,\n\tDRAFT_02 = 0xff000002,\n\tDRAFT_03 = 0xff000003,\n\tDRAFT_04 = 0xff000004,\n\tDRAFT_05 = 0xff000005,\n\tKIXEL_00 = 0xbad00,\n\tKIXEL_01 = 0xbad01,\n}\n\n// NOTE: These are forked from moq-transport-00.\n// 1. messages lack a sized length\n// 2. parameters are not optional and written in order (role + path)\n// 3. role indicates local support only, not remote support\n\nexport interface Client {\n\tversions: Version[]\n\trole: Role\n\tparams?: Parameters\n}\n\nexport interface Server {\n\tversion: Version\n\tparams?: Parameters\n}\n\nexport class Stream {\n\trecv: Decoder\n\tsend: Encoder\n\n\tconstructor(r: Reader, w: Writer) {\n\t\tthis.recv = new Decoder(r)\n\t\tthis.send = new Encoder(w)\n\t}\n}\n\nexport type Parameters = Map\n\nexport class Decoder {\n\tr: Reader\n\n\tconstructor(r: Reader) {\n\t\tthis.r = r\n\t}\n\n\tasync client(): Promise {\n\t\tconst type = await this.r.u53()\n\t\tif (type !== 0x40) throw new Error(`client SETUP type must be 0x40, got ${type}`)\n\n\t\tconst count = await this.r.u53()\n\n\t\tconst versions = []\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst version = await this.r.u53()\n\t\t\tversions.push(version)\n\t\t}\n\n\t\tconst params = await this.parameters()\n\t\tconst role = this.role(params?.get(0n))\n\n\t\treturn {\n\t\t\tversions,\n\t\t\trole,\n\t\t\tparams,\n\t\t}\n\t}\n\n\tasync server(): Promise {\n\t\tconst type = await this.r.u53()\n\t\tif (type !== 0x41) throw new Error(`server SETUP type must be 0x41, got ${type}`)\n\n\t\tconst version = await this.r.u53()\n\t\tconst params = await this.parameters()\n\n\t\treturn {\n\t\t\tversion,\n\t\t\tparams,\n\t\t}\n\t}\n\n\tprivate async parameters(): Promise {\n\t\tconst count = await this.r.u53()\n\t\tif (count == 0) return undefined\n\n\t\tconst params = new Map()\n\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst id = await this.r.u62()\n\t\t\tconst size = await this.r.u53()\n\t\t\tconst value = await this.r.read(size)\n\n\t\t\tif (params.has(id)) {\n\t\t\t\tthrow new Error(`duplicate parameter id: ${id}`)\n\t\t\t}\n\n\t\t\tparams.set(id, value)\n\t\t}\n\n\t\treturn params\n\t}\n\n\trole(raw: Uint8Array | undefined): Role {\n\t\tif (!raw) throw new Error(\"missing role parameter\")\n\t\tif (raw.length != 1) throw new Error(\"multi-byte varint not supported\")\n\n\t\tswitch (raw[0]) {\n\t\t\tcase 1:\n\t\t\t\treturn \"publisher\"\n\t\t\tcase 2:\n\t\t\t\treturn \"subscriber\"\n\t\t\tcase 3:\n\t\t\t\treturn \"both\"\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`invalid role: ${raw[0]}`)\n\t\t}\n\t}\n}\n\nexport class Encoder {\n\tw: Writer\n\n\tconstructor(w: Writer) {\n\t\tthis.w = w\n\t}\n\n\tasync client(c: Client) {\n\t\tawait this.w.u53(0x40)\n\t\tawait this.w.u53(c.versions.length)\n\t\tfor (const v of c.versions) {\n\t\t\tawait this.w.u53(v)\n\t\t}\n\n\t\t// I hate it\n\t\tconst params = c.params ?? new Map()\n\t\tparams.set(0n, new Uint8Array([c.role == \"publisher\" ? 1 : c.role == \"subscriber\" ? 2 : 3]))\n\t\tawait this.parameters(params)\n\t}\n\n\tasync server(s: Server) {\n\t\tawait this.w.u53(0x41)\n\t\tawait this.w.u53(s.version)\n\t\tawait this.parameters(s.params)\n\t}\n\n\tprivate async parameters(p: Parameters | undefined) {\n\t\tif (!p) {\n\t\t\tawait this.w.u8(0)\n\t\t\treturn\n\t\t}\n\n\t\tawait this.w.u53(p.size)\n\t\tfor (const [id, value] of p) {\n\t\t\tawait this.w.u62(id)\n\t\t\tawait this.w.u53(value.length)\n\t\t\tawait this.w.write(value)\n\t\t}\n\t}\n}\n","import { Reader, Writer } from \"./stream\"\n\nexport type Message = Subscriber | Publisher\n\n// Sent by subscriber\nexport type Subscriber = Subscribe | Unsubscribe | AnnounceOk | AnnounceError\n\nexport function isSubscriber(m: Message): m is Subscriber {\n\treturn (\n\t\tm.kind == Msg.Subscribe || m.kind == Msg.Unsubscribe || m.kind == Msg.AnnounceOk || m.kind == Msg.AnnounceError\n\t)\n}\n\n// Sent by publisher\nexport type Publisher = SubscribeOk | SubscribeError | SubscribeDone | Announce | Unannounce\n\nexport function isPublisher(m: Message): m is Publisher {\n\treturn (\n\t\tm.kind == Msg.SubscribeOk ||\n\t\tm.kind == Msg.SubscribeError ||\n\t\tm.kind == Msg.SubscribeDone ||\n\t\tm.kind == Msg.Announce ||\n\t\tm.kind == Msg.Unannounce\n\t)\n}\n\n// I wish we didn't have to split Msg and Id into separate enums.\n// However using the string in the message makes it easier to debug.\n// We'll take the tiny performance hit until I'm better at Typescript.\nexport enum Msg {\n\t// NOTE: object and setup are in other modules\n\tSubscribe = \"subscribe\",\n\tSubscribeOk = \"subscribe_ok\",\n\tSubscribeError = \"subscribe_error\",\n\tSubscribeDone = \"subscribe_done\",\n\tUnsubscribe = \"unsubscribe\",\n\tAnnounce = \"announce\",\n\tAnnounceOk = \"announce_ok\",\n\tAnnounceError = \"announce_error\",\n\tUnannounce = \"unannounce\",\n\tGoAway = \"go_away\",\n}\n\nenum Id {\n\t// NOTE: object and setup are in other modules\n\t// Object = 0,\n\t// Setup = 1,\n\n\tSubscribe = 0x3,\n\tSubscribeOk = 0x4,\n\tSubscribeError = 0x5,\n\tSubscribeDone = 0xb,\n\tUnsubscribe = 0xa,\n\tAnnounce = 0x6,\n\tAnnounceOk = 0x7,\n\tAnnounceError = 0x8,\n\tUnannounce = 0x9,\n\tGoAway = 0x10,\n}\n\nexport interface Subscribe {\n\tkind: Msg.Subscribe\n\n\tid: bigint\n\ttrackId: bigint\n\tnamespace: string\n\tname: string\n\tsubscriber_priority: number\n\tgroup_order: GroupOrder\n\n\tlocation: Location\n\n\tparams?: Parameters\n}\n\nexport enum GroupOrder {\n\tPublisher = 0x0,\n\tAscending = 0x1,\n\tDescending = 0x2,\n}\n\nexport type Location = LatestGroup | LatestObject | AbsoluteStart | AbsoluteRange\n\nexport interface LatestGroup {\n\tmode: \"latest_group\"\n}\n\nexport interface LatestObject {\n\tmode: \"latest_object\"\n}\n\nexport interface AbsoluteStart {\n\tmode: \"absolute_start\"\n\tstart_group: number\n\tstart_object: number\n}\n\nexport interface AbsoluteRange {\n\tmode: \"absolute_range\"\n\tstart_group: number\n\tstart_object: number\n\tend_group: number\n\tend_object: number\n}\n\nexport type Parameters = Map\n\nexport interface SubscribeOk {\n\tkind: Msg.SubscribeOk\n\tid: bigint\n\texpires: bigint\n\tgroup_order: GroupOrder\n\tlatest?: [number, number]\n}\n\nexport interface SubscribeDone {\n\tkind: Msg.SubscribeDone\n\tid: bigint\n\tcode: bigint\n\treason: string\n\tfinal?: [number, number]\n}\n\nexport interface SubscribeError {\n\tkind: Msg.SubscribeError\n\tid: bigint\n\tcode: bigint\n\treason: string\n}\n\nexport interface Unsubscribe {\n\tkind: Msg.Unsubscribe\n\tid: bigint\n}\n\nexport interface Announce {\n\tkind: Msg.Announce\n\tnamespace: string\n\tparams?: Parameters\n}\n\nexport interface AnnounceOk {\n\tkind: Msg.AnnounceOk\n\tnamespace: string\n}\n\nexport interface AnnounceError {\n\tkind: Msg.AnnounceError\n\tnamespace: string\n\tcode: bigint\n\treason: string\n}\n\nexport interface Unannounce {\n\tkind: Msg.Unannounce\n\tnamespace: string\n}\n\nexport class Stream {\n\tprivate decoder: Decoder\n\tprivate encoder: Encoder\n\n\t#mutex = Promise.resolve()\n\n\tconstructor(r: Reader, w: Writer) {\n\t\tthis.decoder = new Decoder(r)\n\t\tthis.encoder = new Encoder(w)\n\t}\n\n\t// Will error if two messages are read at once.\n\tasync recv(): Promise {\n\t\tconst msg = await this.decoder.message()\n\t\tconsole.log(\"received message\", msg)\n\t\treturn msg\n\t}\n\n\tasync send(msg: Message) {\n\t\tconst unlock = await this.#lock()\n\t\ttry {\n\t\t\tconsole.log(\"sending message\", msg)\n\t\t\tawait this.encoder.message(msg)\n\t\t} finally {\n\t\t\tunlock()\n\t\t}\n\t}\n\n\tasync #lock() {\n\t\t// Make a new promise that we can resolve later.\n\t\tlet done: () => void\n\t\tconst p = new Promise((resolve) => {\n\t\t\tdone = () => resolve()\n\t\t})\n\n\t\t// Wait until the previous lock is done, then resolve our our lock.\n\t\tconst lock = this.#mutex.then(() => done)\n\n\t\t// Save our lock as the next lock.\n\t\tthis.#mutex = p\n\n\t\t// Return the lock.\n\t\treturn lock\n\t}\n}\n\nexport class Decoder {\n\tr: Reader\n\n\tconstructor(r: Reader) {\n\t\tthis.r = r\n\t}\n\n\tprivate async msg(): Promise {\n\t\tconst t = await this.r.u53()\n\t\tswitch (t) {\n\t\t\tcase Id.Subscribe:\n\t\t\t\treturn Msg.Subscribe\n\t\t\tcase Id.SubscribeOk:\n\t\t\t\treturn Msg.SubscribeOk\n\t\t\tcase Id.SubscribeDone:\n\t\t\t\treturn Msg.SubscribeDone\n\t\t\tcase Id.SubscribeError:\n\t\t\t\treturn Msg.SubscribeError\n\t\t\tcase Id.Unsubscribe:\n\t\t\t\treturn Msg.Unsubscribe\n\t\t\tcase Id.Announce:\n\t\t\t\treturn Msg.Announce\n\t\t\tcase Id.AnnounceOk:\n\t\t\t\treturn Msg.AnnounceOk\n\t\t\tcase Id.AnnounceError:\n\t\t\t\treturn Msg.AnnounceError\n\t\t\tcase Id.Unannounce:\n\t\t\t\treturn Msg.Unannounce\n\t\t\tcase Id.GoAway:\n\t\t\t\treturn Msg.GoAway\n\t\t}\n\n\t\tthrow new Error(`unknown control message type: ${t}`)\n\t}\n\n\tasync message(): Promise {\n\t\tconst t = await this.msg()\n\t\tswitch (t) {\n\t\t\tcase Msg.Subscribe:\n\t\t\t\treturn this.subscribe()\n\t\t\tcase Msg.SubscribeOk:\n\t\t\t\treturn this.subscribe_ok()\n\t\t\tcase Msg.SubscribeError:\n\t\t\t\treturn this.subscribe_error()\n\t\t\tcase Msg.SubscribeDone:\n\t\t\t\treturn this.subscribe_done()\n\t\t\tcase Msg.Unsubscribe:\n\t\t\t\treturn this.unsubscribe()\n\t\t\tcase Msg.Announce:\n\t\t\t\treturn this.announce()\n\t\t\tcase Msg.AnnounceOk:\n\t\t\t\treturn this.announce_ok()\n\t\t\tcase Msg.Unannounce:\n\t\t\t\treturn this.unannounce()\n\t\t\tcase Msg.AnnounceError:\n\t\t\t\treturn this.announce_error()\n\t\t\tcase Msg.GoAway:\n\t\t\t\tthrow new Error(\"TODO: implement go away\")\n\t\t}\n\t}\n\n\tprivate async subscribe(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.Subscribe,\n\t\t\tid: await this.r.u62(),\n\t\t\ttrackId: await this.r.u62(),\n\t\t\tnamespace: await this.r.string(),\n\t\t\tname: await this.r.string(),\n\t\t\tsubscriber_priority: await this.r.u8(),\n\t\t\tgroup_order: await this.decodeGroupOrder(),\n\t\t\tlocation: await this.location(),\n\t\t\tparams: await this.parameters(),\n\t\t}\n\t}\n\n\tprivate async decodeGroupOrder(): Promise {\n\t\tconst orderCode = await this.r.u8()\n\t\tswitch (orderCode) {\n\t\t\tcase 0:\n\t\t\t\treturn GroupOrder.Publisher\n\t\t\tcase 1:\n\t\t\t\treturn GroupOrder.Ascending\n\t\t\tcase 2:\n\t\t\t\treturn GroupOrder.Descending\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Invalid GroupOrder value: ${orderCode}`)\n\t\t}\n\t}\n\n\tprivate async location(): Promise {\n\t\tconst mode = await this.r.u62()\n\t\tif (mode == 1n) {\n\t\t\treturn {\n\t\t\t\tmode: \"latest_group\",\n\t\t\t}\n\t\t} else if (mode == 2n) {\n\t\t\treturn {\n\t\t\t\tmode: \"latest_object\",\n\t\t\t}\n\t\t} else if (mode == 3n) {\n\t\t\treturn {\n\t\t\t\tmode: \"absolute_start\",\n\t\t\t\tstart_group: await this.r.u53(),\n\t\t\t\tstart_object: await this.r.u53(),\n\t\t\t}\n\t\t} else if (mode == 4n) {\n\t\t\treturn {\n\t\t\t\tmode: \"absolute_range\",\n\t\t\t\tstart_group: await this.r.u53(),\n\t\t\t\tstart_object: await this.r.u53(),\n\t\t\t\tend_group: await this.r.u53(),\n\t\t\t\tend_object: await this.r.u53(),\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new Error(`invalid filter type: ${mode}`)\n\t\t}\n\t}\n\n\tprivate async parameters(): Promise {\n\t\tconst count = await this.r.u53()\n\t\tif (count == 0) return undefined\n\n\t\tconst params = new Map()\n\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst id = await this.r.u62()\n\t\t\tconst size = await this.r.u53()\n\t\t\tconst value = await this.r.read(size)\n\n\t\t\tif (params.has(id)) {\n\t\t\t\tthrow new Error(`duplicate parameter id: ${id}`)\n\t\t\t}\n\n\t\t\tparams.set(id, value)\n\t\t}\n\n\t\treturn params\n\t}\n\n\tprivate async subscribe_ok(): Promise {\n\t\tconst id = await this.r.u62()\n\t\tconst expires = await this.r.u62()\n\n\t\tconst group_order = await this.decodeGroupOrder()\n\t\tlet latest: [number, number] | undefined\n\n\t\tconst flag = await this.r.u8()\n\t\tif (flag === 1) {\n\t\t\tlatest = [await this.r.u53(), await this.r.u53()]\n\t\t} else if (flag !== 0) {\n\t\t\tthrow new Error(`invalid final flag: ${flag}`)\n\t\t}\n\n\t\treturn {\n\t\t\tkind: Msg.SubscribeOk,\n\t\t\tid,\n\t\t\texpires,\n\t\t\tgroup_order,\n\t\t\tlatest,\n\t\t}\n\t}\n\n\tprivate async subscribe_done(): Promise {\n\t\tconst id = await this.r.u62()\n\t\tconst code = await this.r.u62()\n\t\tconst reason = await this.r.string()\n\n\t\tlet final: [number, number] | undefined\n\n\t\tconst flag = await this.r.u8()\n\t\tif (flag === 1) {\n\t\t\tfinal = [await this.r.u53(), await this.r.u53()]\n\t\t} else if (flag !== 0) {\n\t\t\tthrow new Error(`invalid final flag: ${flag}`)\n\t\t}\n\n\t\treturn {\n\t\t\tkind: Msg.SubscribeDone,\n\t\t\tid,\n\t\t\tcode,\n\t\t\treason,\n\t\t\tfinal,\n\t\t}\n\t}\n\n\tprivate async subscribe_error(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.SubscribeError,\n\t\t\tid: await this.r.u62(),\n\t\t\tcode: await this.r.u62(),\n\t\t\treason: await this.r.string(),\n\t\t}\n\t}\n\n\tprivate async unsubscribe(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.Unsubscribe,\n\t\t\tid: await this.r.u62(),\n\t\t}\n\t}\n\n\tprivate async announce(): Promise {\n\t\tconst namespace = await this.r.string()\n\n\t\treturn {\n\t\t\tkind: Msg.Announce,\n\t\t\tnamespace,\n\t\t\tparams: await this.parameters(),\n\t\t}\n\t}\n\n\tprivate async announce_ok(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.AnnounceOk,\n\t\t\tnamespace: await this.r.string(),\n\t\t}\n\t}\n\n\tprivate async announce_error(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.AnnounceError,\n\t\t\tnamespace: await this.r.string(),\n\t\t\tcode: await this.r.u62(),\n\t\t\treason: await this.r.string(),\n\t\t}\n\t}\n\n\tprivate async unannounce(): Promise {\n\t\treturn {\n\t\t\tkind: Msg.Unannounce,\n\t\t\tnamespace: await this.r.string(),\n\t\t}\n\t}\n}\n\nexport class Encoder {\n\tw: Writer\n\n\tconstructor(w: Writer) {\n\t\tthis.w = w\n\t}\n\n\tasync message(m: Message) {\n\t\tswitch (m.kind) {\n\t\t\tcase Msg.Subscribe:\n\t\t\t\treturn this.subscribe(m)\n\t\t\tcase Msg.SubscribeOk:\n\t\t\t\treturn this.subscribe_ok(m)\n\t\t\tcase Msg.SubscribeError:\n\t\t\t\treturn this.subscribe_error(m)\n\t\t\tcase Msg.SubscribeDone:\n\t\t\t\treturn this.subscribe_done(m)\n\t\t\tcase Msg.Unsubscribe:\n\t\t\t\treturn this.unsubscribe(m)\n\t\t\tcase Msg.Announce:\n\t\t\t\treturn this.announce(m)\n\t\t\tcase Msg.AnnounceOk:\n\t\t\t\treturn this.announce_ok(m)\n\t\t\tcase Msg.AnnounceError:\n\t\t\t\treturn this.announce_error(m)\n\t\t\tcase Msg.Unannounce:\n\t\t\t\treturn this.unannounce(m)\n\t\t}\n\t}\n\n\tasync subscribe(s: Subscribe) {\n\t\tawait this.w.u53(Id.Subscribe)\n\t\tawait this.w.u62(s.id)\n\t\tawait this.w.u62(s.trackId)\n\t\tawait this.w.string(s.namespace)\n\t\tawait this.w.string(s.name)\n\t\tawait this.w.u8(s.subscriber_priority ?? 127)\n\t\tawait this.encodeGroupOrder(s.group_order ?? GroupOrder.Publisher)\n\t\tawait this.location(s.location)\n\t\tawait this.parameters(s.params)\n\t}\n\n\tprivate async encodeGroupOrder(order: GroupOrder) {\n\t\tswitch (order) {\n\t\t\tcase GroupOrder.Publisher:\n\t\t\t\tawait this.w.u8(GroupOrder.Publisher)\n\t\t\t\tbreak\n\t\t\tcase GroupOrder.Ascending:\n\t\t\t\tawait this.w.u8(GroupOrder.Ascending)\n\t\t\t\tbreak\n\t\t\tcase GroupOrder.Descending:\n\t\t\t\tawait this.w.u8(GroupOrder.Descending)\n\t\t\t\tbreak\n\t\t\tdefault:\n\t\t\t\tthrow new Error(\"Invalid GroupOrder value\")\n\t\t}\n\t}\n\n\tprivate async location(l: Location) {\n\t\tswitch (l.mode) {\n\t\t\tcase \"latest_group\":\n\t\t\t\tawait this.w.u62(1n)\n\t\t\t\tbreak\n\t\t\tcase \"latest_object\":\n\t\t\t\tawait this.w.u62(2n)\n\t\t\t\tbreak\n\t\t\tcase \"absolute_start\":\n\t\t\t\tawait this.w.u62(3n)\n\t\t\t\tawait this.w.u53(l.start_group)\n\t\t\t\tawait this.w.u53(l.start_object)\n\t\t\t\tbreak\n\t\t\tcase \"absolute_range\":\n\t\t\t\tawait this.w.u62(3n)\n\t\t\t\tawait this.w.u53(l.start_group)\n\t\t\t\tawait this.w.u53(l.start_object)\n\t\t\t\tawait this.w.u53(l.end_group)\n\t\t\t\tawait this.w.u53(l.end_object)\n\t\t}\n\t}\n\n\tprivate async parameters(p: Parameters | undefined) {\n\t\tif (!p) {\n\t\t\tawait this.w.u8(0)\n\t\t\treturn\n\t\t}\n\n\t\tawait this.w.u53(p.size)\n\t\tfor (const [id, value] of p) {\n\t\t\tawait this.w.u62(id)\n\t\t\tawait this.w.u53(value.length)\n\t\t\tawait this.w.write(value)\n\t\t}\n\t}\n\n\tasync subscribe_ok(s: SubscribeOk) {\n\t\tawait this.w.u53(Id.SubscribeOk)\n\t\tawait this.w.u62(s.id)\n\t\tawait this.w.u62(s.expires)\n\n\t\tawait this.encodeGroupOrder(s.group_order)\n\t\tif (s.latest !== undefined) {\n\t\t\tawait this.w.u8(1)\n\t\t\tawait this.w.u53(s.latest[0])\n\t\t\tawait this.w.u53(s.latest[1])\n\t\t} else {\n\t\t\tawait this.w.u8(0)\n\t\t}\n\t}\n\n\tasync subscribe_done(s: SubscribeDone) {\n\t\tawait this.w.u53(Id.SubscribeDone)\n\t\tawait this.w.u62(s.id)\n\t\tawait this.w.u62(s.code)\n\t\tawait this.w.string(s.reason)\n\n\t\tif (s.final !== undefined) {\n\t\t\tawait this.w.u8(1)\n\t\t\tawait this.w.u53(s.final[0])\n\t\t\tawait this.w.u53(s.final[1])\n\t\t} else {\n\t\t\tawait this.w.u8(0)\n\t\t}\n\t}\n\n\tasync subscribe_error(s: SubscribeError) {\n\t\tawait this.w.u53(Id.SubscribeError)\n\t\tawait this.w.u62(s.id)\n\t}\n\n\tasync unsubscribe(s: Unsubscribe) {\n\t\tawait this.w.u53(Id.Unsubscribe)\n\t\tawait this.w.u62(s.id)\n\t}\n\n\tasync announce(a: Announce) {\n\t\tawait this.w.u53(Id.Announce)\n\t\tawait this.w.string(a.namespace)\n\t\tawait this.w.u53(0) // parameters\n\t}\n\n\tasync announce_ok(a: AnnounceOk) {\n\t\tawait this.w.u53(Id.AnnounceOk)\n\t\tawait this.w.string(a.namespace)\n\t}\n\n\tasync announce_error(a: AnnounceError) {\n\t\tawait this.w.u53(Id.AnnounceError)\n\t\tawait this.w.string(a.namespace)\n\t\tawait this.w.u62(a.code)\n\t\tawait this.w.string(a.reason)\n\t}\n\n\tasync unannounce(a: Unannounce) {\n\t\tawait this.w.u53(Id.Unannounce)\n\t\tawait this.w.string(a.namespace)\n\t}\n}\n","import { Reader, Writer } from \"./stream\"\nexport { Reader, Writer }\n\nexport enum StreamType {\n\tObject = 0x0,\n\tTrack = 0x50,\n\tGroup = 0x51,\n}\n\nexport enum Status {\n\tOBJECT_NULL = 1,\n\tGROUP_NULL = 2,\n\tGROUP_END = 3,\n\tTRACK_END = 4,\n}\n\nexport interface TrackHeader {\n\ttype: StreamType.Track\n\tsub: bigint\n\ttrack: bigint\n\tpublisher_priority: number // VarInt with a u32 maximum value\n}\n\nexport interface TrackChunk {\n\tgroup: number // The group sequence, as a number because 2^53 is enough.\n\tobject: number\n\tpayload: Uint8Array | Status\n}\n\nexport interface GroupHeader {\n\ttype: StreamType.Group\n\tsub: bigint\n\ttrack: bigint\n\tgroup: number // The group sequence, as a number because 2^53 is enough.\n\tpublisher_priority: number // VarInt with a u32 maximum value\n}\n\nexport interface GroupChunk {\n\tobject: number\n\tpayload: Uint8Array | Status\n}\n\nexport interface ObjectHeader {\n\ttype: StreamType.Object\n\tsub: bigint\n\ttrack: bigint\n\tgroup: number\n\tobject: number\n\tpublisher_priority: number\n\tstatus: number\n}\n\nexport interface ObjectChunk {\n\tpayload: Uint8Array\n}\n\ntype WriterType = T extends TrackHeader\n\t? TrackWriter\n\t: T extends GroupHeader\n\t? GroupWriter\n\t: T extends ObjectHeader\n\t? ObjectWriter\n\t: never\n\nexport class Objects {\n\tprivate quic: WebTransport\n\n\tconstructor(quic: WebTransport) {\n\t\tthis.quic = quic\n\t}\n\n\tasync send(h: T): Promise> {\n\t\tconst stream = await this.quic.createUnidirectionalStream()\n\t\tconst w = new Writer(stream)\n\n\t\tawait w.u53(h.type)\n\t\tawait w.u62(h.sub)\n\t\tawait w.u62(h.track)\n\n\t\tlet res: WriterType\n\n\t\tif (h.type == StreamType.Object) {\n\t\t\tawait w.u53(h.group)\n\t\t\tawait w.u53(h.object)\n\t\t\tawait w.u8(h.publisher_priority)\n\t\t\tawait w.u53(h.status)\n\n\t\t\tres = new ObjectWriter(h, w) as WriterType\n\t\t} else if (h.type === StreamType.Group) {\n\t\t\tawait w.u53(h.group)\n\t\t\tawait w.u8(h.publisher_priority)\n\n\t\t\tres = new GroupWriter(h, w) as WriterType\n\t\t} else if (h.type === StreamType.Track) {\n\t\t\tawait w.u8(h.publisher_priority)\n\n\t\t\tres = new TrackWriter(h, w) as WriterType\n\t\t} else {\n\t\t\tthrow new Error(\"unknown header type\")\n\t\t}\n\n\t\t// console.trace(\"send object\", res.header)\n\n\t\treturn res\n\t}\n\n\tasync recv(): Promise {\n\t\tconst streams = this.quic.incomingUnidirectionalStreams.getReader()\n\n\t\tconst { value, done } = await streams.read()\n\t\tstreams.releaseLock()\n\n\t\tif (done) return\n\n\t\tconst r = new Reader(new Uint8Array(), value)\n\t\tconst type = (await r.u53()) as StreamType\n\t\tlet res: TrackReader | GroupReader | ObjectReader\n\n\t\tif (type == StreamType.Track) {\n\t\t\tconst h: TrackHeader = {\n\t\t\t\ttype,\n\t\t\t\tsub: await r.u62(),\n\t\t\t\ttrack: await r.u62(),\n\t\t\t\tpublisher_priority: await r.u8(),\n\t\t\t}\n\n\t\t\tres = new TrackReader(h, r)\n\t\t} else if (type == StreamType.Group) {\n\t\t\tconst h: GroupHeader = {\n\t\t\t\ttype,\n\t\t\t\tsub: await r.u62(),\n\t\t\t\ttrack: await r.u62(),\n\t\t\t\tgroup: await r.u53(),\n\t\t\t\tpublisher_priority: await r.u8(),\n\t\t\t}\n\t\t\tres = new GroupReader(h, r)\n\t\t} else if (type == StreamType.Object) {\n\t\t\tconst h = {\n\t\t\t\ttype,\n\t\t\t\tsub: await r.u62(),\n\t\t\t\ttrack: await r.u62(),\n\t\t\t\tgroup: await r.u53(),\n\t\t\t\tobject: await r.u53(),\n\t\t\t\tstatus: await r.u53(),\n\t\t\t\tpublisher_priority: await r.u8(),\n\t\t\t}\n\n\t\t\tres = new ObjectReader(h, r)\n\t\t} else {\n\t\t\tthrow new Error(\"unknown stream type\")\n\t\t}\n\n\t\t// console.trace(\"receive object\", res.header)\n\n\t\treturn res\n\t}\n}\n\nexport class TrackWriter {\n\tconstructor(\n\t\tpublic header: TrackHeader,\n\t\tpublic stream: Writer,\n\t) {}\n\n\tasync write(c: TrackChunk) {\n\t\tawait this.stream.u53(c.group)\n\t\tawait this.stream.u53(c.object)\n\n\t\tif (c.payload instanceof Uint8Array) {\n\t\t\tawait this.stream.u53(c.payload.byteLength)\n\t\t\tawait this.stream.write(c.payload)\n\t\t} else {\n\t\t\t// empty payload with status\n\t\t\tawait this.stream.u53(0)\n\t\t\tawait this.stream.u53(c.payload as number)\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class GroupWriter {\n\tconstructor(\n\t\tpublic header: GroupHeader,\n\t\tpublic stream: Writer,\n\t) {}\n\n\tasync write(c: GroupChunk) {\n\t\tawait this.stream.u53(c.object)\n\t\tif (c.payload instanceof Uint8Array) {\n\t\t\tawait this.stream.u53(c.payload.byteLength)\n\t\t\tawait this.stream.write(c.payload)\n\t\t} else {\n\t\t\tawait this.stream.u53(0)\n\t\t\tawait this.stream.u53(c.payload as number)\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class ObjectWriter {\n\tconstructor(\n\t\tpublic header: ObjectHeader,\n\t\tpublic stream: Writer,\n\t) {}\n\n\tasync write(c: ObjectChunk) {\n\t\tawait this.stream.write(c.payload)\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class TrackReader {\n\tconstructor(\n\t\tpublic header: TrackHeader,\n\t\tpublic stream: Reader,\n\t) {}\n\n\tasync read(): Promise {\n\t\tif (await this.stream.done()) {\n\t\t\treturn\n\t\t}\n\n\t\tconst group = await this.stream.u53()\n\t\tconst object = await this.stream.u53()\n\t\tconst size = await this.stream.u53()\n\n\t\tlet payload\n\t\tif (size == 0) {\n\t\t\tpayload = (await this.stream.u53()) as Status\n\t\t} else {\n\t\t\tpayload = await this.stream.read(size)\n\t\t}\n\n\t\treturn {\n\t\t\tgroup,\n\t\t\tobject,\n\t\t\tpayload,\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class GroupReader {\n\tconstructor(\n\t\tpublic header: GroupHeader,\n\t\tpublic stream: Reader,\n\t) {}\n\n\tasync read(): Promise {\n\t\tif (await this.stream.done()) {\n\t\t\treturn\n\t\t}\n\n\t\tconst object = await this.stream.u53()\n\t\tconst size = await this.stream.u53()\n\n\t\tlet payload\n\t\tif (size == 0) {\n\t\t\tpayload = (await this.stream.u53()) as Status\n\t\t} else {\n\t\t\tpayload = await this.stream.read(size)\n\t\t}\n\n\t\treturn {\n\t\t\tobject,\n\t\t\tpayload,\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n\nexport class ObjectReader {\n\tconstructor(\n\t\tpublic header: ObjectHeader,\n\t\tpublic stream: Reader,\n\t) {}\n\n\t// NOTE: Can only be called once.\n\tasync read(): Promise {\n\t\tif (await this.stream.done()) {\n\t\t\treturn\n\t\t}\n\n\t\treturn {\n\t\t\tpayload: await this.stream.readAll(),\n\t\t}\n\t}\n\n\tasync close() {\n\t\tawait this.stream.close()\n\t}\n}\n","export class Deferred {\n\tpromise: Promise\n\tresolve!: (value: T | PromiseLike) => void\n\treject!: (reason: any) => void\n\tpending = true\n\n\tconstructor() {\n\t\tthis.promise = new Promise((resolve, reject) => {\n\t\t\tthis.resolve = (value) => {\n\t\t\t\tthis.pending = false\n\t\t\t\tresolve(value)\n\t\t\t}\n\t\t\tthis.reject = (reason) => {\n\t\t\t\tthis.pending = false\n\t\t\t\treject(reason)\n\t\t\t}\n\t\t})\n\t}\n}\n\nexport type WatchNext = [T, Promise> | undefined]\n\nexport class Watch {\n\t#current: WatchNext\n\t#next = new Deferred>()\n\n\tconstructor(init: T) {\n\t\tthis.#next = new Deferred>()\n\t\tthis.#current = [init, this.#next.promise]\n\t}\n\n\tvalue(): WatchNext {\n\t\treturn this.#current\n\t}\n\n\tupdate(v: T | ((v: T) => T)) {\n\t\tif (!this.#next.pending) {\n\t\t\tthrow new Error(\"already closed\")\n\t\t}\n\n\t\t// If we're given a function, call it with the current value\n\t\tif (v instanceof Function) {\n\t\t\tv = v(this.#current[0])\n\t\t}\n\n\t\tconst next = new Deferred>()\n\t\tthis.#current = [v, next.promise]\n\t\tthis.#next.resolve(this.#current)\n\t\tthis.#next = next\n\t}\n\n\tclose() {\n\t\tthis.#current[1] = undefined\n\t\tthis.#next.resolve(this.#current)\n\t}\n}\n\n// Wakes up a multiple consumers.\nexport class Notify {\n\t#next = new Deferred()\n\n\tasync wait() {\n\t\treturn this.#next.promise\n\t}\n\n\twake() {\n\t\tif (!this.#next.pending) {\n\t\t\tthrow new Error(\"closed\")\n\t\t}\n\n\t\tthis.#next.resolve()\n\t\tthis.#next = new Deferred()\n\t}\n\n\tclose() {\n\t\tthis.#next.resolve()\n\t}\n}\n\n// Allows queuing N values, like a Channel.\nexport class Queue {\n\t#stream: TransformStream\n\t#closed = false\n\n\tconstructor(capacity = 1) {\n\t\tconst queue = new CountQueuingStrategy({ highWaterMark: capacity })\n\t\tthis.#stream = new TransformStream({}, undefined, queue)\n\t}\n\n\tasync push(v: T) {\n\t\tconst w = this.#stream.writable.getWriter()\n\t\tawait w.write(v)\n\t\tw.releaseLock()\n\t}\n\n\tasync next(): Promise {\n\t\tconst r = this.#stream.readable.getReader()\n\t\tconst { value, done } = await r.read()\n\t\tr.releaseLock()\n\n\t\tif (done) return\n\t\treturn value\n\t}\n\n\tasync abort(err: Error) {\n\t\tif (this.#closed) return\n\t\tawait this.#stream.writable.abort(err)\n\t\tthis.#closed = true\n\t}\n\n\tasync close() {\n\t\tif (this.#closed) return\n\t\tawait this.#stream.writable.close()\n\t\tthis.#closed = true\n\t}\n\n\tclosed() {\n\t\treturn this.#closed\n\t}\n}\n","import * as Control from \"./control\"\nimport { Queue, Watch } from \"../common/async\"\nimport { Objects, GroupWriter, ObjectWriter, StreamType, TrackWriter } from \"./objects\"\n\nexport class Publisher {\n\t// Used to send control messages\n\t#control: Control.Stream\n\n\t// Use to send objects.\n\t#objects: Objects\n\n\t// Our announced tracks.\n\t#announce = new Map()\n\n\t// Their subscribed tracks.\n\t#subscribe = new Map()\n\t#subscribeQueue = new Queue(Number.MAX_SAFE_INTEGER) // Unbounded queue in case there's no receiver\n\n\tconstructor(control: Control.Stream, objects: Objects) {\n\t\tthis.#control = control\n\t\tthis.#objects = objects\n\t}\n\n\t// Announce a track namespace.\n\tasync announce(namespace: string): Promise {\n\t\tif (this.#announce.has(namespace)) {\n\t\t\tthrow new Error(`already announce: ${namespace}`)\n\t\t}\n\n\t\tconst announce = new AnnounceSend(this.#control, namespace)\n\t\tthis.#announce.set(namespace, announce)\n\n\t\tawait this.#control.send({\n\t\t\tkind: Control.Msg.Announce,\n\t\t\tnamespace,\n\t\t})\n\n\t\treturn announce\n\t}\n\n\t// Receive the next new subscription\n\tasync subscribed() {\n\t\treturn await this.#subscribeQueue.next()\n\t}\n\n\tasync recv(msg: Control.Subscriber) {\n\t\tif (msg.kind == Control.Msg.Subscribe) {\n\t\t\tawait this.recvSubscribe(msg)\n\t\t} else if (msg.kind == Control.Msg.Unsubscribe) {\n\t\t\tthis.recvUnsubscribe(msg)\n\t\t} else if (msg.kind == Control.Msg.AnnounceOk) {\n\t\t\tthis.recvAnnounceOk(msg)\n\t\t} else if (msg.kind == Control.Msg.AnnounceError) {\n\t\t\tthis.recvAnnounceError(msg)\n\t\t} else {\n\t\t\tthrow new Error(`unknown control message`) // impossible\n\t\t}\n\t}\n\n\trecvAnnounceOk(msg: Control.AnnounceOk) {\n\t\tconst announce = this.#announce.get(msg.namespace)\n\t\tif (!announce) {\n\t\t\tthrow new Error(`announce OK for unknown announce: ${msg.namespace}`)\n\t\t}\n\n\t\tannounce.onOk()\n\t}\n\n\trecvAnnounceError(msg: Control.AnnounceError) {\n\t\tconst announce = this.#announce.get(msg.namespace)\n\t\tif (!announce) {\n\t\t\t// TODO debug this\n\t\t\tconsole.warn(`announce error for unknown announce: ${msg.namespace}`)\n\t\t\treturn\n\t\t}\n\n\t\tannounce.onError(msg.code, msg.reason)\n\t}\n\n\tasync recvSubscribe(msg: Control.Subscribe) {\n\t\tif (this.#subscribe.has(msg.id)) {\n\t\t\tthrow new Error(`duplicate subscribe for id: ${msg.id}`)\n\t\t}\n\n\t\tconst subscribe = new SubscribeRecv(this.#control, this.#objects, msg)\n\t\tthis.#subscribe.set(msg.id, subscribe)\n\t\tawait this.#subscribeQueue.push(subscribe)\n\n\t\tawait this.#control.send({\n\t\t\tkind: Control.Msg.SubscribeOk,\n\t\t\tid: msg.id,\n\t\t\texpires: 0n,\n\t\t\tgroup_order: msg.group_order,\n\t\t})\n\t}\n\n\trecvUnsubscribe(_msg: Control.Unsubscribe) {\n\t\tthrow new Error(\"TODO unsubscribe\")\n\t}\n}\n\nexport class AnnounceSend {\n\t#control: Control.Stream\n\n\treadonly namespace: string\n\n\t// The current state, updated by control messages.\n\t#state = new Watch<\"init\" | \"ack\" | Error>(\"init\")\n\n\tconstructor(control: Control.Stream, namespace: string) {\n\t\tthis.#control = control\n\t\tthis.namespace = namespace\n\t}\n\n\tasync ok() {\n\t\tfor (;;) {\n\t\t\tconst [state, next] = this.#state.value()\n\t\t\tif (state === \"ack\") return\n\t\t\tif (state instanceof Error) throw state\n\t\t\tif (!next) throw new Error(\"closed\")\n\n\t\t\tawait next\n\t\t}\n\t}\n\n\tasync active() {\n\t\tfor (;;) {\n\t\t\tconst [state, next] = this.#state.value()\n\t\t\tif (state instanceof Error) throw state\n\t\t\tif (!next) return\n\n\t\t\tawait next\n\t\t}\n\t}\n\n\tasync close() {\n\t\t// TODO implement unsubscribe\n\t\t// await this.#inner.sendUnsubscribe()\n\t}\n\n\tclosed() {\n\t\tconst [state, next] = this.#state.value()\n\t\treturn state instanceof Error || next == undefined\n\t}\n\n\tonOk() {\n\t\tif (this.closed()) return\n\t\tthis.#state.update(\"ack\")\n\t}\n\n\tonError(code: bigint, reason: string) {\n\t\tif (this.closed()) return\n\n\t\tconst err = new Error(`ANNOUNCE_ERROR (${code})` + reason ? `: ${reason}` : \"\")\n\t\tthis.#state.update(err)\n\t}\n}\n\nexport class SubscribeRecv {\n\t#control: Control.Stream\n\t#objects: Objects\n\t#id: bigint\n\t#trackId: bigint\n\t#subscriberPriority: number\n\tgroupOrder: Control.GroupOrder\n\n\treadonly namespace: string\n\treadonly track: string\n\n\t// The current state of the subscription.\n\t#state: \"init\" | \"ack\" | \"closed\" = \"init\"\n\n\tconstructor(control: Control.Stream, objects: Objects, msg: Control.Subscribe) {\n\t\tthis.#control = control // so we can send messages\n\t\tthis.#objects = objects // so we can send objects\n\t\tthis.#id = msg.id\n\t\tthis.#trackId = msg.trackId\n\t\tthis.namespace = msg.namespace\n\t\tthis.track = msg.name\n\t\tthis.#subscriberPriority = msg.subscriber_priority\n\t\tthis.groupOrder = msg.group_order\n\t}\n\n\t// Acknowledge the subscription as valid.\n\tasync ack() {\n\t\tif (this.#state !== \"init\") return\n\t\tthis.#state = \"ack\"\n\n\t\t// Send the control message.\n\t\treturn this.#control.send({\n\t\t\tkind: Control.Msg.SubscribeOk,\n\t\t\tid: this.#id,\n\t\t\texpires: 0n,\n\t\t\tgroup_order: this.groupOrder,\n\t\t})\n\t}\n\n\t// Close the subscription with an error.\n\tasync close(code = 0n, reason = \"\") {\n\t\tif (this.#state === \"closed\") return\n\t\tthis.#state = \"closed\"\n\n\t\treturn this.#control.send({\n\t\t\tkind: Control.Msg.SubscribeDone,\n\t\t\tid: this.#id,\n\t\t\tcode,\n\t\t\treason,\n\t\t})\n\t}\n\n\t// Create a writable data stream for the entire track\n\tasync serve(props?: { priority: number }): Promise {\n\t\treturn this.#objects.send({\n\t\t\ttype: StreamType.Track,\n\t\t\tsub: this.#id,\n\t\t\ttrack: this.#trackId,\n\t\t\tpublisher_priority: props?.priority ?? 127,\n\t\t})\n\t}\n\n\t// Create a writable data stream for a group within the track\n\tasync group(props: { group: number; priority?: number }): Promise {\n\t\treturn this.#objects.send({\n\t\t\ttype: StreamType.Group,\n\t\t\tsub: this.#id,\n\t\t\ttrack: this.#trackId,\n\t\t\tgroup: props.group,\n\t\t\tpublisher_priority: props.priority ?? 127,\n\t\t})\n\t}\n\n\t// Create a writable data stream for a single object within the track\n\tasync object(props: { group: number; object: number; priority?: number }): Promise {\n\t\treturn this.#objects.send({\n\t\t\ttype: StreamType.Object,\n\t\t\tsub: this.#id,\n\t\t\ttrack: this.#trackId,\n\t\t\tgroup: props.group,\n\t\t\tobject: props.object,\n\t\t\tpublisher_priority: props.priority ?? 127,\n\t\t\tstatus: 0,\n\t\t})\n\t}\n}\n","import * as Control from \"./control\"\nimport { Queue, Watch } from \"../common/async\"\nimport { Objects } from \"./objects\"\nimport type { TrackReader, GroupReader, ObjectReader } from \"./objects\"\n\nexport class Subscriber {\n\t// Use to send control messages.\n\t#control: Control.Stream\n\n\t// Use to send objects.\n\t#objects: Objects\n\n\t// Announced broadcasts.\n\t#announce = new Map()\n\t#announceQueue = new Watch([])\n\n\t// Our subscribed tracks.\n\t#subscribe = new Map()\n\t#subscribeNext = 0n\n\n\t#trackToIDMap = new Map()\n\n\tconstructor(control: Control.Stream, objects: Objects) {\n\t\tthis.#control = control\n\t\tthis.#objects = objects\n\t}\n\n\tannounced(): Watch {\n\t\treturn this.#announceQueue\n\t}\n\n\tasync recv(msg: Control.Publisher) {\n\t\tif (msg.kind == Control.Msg.Announce) {\n\t\t\tawait this.recvAnnounce(msg)\n\t\t} else if (msg.kind == Control.Msg.Unannounce) {\n\t\t\tthis.recvUnannounce(msg)\n\t\t} else if (msg.kind == Control.Msg.SubscribeOk) {\n\t\t\tthis.recvSubscribeOk(msg)\n\t\t} else if (msg.kind == Control.Msg.SubscribeError) {\n\t\t\tawait this.recvSubscribeError(msg)\n\t\t} else if (msg.kind == Control.Msg.SubscribeDone) {\n\t\t\tawait this.recvSubscribeDone(msg)\n\t\t} else {\n\t\t\tthrow new Error(`unknown control message`) // impossible\n\t\t}\n\t}\n\n\tasync recvAnnounce(msg: Control.Announce) {\n\t\tif (this.#announce.has(msg.namespace)) {\n\t\t\tthrow new Error(`duplicate announce for namespace: ${msg.namespace}`)\n\t\t}\n\n\t\tawait this.#control.send({ kind: Control.Msg.AnnounceOk, namespace: msg.namespace })\n\n\t\tconst announce = new AnnounceRecv(this.#control, msg.namespace)\n\t\tthis.#announce.set(msg.namespace, announce)\n\n\t\tthis.#announceQueue.update((queue) => [...queue, announce])\n\t}\n\n\trecvUnannounce(_msg: Control.Unannounce) {\n\t\tthrow new Error(`TODO Unannounce`)\n\t}\n\n\tasync subscribe(namespace: string, track: string) {\n\t\tconst id = this.#subscribeNext++\n\n\t\tconst subscribe = new SubscribeSend(this.#control, id, namespace, track)\n\t\tthis.#subscribe.set(id, subscribe)\n\n\t\tthis.#trackToIDMap.set(track, id)\n\n\t\tawait this.#control.send({\n\t\t\tkind: Control.Msg.Subscribe,\n\t\t\tid,\n\t\t\ttrackId: id,\n\t\t\tnamespace,\n\t\t\tname: track,\n\t\t\tsubscriber_priority: 127, // default to mid value, see: https://github.com/moq-wg/moq-transport/issues/504\n\t\t\tgroup_order: Control.GroupOrder.Publisher,\n\t\t\tlocation: {\n\t\t\t\tmode: \"latest_group\",\n\t\t\t},\n\t\t})\n\n\t\treturn subscribe\n\t}\n\n\tasync unsubscribe(track: string) {\n\t\tif (this.#trackToIDMap.has(track)) {\n\t\t\tconst trackID = this.#trackToIDMap.get(track)\n\t\t\tif (trackID === undefined) {\n\t\t\t\tconsole.warn(`Exception track ${track} not found in trackToIDMap.`)\n\t\t\t\treturn\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tawait this.#control.send({ kind: Control.Msg.Unsubscribe, id: trackID })\n\t\t\t\tthis.#trackToIDMap.delete(track)\n\t\t\t} catch (error) {\n\t\t\t\tconsole.error(`Failed to unsubscribe from track ${track}:`, error)\n\t\t\t}\n\t\t} else {\n\t\t\tconsole.warn(`During unsubscribe request initiation attempt track ${track} not found in trackToIDMap.`)\n\t\t}\n\t}\n\n\trecvSubscribeOk(msg: Control.SubscribeOk) {\n\t\tconst subscribe = this.#subscribe.get(msg.id)\n\t\tif (!subscribe) {\n\t\t\tthrow new Error(`subscribe ok for unknown id: ${msg.id}`)\n\t\t}\n\n\t\tsubscribe.onOk()\n\t}\n\n\tasync recvSubscribeError(msg: Control.SubscribeError) {\n\t\tconst subscribe = this.#subscribe.get(msg.id)\n\t\tif (!subscribe) {\n\t\t\tthrow new Error(`subscribe error for unknown id: ${msg.id}`)\n\t\t}\n\n\t\tawait subscribe.onError(msg.code, msg.reason)\n\t}\n\n\tasync recvSubscribeDone(msg: Control.SubscribeDone) {\n\t\tconst subscribe = this.#subscribe.get(msg.id)\n\t\tif (!subscribe) {\n\t\t\tthrow new Error(`subscribe error for unknown id: ${msg.id}`)\n\t\t}\n\n\t\tawait subscribe.onError(msg.code, msg.reason)\n\t}\n\n\tasync recvObject(reader: TrackReader | GroupReader | ObjectReader) {\n\t\tconst subscribe = this.#subscribe.get(reader.header.track)\n\t\tif (!subscribe) {\n\t\t\tthrow new Error(`data for for unknown track: ${reader.header.track}`)\n\t\t}\n\n\t\tawait subscribe.onData(reader)\n\t}\n}\n\nexport class AnnounceRecv {\n\t#control: Control.Stream\n\n\treadonly namespace: string\n\n\t// The current state of the announce\n\t#state: \"init\" | \"ack\" | \"closed\" = \"init\"\n\n\tconstructor(control: Control.Stream, namespace: string) {\n\t\tthis.#control = control // so we can send messages\n\t\tthis.namespace = namespace\n\t}\n\n\t// Acknowledge the subscription as valid.\n\tasync ok() {\n\t\tif (this.#state !== \"init\") return\n\t\tthis.#state = \"ack\"\n\n\t\t// Send the control message.\n\t\treturn this.#control.send({ kind: Control.Msg.AnnounceOk, namespace: this.namespace })\n\t}\n\n\tasync close(code = 0n, reason = \"\") {\n\t\tif (this.#state === \"closed\") return\n\t\tthis.#state = \"closed\"\n\n\t\treturn this.#control.send({ kind: Control.Msg.AnnounceError, namespace: this.namespace, code, reason })\n\t}\n}\n\nexport class SubscribeSend {\n\t#control: Control.Stream\n\t#id: bigint\n\n\treadonly namespace: string\n\treadonly track: string\n\n\t// A queue of received streams for this subscription.\n\t#data = new Queue()\n\n\tconstructor(control: Control.Stream, id: bigint, namespace: string, track: string) {\n\t\tthis.#control = control // so we can send messages\n\t\tthis.#id = id\n\t\tthis.namespace = namespace\n\t\tthis.track = track\n\t}\n\n\tasync close(_code = 0n, _reason = \"\") {\n\t\t// TODO implement unsubscribe\n\t\t// await this.#inner.sendReset(code, reason)\n\t}\n\n\tonOk() {\n\t\t// noop\n\t}\n\n\tasync onError(code: bigint, reason: string) {\n\t\tif (code == 0n) {\n\t\t\treturn await this.#data.close()\n\t\t}\n\n\t\tif (reason !== \"\") {\n\t\t\treason = `: ${reason}`\n\t\t}\n\n\t\tconst err = new Error(`SUBSCRIBE_ERROR (${code})${reason}`)\n\t\treturn await this.#data.abort(err)\n\t}\n\n\tasync onData(reader: TrackReader | GroupReader | ObjectReader) {\n\t\tif (!this.#data.closed()) await this.#data.push(reader)\n\t}\n\n\t// Receive the next a readable data stream\n\tasync data() {\n\t\treturn await this.#data.next()\n\t}\n}\n","import * as Control from \"./control\"\nimport { Objects } from \"./objects\"\nimport { asError } from \"../common/error\"\n\nimport { Publisher } from \"./publisher\"\nimport { Subscriber } from \"./subscriber\"\n\nexport class Connection {\n\t// The established WebTransport session.\n\t#quic: WebTransport\n\n\t// Use to receive/send control messages.\n\t#control: Control.Stream\n\n\t// Use to receive/send objects.\n\t#objects: Objects\n\n\t// Module for contributing tracks.\n\t#publisher: Publisher\n\n\t// Module for distributing tracks.\n\t#subscriber: Subscriber\n\n\t// Async work running in the background\n\t#running: Promise\n\n\tconstructor(quic: WebTransport, control: Control.Stream, objects: Objects) {\n\t\tthis.#quic = quic\n\t\tthis.#control = control\n\t\tthis.#objects = objects\n\n\t\tthis.#publisher = new Publisher(this.#control, this.#objects)\n\t\tthis.#subscriber = new Subscriber(this.#control, this.#objects)\n\n\t\tthis.#running = this.#run()\n\t}\n\n\tclose(code = 0, reason = \"\") {\n\t\tthis.#quic.close({ closeCode: code, reason })\n\t}\n\n\tasync #run(): Promise {\n\t\tawait Promise.all([this.#runControl(), this.#runObjects()])\n\t}\n\n\tannounce(namespace: string) {\n\t\treturn this.#publisher.announce(namespace)\n\t}\n\n\tannounced() {\n\t\treturn this.#subscriber.announced()\n\t}\n\n\tsubscribe(namespace: string, track: string) {\n\t\treturn this.#subscriber.subscribe(namespace, track)\n\t}\n\n\tunsubscribe(track: string) {\n\t\treturn this.#subscriber.unsubscribe(track)\n\t}\n\n\tsubscribed() {\n\t\treturn this.#publisher.subscribed()\n\t}\n\n\tasync #runControl() {\n\t\t// Receive messages until the connection is closed.\n\t\tfor (;;) {\n\t\t\tconst msg = await this.#control.recv()\n\t\t\tawait this.#recv(msg)\n\t\t}\n\t}\n\n\tasync #runObjects() {\n\t\tfor (;;) {\n\t\t\tconst obj = await this.#objects.recv()\n\t\t\tif (!obj) break\n\n\t\t\tawait this.#subscriber.recvObject(obj)\n\t\t}\n\t}\n\n\tasync #recv(msg: Control.Message) {\n\t\tif (Control.isPublisher(msg)) {\n\t\t\tawait this.#subscriber.recv(msg)\n\t\t} else {\n\t\t\tawait this.#publisher.recv(msg)\n\t\t}\n\t}\n\n\tasync closed(): Promise {\n\t\ttry {\n\t\t\tawait this.#running\n\t\t\treturn new Error(\"closed\")\n\t\t} catch (e) {\n\t\t\treturn asError(e)\n\t\t}\n\t}\n}\n","import * as Stream from \"./stream\"\nimport * as Setup from \"./setup\"\nimport * as Control from \"./control\"\nimport { Objects } from \"./objects\"\nimport { Connection } from \"./connection\"\n\nexport interface ClientConfig {\n\turl: string\n\n\t// Parameters used to create the MoQ session\n\trole: Setup.Role\n\n\t// If set, the server fingerprint will be fetched from this URL.\n\t// This is required to use self-signed certificates with Chrome (May 2023)\n\tfingerprint?: string\n}\n\nexport class Client {\n\t#fingerprint: Promise\n\n\treadonly config: ClientConfig\n\n\tconstructor(config: ClientConfig) {\n\t\tthis.config = config\n\n\t\tthis.#fingerprint = this.#fetchFingerprint(config.fingerprint).catch((e) => {\n\t\t\tconsole.warn(\"failed to fetch fingerprint: \", e)\n\t\t\treturn undefined\n\t\t})\n\t}\n\n\tasync connect(): Promise {\n\t\t// Helper function to make creating a promise easier\n\t\tconst options: WebTransportOptions = {}\n\n\t\tconst fingerprint = await this.#fingerprint\n\t\tif (fingerprint) options.serverCertificateHashes = [fingerprint]\n\n\t\tconst quic = new WebTransport(this.config.url, options)\n\t\tawait quic.ready\n\n\t\tconst stream = await quic.createBidirectionalStream()\n\n\t\tconst writer = new Stream.Writer(stream.writable)\n\t\tconst reader = new Stream.Reader(new Uint8Array(), stream.readable)\n\n\t\tconst setup = new Setup.Stream(reader, writer)\n\n\t\t// Send the setup message.\n\t\tawait setup.send.client({ versions: [Setup.Version.DRAFT_05], role: this.config.role })\n\n\t\t// Receive the setup message.\n\t\t// TODO verify the SETUP response.\n\t\tconst server = await setup.recv.server()\n\n\t\tif (server.version != Setup.Version.DRAFT_05) {\n\t\t\tthrow new Error(`unsupported server version: ${server.version}`)\n\t\t}\n\n\t\tconst control = new Control.Stream(reader, writer)\n\t\tconst objects = new Objects(quic)\n\n\t\treturn new Connection(quic, control, objects)\n\t}\n\n\tasync #fetchFingerprint(url?: string): Promise {\n\t\tif (!url) return\n\n\t\t// TODO remove this fingerprint when Chrome WebTransport accepts the system CA\n\t\tconst response = await fetch(url)\n\t\tconst hexString = await response.text()\n\n\t\tconst hexBytes = new Uint8Array(hexString.length / 2)\n\t\tfor (let i = 0; i < hexBytes.length; i += 1) {\n\t\t\thexBytes[i] = parseInt(hexString.slice(2 * i, 2 * i + 2), 16)\n\t\t}\n\n\t\treturn {\n\t\t\talgorithm: \"sha-256\",\n\t\t\tvalue: hexBytes,\n\t\t}\n\t}\n}\n","import * as Message from \"./worker/message\"\n\nimport { Connection } from \"../transport/connection\"\nimport * as Catalog from \"../media/catalog\"\nimport { asError } from \"../common/error\"\n\nimport Backend from \"./backend\"\n\nimport { Client } from \"../transport/client\"\nimport { GroupReader } from \"../transport/objects\"\n\nexport type Range = Message.Range\nexport type Timeline = Message.Timeline\n\nexport interface PlayerConfig {\n\turl: string\n\tnamespace: string\n\tfingerprint?: string // URL to fetch TLS certificate fingerprint\n\tcanvas: HTMLCanvasElement\n}\n\n// This class must be created on the main thread due to AudioContext.\nexport default class Player {\n\t#backend: Backend\n\n\t// A periodically updated timeline\n\t//#timeline = new Watch(undefined)\n\n\t#connection: Connection\n\t#catalog: Catalog.Root\n\t#tracksByName: Map\n\t#tracknum: number\n\t#audioTrackName: string\n\t#videoTrackName: string\n\t#muted: boolean\n\t#paused: boolean\n\n\t// Running is a promise that resolves when the player is closed.\n\t// #close is called with no error, while #abort is called with an error.\n\t#running: Promise\n\t#close!: () => void\n\t#abort!: (err: Error) => void\n\t#trackTasks: Map> = new Map()\n\n\tprivate constructor(connection: Connection, catalog: Catalog.Root, backend: Backend, tracknum: number) {\n\t\tthis.#connection = connection\n\t\tthis.#catalog = catalog\n\t\tthis.#tracksByName = new Map(catalog.tracks.map((track) => [track.name, track]))\n\t\tthis.#backend = backend\n\t\tthis.#tracknum = tracknum\n\t\tthis.#audioTrackName = \"\"\n\t\tthis.#videoTrackName = \"\"\n\t\tthis.#muted = false\n\t\tthis.#paused = false\n\n\t\tconst abort = new Promise((resolve, reject) => {\n\t\t\tthis.#close = resolve\n\t\t\tthis.#abort = reject\n\t\t})\n\n\t\t// Async work\n\t\tthis.#running = abort.catch(this.#close)\n\n\t\tthis.#run().catch((err) => {\n\t\t\tconsole.error(\"Error in #run():\", err)\n\t\t\tthis.#abort(err)\n\t\t})\n\t}\n\n\tstatic async create(config: PlayerConfig, tracknum: number): Promise {\n\t\tconst client = new Client({ url: config.url, fingerprint: config.fingerprint, role: \"subscriber\" })\n\t\tconst connection = await client.connect()\n\n\t\tconst catalog = await Catalog.fetch(connection, config.namespace)\n\t\tconsole.log(\"catalog\", catalog)\n\n\t\tconst canvas = config.canvas.transferControlToOffscreen()\n\t\tconst backend = new Backend({ canvas, catalog })\n\n\t\treturn new Player(connection, catalog, backend, tracknum)\n\t}\n\n\tasync #run() {\n\t\tconst inits = new Set<[string, string]>()\n\t\tconst tracks = new Array()\n\n\t\tthis.#catalog.tracks.forEach((track, index) => {\n\t\t\tif (index == this.#tracknum || Catalog.isAudioTrack(track)) {\n\t\t\t\tif (!track.namespace) throw new Error(\"track has no namespace\")\n\t\t\t\tif (track.initTrack) inits.add([track.namespace, track.initTrack])\n\t\t\t\ttracks.push(track)\n\t\t\t}\n\t\t})\n\n\t\t// Call #runInit on each unique init track\n\t\t// TODO do this in parallel with #runTrack to remove a round trip\n\t\tawait Promise.all(Array.from(inits).map((init) => this.#runInit(...init)))\n\n\t\t// Call #runTrack on each track\n\t\ttracks.forEach((track) => {\n\t\t\tthis.#runTrack(track)\n\t\t})\n\t}\n\n\tasync #runInit(namespace: string, name: string) {\n\t\tconst sub = await this.#connection.subscribe(namespace, name)\n\t\ttry {\n\t\t\tconst init = await Promise.race([sub.data(), this.#running])\n\t\t\tif (!init) throw new Error(\"no init data\")\n\n\t\t\t// We don't care what type of reader we get, we just want the payload.\n\t\t\tconst chunk = await init.read()\n\t\t\tif (!chunk) throw new Error(\"no init chunk\")\n\t\t\tif (!(chunk.payload instanceof Uint8Array)) throw new Error(\"invalid init chunk\")\n\n\t\t\tthis.#backend.init({ data: chunk.payload, name })\n\t\t} finally {\n\t\t\tawait sub.close()\n\t\t}\n\t}\n\n\tasync #trackTask(track: Catalog.Track) {\n\t\tif (!track.namespace) throw new Error(\"track has no namespace\")\n\n\t\tif (this.#paused) return\n\n\t\tconst kind = Catalog.isVideoTrack(track) ? \"video\" : Catalog.isAudioTrack(track) ? \"audio\" : \"unknown\"\n\t\tif (kind == \"audio\" && this.#muted) return\n\n\t\tconst sub = await this.#connection.subscribe(track.namespace, track.name)\n\n\t\tif (kind == \"audio\") {\n\t\t\t// Save ref to last audio track we subscribed to for unmuting\n\t\t\tthis.#audioTrackName = track.name\n\t\t}\n\n\t\tif (kind == \"video\") {\n\t\t\tthis.#videoTrackName = track.name\n\t\t}\n\n\t\ttry {\n\t\t\tfor (;;) {\n\t\t\t\tconst segment = await Promise.race([sub.data(), this.#running])\n\t\t\t\tif (!segment) continue\n\n\t\t\t\tif (!(segment instanceof GroupReader)) {\n\t\t\t\t\tthrow new Error(`expected group reader for segment: ${track.name}`)\n\t\t\t\t}\n\n\t\t\t\tif (kind == \"unknown\") {\n\t\t\t\t\tthrow new Error(`unknown track kind: ${track.name}`)\n\t\t\t\t}\n\n\t\t\t\tif (!track.initTrack) {\n\t\t\t\t\tthrow new Error(`no init track for segment: ${track.name}`)\n\t\t\t\t}\n\n\t\t\t\tconst [buffer, stream] = segment.stream.release()\n\n\t\t\t\tthis.#backend.segment({\n\t\t\t\t\tinit: track.initTrack,\n\t\t\t\t\tkind,\n\t\t\t\t\theader: segment.header,\n\t\t\t\t\tbuffer,\n\t\t\t\t\tstream,\n\t\t\t\t})\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tconsole.error(\"Error in #runTrack:\", error)\n\t\t} finally {\n\t\t\tawait sub.close()\n\t\t}\n\t}\n\n\t#runTrack(track: Catalog.Track) {\n\t\tif (this.#trackTasks.has(track.name)) {\n\t\t\tconsole.warn(`Already exist a runTrack task for the track: ${track.name}`)\n\t\t\treturn\n\t\t}\n\n\t\tconst task = (async () => this.#trackTask(track))()\n\n\t\tthis.#trackTasks.set(track.name, task)\n\n\t\ttask.catch((err) => {\n\t\t\tconsole.error(`Error to subscribe to track ${track.name}`, err)\n\t\t}).finally(() => {\n\t\t\tthis.#trackTasks.delete(track.name)\n\t\t})\n\t}\n\n\tgetCatalog() {\n\t\treturn this.#catalog\n\t}\n\n\tgetCurrentTrack() {\n\t\tif (this.#tracknum >= 0 && this.#tracknum < this.#catalog.tracks.length) {\n\t\t\treturn this.#catalog.tracks[this.#tracknum]\n\t\t} else {\n\t\t\tconsole.warn(\"Invalid track number:\", this.#tracknum)\n\t\t\treturn null\n\t\t}\n\t}\n\n\tgetVideoTracks() {\n\t\treturn this.#catalog.tracks.filter(Catalog.isVideoTrack).map((track) => track.name)\n\t}\n\n\tgetAudioTracks() {\n\t\treturn this.#catalog.tracks.filter(Catalog.isAudioTrack).map((track) => track.name)\n\t}\n\n\tasync switchTrack(trackname: string) {\n\t\tconst currentTrack = this.getCurrentTrack()\n\t\tif (this.#paused) {\n\t\t\tthis.#videoTrackName = trackname\n\t\t\treturn\n\t\t}\n\t\tif (currentTrack) {\n\t\t\tconsole.log(`Unsubscribing from track: ${currentTrack.name} and Subscribing to track: ${trackname}`)\n\t\t\tawait this.unsubscribeFromTrack(currentTrack.name)\n\t\t} else {\n\t\t\tconsole.log(`Subscribing to track: ${trackname}`)\n\t\t}\n\t\tthis.#tracknum = this.#catalog.tracks.findIndex((track) => track.name === trackname)\n\t\tconst tracksToStream = this.#catalog.tracks.filter((track) => track.name === trackname)\n\t\tawait Promise.all(tracksToStream.map((track) => this.#runTrack(track)))\n\t}\n\n\tasync mute(isMuted: boolean) {\n\t\tthis.#muted = isMuted\n\t\tif (isMuted) {\n\t\t\tconsole.log(\"Unsubscribing from audio track: \", this.#audioTrackName)\n\t\t\tawait this.unsubscribeFromTrack(this.#audioTrackName)\n\t\t\tawait this.#backend.mute()\n\t\t} else {\n\t\t\tconsole.log(\"Subscribing to audio track: \", this.#audioTrackName)\n\t\t\tthis.subscribeFromTrackName(this.#audioTrackName)\n\t\t\tawait this.#backend.unmute()\n\t\t}\n\t}\n\n\tasync unsubscribeFromTrack(trackname: string) {\n\t\tconsole.log(`Unsubscribing from track: ${trackname}`)\n\t\tawait this.#connection.unsubscribe(trackname)\n\t\tconst task = this.#trackTasks.get(trackname)\n\t\tif (task) {\n\t\t\tawait task\n\t\t}\n\t}\n\n\tsubscribeFromTrackName(trackname: string) {\n\t\tconsole.log(`Subscribing to track: ${trackname}`)\n\t\tconst track = this.#tracksByName.get(trackname)\n\t\tif (track) {\n\t\t\tthis.#runTrack(track)\n\t\t} else {\n\t\t\tconsole.warn(`Track ${trackname} not in #tracksByName`)\n\t\t}\n\t}\n\n\t#onMessage(msg: Message.FromWorker) {\n\t\tif (msg.timeline) {\n\t\t\t//this.#timeline.update(msg.timeline)\n\t\t}\n\t}\n\n\tasync close(err?: Error) {\n\t\tif (err) this.#abort(err)\n\t\telse this.#close()\n\n\t\tif (this.#connection) this.#connection.close()\n\t\tif (this.#backend) await this.#backend.close()\n\t}\n\n\tasync closed(): Promise {\n\t\ttry {\n\t\t\tawait this.#running\n\t\t} catch (e) {\n\t\t\treturn asError(e)\n\t\t}\n\t}\n\n\t/*\n\tplay() {\n\t\tthis.#backend.play({ minBuffer: 0.5 }) // TODO configurable\n\t}\n\n\tseek(timestamp: number) {\n\t\tthis.#backend.seek({ timestamp })\n\t}\n\t*/\n\n\tasync play() {\n\t\tif (this.#paused) {\n\t\t\tthis.#paused = false\n\t\t\tthis.subscribeFromTrackName(this.#videoTrackName)\n\t\t\tif (!this.#muted) {\n\t\t\t\tthis.subscribeFromTrackName(this.#audioTrackName)\n\t\t\t\tawait this.#backend.unmute()\n\t\t\t}\n\t\t} else {\n\t\t\tawait this.unsubscribeFromTrack(this.#videoTrackName)\n\t\t\tawait this.unsubscribeFromTrack(this.#audioTrackName)\n\t\t\tawait this.#backend.mute()\n\t\t\tthis.#backend.pause()\n\t\t\tthis.#paused = true\n\t\t}\n\t}\n\n\t/*\n\tasync *timeline() {\n\t\tfor (;;) {\n\t\t\tconst [timeline, next] = this.#timeline.value()\n\t\t\tif (timeline) yield timeline\n\t\t\tif (!next) break\n\n\t\t\tawait next\n\t\t}\n\t}\n\t*/\n}\n"],"names":["fetch","registerMyAudioWorklet","MediaWorker","Decoder","Encoder","Control.Msg","Control.GroupOrder","Control.isPublisher","Stream.Writer","Stream.Reader","Setup.Stream","Setup.Version","Control.Stream","Catalog.fetch","Catalog.isAudioTrack","Catalog.isVideoTrack"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CC5CD;CAEA,IAAK,KAIJ;CAJD,CAAA,UAAK,KAAK,EAAA;CACT,IAAA,KAAA,CAAA,KAAA,CAAA,UAAA,CAAA,GAAA,CAAA,CAAA,GAAA,UAAY;CACZ,IAAA,KAAA,CAAA,KAAA,CAAA,WAAA,CAAA,GAAA,CAAA,CAAA,GAAA,WAAS;CACT,IAAA,KAAA,CAAA,KAAA,CAAA,QAAA,CAAA,GAAA,CAAA,CAAA,GAAA,QAAM;CACP,CAAC,EAJI,KAAK,KAAL,KAAK,GAIT,EAAA,CAAA,CAAA;CAeD;OACa,UAAU,CAAA;CACtB,IAAA,KAAK;CAEL,IAAA,QAAQ;CACR,IAAA,QAAQ;KAER,WAAY,CAAA,QAAgB,EAAE,QAAgB,EAAA;;CAE7C,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI,iBAAiB,CAAC,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC,iBAAiB,CAAC;;CAG/E,QAAA,IAAI,CAAC,QAAQ,GAAG,EAAE;CAClB,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE;aACrC,MAAM,MAAM,GAAG,IAAI,iBAAiB,CAAC,QAAQ,GAAG,YAAY,CAAC,iBAAiB,CAAC;CAC/E,YAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;;CAG3B,QAAA,IAAI,CAAC,QAAQ,GAAG,QAAQ;;CAEzB;;CC1BD;CACA;CAEA;CACc,MAAO,OAAO,CAAA;;CAE3B,IAAA,OAAO;;CAGP,IAAA,MAAM;CAEN,IAAA,WAAA,CAAY,MAAoB,EAAA;;CAE/B,QAAA,IAAI,CAAC,OAAO,GAAG,IAAIC,aAAW,EAAE;CAChC,QAAA,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;CAE5D,QAAA,IAAI,UAA8B;CAClC,QAAA,IAAI,QAA4B;SAEhC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE;CAC1C,YAAA,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE;iBACxB,IAAI,UAAU,IAAI,KAAK,CAAC,eAAe,CAAC,UAAU,KAAK,UAAU,EAAE;CAClE,oBAAA,MAAM,IAAI,KAAK,CAAC,CAAA,sDAAA,CAAwD,CAAC;;CAG1E,gBAAA,UAAU,GAAG,KAAK,CAAC,eAAe,CAAC,UAAU;;CAG7C,gBAAA,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,aAAa,EAAE,QAAQ,IAAI,CAAC,CAAC;;;SAI1E,MAAM,GAAG,GAAmB,EAAE;;CAG9B,QAAA,IAAI,UAAU,IAAI,QAAQ,EAAE;aAC3B,GAAG,CAAC,KAAK,GAAG;CACX,gBAAA,QAAQ,EAAE,QAAQ;CAClB,gBAAA,UAAU,EAAE,UAAU;iBACtB,IAAI,EAAE,IAAI,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,EAAE,CAAC;cACxC;aAED,IAAI,CAAC,MAAM,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC;;;SAInC,GAAG,CAAC,KAAK,GAAG;aACX,MAAM,EAAE,MAAM,CAAC,MAAM;UACrB;CAED,QAAA,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;;KAG7C,KAAK,GAAA;SACJ,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;CAG3B,IAAA,MAAM,IAAI,GAAA;SACT,MAAM,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE;;CAGrC,IAAA,MAAM,MAAM,GAAA;SACX,MAAM,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;;CAGpC,IAAA,IAAI,CAAC,IAAU,EAAA;CACd,QAAA,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;;CAGpB,IAAA,OAAO,CAAC,OAAgB,EAAA;SACvB,IAAI,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,MAAM,CAAC;;CAGvC,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;SACxB,MAAM,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,EAAE;;;CAI3B,IAAA,IAAI,CAAC,GAAqB,EAAE,GAAG,QAAwB,EAAA;;SAE9D,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,CAAC;;CAGhC,IAAA,EAAE,CAAC,CAAe,EAAA;CACzB,QAAA,MAAM,GAAG,GAAG,CAAC,CAAC,IAA0B;;CAGxC,QAAA,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE;;CAIpB;;CC3GD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC;CACjC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;CACnC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;CACnC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC;CACnC,MAAM,OAAO,GAAG,MAAM,CAAC,gBAAgB;CACvC,MAAM,OAAO,GAAW,EAAE,IAAI,GAAG,GAAG,EAAE;CAEtC;CACA;OACa,MAAM,CAAA;CAClB,IAAA,OAAO;CACP,IAAA,OAAO;CACP,IAAA,OAAO;KAEP,WAAY,CAAA,MAAkB,EAAE,MAAkC,EAAA;CACjE,QAAA,IAAI,CAAC,OAAO,GAAG,MAAM;CACrB,QAAA,IAAI,CAAC,OAAO,GAAG,MAAM;SACrB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;;;CAIxC,IAAA,MAAM,KAAK,GAAA;SACV,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;CACxC,QAAA,IAAI,MAAM,CAAC,IAAI,EAAE;CAChB,YAAA,OAAO,KAAK;;SAGb,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC;SAE3C,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,EAAE;CACjC,YAAA,IAAI,CAAC,OAAO,GAAG,MAAM;;cACf;CACN,YAAA,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;CACxE,YAAA,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC;aACtB,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;CACzC,YAAA,IAAI,CAAC,OAAO,GAAG,IAAI;;CAGpB,QAAA,OAAO,IAAI;;;KAIZ,MAAM,OAAO,CAAC,IAAY,EAAA;SACzB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,EAAE;aACtC,IAAI,EAAE,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE;CAC1B,gBAAA,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC;;;;;CAM9C,IAAA,MAAM,CAAC,IAAY,EAAA;CAClB,QAAA,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC;SACjF,IAAI,CAAC,OAAO,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;CAElF,QAAA,OAAO,MAAM;;KAGd,MAAM,IAAI,CAAC,IAAY,EAAA;SACtB,IAAI,IAAI,IAAI,CAAC;aAAE,OAAO,IAAI,UAAU,EAAE;CAEtC,QAAA,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;CACxB,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;;CAGzB,IAAA,MAAM,OAAO,GAAA;;SAEZ,OAAO,MAAM,IAAI,CAAC,KAAK,EAAE,EAAE;SAC3B,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;;KAG5C,MAAM,MAAM,CAAC,SAAkB,EAAA;CAC9B,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE;SAC/B,IAAI,SAAS,KAAK,SAAS,IAAI,MAAM,GAAG,SAAS,EAAE;aAClD,MAAM,IAAI,KAAK,CAAC,CAAA,cAAA,EAAiB,MAAM,CAAuB,oBAAA,EAAA,SAAS,CAAE,CAAA,CAAC;;SAG3E,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;SACtC,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC;;CAGxC,IAAA,MAAM,EAAE,GAAA;CACP,QAAA,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;SACrB,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;;;CAIzB,IAAA,MAAM,GAAG,GAAA;CACR,QAAA,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE;CAC1B,QAAA,IAAI,CAAC,GAAG,OAAO,EAAE;CAChB,YAAA,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC;;CAG9D,QAAA,OAAO,MAAM,CAAC,CAAC,CAAC;;;CAIjB,IAAA,MAAM,GAAG,GAAA;CACR,QAAA,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;CACrB,QAAA,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,CAAC;CAE1C,QAAA,IAAI,IAAI,IAAI,CAAC,EAAE;aACd,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/B,YAAA,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK;;CACtB,aAAA,IAAI,IAAI,IAAI,CAAC,EAAE;CACrB,YAAA,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;aACrB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;CAC5B,YAAA,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC;aAE3E,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO;;CACnC,aAAA,IAAI,IAAI,IAAI,CAAC,EAAE;CACrB,YAAA,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;aACrB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;CAC5B,YAAA,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC;aAE3E,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,WAAW;;CACxC,aAAA,IAAI,IAAI,IAAI,CAAC,EAAE;CACrB,YAAA,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;aACrB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;CAC5B,YAAA,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC;aAE3E,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,mBAAmB;;cAC3C;CACN,YAAA,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC;;;CAI/B,IAAA,MAAM,IAAI,GAAA;CACT,QAAA,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,CAAC;CAAE,YAAA,OAAO,KAAK;SAC7C,OAAO,EAAE,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;;CAG7B,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;CAC1B,QAAA,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;;KAG5B,OAAO,GAAA;CACN,QAAA,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;SAC1B,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC;;CAEpC;CAED;OACa,MAAM,CAAA;CAClB,IAAA,QAAQ;CACR,IAAA,OAAO;CACP,IAAA,OAAO;CAEP,IAAA,WAAA,CAAY,MAAkC,EAAA;CAC7C,QAAA,IAAI,CAAC,OAAO,GAAG,MAAM;SACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC;SACjC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;;KAGxC,MAAM,EAAE,CAAC,CAAS,EAAA;CACjB,QAAA,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;;KAG7C,MAAM,GAAG,CAAC,CAAS,EAAA;SAClB,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE;CAC1B,YAAA,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA,CAAE,CAAC;;;;CAK7D,QAAA,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;;KAG7C,MAAM,GAAG,CAAC,CAAS,EAAA;CAClB,QAAA,IAAI,CAAC,GAAG,CAAC,EAAE;CACV,YAAA,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA,CAAE,CAAC;;CAC/C,aAAA,IAAI,CAAC,GAAG,OAAO,EAAE;CACvB,YAAA,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA,CAAE,CAAC;;CAG7D,QAAA,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;;KAG9C,MAAM,GAAG,CAAC,CAAS,EAAA;CAClB,QAAA,IAAI,CAAC,GAAG,CAAC,EAAE;CACV,YAAA,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA,CAAE,CAAC;;CAC/C,aAAA,IAAI,CAAC,IAAI,OAAO,EAAE;CACxB,YAAA,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA,CAAE,CAAC;;CAG7D,QAAA,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;;KAG9C,MAAM,KAAK,CAAC,CAAa,EAAA;SACxB,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;;KAG5B,MAAM,MAAM,CAAC,GAAW,EAAA;SACvB,MAAM,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC;SAC1C,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC;CAC/B,QAAA,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;;CAGvB,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;CAC1B,QAAA,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;;KAG3B,OAAO,GAAA;CACN,QAAA,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;SAC1B,OAAO,IAAI,CAAC,OAAO;;CAEpB;CAED,SAAS,QAAQ,CAAC,GAAe,EAAE,CAAS,EAAA;CAC3C,IAAA,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;KACV,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;CACvB;CAEA,SAAS,SAAS,CAAC,GAAe,EAAE,CAAS,EAAA;CAC5C,IAAA,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;CACxD,IAAA,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;CAEpB,IAAA,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC;CACrE;CAEA,SAAS,QAAQ,CAAC,GAAe,EAAE,CAAS,EAAA;CAC3C,IAAA,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;CACxD,IAAA,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;CAEnB,IAAA,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC;CACrE;CAEA,SAAS,SAAS,CAAC,GAAe,EAAE,CAAS,EAAA;CAC5C,IAAA,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;CACxD,IAAA,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;CAEpB,IAAA,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC;CACrE;CAEA,SAAS,SAAS,CAAC,GAAe,EAAE,CAAS,EAAA;CAC5C,IAAA,IAAI,CAAC,IAAI,MAAM,EAAE;CAChB,QAAA,OAAO,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;;CACjB,SAAA,IAAI,CAAC,IAAI,OAAO,EAAE;SACxB,OAAO,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC;;CAC3B,SAAA,IAAI,CAAC,IAAI,OAAO,EAAE;SACxB,OAAO,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC;;CAC/B,SAAA,IAAI,CAAC,IAAI,OAAO,EAAE;SACxB,OAAO,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC;;UAChD;CACN,QAAA,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA,CAAE,CAAC;;CAE9D;CAEA,SAAS,SAAS,CAAC,GAAe,EAAE,CAAS,EAAA;CAC5C,IAAA,IAAI,CAAC,GAAG,MAAM,EAAE;SACf,OAAO,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;;CACzB,SAAA,IAAI,CAAC,GAAG,OAAO,EAAE;SACvB,OAAO,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;;CACnC,SAAA,IAAI,CAAC,IAAI,OAAO,EAAE;SACxB,OAAO,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;;CACvC,SAAA,IAAI,CAAC,IAAI,OAAO,EAAE;SACxB,OAAO,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC;;UAChD;CACN,QAAA,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAA,CAAE,CAAC;;CAE9D;CAEA,SAAS,SAAS,CAAC,GAAe,EAAE,CAAS,EAAA;CAC5C,IAAA,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;CACxD,IAAA,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;CAEvB,IAAA,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC;CACrE;;CCxQA,IAAY,OASX;CATD,CAAA,UAAY,OAAO,EAAA;CAClB,IAAA,OAAA,CAAA,OAAA,CAAA,UAAA,CAAA,GAAA,UAAA,CAAA,GAAA,UAAqB;CACrB,IAAA,OAAA,CAAA,OAAA,CAAA,UAAA,CAAA,GAAA,UAAA,CAAA,GAAA,UAAqB;CACrB,IAAA,OAAA,CAAA,OAAA,CAAA,UAAA,CAAA,GAAA,UAAA,CAAA,GAAA,UAAqB;CACrB,IAAA,OAAA,CAAA,OAAA,CAAA,UAAA,CAAA,GAAA,UAAA,CAAA,GAAA,UAAqB;CACrB,IAAA,OAAA,CAAA,OAAA,CAAA,UAAA,CAAA,GAAA,UAAA,CAAA,GAAA,UAAqB;CACrB,IAAA,OAAA,CAAA,OAAA,CAAA,UAAA,CAAA,GAAA,UAAA,CAAA,GAAA,UAAqB;CACrB,IAAA,OAAA,CAAA,OAAA,CAAA,UAAA,CAAA,GAAA,MAAA,CAAA,GAAA,UAAkB;CAClB,IAAA,OAAA,CAAA,OAAA,CAAA,UAAA,CAAA,GAAA,MAAA,CAAA,GAAA,UAAkB;CACnB,CAAC,EATW,OAAO,KAAP,OAAO,GASlB,EAAA,CAAA,CAAA;sBAkBY,MAAM,CAAA;CAClB,IAAA,IAAI;CACJ,IAAA,IAAI;KAEJ,WAAY,CAAA,CAAS,EAAE,CAAS,EAAA;SAC/B,IAAI,CAAC,IAAI,GAAG,IAAIC,SAAO,CAAC,CAAC,CAAC;SAC1B,IAAI,CAAC,IAAI,GAAG,IAAIC,SAAO,CAAC,CAAC,CAAC;;CAE3B;uBAIY,OAAO,CAAA;CACnB,IAAA,CAAC;CAED,IAAA,WAAA,CAAY,CAAS,EAAA;CACpB,QAAA,IAAI,CAAC,CAAC,GAAG,CAAC;;CAGX,IAAA,MAAM,MAAM,GAAA;SACX,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAC/B,IAAI,IAAI,KAAK,IAAI;CAAE,YAAA,MAAM,IAAI,KAAK,CAAC,uCAAuC,IAAI,CAAA,CAAE,CAAC;SAEjF,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAEhC,MAAM,QAAQ,GAAG,EAAE;CACnB,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;aAC/B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAClC,YAAA,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC;;CAGvB,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE;CACtC,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;SAEvC,OAAO;aACN,QAAQ;aACR,IAAI;aACJ,MAAM;UACN;;CAGF,IAAA,MAAM,MAAM,GAAA;SACX,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAC/B,IAAI,IAAI,KAAK,IAAI;CAAE,YAAA,MAAM,IAAI,KAAK,CAAC,uCAAuC,IAAI,CAAA,CAAE,CAAC;SAEjF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAClC,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE;SAEtC,OAAO;aACN,OAAO;aACP,MAAM;UACN;;CAGM,IAAA,MAAM,UAAU,GAAA;SACvB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAChC,IAAI,KAAK,IAAI,CAAC;CAAE,YAAA,OAAO,SAAS;CAEhC,QAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAAsB;CAE5C,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;aAC/B,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;aAC7B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;aAC/B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;CAErC,YAAA,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;CACnB,gBAAA,MAAM,IAAI,KAAK,CAAC,2BAA2B,EAAE,CAAA,CAAE,CAAC;;CAGjD,YAAA,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC;;CAGtB,QAAA,OAAO,MAAM;;CAGd,IAAA,IAAI,CAAC,GAA2B,EAAA;CAC/B,QAAA,IAAI,CAAC,GAAG;CAAE,YAAA,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC;CACnD,QAAA,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC;CAAE,YAAA,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC;CAEvE,QAAA,QAAQ,GAAG,CAAC,CAAC,CAAC;CACb,YAAA,KAAK,CAAC;CACL,gBAAA,OAAO,WAAW;CACnB,YAAA,KAAK,CAAC;CACL,gBAAA,OAAO,YAAY;CACpB,YAAA,KAAK,CAAC;CACL,gBAAA,OAAO,MAAM;CACd,YAAA;iBACC,MAAM,IAAI,KAAK,CAAC,CAAiB,cAAA,EAAA,GAAG,CAAC,CAAC,CAAC,CAAE,CAAA,CAAC;;;CAG7C;uBAEY,OAAO,CAAA;CACnB,IAAA,CAAC;CAED,IAAA,WAAA,CAAY,CAAS,EAAA;CACpB,QAAA,IAAI,CAAC,CAAC,GAAG,CAAC;;KAGX,MAAM,MAAM,CAAC,CAAS,EAAA;SACrB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;CACtB,QAAA,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;CACnC,QAAA,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;aAC3B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;;;SAIpB,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,IAAI,IAAI,GAAG,EAAE;CACpC,QAAA,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,WAAW,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,YAAY,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC5F,QAAA,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;;KAG9B,MAAM,MAAM,CAAC,CAAS,EAAA;SACrB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;SACtB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;SAC3B,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC;;KAGxB,MAAM,UAAU,CAAC,CAAyB,EAAA;SACjD,IAAI,CAAC,CAAC,EAAE;aACP,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;aAClB;;SAGD,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;SACxB,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE;aAC5B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;aACpB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;aAC9B,MAAM,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;;;CAG3B;;CCnJK,SAAU,WAAW,CAAC,CAAU,EAAA;CACrC,IAAA,QACC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,WAAW;CACzB,QAAA,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,cAAc;CAC5B,QAAA,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,aAAa;CAC3B,QAAA,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,QAAQ;CACtB,QAAA,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,UAAU;CAE1B;CAEA;CACA;CACA;CACA,IAAY,GAYX;CAZD,CAAA,UAAY,GAAG,EAAA;;CAEd,IAAA,GAAA,CAAA,WAAA,CAAA,GAAA,WAAuB;CACvB,IAAA,GAAA,CAAA,aAAA,CAAA,GAAA,cAA4B;CAC5B,IAAA,GAAA,CAAA,gBAAA,CAAA,GAAA,iBAAkC;CAClC,IAAA,GAAA,CAAA,eAAA,CAAA,GAAA,gBAAgC;CAChC,IAAA,GAAA,CAAA,aAAA,CAAA,GAAA,aAA2B;CAC3B,IAAA,GAAA,CAAA,UAAA,CAAA,GAAA,UAAqB;CACrB,IAAA,GAAA,CAAA,YAAA,CAAA,GAAA,aAA0B;CAC1B,IAAA,GAAA,CAAA,eAAA,CAAA,GAAA,gBAAgC;CAChC,IAAA,GAAA,CAAA,YAAA,CAAA,GAAA,YAAyB;CACzB,IAAA,GAAA,CAAA,QAAA,CAAA,GAAA,SAAkB;CACnB,CAAC,EAZW,GAAG,KAAH,GAAG,GAYd,EAAA,CAAA,CAAA;CAED,IAAK,EAeJ;CAfD,CAAA,UAAK,EAAE,EAAA;;;;CAKN,IAAA,EAAA,CAAA,EAAA,CAAA,WAAA,CAAA,GAAA,CAAA,CAAA,GAAA,WAAe;CACf,IAAA,EAAA,CAAA,EAAA,CAAA,aAAA,CAAA,GAAA,CAAA,CAAA,GAAA,aAAiB;CACjB,IAAA,EAAA,CAAA,EAAA,CAAA,gBAAA,CAAA,GAAA,CAAA,CAAA,GAAA,gBAAoB;CACpB,IAAA,EAAA,CAAA,EAAA,CAAA,eAAA,CAAA,GAAA,EAAA,CAAA,GAAA,eAAmB;CACnB,IAAA,EAAA,CAAA,EAAA,CAAA,aAAA,CAAA,GAAA,EAAA,CAAA,GAAA,aAAiB;CACjB,IAAA,EAAA,CAAA,EAAA,CAAA,UAAA,CAAA,GAAA,CAAA,CAAA,GAAA,UAAc;CACd,IAAA,EAAA,CAAA,EAAA,CAAA,YAAA,CAAA,GAAA,CAAA,CAAA,GAAA,YAAgB;CAChB,IAAA,EAAA,CAAA,EAAA,CAAA,eAAA,CAAA,GAAA,CAAA,CAAA,GAAA,eAAmB;CACnB,IAAA,EAAA,CAAA,EAAA,CAAA,YAAA,CAAA,GAAA,CAAA,CAAA,GAAA,YAAgB;CAChB,IAAA,EAAA,CAAA,EAAA,CAAA,QAAA,CAAA,GAAA,EAAA,CAAA,GAAA,QAAa;CACd,CAAC,EAfI,EAAE,KAAF,EAAE,GAeN,EAAA,CAAA,CAAA;CAiBD,IAAY,UAIX;CAJD,CAAA,UAAY,UAAU,EAAA;CACrB,IAAA,UAAA,CAAA,UAAA,CAAA,WAAA,CAAA,GAAA,CAAA,CAAA,GAAA,WAAe;CACf,IAAA,UAAA,CAAA,UAAA,CAAA,WAAA,CAAA,GAAA,CAAA,CAAA,GAAA,WAAe;CACf,IAAA,UAAA,CAAA,UAAA,CAAA,YAAA,CAAA,GAAA,CAAA,CAAA,GAAA,YAAgB;CACjB,CAAC,EAJW,UAAU,KAAV,UAAU,GAIrB,EAAA,CAAA,CAAA;OA+EY,MAAM,CAAA;CACV,IAAA,OAAO;CACP,IAAA,OAAO;CAEf,IAAA,MAAM,GAAG,OAAO,CAAC,OAAO,EAAE;KAE1B,WAAY,CAAA,CAAS,EAAE,CAAS,EAAA;SAC/B,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC;SAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC;;;CAI9B,IAAA,MAAM,IAAI,GAAA;SACT,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;CACxC,QAAA,OAAO,CAAC,GAAG,CAAC,kBAAkB,EAAE,GAAG,CAAC;CACpC,QAAA,OAAO,GAAG;;KAGX,MAAM,IAAI,CAAC,GAAY,EAAA;CACtB,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,EAAE;CACjC,QAAA,IAAI;CACH,YAAA,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,GAAG,CAAC;aACnC,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC;;iBACtB;CACT,YAAA,MAAM,EAAE;;;CAIV,IAAA,MAAM,KAAK,GAAA;;CAEV,QAAA,IAAI,IAAgB;SACpB,MAAM,CAAC,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,KAAI;CACvC,YAAA,IAAI,GAAG,MAAM,OAAO,EAAE;CACvB,SAAC,CAAC;;CAGF,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC;;CAGzC,QAAA,IAAI,CAAC,MAAM,GAAG,CAAC;;CAGf,QAAA,OAAO,IAAI;;CAEZ;OAEY,OAAO,CAAA;CACnB,IAAA,CAAC;CAED,IAAA,WAAA,CAAY,CAAS,EAAA;CACpB,QAAA,IAAI,CAAC,CAAC,GAAG,CAAC;;CAGH,IAAA,MAAM,GAAG,GAAA;SAChB,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAC5B,QAAQ,CAAC;aACR,KAAK,EAAE,CAAC,SAAS;iBAChB,OAAO,GAAG,CAAC,SAAS;aACrB,KAAK,EAAE,CAAC,WAAW;iBAClB,OAAO,GAAG,CAAC,WAAW;aACvB,KAAK,EAAE,CAAC,aAAa;iBACpB,OAAO,GAAG,CAAC,aAAa;aACzB,KAAK,EAAE,CAAC,cAAc;iBACrB,OAAO,GAAG,CAAC,cAAc;aAC1B,KAAK,EAAE,CAAC,WAAW;iBAClB,OAAO,GAAG,CAAC,WAAW;aACvB,KAAK,EAAE,CAAC,QAAQ;iBACf,OAAO,GAAG,CAAC,QAAQ;aACpB,KAAK,EAAE,CAAC,UAAU;iBACjB,OAAO,GAAG,CAAC,UAAU;aACtB,KAAK,EAAE,CAAC,aAAa;iBACpB,OAAO,GAAG,CAAC,aAAa;aACzB,KAAK,EAAE,CAAC,UAAU;iBACjB,OAAO,GAAG,CAAC,UAAU;aACtB,KAAK,EAAE,CAAC,MAAM;iBACb,OAAO,GAAG,CAAC,MAAM;;CAGnB,QAAA,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA,CAAE,CAAC;;CAGtD,IAAA,MAAM,OAAO,GAAA;CACZ,QAAA,MAAM,CAAC,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE;SAC1B,QAAQ,CAAC;aACR,KAAK,GAAG,CAAC,SAAS;CACjB,gBAAA,OAAO,IAAI,CAAC,SAAS,EAAE;aACxB,KAAK,GAAG,CAAC,WAAW;CACnB,gBAAA,OAAO,IAAI,CAAC,YAAY,EAAE;aAC3B,KAAK,GAAG,CAAC,cAAc;CACtB,gBAAA,OAAO,IAAI,CAAC,eAAe,EAAE;aAC9B,KAAK,GAAG,CAAC,aAAa;CACrB,gBAAA,OAAO,IAAI,CAAC,cAAc,EAAE;aAC7B,KAAK,GAAG,CAAC,WAAW;CACnB,gBAAA,OAAO,IAAI,CAAC,WAAW,EAAE;aAC1B,KAAK,GAAG,CAAC,QAAQ;CAChB,gBAAA,OAAO,IAAI,CAAC,QAAQ,EAAE;aACvB,KAAK,GAAG,CAAC,UAAU;CAClB,gBAAA,OAAO,IAAI,CAAC,WAAW,EAAE;aAC1B,KAAK,GAAG,CAAC,UAAU;CAClB,gBAAA,OAAO,IAAI,CAAC,UAAU,EAAE;aACzB,KAAK,GAAG,CAAC,aAAa;CACrB,gBAAA,OAAO,IAAI,CAAC,cAAc,EAAE;aAC7B,KAAK,GAAG,CAAC,MAAM;CACd,gBAAA,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC;;;CAIrC,IAAA,MAAM,SAAS,GAAA;SACtB,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,SAAS;CACnB,YAAA,EAAE,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CACtB,YAAA,OAAO,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAC3B,YAAA,SAAS,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;CAChC,YAAA,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;CAC3B,YAAA,mBAAmB,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;CACtC,YAAA,WAAW,EAAE,MAAM,IAAI,CAAC,gBAAgB,EAAE;CAC1C,YAAA,QAAQ,EAAE,MAAM,IAAI,CAAC,QAAQ,EAAE;CAC/B,YAAA,MAAM,EAAE,MAAM,IAAI,CAAC,UAAU,EAAE;UAC/B;;CAGM,IAAA,MAAM,gBAAgB,GAAA;SAC7B,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;SACnC,QAAQ,SAAS;CAChB,YAAA,KAAK,CAAC;iBACL,OAAO,UAAU,CAAC,SAAS;CAC5B,YAAA,KAAK,CAAC;iBACL,OAAO,UAAU,CAAC,SAAS;CAC5B,YAAA,KAAK,CAAC;iBACL,OAAO,UAAU,CAAC,UAAU;CAC7B,YAAA;CACC,gBAAA,MAAM,IAAI,KAAK,CAAC,6BAA6B,SAAS,CAAA,CAAE,CAAC;;;CAIpD,IAAA,MAAM,QAAQ,GAAA;SACrB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAC/B,QAAA,IAAI,IAAI,IAAI,EAAE,EAAE;aACf,OAAO;CACN,gBAAA,IAAI,EAAE,cAAc;cACpB;;CACK,aAAA,IAAI,IAAI,IAAI,EAAE,EAAE;aACtB,OAAO;CACN,gBAAA,IAAI,EAAE,eAAe;cACrB;;CACK,aAAA,IAAI,IAAI,IAAI,EAAE,EAAE;aACtB,OAAO;CACN,gBAAA,IAAI,EAAE,gBAAgB;CACtB,gBAAA,WAAW,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAC/B,gBAAA,YAAY,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;cAChC;;CACK,aAAA,IAAI,IAAI,IAAI,EAAE,EAAE;aACtB,OAAO;CACN,gBAAA,IAAI,EAAE,gBAAgB;CACtB,gBAAA,WAAW,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAC/B,gBAAA,YAAY,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAChC,gBAAA,SAAS,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAC7B,gBAAA,UAAU,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;cAC9B;;cACK;CACN,YAAA,MAAM,IAAI,KAAK,CAAC,wBAAwB,IAAI,CAAA,CAAE,CAAC;;;CAIzC,IAAA,MAAM,UAAU,GAAA;SACvB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAChC,IAAI,KAAK,IAAI,CAAC;CAAE,YAAA,OAAO,SAAS;CAEhC,QAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAAsB;CAE5C,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;aAC/B,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;aAC7B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;aAC/B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;CAErC,YAAA,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;CACnB,gBAAA,MAAM,IAAI,KAAK,CAAC,2BAA2B,EAAE,CAAA,CAAE,CAAC;;CAGjD,YAAA,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC;;CAGtB,QAAA,OAAO,MAAM;;CAGN,IAAA,MAAM,YAAY,GAAA;SACzB,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAC7B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CAElC,QAAA,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,gBAAgB,EAAE;CACjD,QAAA,IAAI,MAAoC;SAExC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;CAC9B,QAAA,IAAI,IAAI,KAAK,CAAC,EAAE;CACf,YAAA,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;;CAC3C,aAAA,IAAI,IAAI,KAAK,CAAC,EAAE;CACtB,YAAA,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAA,CAAE,CAAC;;SAG/C,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,WAAW;aACrB,EAAE;aACF,OAAO;aACP,WAAW;aACX,MAAM;UACN;;CAGM,IAAA,MAAM,cAAc,GAAA;SAC3B,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAC7B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;SAC/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;CAEpC,QAAA,IAAI,KAAmC;SAEvC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;CAC9B,QAAA,IAAI,IAAI,KAAK,CAAC,EAAE;CACf,YAAA,KAAK,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;;CAC1C,aAAA,IAAI,IAAI,KAAK,CAAC,EAAE;CACtB,YAAA,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAA,CAAE,CAAC;;SAG/C,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,aAAa;aACvB,EAAE;aACF,IAAI;aACJ,MAAM;aACN,KAAK;UACL;;CAGM,IAAA,MAAM,eAAe,GAAA;SAC5B,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,cAAc;CACxB,YAAA,EAAE,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CACtB,YAAA,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CACxB,YAAA,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;UAC7B;;CAGM,IAAA,MAAM,WAAW,GAAA;SACxB,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,WAAW;CACrB,YAAA,EAAE,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;UACtB;;CAGM,IAAA,MAAM,QAAQ,GAAA;SACrB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;SAEvC,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,QAAQ;aAClB,SAAS;CACT,YAAA,MAAM,EAAE,MAAM,IAAI,CAAC,UAAU,EAAE;UAC/B;;CAGM,IAAA,MAAM,WAAW,GAAA;SACxB,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,UAAU;CACpB,YAAA,SAAS,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;UAChC;;CAGM,IAAA,MAAM,cAAc,GAAA;SAC3B,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,aAAa;CACvB,YAAA,SAAS,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;CAChC,YAAA,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE;CACxB,YAAA,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;UAC7B;;CAGM,IAAA,MAAM,UAAU,GAAA;SACvB,OAAO;aACN,IAAI,EAAE,GAAG,CAAC,UAAU;CACpB,YAAA,SAAS,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;UAChC;;CAEF;OAEY,OAAO,CAAA;CACnB,IAAA,CAAC;CAED,IAAA,WAAA,CAAY,CAAS,EAAA;CACpB,QAAA,IAAI,CAAC,CAAC,GAAG,CAAC;;KAGX,MAAM,OAAO,CAAC,CAAU,EAAA;CACvB,QAAA,QAAQ,CAAC,CAAC,IAAI;aACb,KAAK,GAAG,CAAC,SAAS;CACjB,gBAAA,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;aACzB,KAAK,GAAG,CAAC,WAAW;CACnB,gBAAA,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;aAC5B,KAAK,GAAG,CAAC,cAAc;CACtB,gBAAA,OAAO,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;aAC/B,KAAK,GAAG,CAAC,aAAa;CACrB,gBAAA,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;aAC9B,KAAK,GAAG,CAAC,WAAW;CACnB,gBAAA,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;aAC3B,KAAK,GAAG,CAAC,QAAQ;CAChB,gBAAA,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;aACxB,KAAK,GAAG,CAAC,UAAU;CAClB,gBAAA,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;aAC3B,KAAK,GAAG,CAAC,aAAa;CACrB,gBAAA,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;aAC9B,KAAK,GAAG,CAAC,UAAU;CAClB,gBAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;;;KAI5B,MAAM,SAAS,CAAC,CAAY,EAAA;SAC3B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC;SAC9B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;SACtB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;SAC3B,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;SAChC,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;CAC3B,QAAA,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,IAAI,GAAG,CAAC;CAC7C,QAAA,MAAM,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,WAAW,IAAI,UAAU,CAAC,SAAS,CAAC;SAClE,MAAM,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC;SAC/B,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC;;KAGxB,MAAM,gBAAgB,CAAC,KAAiB,EAAA;SAC/C,QAAQ,KAAK;aACZ,KAAK,UAAU,CAAC,SAAS;iBACxB,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;iBACrC;aACD,KAAK,UAAU,CAAC,SAAS;iBACxB,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;iBACrC;aACD,KAAK,UAAU,CAAC,UAAU;iBACzB,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC;iBACtC;CACD,YAAA;CACC,gBAAA,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC;;;KAItC,MAAM,QAAQ,CAAC,CAAW,EAAA;CACjC,QAAA,QAAQ,CAAC,CAAC,IAAI;CACb,YAAA,KAAK,cAAc;iBAClB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;iBACpB;CACD,YAAA,KAAK,eAAe;iBACnB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;iBACpB;CACD,YAAA,KAAK,gBAAgB;iBACpB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;iBACpB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC;iBAC/B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC;iBAChC;CACD,YAAA,KAAK,gBAAgB;iBACpB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;iBACpB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC;iBAC/B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC;iBAChC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;iBAC7B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC;;;KAIzB,MAAM,UAAU,CAAC,CAAyB,EAAA;SACjD,IAAI,CAAC,CAAC,EAAE;aACP,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;aAClB;;SAGD,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;SACxB,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE;aAC5B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;aACpB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;aAC9B,MAAM,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC;;;KAI3B,MAAM,YAAY,CAAC,CAAc,EAAA;SAChC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,WAAW,CAAC;SAChC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;SACtB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;SAE3B,MAAM,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,WAAW,CAAC;CAC1C,QAAA,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS,EAAE;aAC3B,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB,YAAA,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC7B,YAAA,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;;cACvB;aACN,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;;;KAIpB,MAAM,cAAc,CAAC,CAAgB,EAAA;SACpC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC;SAClC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;SACtB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;SACxB,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;CAE7B,QAAA,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,EAAE;aAC1B,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAClB,YAAA,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;CAC5B,YAAA,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;;cACtB;aACN,MAAM,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;;;KAIpB,MAAM,eAAe,CAAC,CAAiB,EAAA;SACtC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,cAAc,CAAC;SACnC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;;KAGvB,MAAM,WAAW,CAAC,CAAc,EAAA;SAC/B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,WAAW,CAAC;SAChC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;;KAGvB,MAAM,QAAQ,CAAC,CAAW,EAAA;SACzB,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC;SAC7B,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;SAChC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;;KAGpB,MAAM,WAAW,CAAC,CAAa,EAAA;SAC9B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC;SAC/B,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;;KAGjC,MAAM,cAAc,CAAC,CAAgB,EAAA;SACpC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC;SAClC,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;SAChC,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;SACxB,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;;KAG9B,MAAM,UAAU,CAAC,CAAa,EAAA;SAC7B,MAAM,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC;SAC/B,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;;CAEjC;;CChlBD,IAAY,UAIX;CAJD,CAAA,UAAY,UAAU,EAAA;CACrB,IAAA,UAAA,CAAA,UAAA,CAAA,QAAA,CAAA,GAAA,CAAA,CAAA,GAAA,QAAY;CACZ,IAAA,UAAA,CAAA,UAAA,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAA,OAAY;CACZ,IAAA,UAAA,CAAA,UAAA,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAAA,OAAY;CACb,CAAC,EAJW,UAAU,KAAV,UAAU,GAIrB,EAAA,CAAA,CAAA;CAED,IAAY,MAKX;CALD,CAAA,UAAY,MAAM,EAAA;CACjB,IAAA,MAAA,CAAA,MAAA,CAAA,aAAA,CAAA,GAAA,CAAA,CAAA,GAAA,aAAe;CACf,IAAA,MAAA,CAAA,MAAA,CAAA,YAAA,CAAA,GAAA,CAAA,CAAA,GAAA,YAAc;CACd,IAAA,MAAA,CAAA,MAAA,CAAA,WAAA,CAAA,GAAA,CAAA,CAAA,GAAA,WAAa;CACb,IAAA,MAAA,CAAA,MAAA,CAAA,WAAA,CAAA,GAAA,CAAA,CAAA,GAAA,WAAa;CACd,CAAC,EALW,MAAM,KAAN,MAAM,GAKjB,EAAA,CAAA,CAAA;OAkDY,OAAO,CAAA;CACX,IAAA,IAAI;CAEZ,IAAA,WAAA,CAAY,IAAkB,EAAA;CAC7B,QAAA,IAAI,CAAC,IAAI,GAAG,IAAI;;KAGjB,MAAM,IAAI,CAAqD,CAAI,EAAA;SAClE,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE;CAC3D,QAAA,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC;SAE5B,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;SACnB,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;SAClB,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;CAEpB,QAAA,IAAI,GAAkB;SAEtB,IAAI,CAAC,CAAC,IAAI,IAAI,UAAU,CAAC,MAAM,EAAE;aAChC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;aACpB,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;aACrB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC;aAChC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;aAErB,GAAG,GAAG,IAAI,YAAY,CAAC,CAAC,EAAE,CAAC,CAAkB;;cACvC,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,CAAC,KAAK,EAAE;aACvC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;aACpB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC;aAEhC,GAAG,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAkB;;cACtC,IAAI,CAAC,CAAC,IAAI,KAAK,UAAU,CAAC,KAAK,EAAE;aACvC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC;aAEhC,GAAG,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAkB;;cACtC;CACN,YAAA,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC;;;CAKvC,QAAA,OAAO,GAAG;;CAGX,IAAA,MAAM,IAAI,GAAA;SACT,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,6BAA6B,CAAC,SAAS,EAAE;SAEnE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,OAAO,CAAC,IAAI,EAAE;SAC5C,OAAO,CAAC,WAAW,EAAE;CAErB,QAAA,IAAI,IAAI;aAAE;SAEV,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,IAAI,UAAU,EAAE,EAAE,KAAK,CAAC;SAC7C,MAAM,IAAI,IAAI,MAAM,CAAC,CAAC,GAAG,EAAE,CAAe;CAC1C,QAAA,IAAI,GAA6C;CAEjD,QAAA,IAAI,IAAI,IAAI,UAAU,CAAC,KAAK,EAAE;CAC7B,YAAA,MAAM,CAAC,GAAgB;iBACtB,IAAI;CACJ,gBAAA,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CAClB,gBAAA,KAAK,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CACpB,gBAAA,kBAAkB,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE;cAChC;aAED,GAAG,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC;;CACrB,aAAA,IAAI,IAAI,IAAI,UAAU,CAAC,KAAK,EAAE;CACpC,YAAA,MAAM,CAAC,GAAgB;iBACtB,IAAI;CACJ,gBAAA,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CAClB,gBAAA,KAAK,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CACpB,gBAAA,KAAK,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CACpB,gBAAA,kBAAkB,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE;cAChC;aACD,GAAG,GAAG,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC;;CACrB,aAAA,IAAI,IAAI,IAAI,UAAU,CAAC,MAAM,EAAE;CACrC,YAAA,MAAM,CAAC,GAAG;iBACT,IAAI;CACJ,gBAAA,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CAClB,gBAAA,KAAK,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CACpB,gBAAA,KAAK,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CACpB,gBAAA,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CACrB,gBAAA,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE;CACrB,gBAAA,kBAAkB,EAAE,MAAM,CAAC,CAAC,EAAE,EAAE;cAChC;aAED,GAAG,GAAG,IAAI,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;;cACtB;CACN,YAAA,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC;;;CAKvC,QAAA,OAAO,GAAG;;CAEX;OAEY,WAAW,CAAA;CAEf,IAAA,MAAA;CACA,IAAA,MAAA;KAFR,WACQ,CAAA,MAAmB,EACnB,MAAc,EAAA;SADd,IAAM,CAAA,MAAA,GAAN,MAAM;SACN,IAAM,CAAA,MAAA,GAAN,MAAM;;KAGd,MAAM,KAAK,CAAC,CAAa,EAAA;SACxB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;SAC9B,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;CAE/B,QAAA,IAAI,CAAC,CAAC,OAAO,YAAY,UAAU,EAAE;CACpC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;aAC3C,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;;cAC5B;;aAEN,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aACxB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,OAAiB,CAAC;;;CAI5C,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;;CAE1B;OAEY,WAAW,CAAA;CAEf,IAAA,MAAA;CACA,IAAA,MAAA;KAFR,WACQ,CAAA,MAAmB,EACnB,MAAc,EAAA;SADd,IAAM,CAAA,MAAA,GAAN,MAAM;SACN,IAAM,CAAA,MAAA,GAAN,MAAM;;KAGd,MAAM,KAAK,CAAC,CAAa,EAAA;SACxB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;CAC/B,QAAA,IAAI,CAAC,CAAC,OAAO,YAAY,UAAU,EAAE;CACpC,YAAA,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;aAC3C,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;;cAC5B;aACN,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aACxB,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,OAAiB,CAAC;;;CAI5C,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;;CAE1B;OAEY,YAAY,CAAA;CAEhB,IAAA,MAAA;CACA,IAAA,MAAA;KAFR,WACQ,CAAA,MAAoB,EACpB,MAAc,EAAA;SADd,IAAM,CAAA,MAAA,GAAN,MAAM;SACN,IAAM,CAAA,MAAA,GAAN,MAAM;;KAGd,MAAM,KAAK,CAAC,CAAc,EAAA;SACzB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;;CAGnC,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;;CAE1B;OAEY,WAAW,CAAA;CAEf,IAAA,MAAA;CACA,IAAA,MAAA;KAFR,WACQ,CAAA,MAAmB,EACnB,MAAc,EAAA;SADd,IAAM,CAAA,MAAA,GAAN,MAAM;SACN,IAAM,CAAA,MAAA,GAAN,MAAM;;CAGd,IAAA,MAAM,IAAI,GAAA;SACT,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE;aAC7B;;SAGD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;SACrC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;SACtC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;CAEpC,QAAA,IAAI,OAAO;CACX,QAAA,IAAI,IAAI,IAAI,CAAC,EAAE;aACd,OAAO,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAW;;cACvC;aACN,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;SAGvC,OAAO;aACN,KAAK;aACL,MAAM;aACN,OAAO;UACP;;CAGF,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;;CAE1B;OAEY,WAAW,CAAA;CAEf,IAAA,MAAA;CACA,IAAA,MAAA;KAFR,WACQ,CAAA,MAAmB,EACnB,MAAc,EAAA;SADd,IAAM,CAAA,MAAA,GAAN,MAAM;SACN,IAAM,CAAA,MAAA,GAAN,MAAM;;CAGd,IAAA,MAAM,IAAI,GAAA;SACT,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE;aAC7B;;SAGD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;SACtC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;CAEpC,QAAA,IAAI,OAAO;CACX,QAAA,IAAI,IAAI,IAAI,CAAC,EAAE;aACd,OAAO,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAW;;cACvC;aACN,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;SAGvC,OAAO;aACN,MAAM;aACN,OAAO;UACP;;CAGF,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;;CAE1B;OAEY,YAAY,CAAA;CAEhB,IAAA,MAAA;CACA,IAAA,MAAA;KAFR,WACQ,CAAA,MAAoB,EACpB,MAAc,EAAA;SADd,IAAM,CAAA,MAAA,GAAN,MAAM;SACN,IAAM,CAAA,MAAA,GAAN,MAAM;;;CAId,IAAA,MAAM,IAAI,GAAA;SACT,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE;aAC7B;;SAGD,OAAO;CACN,YAAA,OAAO,EAAE,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE;UACpC;;CAGF,IAAA,MAAM,KAAK,GAAA;CACV,QAAA,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;;CAE1B;;OClTY,QAAQ,CAAA;CACpB,IAAA,OAAO;CACP,IAAA,OAAO;CACP,IAAA,MAAM;KACN,OAAO,GAAG,IAAI;CAEd,IAAA,WAAA,GAAA;SACC,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,KAAI;CAC9C,YAAA,IAAI,CAAC,OAAO,GAAG,CAAC,KAAK,KAAI;CACxB,gBAAA,IAAI,CAAC,OAAO,GAAG,KAAK;iBACpB,OAAO,CAAC,KAAK,CAAC;CACf,aAAC;CACD,YAAA,IAAI,CAAC,MAAM,GAAG,CAAC,MAAM,KAAI;CACxB,gBAAA,IAAI,CAAC,OAAO,GAAG,KAAK;iBACpB,MAAM,CAAC,MAAM,CAAC;CACf,aAAC;CACF,SAAC,CAAC;;CAEH;OAIY,KAAK,CAAA;CACjB,IAAA,QAAQ;CACR,IAAA,KAAK,GAAG,IAAI,QAAQ,EAAgB;CAEpC,IAAA,WAAA,CAAY,IAAO,EAAA;CAClB,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI,QAAQ,EAAgB;CACzC,QAAA,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;;KAG3C,KAAK,GAAA;SACJ,OAAO,IAAI,CAAC,QAAQ;;CAGrB,IAAA,MAAM,CAAC,CAAoB,EAAA;CAC1B,QAAA,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;CACxB,YAAA,MAAM,IAAI,KAAK,CAAC,gBAAgB,CAAC;;;CAIlC,QAAA,IAAI,CAAC,YAAY,QAAQ,EAAE;aAC1B,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;;CAGxB,QAAA,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAgB;SACzC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC;SACjC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC;CACjC,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI;;KAGlB,KAAK,GAAA;CACJ,QAAA,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS;SAC5B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC;;CAElC;CAwBD;OACa,KAAK,CAAA;CACjB,IAAA,OAAO;KACP,OAAO,GAAG,KAAK;KAEf,WAAY,CAAA,QAAQ,GAAG,CAAC,EAAA;SACvB,MAAM,KAAK,GAAG,IAAI,oBAAoB,CAAC,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC;CACnE,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC;;KAGzD,MAAM,IAAI,CAAC,CAAI,EAAA;SACd,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE;CAC3C,QAAA,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;SAChB,CAAC,CAAC,WAAW,EAAE;;CAGhB,IAAA,MAAM,IAAI,GAAA;SACT,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE;SAC3C,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC,CAAC,IAAI,EAAE;SACtC,CAAC,CAAC,WAAW,EAAE;CAEf,QAAA,IAAI,IAAI;aAAE;CACV,QAAA,OAAO,KAAK;;KAGb,MAAM,KAAK,CAAC,GAAU,EAAA;SACrB,IAAI,IAAI,CAAC,OAAO;aAAE;SAClB,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC;CACtC,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI;;CAGpB,IAAA,MAAM,KAAK,GAAA;SACV,IAAI,IAAI,CAAC,OAAO;aAAE;SAClB,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE;CACnC,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI;;KAGpB,MAAM,GAAA;SACL,OAAO,IAAI,CAAC,OAAO;;CAEpB;;OCnHY,SAAS,CAAA;;CAErB,IAAA,QAAQ;;CAGR,IAAA,QAAQ;;CAGR,IAAA,SAAS,GAAG,IAAI,GAAG,EAAwB;;CAG3C,IAAA,UAAU,GAAG,IAAI,GAAG,EAAyB;KAC7C,eAAe,GAAG,IAAI,KAAK,CAAgB,MAAM,CAAC,gBAAgB,CAAC,CAAA;KAEnE,WAAY,CAAA,OAAuB,EAAE,OAAgB,EAAA;CACpD,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;CACvB,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;;;KAIxB,MAAM,QAAQ,CAAC,SAAiB,EAAA;SAC/B,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;CAClC,YAAA,MAAM,IAAI,KAAK,CAAC,qBAAqB,SAAS,CAAA,CAAE,CAAC;;SAGlD,MAAM,QAAQ,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;SAC3D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC;CAEvC,QAAA,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;CACxB,YAAA,IAAI,EAAEC,GAAW,CAAC,QAAQ;aAC1B,SAAS;CACT,SAAA,CAAC;CAEF,QAAA,OAAO,QAAQ;;;CAIhB,IAAA,MAAM,UAAU,GAAA;CACf,QAAA,OAAO,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE;;KAGzC,MAAM,IAAI,CAAC,GAAuB,EAAA;SACjC,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,SAAS,EAAE;CACtC,YAAA,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC;;cACvB,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,WAAW,EAAE;CAC/C,YAAA,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC;;cACnB,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,UAAU,EAAE;CAC9C,YAAA,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;;cAClB,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,aAAa,EAAE;CACjD,YAAA,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC;;cACrB;CACN,YAAA,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAA;;;CAI5C,IAAA,cAAc,CAAC,GAAuB,EAAA;CACrC,QAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC;SAClD,IAAI,CAAC,QAAQ,EAAE;aACd,MAAM,IAAI,KAAK,CAAC,CAAA,kCAAA,EAAqC,GAAG,CAAC,SAAS,CAAE,CAAA,CAAC;;SAGtE,QAAQ,CAAC,IAAI,EAAE;;CAGhB,IAAA,iBAAiB,CAAC,GAA0B,EAAA;CAC3C,QAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC;SAClD,IAAI,CAAC,QAAQ,EAAE;;aAEd,OAAO,CAAC,IAAI,CAAC,CAAA,qCAAA,EAAwC,GAAG,CAAC,SAAS,CAAE,CAAA,CAAC;aACrE;;SAGD,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC;;KAGvC,MAAM,aAAa,CAAC,GAAsB,EAAA;SACzC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;aAChC,MAAM,IAAI,KAAK,CAAC,CAAA,4BAAA,EAA+B,GAAG,CAAC,EAAE,CAAE,CAAA,CAAC;;CAGzD,QAAA,MAAM,SAAS,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC;SACtE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,CAAC;SACtC,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC;CAE1C,QAAA,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;CACxB,YAAA,IAAI,EAAEA,GAAW,CAAC,WAAW;aAC7B,EAAE,EAAE,GAAG,CAAC,EAAE;CACV,YAAA,OAAO,EAAE,EAAE;aACX,WAAW,EAAE,GAAG,CAAC,WAAW;CAC5B,SAAA,CAAC;;CAGH,IAAA,eAAe,CAAC,IAAyB,EAAA;CACxC,QAAA,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC;;CAEpC;OAEY,YAAY,CAAA;CACxB,IAAA,QAAQ;CAEC,IAAA,SAAS;;CAGlB,IAAA,MAAM,GAAG,IAAI,KAAK,CAAyB,MAAM,CAAC;KAElD,WAAY,CAAA,OAAuB,EAAE,SAAiB,EAAA;CACrD,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;CACvB,QAAA,IAAI,CAAC,SAAS,GAAG,SAAS;;CAG3B,IAAA,MAAM,EAAE,GAAA;CACP,QAAA,SAAS;CACR,YAAA,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;aACzC,IAAI,KAAK,KAAK,KAAK;iBAAE;aACrB,IAAI,KAAK,YAAY,KAAK;CAAE,gBAAA,MAAM,KAAK;CACvC,YAAA,IAAI,CAAC,IAAI;CAAE,gBAAA,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC;CAEpC,YAAA,MAAM,IAAI;;;CAIZ,IAAA,MAAM,MAAM,GAAA;CACX,QAAA,SAAS;CACR,YAAA,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;aACzC,IAAI,KAAK,YAAY,KAAK;CAAE,gBAAA,MAAM,KAAK;CACvC,YAAA,IAAI,CAAC,IAAI;iBAAE;CAEX,YAAA,MAAM,IAAI;;;CAIZ,IAAA,MAAM,KAAK,GAAA;;;;KAKX,MAAM,GAAA;CACL,QAAA,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;CACzC,QAAA,OAAO,KAAK,YAAY,KAAK,IAAI,IAAI,IAAI,SAAS;;KAGnD,IAAI,GAAA;SACH,IAAI,IAAI,CAAC,MAAM,EAAE;aAAE;CACnB,QAAA,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;;KAG1B,OAAO,CAAC,IAAY,EAAE,MAAc,EAAA;SACnC,IAAI,IAAI,CAAC,MAAM,EAAE;aAAE;SAEnB,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,CAAmB,gBAAA,EAAA,IAAI,GAAG,GAAG,MAAM,GAAG,KAAK,MAAM,CAAA,CAAE,GAAG,EAAE,CAAC;CAC/E,QAAA,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC;;CAExB;OAEY,aAAa,CAAA;CACzB,IAAA,QAAQ;CACR,IAAA,QAAQ;CACR,IAAA,GAAG;CACH,IAAA,QAAQ;CACR,IAAA,mBAAmB;CACnB,IAAA,UAAU;CAED,IAAA,SAAS;CACT,IAAA,KAAK;;KAGd,MAAM,GAA8B,MAAM;CAE1C,IAAA,WAAA,CAAY,OAAuB,EAAE,OAAgB,EAAE,GAAsB,EAAA;CAC5E,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;CACvB,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;CACvB,QAAA,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,EAAE;CACjB,QAAA,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC,OAAO;CAC3B,QAAA,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC,SAAS;CAC9B,QAAA,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI;CACrB,QAAA,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAC,mBAAmB;CAClD,QAAA,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,WAAW;;;CAIlC,IAAA,MAAM,GAAG,GAAA;CACR,QAAA,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM;aAAE;CAC5B,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;;CAGnB,QAAA,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;CACzB,YAAA,IAAI,EAAEA,GAAW,CAAC,WAAW;aAC7B,EAAE,EAAE,IAAI,CAAC,GAAG;CACZ,YAAA,OAAO,EAAE,EAAE;aACX,WAAW,EAAE,IAAI,CAAC,UAAU;CAC5B,SAAA,CAAC;;;KAIH,MAAM,KAAK,CAAC,IAAI,GAAG,EAAE,EAAE,MAAM,GAAG,EAAE,EAAA;CACjC,QAAA,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ;aAAE;CAC9B,QAAA,IAAI,CAAC,MAAM,GAAG,QAAQ;CAEtB,QAAA,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;CACzB,YAAA,IAAI,EAAEA,GAAW,CAAC,aAAa;aAC/B,EAAE,EAAE,IAAI,CAAC,GAAG;aACZ,IAAI;aACJ,MAAM;CACN,SAAA,CAAC;;;KAIH,MAAM,KAAK,CAAC,KAA4B,EAAA;CACvC,QAAA,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;aACzB,IAAI,EAAE,UAAU,CAAC,KAAK;aACtB,GAAG,EAAE,IAAI,CAAC,GAAG;aACb,KAAK,EAAE,IAAI,CAAC,QAAQ;CACpB,YAAA,kBAAkB,EAAE,KAAK,EAAE,QAAQ,IAAI,GAAG;CAC1C,SAAA,CAAC;;;KAIH,MAAM,KAAK,CAAC,KAA2C,EAAA;CACtD,QAAA,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;aACzB,IAAI,EAAE,UAAU,CAAC,KAAK;aACtB,GAAG,EAAE,IAAI,CAAC,GAAG;aACb,KAAK,EAAE,IAAI,CAAC,QAAQ;aACpB,KAAK,EAAE,KAAK,CAAC,KAAK;CAClB,YAAA,kBAAkB,EAAE,KAAK,CAAC,QAAQ,IAAI,GAAG;CACzC,SAAA,CAAC;;;KAIH,MAAM,MAAM,CAAC,KAA2D,EAAA;CACvE,QAAA,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;aACzB,IAAI,EAAE,UAAU,CAAC,MAAM;aACvB,GAAG,EAAE,IAAI,CAAC,GAAG;aACb,KAAK,EAAE,IAAI,CAAC,QAAQ;aACpB,KAAK,EAAE,KAAK,CAAC,KAAK;aAClB,MAAM,EAAE,KAAK,CAAC,MAAM;CACpB,YAAA,kBAAkB,EAAE,KAAK,CAAC,QAAQ,IAAI,GAAG;CACzC,YAAA,MAAM,EAAE,CAAC;CACT,SAAA,CAAC;;CAEH;;OC9OY,UAAU,CAAA;;CAEtB,IAAA,QAAQ;;CAGR,IAAA,QAAQ;;CAGR,IAAA,SAAS,GAAG,IAAI,GAAG,EAAwB;CAC3C,IAAA,cAAc,GAAG,IAAI,KAAK,CAAiB,EAAE,CAAC;;CAG9C,IAAA,UAAU,GAAG,IAAI,GAAG,EAAyB;KAC7C,cAAc,GAAG,EAAE;CAEnB,IAAA,aAAa,GAAG,IAAI,GAAG,EAAkB;KAEzC,WAAY,CAAA,OAAuB,EAAE,OAAgB,EAAA;CACpD,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;CACvB,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;;KAGxB,SAAS,GAAA;SACR,OAAO,IAAI,CAAC,cAAc;;KAG3B,MAAM,IAAI,CAAC,GAAsB,EAAA;SAChC,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,QAAQ,EAAE;CACrC,YAAA,MAAM,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC;;cACtB,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,UAAU,EAAE;CAC9C,YAAA,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;;cAClB,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,WAAW,EAAE;CAC/C,YAAA,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC;;cACnB,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,cAAc,EAAE;CAClD,YAAA,MAAM,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC;;cAC5B,IAAI,GAAG,CAAC,IAAI,IAAIA,GAAW,CAAC,aAAa,EAAE;CACjD,YAAA,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC;;cAC3B;CACN,YAAA,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAA;;;KAI5C,MAAM,YAAY,CAAC,GAAqB,EAAA;SACvC,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;aACtC,MAAM,IAAI,KAAK,CAAC,CAAA,kCAAA,EAAqC,GAAG,CAAC,SAAS,CAAE,CAAA,CAAC;;SAGtE,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAEA,GAAW,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;CAEpF,QAAA,MAAM,QAAQ,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,SAAS,CAAC;SAC/D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC;CAE3C,QAAA,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,CAAC,GAAG,KAAK,EAAE,QAAQ,CAAC,CAAC;;CAG5D,IAAA,cAAc,CAAC,IAAwB,EAAA;CACtC,QAAA,MAAM,IAAI,KAAK,CAAC,CAAA,eAAA,CAAiB,CAAC;;CAGnC,IAAA,MAAM,SAAS,CAAC,SAAiB,EAAE,KAAa,EAAA;CAC/C,QAAA,MAAM,EAAE,GAAG,IAAI,CAAC,cAAc,EAAE;CAEhC,QAAA,MAAM,SAAS,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC;SACxE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,CAAC;SAElC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC;CAEjC,QAAA,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;CACxB,YAAA,IAAI,EAAEA,GAAW,CAAC,SAAS;aAC3B,EAAE;CACF,YAAA,OAAO,EAAE,EAAE;aACX,SAAS;CACT,YAAA,IAAI,EAAE,KAAK;aACX,mBAAmB,EAAE,GAAG;CACxB,YAAA,WAAW,EAAEC,UAAkB,CAAC,SAAS;CACzC,YAAA,QAAQ,EAAE;CACT,gBAAA,IAAI,EAAE,cAAc;CACpB,aAAA;CACD,SAAA,CAAC;CAEF,QAAA,OAAO,SAAS;;KAGjB,MAAM,WAAW,CAAC,KAAa,EAAA;SAC9B,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;aAClC,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC;CAC7C,YAAA,IAAI,OAAO,KAAK,SAAS,EAAE;CAC1B,gBAAA,OAAO,CAAC,IAAI,CAAC,mBAAmB,KAAK,CAAA,2BAAA,CAA6B,CAAC;iBACnE;;CAED,YAAA,IAAI;iBACH,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAED,GAAW,CAAC,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC;CACxE,gBAAA,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC;;aAC/B,OAAO,KAAK,EAAE;iBACf,OAAO,CAAC,KAAK,CAAC,CAAA,iCAAA,EAAoC,KAAK,CAAG,CAAA,CAAA,EAAE,KAAK,CAAC;;;cAE7D;CACN,YAAA,OAAO,CAAC,IAAI,CAAC,uDAAuD,KAAK,CAAA,2BAAA,CAA6B,CAAC;;;CAIzG,IAAA,eAAe,CAAC,GAAwB,EAAA;CACvC,QAAA,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;SAC7C,IAAI,CAAC,SAAS,EAAE;aACf,MAAM,IAAI,KAAK,CAAC,CAAA,6BAAA,EAAgC,GAAG,CAAC,EAAE,CAAE,CAAA,CAAC;;SAG1D,SAAS,CAAC,IAAI,EAAE;;KAGjB,MAAM,kBAAkB,CAAC,GAA2B,EAAA;CACnD,QAAA,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;SAC7C,IAAI,CAAC,SAAS,EAAE;aACf,MAAM,IAAI,KAAK,CAAC,CAAA,gCAAA,EAAmC,GAAG,CAAC,EAAE,CAAE,CAAA,CAAC;;CAG7D,QAAA,MAAM,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC;;KAG9C,MAAM,iBAAiB,CAAC,GAA0B,EAAA;CACjD,QAAA,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;SAC7C,IAAI,CAAC,SAAS,EAAE;aACf,MAAM,IAAI,KAAK,CAAC,CAAA,gCAAA,EAAmC,GAAG,CAAC,EAAE,CAAE,CAAA,CAAC;;CAG7D,QAAA,MAAM,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC;;KAG9C,MAAM,UAAU,CAAC,MAAgD,EAAA;CAChE,QAAA,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;SAC1D,IAAI,CAAC,SAAS,EAAE;aACf,MAAM,IAAI,KAAK,CAAC,CAA+B,4BAAA,EAAA,MAAM,CAAC,MAAM,CAAC,KAAK,CAAE,CAAA,CAAC;;CAGtE,QAAA,MAAM,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC;;CAE/B;OAEY,YAAY,CAAA;CACxB,IAAA,QAAQ;CAEC,IAAA,SAAS;;KAGlB,MAAM,GAA8B,MAAM;KAE1C,WAAY,CAAA,OAAuB,EAAE,SAAiB,EAAA;CACrD,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;CACvB,QAAA,IAAI,CAAC,SAAS,GAAG,SAAS;;;CAI3B,IAAA,MAAM,EAAE,GAAA;CACP,QAAA,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM;aAAE;CAC5B,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;;SAGnB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAEA,GAAW,CAAC,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC;;KAGvF,MAAM,KAAK,CAAC,IAAI,GAAG,EAAE,EAAE,MAAM,GAAG,EAAE,EAAA;CACjC,QAAA,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ;aAAE;CAC9B,QAAA,IAAI,CAAC,MAAM,GAAG,QAAQ;SAEtB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAEA,GAAW,CAAC,aAAa,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;;CAExG;OAEY,aAAa,CAAA;CACzB,IAAA,QAAQ;CACR,IAAA,GAAG;CAEM,IAAA,SAAS;CACT,IAAA,KAAK;;CAGd,IAAA,KAAK,GAAG,IAAI,KAAK,EAA4C;CAE7D,IAAA,WAAA,CAAY,OAAuB,EAAE,EAAU,EAAE,SAAiB,EAAE,KAAa,EAAA;CAChF,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;CACvB,QAAA,IAAI,CAAC,GAAG,GAAG,EAAE;CACb,QAAA,IAAI,CAAC,SAAS,GAAG,SAAS;CAC1B,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK;;KAGnB,MAAM,KAAK,CAAC,KAAK,GAAG,EAAE,EAAE,OAAO,GAAG,EAAE,EAAA;;;;KAKpC,IAAI,GAAA;;;CAIJ,IAAA,MAAM,OAAO,CAAC,IAAY,EAAE,MAAc,EAAA;CACzC,QAAA,IAAI,IAAI,IAAI,EAAE,EAAE;CACf,YAAA,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE;;CAGhC,QAAA,IAAI,MAAM,KAAK,EAAE,EAAE;CAClB,YAAA,MAAM,GAAG,CAAA,EAAA,EAAK,MAAM,CAAA,CAAE;;SAGvB,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,CAAoB,iBAAA,EAAA,IAAI,CAAI,CAAA,EAAA,MAAM,CAAE,CAAA,CAAC;SAC3D,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC;;KAGnC,MAAM,MAAM,CAAC,MAAgD,EAAA;CAC5D,QAAA,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;aAAE,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;;;CAIxD,IAAA,MAAM,IAAI,GAAA;CACT,QAAA,OAAO,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE;;CAE/B;;OCrNY,UAAU,CAAA;;CAEtB,IAAA,KAAK;;CAGL,IAAA,QAAQ;;CAGR,IAAA,QAAQ;;CAGR,IAAA,UAAU;;CAGV,IAAA,WAAW;;CAGX,IAAA,QAAQ;CAER,IAAA,WAAA,CAAY,IAAkB,EAAE,OAAuB,EAAE,OAAgB,EAAA;CACxE,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI;CACjB,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;CACvB,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;CAEvB,QAAA,IAAI,CAAC,UAAU,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC;CAC7D,QAAA,IAAI,CAAC,WAAW,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC;CAE/D,QAAA,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE;;CAG5B,IAAA,KAAK,CAAC,IAAI,GAAG,CAAC,EAAE,MAAM,GAAG,EAAE,EAAA;CAC1B,QAAA,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;;CAG9C,IAAA,MAAM,IAAI,GAAA;CACT,QAAA,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;;CAG5D,IAAA,QAAQ,CAAC,SAAiB,EAAA;SACzB,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC;;KAG3C,SAAS,GAAA;CACR,QAAA,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;;KAGpC,SAAS,CAAC,SAAiB,EAAE,KAAa,EAAA;SACzC,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,SAAS,EAAE,KAAK,CAAC;;CAGpD,IAAA,WAAW,CAAC,KAAa,EAAA;SACxB,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC;;KAG3C,UAAU,GAAA;CACT,QAAA,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE;;CAGpC,IAAA,MAAM,WAAW,GAAA;;CAEhB,QAAA,SAAS;aACR,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE;CACtC,YAAA,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;;;CAIvB,IAAA,MAAM,WAAW,GAAA;CAChB,QAAA,SAAS;aACR,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE;CACtC,YAAA,IAAI,CAAC,GAAG;iBAAE;aAEV,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC;;;KAIxC,MAAM,KAAK,CAAC,GAAoB,EAAA;CAC/B,QAAA,IAAIE,WAAmB,CAAC,GAAG,CAAC,EAAE;aAC7B,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC;;cAC1B;aACN,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC;;;CAIjC,IAAA,MAAM,MAAM,GAAA;CACX,QAAA,IAAI;aACH,MAAM,IAAI,CAAC,QAAQ;CACnB,YAAA,OAAO,IAAI,KAAK,CAAC,QAAQ,CAAC;;SACzB,OAAO,CAAC,EAAE;CACX,YAAA,OAAO,OAAO,CAAC,CAAC,CAAC;;;CAGnB;;OCjFY,MAAM,CAAA;CAClB,IAAA,YAAY;CAEH,IAAA,MAAM;CAEf,IAAA,WAAA,CAAY,MAAoB,EAAA;CAC/B,QAAA,IAAI,CAAC,MAAM,GAAG,MAAM;CAEpB,QAAA,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAI;CAC1E,YAAA,OAAO,CAAC,IAAI,CAAC,+BAA+B,EAAE,CAAC,CAAC;CAChD,YAAA,OAAO,SAAS;CACjB,SAAC,CAAC;;CAGH,IAAA,MAAM,OAAO,GAAA;;SAEZ,MAAM,OAAO,GAAwB,EAAE;CAEvC,QAAA,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,YAAY;CAC3C,QAAA,IAAI,WAAW;CAAE,YAAA,OAAO,CAAC,uBAAuB,GAAG,CAAC,WAAW,CAAC;CAEhE,QAAA,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC;SACvD,MAAM,IAAI,CAAC,KAAK;CAEhB,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,yBAAyB,EAAE;SAErD,MAAM,MAAM,GAAG,IAAIC,MAAa,CAAC,MAAM,CAAC,QAAQ,CAAC;CACjD,QAAA,MAAM,MAAM,GAAG,IAAIC,MAAa,CAAC,IAAI,UAAU,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC;SAEnE,MAAM,KAAK,GAAG,IAAIC,QAAY,CAAC,MAAM,EAAE,MAAM,CAAC;;SAG9C,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAACC,OAAa,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;;;SAIvF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE;SAExC,IAAI,MAAM,CAAC,OAAO,IAAIA,OAAa,CAAC,QAAQ,EAAE;aAC7C,MAAM,IAAI,KAAK,CAAC,CAAA,4BAAA,EAA+B,MAAM,CAAC,OAAO,CAAE,CAAA,CAAC;;SAGjE,MAAM,OAAO,GAAG,IAAIC,MAAc,CAAC,MAAM,EAAE,MAAM,CAAC;CAClD,QAAA,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;SAEjC,OAAO,IAAI,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC;;KAG9C,MAAM,iBAAiB,CAAC,GAAY,EAAA;CACnC,QAAA,IAAI,CAAC,GAAG;aAAE;;CAGV,QAAA,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC;CACjC,QAAA,MAAM,SAAS,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE;SAEvC,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;CACrD,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE;aAC5C,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC;;SAG9D,OAAO;CACN,YAAA,SAAS,EAAE,SAAS;CACpB,YAAA,KAAK,EAAE,QAAQ;UACf;;CAEF;;CC7DD;CACc,MAAO,MAAM,CAAA;CAC1B,IAAA,QAAQ;;;CAKR,IAAA,WAAW;CACX,IAAA,QAAQ;CACR,IAAA,aAAa;CACb,IAAA,SAAS;CACT,IAAA,eAAe;CACf,IAAA,eAAe;CACf,IAAA,MAAM;CACN,IAAA,OAAO;;;CAIP,IAAA,QAAQ;CACR,IAAA,MAAM;CACN,IAAA,MAAM;CACN,IAAA,WAAW,GAA+B,IAAI,GAAG,EAAE;CAEnD,IAAA,WAAA,CAAoB,UAAsB,EAAE,OAAqB,EAAE,OAAgB,EAAE,QAAgB,EAAA;CACpG,QAAA,IAAI,CAAC,WAAW,GAAG,UAAU;CAC7B,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;SACvB,IAAI,CAAC,aAAa,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;CAChF,QAAA,IAAI,CAAC,QAAQ,GAAG,OAAO;CACvB,QAAA,IAAI,CAAC,SAAS,GAAG,QAAQ;CACzB,QAAA,IAAI,CAAC,eAAe,GAAG,EAAE;CACzB,QAAA,IAAI,CAAC,eAAe,GAAG,EAAE;CACzB,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;CACnB,QAAA,IAAI,CAAC,OAAO,GAAG,KAAK;SAEpB,MAAM,KAAK,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,KAAI;CACnD,YAAA,IAAI,CAAC,MAAM,GAAG,OAAO;CACrB,YAAA,IAAI,CAAC,MAAM,GAAG,MAAM;CACrB,SAAC,CAAC;;SAGF,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;SAExC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,KAAI;CACzB,YAAA,OAAO,CAAC,KAAK,CAAC,kBAAkB,EAAE,GAAG,CAAC;CACtC,YAAA,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;CACjB,SAAC,CAAC;;CAGH,IAAA,aAAa,MAAM,CAAC,MAAoB,EAAE,QAAgB,EAAA;SACzD,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;CACnG,QAAA,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,OAAO,EAAE;CAEzC,QAAA,MAAM,OAAO,GAAG,MAAMC,OAAa,CAAC,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC;CACjE,QAAA,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC;SAE/B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,0BAA0B,EAAE;SACzD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;SAEhD,OAAO,IAAI,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC;;CAG1D,IAAA,MAAM,IAAI,GAAA;CACT,QAAA,MAAM,KAAK,GAAG,IAAI,GAAG,EAAoB;CACzC,QAAA,MAAM,MAAM,GAAG,IAAI,KAAK,EAAiB;CAEzC,QAAA,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,KAAI;CAC7C,YAAA,IAAI,KAAK,IAAI,IAAI,CAAC,SAAS,IAAIC,YAAoB,CAAC,KAAK,CAAC,EAAE;iBAC3D,IAAI,CAAC,KAAK,CAAC,SAAS;CAAE,oBAAA,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC;iBAC/D,IAAI,KAAK,CAAC,SAAS;CAAE,oBAAA,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CAClE,gBAAA,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;;CAEpB,SAAC,CAAC;;;SAIF,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;;CAG1E,QAAA,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,KAAI;CACxB,YAAA,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;CACtB,SAAC,CAAC;;CAGH,IAAA,MAAM,QAAQ,CAAC,SAAiB,EAAE,IAAY,EAAA;CAC7C,QAAA,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC;CAC7D,QAAA,IAAI;CACH,YAAA,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;CAC5D,YAAA,IAAI,CAAC,IAAI;CAAE,gBAAA,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC;;CAG1C,YAAA,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE;CAC/B,YAAA,IAAI,CAAC,KAAK;CAAE,gBAAA,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC;CAC5C,YAAA,IAAI,EAAE,KAAK,CAAC,OAAO,YAAY,UAAU,CAAC;CAAE,gBAAA,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC;CAEjF,YAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC;;iBACxC;CACT,YAAA,MAAM,GAAG,CAAC,KAAK,EAAE;;;KAInB,MAAM,UAAU,CAAC,KAAoB,EAAA;SACpC,IAAI,CAAC,KAAK,CAAC,SAAS;CAAE,YAAA,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC;SAE/D,IAAI,IAAI,CAAC,OAAO;aAAE;CAElB,QAAA,MAAM,IAAI,GAAGC,YAAoB,CAAC,KAAK,CAAC,GAAG,OAAO,GAAGD,YAAoB,CAAC,KAAK,CAAC,GAAG,OAAO,GAAG,SAAS;CACtG,QAAA,IAAI,IAAI,IAAI,OAAO,IAAI,IAAI,CAAC,MAAM;aAAE;CAEpC,QAAA,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC;CAEzE,QAAA,IAAI,IAAI,IAAI,OAAO,EAAE;;CAEpB,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI;;CAGlC,QAAA,IAAI,IAAI,IAAI,OAAO,EAAE;CACpB,YAAA,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,IAAI;;CAGlC,QAAA,IAAI;CACH,YAAA,SAAS;CACR,gBAAA,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;CAC/D,gBAAA,IAAI,CAAC,OAAO;qBAAE;CAEd,gBAAA,IAAI,EAAE,OAAO,YAAY,WAAW,CAAC,EAAE;qBACtC,MAAM,IAAI,KAAK,CAAC,CAAA,mCAAA,EAAsC,KAAK,CAAC,IAAI,CAAE,CAAA,CAAC;;CAGpE,gBAAA,IAAI,IAAI,IAAI,SAAS,EAAE;qBACtB,MAAM,IAAI,KAAK,CAAC,CAAA,oBAAA,EAAuB,KAAK,CAAC,IAAI,CAAE,CAAA,CAAC;;CAGrD,gBAAA,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE;qBACrB,MAAM,IAAI,KAAK,CAAC,CAAA,2BAAA,EAA8B,KAAK,CAAC,IAAI,CAAE,CAAA,CAAC;;CAG5D,gBAAA,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE;CAEjD,gBAAA,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;qBACrB,IAAI,EAAE,KAAK,CAAC,SAAS;qBACrB,IAAI;qBACJ,MAAM,EAAE,OAAO,CAAC,MAAM;qBACtB,MAAM;qBACN,MAAM;CACN,iBAAA,CAAC;;;SAEF,OAAO,KAAK,EAAE;CACf,YAAA,OAAO,CAAC,KAAK,CAAC,qBAAqB,EAAE,KAAK,CAAC;;iBAClC;CACT,YAAA,MAAM,GAAG,CAAC,KAAK,EAAE;;;CAInB,IAAA,SAAS,CAAC,KAAoB,EAAA;SAC7B,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;aACrC,OAAO,CAAC,IAAI,CAAC,CAAA,6CAAA,EAAgD,KAAK,CAAC,IAAI,CAAE,CAAA,CAAC;aAC1E;;CAGD,QAAA,MAAM,IAAI,GAAG,CAAC,YAAY,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG;SAEnD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;CAEtC,QAAA,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAI;aAClB,OAAO,CAAC,KAAK,CAAC,CAA+B,4BAAA,EAAA,KAAK,CAAC,IAAI,CAAE,CAAA,EAAE,GAAG,CAAC;CAChE,SAAC,CAAC,CAAC,OAAO,CAAC,MAAK;aACf,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;CACpC,SAAC,CAAC;;KAGH,UAAU,GAAA;SACT,OAAO,IAAI,CAAC,QAAQ;;KAGrB,eAAe,GAAA;CACd,QAAA,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;aACxE,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;;cACrC;aACN,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,IAAI,CAAC,SAAS,CAAC;CACrD,YAAA,OAAO,IAAI;;;KAIb,cAAc,GAAA;SACb,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAACC,YAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,IAAI,CAAC;;KAGpF,cAAc,GAAA;SACb,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAACD,YAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,IAAI,CAAC;;KAGpF,MAAM,WAAW,CAAC,SAAiB,EAAA;CAClC,QAAA,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE;CAC3C,QAAA,IAAI,IAAI,CAAC,OAAO,EAAE;CACjB,YAAA,IAAI,CAAC,eAAe,GAAG,SAAS;aAChC;;SAED,IAAI,YAAY,EAAE;aACjB,OAAO,CAAC,GAAG,CAAC,CAA6B,0BAAA,EAAA,YAAY,CAAC,IAAI,CAA8B,2BAAA,EAAA,SAAS,CAAE,CAAA,CAAC;aACpG,MAAM,IAAI,CAAC,oBAAoB,CAAC,YAAY,CAAC,IAAI,CAAC;;cAC5C;CACN,YAAA,OAAO,CAAC,GAAG,CAAC,yBAAyB,SAAS,CAAA,CAAE,CAAC;;SAElD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;SACpF,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;SACvF,MAAM,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;;KAGxE,MAAM,IAAI,CAAC,OAAgB,EAAA;CAC1B,QAAA,IAAI,CAAC,MAAM,GAAG,OAAO;SACrB,IAAI,OAAO,EAAE;aACZ,OAAO,CAAC,GAAG,CAAC,kCAAkC,EAAE,IAAI,CAAC,eAAe,CAAC;aACrE,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC;CACrD,YAAA,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE;;cACpB;aACN,OAAO,CAAC,GAAG,CAAC,8BAA8B,EAAE,IAAI,CAAC,eAAe,CAAC;CACjE,YAAA,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,eAAe,CAAC;CACjD,YAAA,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;;;KAI9B,MAAM,oBAAoB,CAAC,SAAiB,EAAA;CAC3C,QAAA,OAAO,CAAC,GAAG,CAAC,6BAA6B,SAAS,CAAA,CAAE,CAAC;SACrD,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,SAAS,CAAC;SAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC;SAC5C,IAAI,IAAI,EAAE;CACT,YAAA,MAAM,IAAI;;;CAIZ,IAAA,sBAAsB,CAAC,SAAiB,EAAA;CACvC,QAAA,OAAO,CAAC,GAAG,CAAC,yBAAyB,SAAS,CAAA,CAAE,CAAC;SACjD,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC;SAC/C,IAAI,KAAK,EAAE;CACV,YAAA,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;;cACf;CACN,YAAA,OAAO,CAAC,IAAI,CAAC,SAAS,SAAS,CAAA,qBAAA,CAAuB,CAAC;;;CAIzD,IAAA,UAAU,CAAC,GAAuB,EAAA;CACjC,QAAA,IAAI,GAAG,CAAC,QAAQ,EAAE;;KAKnB,MAAM,KAAK,CAAC,GAAW,EAAA;CACtB,QAAA,IAAI,GAAG;CAAE,YAAA,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;;aACpB,IAAI,CAAC,MAAM,EAAE;SAElB,IAAI,IAAI,CAAC,WAAW;CAAE,YAAA,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE;SAC9C,IAAI,IAAI,CAAC,QAAQ;CAAE,YAAA,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;;CAG/C,IAAA,MAAM,MAAM,GAAA;CACX,QAAA,IAAI;aACH,MAAM,IAAI,CAAC,QAAQ;;SAClB,OAAO,CAAC,EAAE;CACX,YAAA,OAAO,OAAO,CAAC,CAAC,CAAC;;;CAInB;;;;;;;;CAQE;CAEF,IAAA,MAAM,IAAI,GAAA;CACT,QAAA,IAAI,IAAI,CAAC,OAAO,EAAE;CACjB,YAAA,IAAI,CAAC,OAAO,GAAG,KAAK;CACpB,YAAA,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,eAAe,CAAC;CACjD,YAAA,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;CACjB,gBAAA,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,eAAe,CAAC;CACjD,gBAAA,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;;;cAEvB;aACN,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC;aACrD,MAAM,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC;CACrD,YAAA,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE;CAC1B,YAAA,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;CACrB,YAAA,IAAI,CAAC,OAAO,GAAG,IAAI;;;CAerB;;;;;;;;"} \ No newline at end of file diff --git a/web/package.json b/web/package.json index 42af306..a7bdcf3 100644 --- a/web/package.json +++ b/web/package.json @@ -18,13 +18,13 @@ "@astrojs/node": "^6.0.1", "@astrojs/solid-js": "^3.0.1", "@astrojs/tailwind": "^5.0.0", - "@kixelated/moq": "^0.1.4", "@tailwindcss/typography": "^0.5.10", "@tailwindcss/forms": "^0.5.6", "@types/dom-webcodecs": "^0.1.8", "solid-js": "^1.4.3", "tailwindcss": "^3.0.24", "vite-plugin-cross-origin-isolation": "^0.1.6", + "moq-player": "*", "vite-plugin-mkcert": "^1.16.0" }, "devDependencies": { diff --git a/web/src/components/publish.tsx b/web/src/components/publish.tsx index e8b14c8..49b708c 100644 --- a/web/src/components/publish.tsx +++ b/web/src/components/publish.tsx @@ -1,5 +1,5 @@ -import { Broadcast, VideoEncoder, AudioEncoder } from "@kixelated/moq/contribute" -import { Client, Connection } from "@kixelated/moq/transport" +// import { Broadcast, VideoEncoder, AudioEncoder } from "@kixelated/moq/contribute" +// import { Client, Connection } from "@kixelated/moq/transport" import { createSignal, createEffect, @@ -420,7 +420,7 @@ function Device(props: { }, sampleRate: { ideal: 48_000 }, deviceId: audioDeviceId(), - }, + }, video: videoDeviceId() === "disabled" ? false : videoTrackConstraints, }) } diff --git a/web/src/components/watch.tsx b/web/src/components/watch.tsx index d912fab..a7aa542 100644 --- a/web/src/components/watch.tsx +++ b/web/src/components/watch.tsx @@ -1,5 +1,5 @@ /* eslint-disable jsx-a11y/media-has-caption */ -import { Player } from "@kixelated/moq/playback" +import Player from "moq-player" import Fail from "./fail" diff --git a/web/src/layouts/global.astro b/web/src/layouts/global.astro index 49bfa5a..a6af2a8 100644 --- a/web/src/layouts/global.astro +++ b/web/src/layouts/global.astro @@ -34,9 +34,9 @@ if (frontmatter && frontmatter.title) title = frontmatter.title Watch - + Blog From 8fba1ad0837b75899bc9aa86c65ada22e17f088f Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Mon, 9 Dec 2024 16:18:23 -0300 Subject: [PATCH 04/14] refactor: scripts in parallel for easier local development --- package-lock.json | 7281 ++++++++----- package.json | 10 +- simple-web/index.js | 3 + simple-web/public/index.html | 2 +- simple-web/public/moq-player.iife.js | 11321 --------------------- simple-web/public/moq-player.iife.js.map | 1 - 6 files changed, 4912 insertions(+), 13706 deletions(-) delete mode 100644 simple-web/public/moq-player.iife.js delete mode 100644 simple-web/public/moq-player.iife.js.map diff --git a/package-lock.json b/package-lock.json index 0bf0535..55de99d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -7,28 +7,84 @@ "name": "moq-js", "workspaces": [ "lib", - "web" - ] + "web", + "simple-web" + ], + "devDependencies": { + "npm-run-all": "^4.1.5" + } }, "lib": { - "name": "@kixelated/moq", - "version": "0.1.4", + "name": "moq-player", + "version": "0.0.1", "license": "(MIT OR Apache-2.0)", "dependencies": { "mp4box": "^0.5.2" }, "devDependencies": { + "@babel/core": "^7.26.0", + "@babel/preset-env": "^7.26.0", + "@babel/preset-typescript": "^7.26.0", + "@rollup/plugin-babel": "^6.0.4", + "@rollup/plugin-commonjs": "^28.0.1", + "@rollup/plugin-node-resolve": "^15.3.0", + "@rollup/plugin-typescript": "^12.1.1", "@types/audioworklet": "^0.0.50", "@types/dom-mediacapture-transform": "^0.1.6", "@types/dom-webcodecs": "^0.1.8", "@typescript-eslint/eslint-plugin": "^6.4.0", "@typescript-eslint/parser": "^6.4.0", "@typescript/lib-dom": "npm:@types/web@^0.0.115", + "cross-env": "^7.0.2", "eslint": "^8.47.0", "eslint-config-prettier": "^9.0.0", "eslint-plugin-prettier": "^5.0.0", + "npm-run-all": "^4.1.5", "prettier": "^3.0.1", - "typescript": "^5.1.6" + "rollup": "^4.28.0", + "rollup-plugin-sourcemaps": "^0.6.2", + "rollup-plugin-web-worker-loader": "github:htoooth/rollup-plugin-web-worker-loader", + "tslib": "^2.8.1", + "typescript": "^5.7.2" + } + }, + "lib/node_modules/rollup": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.28.1.tgz", + "integrity": "sha512-61fXYl/qNVinKmGSTHAZ6Yy8I3YIJC/r2m9feHo6SwVAVcLT5MPwOUFe7EuURA/4m0NR8lXG4BBXuo/IZEsjMg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.6" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.28.1", + "@rollup/rollup-android-arm64": "4.28.1", + "@rollup/rollup-darwin-arm64": "4.28.1", + "@rollup/rollup-darwin-x64": "4.28.1", + "@rollup/rollup-freebsd-arm64": "4.28.1", + "@rollup/rollup-freebsd-x64": "4.28.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.28.1", + "@rollup/rollup-linux-arm-musleabihf": "4.28.1", + "@rollup/rollup-linux-arm64-gnu": "4.28.1", + "@rollup/rollup-linux-arm64-musl": "4.28.1", + "@rollup/rollup-linux-loongarch64-gnu": "4.28.1", + "@rollup/rollup-linux-powerpc64le-gnu": "4.28.1", + "@rollup/rollup-linux-riscv64-gnu": "4.28.1", + "@rollup/rollup-linux-s390x-gnu": "4.28.1", + "@rollup/rollup-linux-x64-gnu": "4.28.1", + "@rollup/rollup-linux-x64-musl": "4.28.1", + "@rollup/rollup-win32-arm64-msvc": "4.28.1", + "@rollup/rollup-win32-ia32-msvc": "4.28.1", + "@rollup/rollup-win32-x64-msvc": "4.28.1", + "fsevents": "~2.3.2" } }, "node_modules/@aashutoshrathi/word-wrap": { @@ -194,11 +250,13 @@ } }, "node_modules/@babel/code-frame": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.24.7.tgz", - "integrity": "sha512-BcYH1CVJBO9tvyIZ2jVeXgSIMvGZ2FDRvDdOIVQyuklNKSsx+eppDEBq/g47Ayw+RqNFE+URvOShmf+f/qwAlA==", + "version": "7.26.2", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz", + "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==", + "license": "MIT", "dependencies": { - "@babel/highlight": "^7.24.7", + "@babel/helper-validator-identifier": "^7.25.9", + "js-tokens": "^4.0.0", "picocolors": "^1.0.0" }, "engines": { @@ -206,28 +264,30 @@ } }, "node_modules/@babel/compat-data": { - "version": "7.22.20", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.22.20.tgz", - "integrity": "sha512-BQYjKbpXjoXwFW5jGqiizJQQT/aC7pFm9Ok1OWssonuguICi264lbgMzRp2ZMmRSlfkX6DsWDDcsrctK8Rwfiw==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.26.3.tgz", + "integrity": "sha512-nHIxvKPniQXpmQLb0vhY3VaFb3S0YrTAwpOWJZh1wn3oJPjJk9Asva204PsBdmAE8vpzfHudT8DB0scYvy9q0g==", + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/core": { - "version": "7.23.0", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.23.0.tgz", - "integrity": "sha512-97z/ju/Jy1rZmDxybphrBuI+jtJjFVoz7Mr9yUQVVVi+DNZE333uFQeMOqcCIy1x3WYBIbWftUSLmbNXNT7qFQ==", + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.26.0.tgz", + "integrity": "sha512-i1SLeK+DzNnQ3LL/CswPCa/E5u4lh1k6IAEphON8F+cXt0t9euTshDru0q7/IqMa1PMPz5RnHuHscF8/ZJsStg==", + "license": "MIT", "dependencies": { "@ampproject/remapping": "^2.2.0", - "@babel/code-frame": "^7.22.13", - "@babel/generator": "^7.23.0", - "@babel/helper-compilation-targets": "^7.22.15", - "@babel/helper-module-transforms": "^7.23.0", - "@babel/helpers": "^7.23.0", - "@babel/parser": "^7.23.0", - "@babel/template": "^7.22.15", - "@babel/traverse": "^7.23.0", - "@babel/types": "^7.23.0", + "@babel/code-frame": "^7.26.0", + "@babel/generator": "^7.26.0", + "@babel/helper-compilation-targets": "^7.25.9", + "@babel/helper-module-transforms": "^7.26.0", + "@babel/helpers": "^7.26.0", + "@babel/parser": "^7.26.0", + "@babel/template": "^7.25.9", + "@babel/traverse": "^7.25.9", + "@babel/types": "^7.26.0", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", @@ -251,38 +311,42 @@ } }, "node_modules/@babel/generator": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.24.7.tgz", - "integrity": "sha512-oipXieGC3i45Y1A41t4tAqpnEZWgB/lC6Ehh6+rOviR5XWpTtMmLN+fGjz9vOiNRt0p6RtO6DtD0pdU3vpqdSA==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.26.3.tgz", + "integrity": "sha512-6FF/urZvD0sTeO7k6/B15pMLC4CHUv1426lzr3N01aHJTl046uCAh9LXW/fzeXXjPNCJ6iABW5XaWOsIZB93aQ==", + "license": "MIT", "dependencies": { - "@babel/types": "^7.24.7", + "@babel/parser": "^7.26.3", + "@babel/types": "^7.26.3", "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.25", - "jsesc": "^2.5.1" + "jsesc": "^3.0.2" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-annotate-as-pure": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.22.5.tgz", - "integrity": "sha512-LvBTxu8bQSQkcyKOU+a1btnNFQ1dMAd0R6PyW3arXes06F6QLWLIrd681bxRPIXlrMGR3XYnW9JyML7dP3qgxg==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.25.9.tgz", + "integrity": "sha512-gv7320KBUFJz1RnylIg5WWYPRXKZ884AGkYpgpWW02TH66Dl+HaC1t1CKd0z3R4b6hdYEcmrNZHUmfCP+1u3/g==", + "license": "MIT", "dependencies": { - "@babel/types": "^7.22.5" + "@babel/types": "^7.25.9" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-compilation-targets": { - "version": "7.22.15", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.15.tgz", - "integrity": "sha512-y6EEzULok0Qvz8yyLkCvVX+02ic+By2UdOhylwUOvOn9dvYc9mKICJuuU1n1XBI02YWsNsnrY1kc6DVbjcXbtw==", - "dependencies": { - "@babel/compat-data": "^7.22.9", - "@babel/helper-validator-option": "^7.22.15", - "browserslist": "^4.21.9", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.25.9.tgz", + "integrity": "sha512-j9Db8Suy6yV/VHa4qzrj9yZfZxhLWQdVnRlXxmKLYlhWUVB1sB2G5sxuWYXk/whHD9iW76PmNzxZ4UCnTQTVEQ==", + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.25.9", + "@babel/helper-validator-option": "^7.25.9", + "browserslist": "^4.24.0", "lru-cache": "^5.1.1", "semver": "^6.3.1" }, @@ -294,23 +358,23 @@ "version": "6.3.1", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", "bin": { "semver": "bin/semver.js" } }, "node_modules/@babel/helper-create-class-features-plugin": { - "version": "7.22.15", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.22.15.tgz", - "integrity": "sha512-jKkwA59IXcvSaiK2UN45kKwSC9o+KuoXsBDvHvU/7BecYIp8GQ2UwrVvFgJASUT+hBnwJx6MhvMCuMzwZZ7jlg==", - "dependencies": { - "@babel/helper-annotate-as-pure": "^7.22.5", - "@babel/helper-environment-visitor": "^7.22.5", - "@babel/helper-function-name": "^7.22.5", - "@babel/helper-member-expression-to-functions": "^7.22.15", - "@babel/helper-optimise-call-expression": "^7.22.5", - "@babel/helper-replace-supers": "^7.22.9", - "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", - "@babel/helper-split-export-declaration": "^7.22.6", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.25.9.tgz", + "integrity": "sha512-UTZQMvt0d/rSz6KI+qdu7GQze5TIajwTS++GUozlw8VBJDEOAqSXwm1WvmYEZwqdqSGQshRocPDqrt4HBZB3fQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.25.9", + "@babel/helper-member-expression-to-functions": "^7.25.9", + "@babel/helper-optimise-call-expression": "^7.25.9", + "@babel/helper-replace-supers": "^7.25.9", + "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9", + "@babel/traverse": "^7.25.9", "semver": "^6.3.1" }, "engines": { @@ -324,76 +388,91 @@ "version": "6.3.1", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", "bin": { "semver": "bin/semver.js" } }, - "node_modules/@babel/helper-environment-visitor": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.24.7.tgz", - "integrity": "sha512-DoiN84+4Gnd0ncbBOM9AZENV4a5ZiL39HYMyZJGZ/AZEykHYdJw0wW3kdcsh9/Kn+BRXHLkkklZ51ecPKmI1CQ==", + "node_modules/@babel/helper-create-regexp-features-plugin": { + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.26.3.tgz", + "integrity": "sha512-G7ZRb40uUgdKOQqPLjfD12ZmGA54PzqDFUv2BKImnC9QIfGhIHKvVML0oN8IUiDq4iRqpq74ABpvOaerfWdong==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/types": "^7.24.7" + "@babel/helper-annotate-as-pure": "^7.25.9", + "regexpu-core": "^6.2.0", + "semver": "^6.3.1" }, "engines": { "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" } }, - "node_modules/@babel/helper-function-name": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.24.7.tgz", - "integrity": "sha512-FyoJTsj/PEUWu1/TYRiXTIHc8lbw+TDYkZuoE43opPS5TrI7MyONBE1oNvfguEXAD9yhQRrVBnXdXzSLQl9XnA==", - "dependencies": { - "@babel/template": "^7.24.7", - "@babel/types": "^7.24.7" - }, - "engines": { - "node": ">=6.9.0" + "node_modules/@babel/helper-create-regexp-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" } }, - "node_modules/@babel/helper-hoist-variables": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.24.7.tgz", - "integrity": "sha512-MJJwhkoGy5c4ehfoRyrJ/owKeMl19U54h27YYftT0o2teQ3FJ3nQUf/I3LlJsX4l3qlw7WRXUmiyajvHXoTubQ==", + "node_modules/@babel/helper-define-polyfill-provider": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.3.tgz", + "integrity": "sha512-HK7Bi+Hj6H+VTHA3ZvBis7V/6hu9QuTrnMXNybfUf2iiuU/N97I8VjB+KbhFF8Rld/Lx5MzoCwPCpPjfK+n8Cg==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/types": "^7.24.7" + "@babel/helper-compilation-targets": "^7.22.6", + "@babel/helper-plugin-utils": "^7.22.5", + "debug": "^4.1.1", + "lodash.debounce": "^4.0.8", + "resolve": "^1.14.2" }, - "engines": { - "node": ">=6.9.0" + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" } }, "node_modules/@babel/helper-member-expression-to-functions": { - "version": "7.23.0", - "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.23.0.tgz", - "integrity": "sha512-6gfrPwh7OuT6gZyJZvd6WbTfrqAo7vm4xCzAXOusKqq/vWdKXphTpj5klHKNmRUU6/QRGlBsyU9mAIPaWHlqJA==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.25.9.tgz", + "integrity": "sha512-wbfdZ9w5vk0C0oyHqAJbc62+vet5prjj01jjJ8sKn3j9h3MQQlflEdXYvuqRWjHnM12coDEqiC1IRCi0U/EKwQ==", + "license": "MIT", "dependencies": { - "@babel/types": "^7.23.0" + "@babel/traverse": "^7.25.9", + "@babel/types": "^7.25.9" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-imports": { - "version": "7.22.15", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.22.15.tgz", - "integrity": "sha512-0pYVBnDKZO2fnSPCrgM/6WMc7eS20Fbok+0r88fp+YtWVLZrp4CkafFGIp+W0VKw4a22sgebPT99y+FDNMdP4w==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.25.9.tgz", + "integrity": "sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==", + "license": "MIT", "dependencies": { - "@babel/types": "^7.22.15" + "@babel/traverse": "^7.25.9", + "@babel/types": "^7.25.9" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-transforms": { - "version": "7.23.0", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.23.0.tgz", - "integrity": "sha512-WhDWw1tdrlT0gMgUJSlX0IQvoO1eN279zrAUbVB+KpV2c3Tylz8+GnKOLllCS6Z/iZQEyVYxhZVUdPTqs2YYPw==", + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.26.0.tgz", + "integrity": "sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==", + "license": "MIT", "dependencies": { - "@babel/helper-environment-visitor": "^7.22.20", - "@babel/helper-module-imports": "^7.22.15", - "@babel/helper-simple-access": "^7.22.5", - "@babel/helper-split-export-declaration": "^7.22.6", - "@babel/helper-validator-identifier": "^7.22.20" + "@babel/helper-module-imports": "^7.25.9", + "@babel/helper-validator-identifier": "^7.25.9", + "@babel/traverse": "^7.25.9" }, "engines": { "node": ">=6.9.0" @@ -403,32 +482,36 @@ } }, "node_modules/@babel/helper-optimise-call-expression": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.22.5.tgz", - "integrity": "sha512-HBwaojN0xFRx4yIvpwGqxiV2tUfl7401jlok564NgB9EHS1y6QT17FmKWm4ztqjeVdXLuC4fSvHc5ePpQjoTbw==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.25.9.tgz", + "integrity": "sha512-FIpuNaz5ow8VyrYcnXQTDRGvV6tTjkNtCK/RYNDXGSLlUD6cBuQTSw43CShGxjvfBTfcUA/r6UhUCbtYqkhcuQ==", + "license": "MIT", "dependencies": { - "@babel/types": "^7.22.5" + "@babel/types": "^7.25.9" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-plugin-utils": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", - "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.25.9.tgz", + "integrity": "sha512-kSMlyUVdWe25rEsRGviIgOWnoT/nfABVWlqt9N19/dIPWViAOW2s9wznP5tURbs/IDuNk4gPy3YdYRgH3uxhBw==", + "license": "MIT", "engines": { "node": ">=6.9.0" } }, - "node_modules/@babel/helper-replace-supers": { - "version": "7.22.20", - "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.22.20.tgz", - "integrity": "sha512-qsW0In3dbwQUbK8kejJ4R7IHVGwHJlV6lpG6UA7a9hSa2YEiAib+N1T2kr6PEeUT+Fl7najmSOS6SmAwCHK6Tw==", + "node_modules/@babel/helper-remap-async-to-generator": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.25.9.tgz", + "integrity": "sha512-IZtukuUeBbhgOcaW2s06OXTzVNJR0ybm4W5xC1opWFFJMZbwRj5LCk+ByYH7WdZPZTt8KnFwA8pvjN2yqcPlgw==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/helper-environment-visitor": "^7.22.20", - "@babel/helper-member-expression-to-functions": "^7.22.15", - "@babel/helper-optimise-call-expression": "^7.22.5" + "@babel/helper-annotate-as-pure": "^7.25.9", + "@babel/helper-wrap-function": "^7.25.9", + "@babel/traverse": "^7.25.9" }, "engines": { "node": ">=6.9.0" @@ -437,94 +520,99 @@ "@babel/core": "^7.0.0" } }, - "node_modules/@babel/helper-simple-access": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz", - "integrity": "sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==", + "node_modules/@babel/helper-replace-supers": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.25.9.tgz", + "integrity": "sha512-IiDqTOTBQy0sWyeXyGSC5TBJpGFXBkRynjBeXsvbhQFKj2viwJC76Epz35YLU1fpe/Am6Vppb7W7zM4fPQzLsQ==", + "license": "MIT", "dependencies": { - "@babel/types": "^7.22.5" + "@babel/helper-member-expression-to-functions": "^7.25.9", + "@babel/helper-optimise-call-expression": "^7.25.9", + "@babel/traverse": "^7.25.9" }, "engines": { "node": ">=6.9.0" - } - }, - "node_modules/@babel/helper-skip-transparent-expression-wrappers": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.22.5.tgz", - "integrity": "sha512-tK14r66JZKiC43p8Ki33yLBVJKlQDFoA8GYN67lWCDCqoL6EMMSuM9b+Iff2jHaM/RRFYl7K+iiru7hbRqNx8Q==", - "dependencies": { - "@babel/types": "^7.22.5" }, - "engines": { - "node": ">=6.9.0" + "peerDependencies": { + "@babel/core": "^7.0.0" } }, - "node_modules/@babel/helper-split-export-declaration": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.24.7.tgz", - "integrity": "sha512-oy5V7pD+UvfkEATUKvIjvIAH/xCzfsFVw7ygW2SI6NClZzquT+mwdTfgfdbUiceh6iQO0CHtCPsyze/MZ2YbAA==", + "node_modules/@babel/helper-skip-transparent-expression-wrappers": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.25.9.tgz", + "integrity": "sha512-K4Du3BFa3gvyhzgPcntrkDgZzQaq6uozzcpGbOO1OEJaI+EJdqWIMTLgFgQf6lrfiDFo5FU+BxKepI9RmZqahA==", + "license": "MIT", "dependencies": { - "@babel/types": "^7.24.7" + "@babel/traverse": "^7.25.9", + "@babel/types": "^7.25.9" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-string-parser": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.24.7.tgz", - "integrity": "sha512-7MbVt6xrwFQbunH2DNQsAP5sTGxfqQtErvBIvIMi6EQnbgUOuVYanvREcmFrOPhoXBrTtjhhP+lW+o5UfK+tDg==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz", + "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==", + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-identifier": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.24.7.tgz", - "integrity": "sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz", + "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==", + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-option": { - "version": "7.22.15", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.22.15.tgz", - "integrity": "sha512-bMn7RmyFjY/mdECUbgn9eoSY4vqvacUnS9i9vGAGttgFWesO6B4CYWA7XlpbWgBt71iv/hfbPlynohStqnu5hA==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.25.9.tgz", + "integrity": "sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==", + "license": "MIT", "engines": { "node": ">=6.9.0" } }, - "node_modules/@babel/helpers": { - "version": "7.23.1", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.23.1.tgz", - "integrity": "sha512-chNpneuK18yW5Oxsr+t553UZzzAs3aZnFm4bxhebsNTeshrC95yA7l5yl7GBAG+JG1rF0F7zzD2EixK9mWSDoA==", + "node_modules/@babel/helper-wrap-function": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.25.9.tgz", + "integrity": "sha512-ETzz9UTjQSTmw39GboatdymDq4XIQbR8ySgVrylRhPOFpsd+JrKHIuF0de7GCWmem+T4uC5z7EZguod7Wj4A4g==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/template": "^7.22.15", - "@babel/traverse": "^7.23.0", - "@babel/types": "^7.23.0" + "@babel/template": "^7.25.9", + "@babel/traverse": "^7.25.9", + "@babel/types": "^7.25.9" }, "engines": { "node": ">=6.9.0" } }, - "node_modules/@babel/highlight": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.24.7.tgz", - "integrity": "sha512-EStJpq4OuY8xYfhGVXngigBJRWxftKX9ksiGDnmlY3o7B/V7KIAc9X4oiK87uPJSc/vs5L869bem5fhZa8caZw==", + "node_modules/@babel/helpers": { + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.26.0.tgz", + "integrity": "sha512-tbhNuIxNcVb21pInl3ZSjksLCvgdZy9KwJ8brv993QtIVKJBBkYXz4q4ZbAv31GdnC+R90np23L5FbEBlthAEw==", + "license": "MIT", "dependencies": { - "@babel/helper-validator-identifier": "^7.24.7", - "chalk": "^2.4.2", - "js-tokens": "^4.0.0", - "picocolors": "^1.0.0" + "@babel/template": "^7.25.9", + "@babel/types": "^7.26.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/parser": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.24.7.tgz", - "integrity": "sha512-9uUYRm6OqQrCqQdG1iCBwBPZgN8ciDBro2nIOFaiRz1/BCxaI7CNvQbDHvsArAC7Tw9Hda/B3U+6ui9u4HWXPw==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.3.tgz", + "integrity": "sha512-WJ/CvmY8Mea8iDXo6a7RK2wbmJITT5fN3BEkRuFlxVyNx8jOKIIhmC4fSkTcPcf8JyavbBwIe6OpiCOBXt/IcA==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.26.3" + }, "bin": { "parser": "bin/babel-parser.js" }, @@ -532,78 +620,96 @@ "node": ">=6.0.0" } }, - "node_modules/@babel/plugin-syntax-jsx": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.22.5.tgz", - "integrity": "sha512-gvyP4hZrgrs/wWMaocvxZ44Hw0b3W8Pe+cMxc8V1ULQ07oh8VNbIRaoD1LRZVTvD+0nieDKjfgKg89sD7rrKrg==", + "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.25.9.tgz", + "integrity": "sha512-ZkRyVkThtxQ/J6nv3JFYv1RYY+JT5BvU0y3k5bWrmuG4woXypRa4PXmm9RhOwodRkYFWqC0C0cqcJ4OqR7kW+g==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.22.5" + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/traverse": "^7.25.9" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.0.0" } }, - "node_modules/@babel/plugin-syntax-typescript": { - "version": "7.22.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.22.5.tgz", - "integrity": "sha512-1mS2o03i7t1c6VzH6fdQ3OA8tcEIxwG18zIPRp+UY1Ihv6W+XZzBCVxExF9upussPXJ0xE9XRHwMoNs1ep/nRQ==", + "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.25.9.tgz", + "integrity": "sha512-MrGRLZxLD/Zjj0gdU15dfs+HH/OXvnw/U4jJD8vpcP2CJQapPEv1IWwjc/qMg7ItBlPwSv1hRBbb7LeuANdcnw==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.22.5" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.0.0" } }, - "node_modules/@babel/plugin-transform-modules-commonjs": { - "version": "7.23.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.23.0.tgz", - "integrity": "sha512-32Xzss14/UVc7k9g775yMIvkVK8xwKE0DPdP5JTapr3+Z9w4tzeOuLNY6BXDQR6BdnzIlXnCGAzsk/ICHBLVWQ==", + "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.25.9.tgz", + "integrity": "sha512-2qUwwfAFpJLZqxd02YW9btUCZHl+RFvdDkNfZwaIJrvB8Tesjsk8pEQkTvGwZXLqXUx/2oyY3ySRhm6HOXuCug==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/helper-module-transforms": "^7.23.0", - "@babel/helper-plugin-utils": "^7.22.5", - "@babel/helper-simple-access": "^7.22.5" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.0.0" } }, - "node_modules/@babel/plugin-transform-react-jsx": { - "version": "7.22.15", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.22.15.tgz", - "integrity": "sha512-oKckg2eZFa8771O/5vi7XeTvmM6+O9cxZu+kanTU7tD4sin5nO/G8jGJhq8Hvt2Z0kUoEDRayuZLaUlYl8QuGA==", + "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.25.9.tgz", + "integrity": "sha512-6xWgLZTJXwilVjlnV7ospI3xi+sl8lN8rXXbBD6vYn3UYDlGsag8wrZkKcSI8G6KgqKP7vNFaDgeDnfAABq61g==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.22.5", - "@babel/helper-module-imports": "^7.22.15", - "@babel/helper-plugin-utils": "^7.22.5", - "@babel/plugin-syntax-jsx": "^7.22.5", - "@babel/types": "^7.22.15" + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9", + "@babel/plugin-transform-optional-chaining": "^7.25.9" }, "engines": { "node": ">=6.9.0" }, "peerDependencies": { - "@babel/core": "^7.0.0-0" + "@babel/core": "^7.13.0" } }, - "node_modules/@babel/plugin-transform-typescript": { - "version": "7.22.15", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.22.15.tgz", - "integrity": "sha512-1uirS0TnijxvQLnlv5wQBwOX3E1wCFX7ITv+9pBV2wKEk4K+M5tqDaoNXnTH8tjEIYHLO98MwiTWO04Ggz4XuA==", + "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.25.9.tgz", + "integrity": "sha512-aLnMXYPnzwwqhYSCyXfKkIkYgJ8zv9RK+roo9DkTXz38ynIhd9XCbN08s3MGvqL2MYGVUGdRQLL/JqBIeJhJBg==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.22.5", - "@babel/helper-create-class-features-plugin": "^7.22.15", - "@babel/helper-plugin-utils": "^7.22.5", - "@babel/plugin-syntax-typescript": "^7.22.5" + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/traverse": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.21.0-placeholder-for-preset-env.2", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz", + "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==", + "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" }, @@ -611,16 +717,14 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/preset-typescript": { - "version": "7.23.0", - "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.23.0.tgz", - "integrity": "sha512-6P6VVa/NM/VlAYj5s2Aq/gdVg8FSENCg3wlZ6Qau9AcPaoF5LbN1nyGlR9DTRIw9PpxI94e+ReydsJHcjwAweg==", + "node_modules/@babel/plugin-syntax-import-assertions": { + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.26.0.tgz", + "integrity": "sha512-QCWT5Hh830hK5EQa7XzuqIkQU9tT/whqbDz7kuaZMHFl1inRRg7JnuAEOQ0Ur0QUl0NufCk1msK2BeY79Aj/eg==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.22.5", - "@babel/helper-validator-option": "^7.22.15", - "@babel/plugin-syntax-jsx": "^7.22.5", - "@babel/plugin-transform-modules-commonjs": "^7.23.0", - "@babel/plugin-transform-typescript": "^7.22.15" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { "node": ">=6.9.0" @@ -629,1748 +733,2817 @@ "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/runtime": { - "version": "7.23.1", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.23.1.tgz", - "integrity": "sha512-hC2v6p8ZSI/W0HUzh3V8C5g+NwSKzKPtJwSpTjwl0o297GP9+ZLQSkdvHz46CM3LqyoXxq+5G9komY+eSqSO0g==", + "node_modules/@babel/plugin-syntax-import-attributes": { + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.26.0.tgz", + "integrity": "sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A==", "dev": true, + "license": "MIT", "dependencies": { - "regenerator-runtime": "^0.14.0" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/template": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.24.7.tgz", - "integrity": "sha512-jYqfPrU9JTF0PmPy1tLYHW4Mp4KlgxJD9l2nP9fD6yT/ICi554DmrWBAEYpIelzjHf1msDP3PxJIRt/nFNfBig==", + "node_modules/@babel/plugin-syntax-jsx": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.25.9.tgz", + "integrity": "sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA==", + "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.24.7", - "@babel/parser": "^7.24.7", - "@babel/types": "^7.24.7" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/traverse": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.24.7.tgz", - "integrity": "sha512-yb65Ed5S/QAcewNPh0nZczy9JdYXkkAbIsEo+P7BE7yO3txAY30Y/oPa3QkQ5It3xVG2kpKMg9MsdxZaO31uKA==", - "dependencies": { - "@babel/code-frame": "^7.24.7", - "@babel/generator": "^7.24.7", - "@babel/helper-environment-visitor": "^7.24.7", - "@babel/helper-function-name": "^7.24.7", - "@babel/helper-hoist-variables": "^7.24.7", - "@babel/helper-split-export-declaration": "^7.24.7", - "@babel/parser": "^7.24.7", - "@babel/types": "^7.24.7", - "debug": "^4.3.1", - "globals": "^11.1.0" + "node_modules/@babel/plugin-syntax-typescript": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.25.9.tgz", + "integrity": "sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@babel/types": { - "version": "7.24.7", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.24.7.tgz", - "integrity": "sha512-XEFXSlxiG5td2EJRe8vOmRbaXVgfcBlszKujvVmWIK/UpywWljQCfzAv3RQCGujWQ1RD4YYWEAqDXfuJiy8f5Q==", + "node_modules/@babel/plugin-syntax-unicode-sets-regex": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz", + "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/helper-string-parser": "^7.24.7", - "@babel/helper-validator-identifier": "^7.24.7", - "to-fast-properties": "^2.0.0" + "@babel/helper-create-regexp-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" }, "engines": { "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" } }, - "node_modules/@esbuild/android-arm": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.4.tgz", - "integrity": "sha512-uBIbiYMeSsy2U0XQoOGVVcpIktjLMEKa7ryz2RLr7L/vTnANNEsPVAh4xOv7ondGz6ac1zVb0F8Jx20rQikffQ==", - "cpu": [ - "arm" - ], - "optional": true, - "os": [ - "android" - ], + "node_modules/@babel/plugin-transform-arrow-functions": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.25.9.tgz", + "integrity": "sha512-6jmooXYIwn9ca5/RylZADJ+EnSxVUS5sjeJ9UPk6RWRzXCmOJCy6dqItPJFpw2cuCangPK4OYr5uhGKcmrm5Qg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/android-arm64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.4.tgz", - "integrity": "sha512-mRsi2vJsk4Bx/AFsNBqOH2fqedxn5L/moT58xgg51DjX1la64Z3Npicut2VbhvDFO26qjWtPMsVxCd80YTFVeg==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "android" - ], + "node_modules/@babel/plugin-transform-async-generator-functions": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.25.9.tgz", + "integrity": "sha512-RXV6QAzTBbhDMO9fWwOmwwTuYaiPbggWQ9INdZqAYeSHyG7FzQ+nOZaUUjNwKv9pV3aE4WFqFm1Hnbci5tBCAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-remap-async-to-generator": "^7.25.9", + "@babel/traverse": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/android-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.4.tgz", - "integrity": "sha512-4iPufZ1TMOD3oBlGFqHXBpa3KFT46aLl6Vy7gwed0ZSYgHaZ/mihbYb4t7Z9etjkC9Al3ZYIoOaHrU60gcMy7g==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "android" - ], + "node_modules/@babel/plugin-transform-async-to-generator": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.25.9.tgz", + "integrity": "sha512-NT7Ejn7Z/LjUH0Gv5KsBCxh7BH3fbLTV0ptHvpeMvrt3cPThHfJfst9Wrb7S8EvJ7vRTFI7z+VAvFVEQn/m5zQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-remap-async-to-generator": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/darwin-arm64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.4.tgz", - "integrity": "sha512-Lviw8EzxsVQKpbS+rSt6/6zjn9ashUZ7Tbuvc2YENgRl0yZTktGlachZ9KMJUsVjZEGFVu336kl5lBgDN6PmpA==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "darwin" - ], + "node_modules/@babel/plugin-transform-block-scoped-functions": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.25.9.tgz", + "integrity": "sha512-toHc9fzab0ZfenFpsyYinOX0J/5dgJVA2fm64xPewu7CoYHWEivIWKxkK2rMi4r3yQqLnVmheMXRdG+k239CgA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.4.tgz", - "integrity": "sha512-YHbSFlLgDwglFn0lAO3Zsdrife9jcQXQhgRp77YiTDja23FrC2uwnhXMNkAucthsf+Psr7sTwYEryxz6FPAVqw==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "darwin" - ], + "node_modules/@babel/plugin-transform-block-scoping": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.25.9.tgz", + "integrity": "sha512-1F05O7AYjymAtqbsFETboN1NvBdcnzMerO+zlMyJBEz6WkMdejvGWw9p05iTSjC85RLlBseHHQpYaM4gzJkBGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.4.tgz", - "integrity": "sha512-vz59ijyrTG22Hshaj620e5yhs2dU1WJy723ofc+KUgxVCM6zxQESmWdMuVmUzxtGqtj5heHyB44PjV/HKsEmuQ==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "freebsd" - ], + "node_modules/@babel/plugin-transform-class-properties": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.25.9.tgz", + "integrity": "sha512-bbMAII8GRSkcd0h0b4X+36GksxuheLFjP65ul9w6C3KgAamI3JqErNgSrosX6ZPj+Mpim5VvEbawXxJCyEUV3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.4.tgz", - "integrity": "sha512-3sRbQ6W5kAiVQRBWREGJNd1YE7OgzS0AmOGjDmX/qZZecq8NFlQsQH0IfXjjmD0XtUYqr64e0EKNFjMUlPL3Cw==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "freebsd" - ], + "node_modules/@babel/plugin-transform-class-static-block": { + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.26.0.tgz", + "integrity": "sha512-6J2APTs7BDDm+UMqP1useWqhcRAXo0WIoVj26N7kPFB6S73Lgvyka4KTZYIxtgYXiN5HTyRObA72N2iu628iTQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0" } }, - "node_modules/@esbuild/linux-arm": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.4.tgz", - "integrity": "sha512-z/4ArqOo9EImzTi4b6Vq+pthLnepFzJ92BnofU1jgNlcVb+UqynVFdoXMCFreTK7FdhqAzH0vmdwW5373Hm9pg==", - "cpu": [ - "arm" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-classes": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.25.9.tgz", + "integrity": "sha512-mD8APIXmseE7oZvZgGABDyM34GUmK45Um2TXiBUt7PnuAxrgoSVf123qUzPxEr/+/BHrRn5NMZCdE2m/1F8DGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.25.9", + "@babel/helper-compilation-targets": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-replace-supers": "^7.25.9", + "@babel/traverse": "^7.25.9", + "globals": "^11.1.0" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.4.tgz", - "integrity": "sha512-ZWmWORaPbsPwmyu7eIEATFlaqm0QGt+joRE9sKcnVUG3oBbr/KYdNE2TnkzdQwX6EDRdg/x8Q4EZQTXoClUqqA==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-computed-properties": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.25.9.tgz", + "integrity": "sha512-HnBegGqXZR12xbcTHlJ9HGxw1OniltT26J5YpfruGqtUHlz/xKf/G2ak9e+t0rVqrjXa9WOhvYPz1ERfMj23AA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/template": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.4.tgz", - "integrity": "sha512-EGc4vYM7i1GRUIMqRZNCTzJh25MHePYsnQfKDexD8uPTCm9mK56NIL04LUfX2aaJ+C9vyEp2fJ7jbqFEYgO9lQ==", - "cpu": [ - "ia32" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-destructuring": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.25.9.tgz", + "integrity": "sha512-WkCGb/3ZxXepmMiX101nnGiU+1CAdut8oHyEOHxkKuS1qKpU2SMXE2uSvfz8PBuLd49V6LEsbtyPhWC7fnkgvQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.4.tgz", - "integrity": "sha512-WVhIKO26kmm8lPmNrUikxSpXcgd6HDog0cx12BUfA2PkmURHSgx9G6vA19lrlQOMw+UjMZ+l3PpbtzffCxFDRg==", - "cpu": [ - "loong64" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-dotall-regex": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.25.9.tgz", + "integrity": "sha512-t7ZQ7g5trIgSRYhI9pIJtRl64KHotutUJsh4Eze5l7olJv+mRSg4/MmbZ0tv1eeqRbdvo/+trvJD/Oc5DmW2cA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.4.tgz", - "integrity": "sha512-keYY+Hlj5w86hNp5JJPuZNbvW4jql7c1eXdBUHIJGTeN/+0QFutU3GrS+c27L+NTmzi73yhtojHk+lr2+502Mw==", - "cpu": [ - "mips64el" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-duplicate-keys": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.25.9.tgz", + "integrity": "sha512-LZxhJ6dvBb/f3x8xwWIuyiAHy56nrRG3PeYTpBkkzkYRRQ6tJLu68lEF5VIqMUZiAV7a8+Tb78nEoMCMcqjXBw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.4.tgz", - "integrity": "sha512-tQ92n0WMXyEsCH4m32S21fND8VxNiVazUbU4IUGVXQpWiaAxOBvtOtbEt3cXIV3GEBydYsY8pyeRMJx9kn3rvw==", - "cpu": [ - "ppc64" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.25.9.tgz", + "integrity": "sha512-0UfuJS0EsXbRvKnwcLjFtJy/Sxc5J5jhLHnFhy7u4zih97Hz6tJkLU+O+FMMrNZrosUPxDi6sYxJ/EA8jDiAog==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" } }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.4.tgz", - "integrity": "sha512-tRRBey6fG9tqGH6V75xH3lFPpj9E8BH+N+zjSUCnFOX93kEzqS0WdyJHkta/mmJHn7MBaa++9P4ARiU4ykjhig==", - "cpu": [ - "riscv64" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-dynamic-import": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.25.9.tgz", + "integrity": "sha512-GCggjexbmSLaFhqsojeugBpeaRIgWNTcgKVq/0qIteFEqY2A+b9QidYadrWlnbWQUrW5fn+mCvf3tr7OeBFTyg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.4.tgz", - "integrity": "sha512-152aLpQqKZYhThiJ+uAM4PcuLCAOxDsCekIbnGzPKVBRUDlgaaAfaUl5NYkB1hgY6WN4sPkejxKlANgVcGl9Qg==", - "cpu": [ - "s390x" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-exponentiation-operator": { + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.26.3.tgz", + "integrity": "sha512-7CAHcQ58z2chuXPWblnn1K6rLDnDWieghSOEmqQsrBenH0P9InCUtOJYD89pvngljmZlJcz3fcmgYsXFNGa1ZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/linux-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.4.tgz", - "integrity": "sha512-Mi4aNA3rz1BNFtB7aGadMD0MavmzuuXNTaYL6/uiYIs08U7YMPETpgNn5oue3ICr+inKwItOwSsJDYkrE9ekVg==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/@babel/plugin-transform-export-namespace-from": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.25.9.tgz", + "integrity": "sha512-2NsEz+CxzJIVOPx2o9UsW1rXLqtChtLoVnwYHHiB04wS5sgn7mrV45fWMBX0Kk+ub9uXytVYfNP2HjbVbCB3Ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.4.tgz", - "integrity": "sha512-9+Wxx1i5N/CYo505CTT7T+ix4lVzEdz0uCoYGxM5JDVlP2YdDC1Bdz+Khv6IbqmisT0Si928eAxbmGkcbiuM/A==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "netbsd" - ], + "node_modules/@babel/plugin-transform-for-of": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.25.9.tgz", + "integrity": "sha512-LqHxduHoaGELJl2uhImHwRQudhCM50pT46rIBNvtT/Oql3nqiS3wOwP+5ten7NpYSXrrVLgtZU3DZmPtWZo16A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.4.tgz", - "integrity": "sha512-MFsHleM5/rWRW9EivFssop+OulYVUoVcqkyOkjiynKBCGBj9Lihl7kh9IzrreDyXa4sNkquei5/DTP4uCk25xw==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "openbsd" - ], + "node_modules/@babel/plugin-transform-function-name": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.25.9.tgz", + "integrity": "sha512-8lP+Yxjv14Vc5MuWBpJsoUCd3hD6V9DgBon2FVYL4jJgbnVQ9fTgYmonchzZJOVNgzEgbxp4OwAf6xz6M/14XA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/traverse": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.4.tgz", - "integrity": "sha512-6Xq8SpK46yLvrGxjp6HftkDwPP49puU4OF0hEL4dTxqCbfx09LyrbUj/D7tmIRMj5D5FCUPksBbxyQhp8tmHzw==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "sunos" - ], + "node_modules/@babel/plugin-transform-json-strings": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.25.9.tgz", + "integrity": "sha512-xoTMk0WXceiiIvsaquQQUaLLXSW1KJ159KP87VilruQm0LNNGxWzahxSS6T6i4Zg3ezp4vA4zuwiNUR53qmQAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.4.tgz", - "integrity": "sha512-PkIl7Jq4mP6ke7QKwyg4fD4Xvn8PXisagV/+HntWoDEdmerB2LTukRZg728Yd1Fj+LuEX75t/hKXE2Ppk8Hh1w==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "win32" - ], + "node_modules/@babel/plugin-transform-literals": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.25.9.tgz", + "integrity": "sha512-9N7+2lFziW8W9pBl2TzaNht3+pgMIRP74zizeCSrtnSKVdUl8mAjjOP2OOVQAfZ881P2cNjDj1uAMEdeD50nuQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.4.tgz", - "integrity": "sha512-ga676Hnvw7/ycdKB53qPusvsKdwrWzEyJ+AtItHGoARszIqvjffTwaaW3b2L6l90i7MO9i+dlAW415INuRhSGg==", - "cpu": [ - "ia32" - ], - "optional": true, - "os": [ - "win32" - ], + "node_modules/@babel/plugin-transform-logical-assignment-operators": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.25.9.tgz", + "integrity": "sha512-wI4wRAzGko551Y8eVf6iOY9EouIDTtPb0ByZx+ktDGHwv6bHFimrgJM/2T021txPZ2s4c7bqvHbd+vXG6K948Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@esbuild/win32-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.4.tgz", - "integrity": "sha512-HP0GDNla1T3ZL8Ko/SHAS2GgtjOg+VmWnnYLhuTksr++EnduYB0f3Y2LzHsUwb2iQ13JGoY6G3R8h6Du/WG6uA==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "win32" - ], + "node_modules/@babel/plugin-transform-member-expression-literals": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.25.9.tgz", + "integrity": "sha512-PYazBVfofCQkkMzh2P6IdIUaCEWni3iYEerAsRWuVd8+jlM1S9S9cz1dF9hIzyoZ8IA3+OwVYIp9v9e+GbgZhA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@eslint-community/eslint-utils": { - "version": "4.4.0", - "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", - "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", + "node_modules/@babel/plugin-transform-modules-amd": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.25.9.tgz", + "integrity": "sha512-g5T11tnI36jVClQlMlt4qKDLlWnG5pP9CSM4GhdRciTNMRgkfpo5cR6b4rGIOYPgRRuFAvwjPQ/Yk+ql4dyhbw==", "dev": true, + "license": "MIT", "dependencies": { - "eslint-visitor-keys": "^3.3.0" + "@babel/helper-module-transforms": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": ">=6.9.0" }, "peerDependencies": { - "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + "@babel/core": "^7.0.0-0" } }, - "node_modules/@eslint-community/regexpp": { - "version": "4.9.1", - "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.9.1.tgz", - "integrity": "sha512-Y27x+MBLjXa+0JWDhykM3+JE+il3kHKAEqabfEWq3SDhZjLYb6/BHL/JKFnH3fe207JaXkyDo685Oc2Glt6ifA==", - "dev": true, + "node_modules/@babel/plugin-transform-modules-commonjs": { + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.26.3.tgz", + "integrity": "sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.26.0", + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@eslint/eslintrc": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.2.tgz", - "integrity": "sha512-+wvgpDsrB1YqAMdEUCcnTlpfVBH7Vqn6A/NT3D8WVXFIaKMlErPIZT3oCIAVCOtarRpMtelZLqJeU3t7WY6X6g==", + "node_modules/@babel/plugin-transform-modules-systemjs": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.25.9.tgz", + "integrity": "sha512-hyss7iIlH/zLHaehT+xwiymtPOpsiwIIRlCAOwBB04ta5Tt+lNItADdlXw3jAWZ96VJ2jlhl/c+PNIQPKNfvcA==", "dev": true, + "license": "MIT", "dependencies": { - "ajv": "^6.12.4", - "debug": "^4.3.2", - "espree": "^9.6.0", - "globals": "^13.19.0", - "ignore": "^5.2.0", - "import-fresh": "^3.2.1", - "js-yaml": "^4.1.0", - "minimatch": "^3.1.2", - "strip-json-comments": "^3.1.1" + "@babel/helper-module-transforms": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-validator-identifier": "^7.25.9", + "@babel/traverse": "^7.25.9" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": ">=6.9.0" }, - "funding": { - "url": "https://opencollective.com/eslint" + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@eslint/eslintrc/node_modules/globals": { - "version": "13.22.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.22.0.tgz", - "integrity": "sha512-H1Ddc/PbZHTDVJSnj8kWptIRSD6AM3pK+mKytuIVF4uoBV7rshFlhhvA58ceJ5wp3Er58w6zj7bykMpYXt3ETw==", + "node_modules/@babel/plugin-transform-modules-umd": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.25.9.tgz", + "integrity": "sha512-bS9MVObUgE7ww36HEfwe6g9WakQ0KF07mQF74uuXdkoziUPfKyu/nIm663kz//e5O1nPInPFx36z7WJmJ4yNEw==", "dev": true, + "license": "MIT", "dependencies": { - "type-fest": "^0.20.2" + "@babel/helper-module-transforms": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">=8" + "node": ">=6.9.0" }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@eslint/eslintrc/node_modules/type-fest": { - "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", - "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.25.9.tgz", + "integrity": "sha512-oqB6WHdKTGl3q/ItQhpLSnWWOpjUJLsOCLVyeFgeTktkBSCiurvPOsyt93gibI9CmuKvTUEtWmG5VhZD+5T/KA==", "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=10" + "node": ">=6.9.0" }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "peerDependencies": { + "@babel/core": "^7.0.0" } }, - "node_modules/@eslint/js": { - "version": "8.50.0", - "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.50.0.tgz", - "integrity": "sha512-NCC3zz2+nvYd+Ckfh87rA47zfu2QsQpvc6k1yzTk+b9KzRj0wkGa8LSoGOXN6Zv4lRf/EIoZ80biDh9HOI+RNQ==", + "node_modules/@babel/plugin-transform-new-target": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.25.9.tgz", + "integrity": "sha512-U/3p8X1yCSoKyUj2eOBIx3FOn6pElFOKvAAGf8HTtItuPyB+ZeOqfn+mvTtg9ZlOAjsPdK3ayQEjqHjU/yLeVQ==", "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@humanwhocodes/config-array": { - "version": "0.11.11", - "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.11.tgz", - "integrity": "sha512-N2brEuAadi0CcdeMXUkhbZB84eskAc8MEX1By6qEchoVywSgXPIjou4rYsl0V3Hj0ZnuGycGCjdNgockbzeWNA==", + "node_modules/@babel/plugin-transform-nullish-coalescing-operator": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.25.9.tgz", + "integrity": "sha512-ENfftpLZw5EItALAD4WsY/KUWvhUlZndm5GC7G3evUsVeSJB6p0pBeLQUnRnBCBx7zV0RKQjR9kCuwrsIrjWog==", "dev": true, + "license": "MIT", "dependencies": { - "@humanwhocodes/object-schema": "^1.2.1", - "debug": "^4.1.1", - "minimatch": "^3.0.5" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">=10.10.0" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@humanwhocodes/module-importer": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", - "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "node_modules/@babel/plugin-transform-numeric-separator": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.25.9.tgz", + "integrity": "sha512-TlprrJ1GBZ3r6s96Yq8gEQv82s8/5HnCVHtEJScUj90thHQbwe+E5MLhi2bbNHBEJuzrvltXSru+BUxHDoog7Q==", "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">=12.22" + "node": ">=6.9.0" }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/nzakas" + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@humanwhocodes/object-schema": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", - "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", - "dev": true - }, - "node_modules/@jridgewell/gen-mapping": { - "version": "0.3.5", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz", - "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==", + "node_modules/@babel/plugin-transform-object-rest-spread": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.25.9.tgz", + "integrity": "sha512-fSaXafEE9CVHPweLYw4J0emp1t8zYTXyzN3UuG+lylqkvYd7RMrsOQ8TYx5RF231be0vqtFC6jnx3UmpJmKBYg==", + "dev": true, + "license": "MIT", "dependencies": { - "@jridgewell/set-array": "^1.2.1", - "@jridgewell/sourcemap-codec": "^1.4.10", - "@jridgewell/trace-mapping": "^0.3.24" + "@babel/helper-compilation-targets": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/plugin-transform-parameters": "^7.25.9" }, "engines": { - "node": ">=6.0.0" - } - }, - "node_modules/@jridgewell/resolve-uri": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", - "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", - "engines": { - "node": ">=6.0.0" - } - }, - "node_modules/@jridgewell/set-array": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", - "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", - "engines": { - "node": ">=6.0.0" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@jridgewell/sourcemap-codec": { - "version": "1.4.15", - "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", - "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==" - }, - "node_modules/@jridgewell/trace-mapping": { - "version": "0.3.25", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", - "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", + "node_modules/@babel/plugin-transform-object-super": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.25.9.tgz", + "integrity": "sha512-Kj/Gh+Rw2RNLbCK1VAWj2U48yxxqL2x0k10nPtSdRa0O2xnHXalD0s+o1A6a0W43gJ00ANo38jxkQreckOzv5A==", + "dev": true, + "license": "MIT", "dependencies": { - "@jridgewell/resolve-uri": "^3.1.0", - "@jridgewell/sourcemap-codec": "^1.4.14" + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-replace-supers": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@kixelated/moq": { - "resolved": "lib", - "link": true - }, - "node_modules/@mdx-js/mdx": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-2.3.0.tgz", - "integrity": "sha512-jLuwRlz8DQfQNiUCJR50Y09CGPq3fLtmtUQfVrj79E0JWu3dvsVcxVIcfhR5h0iXu+/z++zDrYeiJqifRynJkA==", + "node_modules/@babel/plugin-transform-optional-catch-binding": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.25.9.tgz", + "integrity": "sha512-qM/6m6hQZzDcZF3onzIhZeDHDO43bkNNlOX0i8n3lR6zLbu0GN2d8qfM/IERJZYauhAHSLHy39NF0Ctdvcid7g==", + "dev": true, + "license": "MIT", "dependencies": { - "@types/estree-jsx": "^1.0.0", - "@types/mdx": "^2.0.0", - "estree-util-build-jsx": "^2.0.0", - "estree-util-is-identifier-name": "^2.0.0", - "estree-util-to-js": "^1.1.0", - "estree-walker": "^3.0.0", - "hast-util-to-estree": "^2.0.0", - "markdown-extensions": "^1.0.0", - "periscopic": "^3.0.0", - "remark-mdx": "^2.0.0", - "remark-parse": "^10.0.0", - "remark-rehype": "^10.0.0", - "unified": "^10.0.0", - "unist-util-position-from-estree": "^1.0.0", - "unist-util-stringify-position": "^3.0.0", - "unist-util-visit": "^4.0.0", - "vfile": "^5.0.0" + "@babel/helper-plugin-utils": "^7.25.9" }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@nodelib/fs.scandir": { - "version": "2.1.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", - "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "node_modules/@babel/plugin-transform-optional-chaining": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.25.9.tgz", + "integrity": "sha512-6AvV0FsLULbpnXeBjrY4dmWF8F7gf8QnvTEoO/wX/5xm/xE1Xo8oPuD3MPS+KS9f9XBEAWN7X1aWr4z9HdOr7A==", + "dev": true, + "license": "MIT", "dependencies": { - "@nodelib/fs.stat": "2.0.5", - "run-parallel": "^1.1.9" + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9" }, "engines": { - "node": ">= 8" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@nodelib/fs.stat": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", - "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "node_modules/@babel/plugin-transform-parameters": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.25.9.tgz", + "integrity": "sha512-wzz6MKwpnshBAiRmn4jR8LYz/g8Ksg0o80XmwZDlordjwEk9SxBzTWC7F5ef1jhbrbOW2DJ5J6ayRukrJmnr0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">= 8" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@nodelib/fs.walk": { - "version": "1.2.8", - "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", - "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "node_modules/@babel/plugin-transform-private-methods": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.25.9.tgz", + "integrity": "sha512-D/JUozNpQLAPUVusvqMxyvjzllRaF8/nSrP1s2YGQT/W4LHK4xxsMcHjhOGTS01mp9Hda8nswb+FblLdJornQw==", + "dev": true, + "license": "MIT", "dependencies": { - "@nodelib/fs.scandir": "2.1.5", - "fastq": "^1.6.0" + "@babel/helper-create-class-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">= 8" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/auth-token": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-3.0.4.tgz", - "integrity": "sha512-TWFX7cZF2LXoCvdmJWY7XVPi74aSY0+FfBZNSXEXFkMpjcqsQwDSYVv5FhRFaI0V1ECnwbz4j59T/G+rXNWaIQ==", + "node_modules/@babel/plugin-transform-private-property-in-object": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.25.9.tgz", + "integrity": "sha512-Evf3kcMqzXA3xfYJmZ9Pg1OvKdtqsDMSWBDzZOPLvHiTt36E75jLDQo5w1gtRU95Q4E5PDttrTf25Fw8d/uWLw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.25.9", + "@babel/helper-create-class-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/core": { - "version": "4.2.4", - "resolved": "https://registry.npmjs.org/@octokit/core/-/core-4.2.4.tgz", - "integrity": "sha512-rYKilwgzQ7/imScn3M9/pFfUf4I1AZEH3KhyJmtPdE2zfaXAn2mFfUy4FbKewzc2We5y/LlKLj36fWJLKC2SIQ==", + "node_modules/@babel/plugin-transform-property-literals": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.25.9.tgz", + "integrity": "sha512-IvIUeV5KrS/VPavfSM/Iu+RE6llrHrYIKY1yfCzyO/lMXHQ+p7uGhonmGVisv6tSBSVgWzMBohTcvkC9vQcQFA==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/auth-token": "^3.0.0", - "@octokit/graphql": "^5.0.0", - "@octokit/request": "^6.0.0", - "@octokit/request-error": "^3.0.0", - "@octokit/types": "^9.0.0", - "before-after-hook": "^2.2.0", - "universal-user-agent": "^6.0.0" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/endpoint": { - "version": "7.0.6", - "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-7.0.6.tgz", - "integrity": "sha512-5L4fseVRUsDFGR00tMWD/Trdeeihn999rTMGRMC1G/Ldi1uWlWJzI98H4Iak5DB/RVvQuyMYKqSK/R6mbSOQyg==", + "node_modules/@babel/plugin-transform-react-jsx": { + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.22.15.tgz", + "integrity": "sha512-oKckg2eZFa8771O/5vi7XeTvmM6+O9cxZu+kanTU7tD4sin5nO/G8jGJhq8Hvt2Z0kUoEDRayuZLaUlYl8QuGA==", "dependencies": { - "@octokit/types": "^9.0.0", - "is-plain-object": "^5.0.0", - "universal-user-agent": "^6.0.0" + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-jsx": "^7.22.5", + "@babel/types": "^7.22.15" }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/graphql": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-5.0.6.tgz", - "integrity": "sha512-Fxyxdy/JH0MnIB5h+UQ3yCoh1FG4kWXfFKkpWqjZHw/p+Kc8Y44Hu/kCgNBT6nU1shNumEchmW/sUO1JuQnPcw==", + "node_modules/@babel/plugin-transform-regenerator": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.25.9.tgz", + "integrity": "sha512-vwDcDNsgMPDGP0nMqzahDWE5/MLcX8sv96+wfX7as7LoF/kr97Bo/7fI00lXY4wUXYfVmwIIyG80fGZ1uvt2qg==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/request": "^6.0.0", - "@octokit/types": "^9.0.0", - "universal-user-agent": "^6.0.0" + "@babel/helper-plugin-utils": "^7.25.9", + "regenerator-transform": "^0.15.2" }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/openapi-types": { - "version": "18.1.1", - "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-18.1.1.tgz", - "integrity": "sha512-VRaeH8nCDtF5aXWnjPuEMIYf1itK/s3JYyJcWFJT8X9pSNnBtriDf7wlEWsGuhPLl4QIH4xM8fqTXDwJ3Mu6sw==" - }, - "node_modules/@octokit/plugin-paginate-rest": { - "version": "6.1.2", - "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-6.1.2.tgz", - "integrity": "sha512-qhrmtQeHU/IivxucOV1bbI/xZyC/iOBhclokv7Sut5vnejAIAEXVcGQeRpQlU39E0WwK9lNvJHphHri/DB6lbQ==", + "node_modules/@babel/plugin-transform-regexp-modifiers": { + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.26.0.tgz", + "integrity": "sha512-vN6saax7lrA2yA/Pak3sCxuD6F5InBjn9IcrIKQPjpsLvuHYLVroTxjdlVRHjjBWxKOqIwpTXDkOssYT4BFdRw==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/tsconfig": "^1.0.2", - "@octokit/types": "^9.2.3" + "@babel/helper-create-regexp-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" }, "peerDependencies": { - "@octokit/core": ">=4" + "@babel/core": "^7.0.0" } }, - "node_modules/@octokit/plugin-request-log": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz", - "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA==", + "node_modules/@babel/plugin-transform-reserved-words": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.25.9.tgz", + "integrity": "sha512-7DL7DKYjn5Su++4RXu8puKZm2XBPHyjWLUidaPEkCUBbE7IPcsrkRHggAOOKydH1dASWdcUBxrkOGNxUv5P3Jg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { - "@octokit/core": ">=3" + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/plugin-rest-endpoint-methods": { - "version": "7.2.3", - "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-7.2.3.tgz", - "integrity": "sha512-I5Gml6kTAkzVlN7KCtjOM+Ruwe/rQppp0QU372K1GP7kNOYEKe8Xn5BW4sE62JAHdwpq95OQK/qGNyKQMUzVgA==", + "node_modules/@babel/plugin-transform-shorthand-properties": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.25.9.tgz", + "integrity": "sha512-MUv6t0FhO5qHnS/W8XCbHmiRWOphNufpE1IVxhK5kuN3Td9FT1x4rx4K42s3RYdMXCXpfWkGSbCSd0Z64xA7Ng==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/types": "^10.0.0" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" }, "peerDependencies": { - "@octokit/core": ">=3" + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/types": { - "version": "10.0.0", - "resolved": "https://registry.npmjs.org/@octokit/types/-/types-10.0.0.tgz", - "integrity": "sha512-Vm8IddVmhCgU1fxC1eyinpwqzXPEYu0NrYzD3YZjlGjyftdLBTeqNblRC0jmJmgxbJIsQlyogVeGnrNaaMVzIg==", + "node_modules/@babel/plugin-transform-spread": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.25.9.tgz", + "integrity": "sha512-oNknIB0TbURU5pqJFVbOOFspVlrpVwo2H1+HUIsVDvp5VauGGDP1ZEvO8Nn5xyMEs3dakajOxlmkNW7kNgSm6A==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/openapi-types": "^18.0.0" + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/request": { - "version": "6.2.8", - "resolved": "https://registry.npmjs.org/@octokit/request/-/request-6.2.8.tgz", - "integrity": "sha512-ow4+pkVQ+6XVVsekSYBzJC0VTVvh/FCTUUgTsboGq+DTeWdyIFV8WSCdo0RIxk6wSkBTHqIK1mYuY7nOBXOchw==", + "node_modules/@babel/plugin-transform-sticky-regex": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.25.9.tgz", + "integrity": "sha512-WqBUSgeVwucYDP9U/xNRQam7xV8W5Zf+6Eo7T2SRVUFlhRiMNFdFz58u0KZmCVVqs2i7SHgpRnAhzRNmKfi2uA==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/endpoint": "^7.0.0", - "@octokit/request-error": "^3.0.0", - "@octokit/types": "^9.0.0", - "is-plain-object": "^5.0.0", - "node-fetch": "^2.6.7", - "universal-user-agent": "^6.0.0" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/request-error": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-3.0.3.tgz", - "integrity": "sha512-crqw3V5Iy2uOU5Np+8M/YexTlT8zxCfI+qu+LxUB7SZpje4Qmx3mub5DfEKSO8Ylyk0aogi6TYdf6kxzh2BguQ==", + "node_modules/@babel/plugin-transform-template-literals": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.25.9.tgz", + "integrity": "sha512-o97AE4syN71M/lxrCtQByzphAdlYluKPDBzDVzMmfCobUjjhAryZV0AIpRPrxN0eAkxXO6ZLEScmt+PNhj2OTw==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/types": "^9.0.0", - "deprecation": "^2.0.0", - "once": "^1.4.0" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/rest": { - "version": "19.0.13", - "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-19.0.13.tgz", - "integrity": "sha512-/EzVox5V9gYGdbAI+ovYj3nXQT1TtTHRT+0eZPcuC05UFSWO3mdO9UY1C0i2eLF9Un1ONJkAk+IEtYGAC+TahA==", + "node_modules/@babel/plugin-transform-typeof-symbol": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.25.9.tgz", + "integrity": "sha512-v61XqUMiueJROUv66BVIOi0Fv/CUuZuZMl5NkRoCVxLAnMexZ0A3kMe7vvZ0nulxMuMp0Mk6S5hNh48yki08ZA==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/core": "^4.2.1", - "@octokit/plugin-paginate-rest": "^6.1.2", - "@octokit/plugin-request-log": "^1.0.4", - "@octokit/plugin-rest-endpoint-methods": "^7.1.2" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": ">= 14" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@octokit/tsconfig": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@octokit/tsconfig/-/tsconfig-1.0.2.tgz", - "integrity": "sha512-I0vDR0rdtP8p2lGMzvsJzbhdOWy405HcGovrspJ8RRibHnyRgggUSNO5AIox5LmqiwmatHKYsvj6VGFHkqS7lA==" - }, - "node_modules/@octokit/types": { - "version": "9.3.2", - "resolved": "https://registry.npmjs.org/@octokit/types/-/types-9.3.2.tgz", - "integrity": "sha512-D4iHGTdAnEEVsB8fl95m1hiz7D5YiRdQ9b/OEb3BYRVwbLsGHcRVPz+u+BgRLNk0Q0/4iZCBqDN96j2XNxfXrA==", + "node_modules/@babel/plugin-transform-typescript": { + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.26.3.tgz", + "integrity": "sha512-6+5hpdr6mETwSKjmJUdYw0EIkATiQhnELWlE3kJFBwSg/BGIVwVaVbX+gOXBCdc7Ln1RXZxyWGecIXhUfnl7oA==", + "license": "MIT", "dependencies": { - "@octokit/openapi-types": "^18.0.0" + "@babel/helper-annotate-as-pure": "^7.25.9", + "@babel/helper-create-class-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9", + "@babel/plugin-syntax-typescript": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@pkgr/utils": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/@pkgr/utils/-/utils-2.4.2.tgz", - "integrity": "sha512-POgTXhjrTfbTV63DiFXav4lBHiICLKKwDeaKn9Nphwj7WH6m0hMMCaJkMyRWjgtPFyRKRVoMXXjczsTQRDEhYw==", + "node_modules/@babel/plugin-transform-unicode-escapes": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.25.9.tgz", + "integrity": "sha512-s5EDrE6bW97LtxOcGj1Khcx5AaXwiMmi4toFWRDP9/y0Woo6pXC+iyPu/KuhKtfSrNFd7jJB+/fkOtZy6aIC6Q==", "dev": true, + "license": "MIT", "dependencies": { - "cross-spawn": "^7.0.3", - "fast-glob": "^3.3.0", - "is-glob": "^4.0.3", - "open": "^9.1.0", - "picocolors": "^1.0.0", - "tslib": "^2.6.0" + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { - "node": "^12.20.0 || ^14.18.0 || >=16.0.0" + "node": ">=6.9.0" }, - "funding": { - "url": "https://opencollective.com/unts" + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@tailwindcss/forms": { - "version": "0.5.6", - "resolved": "https://registry.npmjs.org/@tailwindcss/forms/-/forms-0.5.6.tgz", - "integrity": "sha512-Fw+2BJ0tmAwK/w01tEFL5TiaJBX1NLT1/YbWgvm7ws3Qcn11kiXxzNTEQDMs5V3mQemhB56l3u0i9dwdzSQldA==", + "node_modules/@babel/plugin-transform-unicode-property-regex": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.25.9.tgz", + "integrity": "sha512-Jt2d8Ga+QwRluxRQ307Vlxa6dMrYEMZCgGxoPR8V52rxPyldHu3hdlHspxaqYmE7oID5+kB+UKUB/eWS+DkkWg==", + "dev": true, + "license": "MIT", "dependencies": { - "mini-svg-data-uri": "^1.2.3" + "@babel/helper-create-regexp-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { - "tailwindcss": ">=3.0.0 || >= 3.0.0-alpha.1" + "@babel/core": "^7.0.0-0" } }, - "node_modules/@tailwindcss/typography": { - "version": "0.5.10", - "resolved": "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.10.tgz", - "integrity": "sha512-Pe8BuPJQJd3FfRnm6H0ulKIGoMEQS+Vq01R6M5aCrFB/ccR/shT+0kXLjouGC1gFLm9hopTFN+DMP0pfwRWzPw==", + "node_modules/@babel/plugin-transform-unicode-regex": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.25.9.tgz", + "integrity": "sha512-yoxstj7Rg9dlNn9UQxzk4fcNivwv4nUYz7fYXBaKxvw/lnmPuOm/ikoELygbYq68Bls3D/D+NBPHiLwZdZZ4HA==", + "dev": true, + "license": "MIT", "dependencies": { - "lodash.castarray": "^4.4.0", - "lodash.isplainobject": "^4.0.6", - "lodash.merge": "^4.6.2", - "postcss-selector-parser": "6.0.10" + "@babel/helper-create-regexp-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { - "tailwindcss": ">=3.0.0 || insiders" + "@babel/core": "^7.0.0-0" } }, - "node_modules/@types/acorn": { - "version": "4.0.6", - "resolved": "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz", - "integrity": "sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==", + "node_modules/@babel/plugin-transform-unicode-sets-regex": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.25.9.tgz", + "integrity": "sha512-8BYqO3GeVNHtx69fdPshN3fnzUNLrWdHhk/icSwigksJGczKSizZ+Z6SBCxTs723Fr5VSNorTIK7a+R2tISvwQ==", + "dev": true, + "license": "MIT", "dependencies": { - "@types/estree": "*" + "@babel/helper-create-regexp-features-plugin": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" } }, - "node_modules/@types/audioworklet": { - "version": "0.0.50", - "resolved": "https://registry.npmjs.org/@types/audioworklet/-/audioworklet-0.0.50.tgz", - "integrity": "sha512-Wic6k+tczhJZz4yq2ianEowIF/xH10wI9ac8sBDh27Jvs+WIvXIeM+nWPPRITFwSKuLZKlvVjfLiNmUjfy4koA==", - "dev": true - }, - "node_modules/@types/babel__core": { - "version": "7.20.2", - "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.2.tgz", - "integrity": "sha512-pNpr1T1xLUc2l3xJKuPtsEky3ybxN3m4fJkknfIpTCTfIZCDW57oAg+EfCgIIp2rvCe0Wn++/FfodDS4YXxBwA==", - "dependencies": { - "@babel/parser": "^7.20.7", - "@babel/types": "^7.20.7", - "@types/babel__generator": "*", - "@types/babel__template": "*", - "@types/babel__traverse": "*" + "node_modules/@babel/preset-env": { + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.26.0.tgz", + "integrity": "sha512-H84Fxq0CQJNdPFT2DrfnylZ3cf5K43rGfWK4LJGPpjKHiZlk0/RzwEus3PDDZZg+/Er7lCA03MVacueUuXdzfw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.26.0", + "@babel/helper-compilation-targets": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-validator-option": "^7.25.9", + "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.25.9", + "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.25.9", + "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.25.9", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.25.9", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.25.9", + "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2", + "@babel/plugin-syntax-import-assertions": "^7.26.0", + "@babel/plugin-syntax-import-attributes": "^7.26.0", + "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6", + "@babel/plugin-transform-arrow-functions": "^7.25.9", + "@babel/plugin-transform-async-generator-functions": "^7.25.9", + "@babel/plugin-transform-async-to-generator": "^7.25.9", + "@babel/plugin-transform-block-scoped-functions": "^7.25.9", + "@babel/plugin-transform-block-scoping": "^7.25.9", + "@babel/plugin-transform-class-properties": "^7.25.9", + "@babel/plugin-transform-class-static-block": "^7.26.0", + "@babel/plugin-transform-classes": "^7.25.9", + "@babel/plugin-transform-computed-properties": "^7.25.9", + "@babel/plugin-transform-destructuring": "^7.25.9", + "@babel/plugin-transform-dotall-regex": "^7.25.9", + "@babel/plugin-transform-duplicate-keys": "^7.25.9", + "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.25.9", + "@babel/plugin-transform-dynamic-import": "^7.25.9", + "@babel/plugin-transform-exponentiation-operator": "^7.25.9", + "@babel/plugin-transform-export-namespace-from": "^7.25.9", + "@babel/plugin-transform-for-of": "^7.25.9", + "@babel/plugin-transform-function-name": "^7.25.9", + "@babel/plugin-transform-json-strings": "^7.25.9", + "@babel/plugin-transform-literals": "^7.25.9", + "@babel/plugin-transform-logical-assignment-operators": "^7.25.9", + "@babel/plugin-transform-member-expression-literals": "^7.25.9", + "@babel/plugin-transform-modules-amd": "^7.25.9", + "@babel/plugin-transform-modules-commonjs": "^7.25.9", + "@babel/plugin-transform-modules-systemjs": "^7.25.9", + "@babel/plugin-transform-modules-umd": "^7.25.9", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.25.9", + "@babel/plugin-transform-new-target": "^7.25.9", + "@babel/plugin-transform-nullish-coalescing-operator": "^7.25.9", + "@babel/plugin-transform-numeric-separator": "^7.25.9", + "@babel/plugin-transform-object-rest-spread": "^7.25.9", + "@babel/plugin-transform-object-super": "^7.25.9", + "@babel/plugin-transform-optional-catch-binding": "^7.25.9", + "@babel/plugin-transform-optional-chaining": "^7.25.9", + "@babel/plugin-transform-parameters": "^7.25.9", + "@babel/plugin-transform-private-methods": "^7.25.9", + "@babel/plugin-transform-private-property-in-object": "^7.25.9", + "@babel/plugin-transform-property-literals": "^7.25.9", + "@babel/plugin-transform-regenerator": "^7.25.9", + "@babel/plugin-transform-regexp-modifiers": "^7.26.0", + "@babel/plugin-transform-reserved-words": "^7.25.9", + "@babel/plugin-transform-shorthand-properties": "^7.25.9", + "@babel/plugin-transform-spread": "^7.25.9", + "@babel/plugin-transform-sticky-regex": "^7.25.9", + "@babel/plugin-transform-template-literals": "^7.25.9", + "@babel/plugin-transform-typeof-symbol": "^7.25.9", + "@babel/plugin-transform-unicode-escapes": "^7.25.9", + "@babel/plugin-transform-unicode-property-regex": "^7.25.9", + "@babel/plugin-transform-unicode-regex": "^7.25.9", + "@babel/plugin-transform-unicode-sets-regex": "^7.25.9", + "@babel/preset-modules": "0.1.6-no-external-plugins", + "babel-plugin-polyfill-corejs2": "^0.4.10", + "babel-plugin-polyfill-corejs3": "^0.10.6", + "babel-plugin-polyfill-regenerator": "^0.6.1", + "core-js-compat": "^3.38.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@types/babel__generator": { - "version": "7.6.5", - "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.5.tgz", - "integrity": "sha512-h9yIuWbJKdOPLJTbmSpPzkF67e659PbQDba7ifWm5BJ8xTv+sDmS7rFmywkWOvXedGTivCdeGSIIX8WLcRTz8w==", - "dependencies": { - "@babel/types": "^7.0.0" + "node_modules/@babel/preset-env/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" } }, - "node_modules/@types/babel__template": { - "version": "7.4.2", - "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.2.tgz", - "integrity": "sha512-/AVzPICMhMOMYoSx9MoKpGDKdBRsIXMNByh1PXSZoa+v6ZoLa8xxtsT/uLQ/NJm0XVAWl/BvId4MlDeXJaeIZQ==", + "node_modules/@babel/preset-modules": { + "version": "0.1.6-no-external-plugins", + "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz", + "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==", + "dev": true, + "license": "MIT", "dependencies": { - "@babel/parser": "^7.1.0", - "@babel/types": "^7.0.0" + "@babel/helper-plugin-utils": "^7.0.0", + "@babel/types": "^7.4.4", + "esutils": "^2.0.2" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0" } }, - "node_modules/@types/babel__traverse": { - "version": "7.20.2", - "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.2.tgz", - "integrity": "sha512-ojlGK1Hsfce93J0+kn3H5R73elidKUaZonirN33GSmgTUMpzI/MIFfSpF3haANe3G1bEBS9/9/QEqwTzwqFsKw==", + "node_modules/@babel/preset-typescript": { + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.26.0.tgz", + "integrity": "sha512-NMk1IGZ5I/oHhoXEElcm+xUnL/szL6xflkFZmoEU9xj1qSJXpiS7rsspYo92B4DRCDvZn2erT5LdsCeXAKNCkg==", + "license": "MIT", "dependencies": { - "@babel/types": "^7.20.7" + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/helper-validator-option": "^7.25.9", + "@babel/plugin-syntax-jsx": "^7.25.9", + "@babel/plugin-transform-modules-commonjs": "^7.25.9", + "@babel/plugin-transform-typescript": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" } }, - "node_modules/@types/debug": { - "version": "4.1.9", - "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.9.tgz", - "integrity": "sha512-8Hz50m2eoS56ldRlepxSBa6PWEVCtzUo/92HgLc2qTMnotJNIm7xP+UZhyWoYsyOdd5dxZ+NZLb24rsKyFs2ow==", + "node_modules/@babel/runtime": { + "version": "7.23.1", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.23.1.tgz", + "integrity": "sha512-hC2v6p8ZSI/W0HUzh3V8C5g+NwSKzKPtJwSpTjwl0o297GP9+ZLQSkdvHz46CM3LqyoXxq+5G9komY+eSqSO0g==", + "dev": true, "dependencies": { - "@types/ms": "*" + "regenerator-runtime": "^0.14.0" + }, + "engines": { + "node": ">=6.9.0" } }, - "node_modules/@types/dom-mediacapture-transform": { - "version": "0.1.7", - "resolved": "https://registry.npmjs.org/@types/dom-mediacapture-transform/-/dom-mediacapture-transform-0.1.7.tgz", - "integrity": "sha512-xrFtEIDCn+VeMEYm4JdjLEOeho3dsTxOxx4hDqCA0WRrENF4DMTF9JaTzTRUVc5rI58j9nRTxIZlU1Wqfr08PA==", - "dev": true, + "node_modules/@babel/template": { + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.25.9.tgz", + "integrity": "sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==", + "license": "MIT", "dependencies": { - "@types/dom-webcodecs": "*" + "@babel/code-frame": "^7.25.9", + "@babel/parser": "^7.25.9", + "@babel/types": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" } }, - "node_modules/@types/dom-webcodecs": { - "version": "0.1.8", - "resolved": "https://registry.npmjs.org/@types/dom-webcodecs/-/dom-webcodecs-0.1.8.tgz", - "integrity": "sha512-KThTPaGQJLITk8Q0XkEkz+GqFdoWDyQfbyeJmfEUagB15TZQdNx5AqP2b7GP6vkVM6X/6T1Z8EHxA8RgHfY9BA==" - }, - "node_modules/@types/estree": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.2.tgz", - "integrity": "sha512-VeiPZ9MMwXjO32/Xu7+OwflfmeoRwkE/qzndw42gGtgJwZopBnzy2gD//NN1+go1mADzkDcqf/KnFRSjTJ8xJA==" - }, - "node_modules/@types/estree-jsx": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.1.tgz", - "integrity": "sha512-sHyakZlAezNFxmYRo0fopDZW+XvK6ipeZkkp5EAOLjdPfZp8VjZBJ67vSRI99RSCAoqXVmXOHS4fnWoxpuGQtQ==", - "dependencies": { - "@types/estree": "*" + "node_modules/@babel/traverse": { + "version": "7.26.4", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.26.4.tgz", + "integrity": "sha512-fH+b7Y4p3yqvApJALCPJcwb0/XaOSgtK4pzV6WVjPR5GLFQBRI7pfoX2V2iM48NXvX07NUxxm1Vw98YjqTcU5w==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.26.2", + "@babel/generator": "^7.26.3", + "@babel/parser": "^7.26.3", + "@babel/template": "^7.25.9", + "@babel/types": "^7.26.3", + "debug": "^4.3.1", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" } }, - "node_modules/@types/hast": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.6.tgz", - "integrity": "sha512-47rJE80oqPmFdVDCD7IheXBrVdwuBgsYwoczFvKmwfo2Mzsnt+V9OONsYauFmICb6lQPpCuXYJWejBNs4pDJRg==", + "node_modules/@babel/types": { + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz", + "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==", + "license": "MIT", "dependencies": { - "@types/unist": "^2" + "@babel/helper-string-parser": "^7.25.9", + "@babel/helper-validator-identifier": "^7.25.9" + }, + "engines": { + "node": ">=6.9.0" } }, - "node_modules/@types/json-schema": { - "version": "7.0.13", - "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.13.tgz", - "integrity": "sha512-RbSSoHliUbnXj3ny0CNFOoxrIDV6SUGyStHsvDqosw6CkdPV8TtWGlfecuK4ToyMEAql6pzNxgCFKanovUzlgQ==", - "dev": true - }, - "node_modules/@types/mdast": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.1.tgz", - "integrity": "sha512-IlKct1rUTJ1T81d8OHzyop15kGv9A/ff7Gz7IJgrk6jDb4Udw77pCJ+vq8oxZf4Ghpm+616+i1s/LNg/Vh7d+g==", - "dependencies": { - "@types/unist": "*" - } - }, - "node_modules/@types/mdx": { - "version": "2.0.8", - "resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.8.tgz", - "integrity": "sha512-r7/zWe+f9x+zjXqGxf821qz++ld8tp6Z4jUS6qmPZUXH6tfh4riXOhAqb12tWGWAevCFtMt1goLWkQMqIJKpsA==" - }, - "node_modules/@types/ms": { - "version": "0.7.32", - "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.32.tgz", - "integrity": "sha512-xPSg0jm4mqgEkNhowKgZFBNtwoEwF6gJ4Dhww+GFpm3IgtNseHQZ5IqdNwnquZEoANxyDAKDRAdVo4Z72VvD/g==" - }, - "node_modules/@types/nlcst": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@types/nlcst/-/nlcst-1.0.2.tgz", - "integrity": "sha512-ykxL/GDDUhqikjU0LIywZvEwb1NTYXTEWf+XgMSS2o6IXIakafPccxZmxgZcvJPZ3yFl2kdL1gJZz3U3iZF3QA==", - "dependencies": { - "@types/unist": "^2" + "node_modules/@esbuild/linux-x64": { + "version": "0.19.4", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.4.tgz", + "integrity": "sha512-Mi4aNA3rz1BNFtB7aGadMD0MavmzuuXNTaYL6/uiYIs08U7YMPETpgNn5oue3ICr+inKwItOwSsJDYkrE9ekVg==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" } }, - "node_modules/@types/parse5": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/@types/parse5/-/parse5-6.0.3.tgz", - "integrity": "sha512-SuT16Q1K51EAVPz1K29DJ/sXjhSQ0zjvsypYJ6tlwVsRV9jwW5Adq2ch8Dq8kDBCkYnELS7N7VNCSB5nC56t/g==" - }, - "node_modules/@types/semver": { - "version": "7.5.3", - "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.3.tgz", - "integrity": "sha512-OxepLK9EuNEIPxWNME+C6WwbRAOOI2o2BaQEGzz5Lu2e4Z5eDnEo+/aVEDMIXywoJitJ7xWd641wrGLZdtwRyw==", - "dev": true - }, - "node_modules/@types/unist": { - "version": "2.0.8", - "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.8.tgz", - "integrity": "sha512-d0XxK3YTObnWVp6rZuev3c49+j4Lo8g4L1ZRm9z5L0xpoZycUPshHgczK5gsUMaZOstjVYYi09p5gYvUtfChYw==" - }, - "node_modules/@typescript-eslint/eslint-plugin": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.7.4.tgz", - "integrity": "sha512-DAbgDXwtX+pDkAHwiGhqP3zWUGpW49B7eqmgpPtg+BKJXwdct79ut9+ifqOFPJGClGKSHXn2PTBatCnldJRUoA==", + "node_modules/@eslint-community/eslint-utils": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", + "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", "dev": true, "dependencies": { - "@eslint-community/regexpp": "^4.5.1", - "@typescript-eslint/scope-manager": "6.7.4", - "@typescript-eslint/type-utils": "6.7.4", - "@typescript-eslint/utils": "6.7.4", - "@typescript-eslint/visitor-keys": "6.7.4", - "debug": "^4.3.4", - "graphemer": "^1.4.0", - "ignore": "^5.2.4", - "natural-compare": "^1.4.0", - "semver": "^7.5.4", - "ts-api-utils": "^1.0.1" + "eslint-visitor-keys": "^3.3.0" }, "engines": { - "node": "^16.0.0 || >=18.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, "peerDependencies": { - "@typescript-eslint/parser": "^6.0.0 || ^6.0.0-alpha", - "eslint": "^7.0.0 || ^8.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, - "node_modules/@typescript-eslint/parser": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.7.4.tgz", - "integrity": "sha512-I5zVZFY+cw4IMZUeNCU7Sh2PO5O57F7Lr0uyhgCJmhN/BuTlnc55KxPonR4+EM3GBdfiCyGZye6DgMjtubQkmA==", + "node_modules/@eslint-community/regexpp": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.9.1.tgz", + "integrity": "sha512-Y27x+MBLjXa+0JWDhykM3+JE+il3kHKAEqabfEWq3SDhZjLYb6/BHL/JKFnH3fe207JaXkyDo685Oc2Glt6ifA==", "dev": true, - "dependencies": { - "@typescript-eslint/scope-manager": "6.7.4", - "@typescript-eslint/types": "6.7.4", - "@typescript-eslint/typescript-estree": "6.7.4", - "@typescript-eslint/visitor-keys": "6.7.4", - "debug": "^4.3.4" - }, "engines": { - "node": "^16.0.0 || >=18.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" - }, - "peerDependencies": { - "eslint": "^7.0.0 || ^8.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" } }, - "node_modules/@typescript-eslint/scope-manager": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.7.4.tgz", - "integrity": "sha512-SdGqSLUPTXAXi7c3Ob7peAGVnmMoGzZ361VswK2Mqf8UOYcODiYvs8rs5ILqEdfvX1lE7wEZbLyELCW+Yrql1A==", + "node_modules/@eslint/eslintrc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.2.tgz", + "integrity": "sha512-+wvgpDsrB1YqAMdEUCcnTlpfVBH7Vqn6A/NT3D8WVXFIaKMlErPIZT3oCIAVCOtarRpMtelZLqJeU3t7WY6X6g==", "dev": true, "dependencies": { - "@typescript-eslint/types": "6.7.4", - "@typescript-eslint/visitor-keys": "6.7.4" + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.6.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" }, "engines": { - "node": "^16.0.0 || >=18.0.0" + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" + "url": "https://opencollective.com/eslint" } }, - "node_modules/@typescript-eslint/type-utils": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.7.4.tgz", - "integrity": "sha512-n+g3zi1QzpcAdHFP9KQF+rEFxMb2KxtnJGID3teA/nxKHOVi3ylKovaqEzGBbVY2pBttU6z85gp0D00ufLzViQ==", + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "13.22.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.22.0.tgz", + "integrity": "sha512-H1Ddc/PbZHTDVJSnj8kWptIRSD6AM3pK+mKytuIVF4uoBV7rshFlhhvA58ceJ5wp3Er58w6zj7bykMpYXt3ETw==", "dev": true, "dependencies": { - "@typescript-eslint/typescript-estree": "6.7.4", - "@typescript-eslint/utils": "6.7.4", - "debug": "^4.3.4", - "ts-api-utils": "^1.0.1" + "type-fest": "^0.20.2" }, "engines": { - "node": "^16.0.0 || >=18.0.0" + "node": ">=8" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" - }, - "peerDependencies": { - "eslint": "^7.0.0 || ^8.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/@typescript-eslint/types": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.7.4.tgz", - "integrity": "sha512-o9XWK2FLW6eSS/0r/tgjAGsYasLAnOWg7hvZ/dGYSSNjCh+49k5ocPN8OmG5aZcSJ8pclSOyVKP2x03Sj+RrCA==", + "node_modules/@eslint/eslintrc/node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", "dev": true, "engines": { - "node": "^16.0.0 || >=18.0.0" + "node": ">=10" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/@typescript-eslint/typescript-estree": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.7.4.tgz", - "integrity": "sha512-ty8b5qHKatlNYd9vmpHooQz3Vki3gG+3PchmtsA4TgrZBKWHNjWfkQid7K7xQogBqqc7/BhGazxMD5vr6Ha+iQ==", + "node_modules/@eslint/js": { + "version": "8.50.0", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.50.0.tgz", + "integrity": "sha512-NCC3zz2+nvYd+Ckfh87rA47zfu2QsQpvc6k1yzTk+b9KzRj0wkGa8LSoGOXN6Zv4lRf/EIoZ80biDh9HOI+RNQ==", "dev": true, - "dependencies": { - "@typescript-eslint/types": "6.7.4", - "@typescript-eslint/visitor-keys": "6.7.4", - "debug": "^4.3.4", - "globby": "^11.1.0", - "is-glob": "^4.0.3", - "semver": "^7.5.4", - "ts-api-utils": "^1.0.1" - }, "engines": { - "node": "^16.0.0 || >=18.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" } }, - "node_modules/@typescript-eslint/utils": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.7.4.tgz", - "integrity": "sha512-PRQAs+HUn85Qdk+khAxsVV+oULy3VkbH3hQ8hxLRJXWBEd7iI+GbQxH5SEUSH7kbEoTp6oT1bOwyga24ELALTA==", + "node_modules/@humanwhocodes/config-array": { + "version": "0.11.11", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.11.tgz", + "integrity": "sha512-N2brEuAadi0CcdeMXUkhbZB84eskAc8MEX1By6qEchoVywSgXPIjou4rYsl0V3Hj0ZnuGycGCjdNgockbzeWNA==", "dev": true, "dependencies": { - "@eslint-community/eslint-utils": "^4.4.0", - "@types/json-schema": "^7.0.12", - "@types/semver": "^7.5.0", - "@typescript-eslint/scope-manager": "6.7.4", - "@typescript-eslint/types": "6.7.4", - "@typescript-eslint/typescript-estree": "6.7.4", - "semver": "^7.5.4" + "@humanwhocodes/object-schema": "^1.2.1", + "debug": "^4.1.1", + "minimatch": "^3.0.5" }, "engines": { - "node": "^16.0.0 || >=18.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" - }, - "peerDependencies": { - "eslint": "^7.0.0 || ^8.0.0" + "node": ">=10.10.0" } }, - "node_modules/@typescript-eslint/visitor-keys": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.7.4.tgz", - "integrity": "sha512-pOW37DUhlTZbvph50x5zZCkFn3xzwkGtNoJHzIM3svpiSkJzwOYr/kVBaXmf+RAQiUDs1AHEZVNPg6UJCJpwRA==", + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", "dev": true, - "dependencies": { - "@typescript-eslint/types": "6.7.4", - "eslint-visitor-keys": "^3.4.1" - }, "engines": { - "node": "^16.0.0 || >=18.0.0" + "node": ">=12.22" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" + "type": "github", + "url": "https://github.com/sponsors/nzakas" } }, - "node_modules/@typescript/lib-dom": { - "name": "@types/web", - "version": "0.0.115", - "resolved": "https://registry.npmjs.org/@types/web/-/web-0.0.115.tgz", - "integrity": "sha512-IBtUgtxnITC7WTCg4tv6kCnSP0T+fM+3PzQPIzLzJY1DDlhBFKM/9+uMURw14YweWPDiFNIZ94Gc1bJtwow97g==", + "node_modules/@humanwhocodes/object-schema": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", + "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", "dev": true }, - "node_modules/@ungap/structured-clone": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz", - "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==" - }, - "node_modules/acorn": { - "version": "8.10.0", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.10.0.tgz", - "integrity": "sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==", - "bin": { - "acorn": "bin/acorn" - }, - "engines": { - "node": ">=0.4.0" - } - }, - "node_modules/acorn-jsx": { - "version": "5.3.2", - "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", - "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", - "peerDependencies": { - "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "node_modules/ajv": { - "version": "6.12.6", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", - "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", - "dev": true, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz", + "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==", "dependencies": { - "fast-deep-equal": "^3.1.1", - "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.4.1", - "uri-js": "^4.2.2" + "@jridgewell/set-array": "^1.2.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.24" }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" + "engines": { + "node": ">=6.0.0" } }, - "node_modules/ansi-align": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.1.tgz", - "integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==", - "dependencies": { - "string-width": "^4.1.0" + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", + "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", + "engines": { + "node": ">=6.0.0" } }, - "node_modules/ansi-align/node_modules/ansi-regex": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "node_modules/@jridgewell/set-array": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", + "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", "engines": { - "node": ">=8" + "node": ">=6.0.0" } }, - "node_modules/ansi-align/node_modules/emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==" }, - "node_modules/ansi-align/node_modules/string-width": { - "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.25", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", + "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", "dependencies": { - "emoji-regex": "^8.0.0", - "is-fullwidth-code-point": "^3.0.0", - "strip-ansi": "^6.0.1" - }, - "engines": { - "node": ">=8" + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" } }, - "node_modules/ansi-align/node_modules/strip-ansi": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "node_modules/@mdx-js/mdx": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-2.3.0.tgz", + "integrity": "sha512-jLuwRlz8DQfQNiUCJR50Y09CGPq3fLtmtUQfVrj79E0JWu3dvsVcxVIcfhR5h0iXu+/z++zDrYeiJqifRynJkA==", "dependencies": { - "ansi-regex": "^5.0.1" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/ansi-regex": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", - "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==", - "engines": { - "node": ">=12" + "@types/estree-jsx": "^1.0.0", + "@types/mdx": "^2.0.0", + "estree-util-build-jsx": "^2.0.0", + "estree-util-is-identifier-name": "^2.0.0", + "estree-util-to-js": "^1.1.0", + "estree-walker": "^3.0.0", + "hast-util-to-estree": "^2.0.0", + "markdown-extensions": "^1.0.0", + "periscopic": "^3.0.0", + "remark-mdx": "^2.0.0", + "remark-parse": "^10.0.0", + "remark-rehype": "^10.0.0", + "unified": "^10.0.0", + "unist-util-position-from-estree": "^1.0.0", + "unist-util-stringify-position": "^3.0.0", + "unist-util-visit": "^4.0.0", + "vfile": "^5.0.0" }, "funding": { - "url": "https://github.com/chalk/ansi-regex?sponsor=1" + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/ansi-sequence-parser": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/ansi-sequence-parser/-/ansi-sequence-parser-1.1.1.tgz", - "integrity": "sha512-vJXt3yiaUL4UU546s3rPXlsry/RnM730G1+HkpKE012AN0sx1eOrxSu95oKDIonskeLTijMgqWZ3uDEe3NFvyg==" - }, - "node_modules/ansi-styles": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", - "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", "dependencies": { - "color-convert": "^1.9.0" + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" }, "engines": { - "node": ">=4" + "node": ">= 8" } }, - "node_modules/any-promise": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", - "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==" + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "engines": { + "node": ">= 8" + } }, - "node_modules/anymatch": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", - "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", "dependencies": { - "normalize-path": "^3.0.0", - "picomatch": "^2.0.4" + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" }, "engines": { "node": ">= 8" } }, - "node_modules/arg": { - "version": "5.0.2", - "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz", - "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==" - }, - "node_modules/argparse": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", - "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + "node_modules/@octokit/auth-token": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-3.0.4.tgz", + "integrity": "sha512-TWFX7cZF2LXoCvdmJWY7XVPi74aSY0+FfBZNSXEXFkMpjcqsQwDSYVv5FhRFaI0V1ECnwbz4j59T/G+rXNWaIQ==", + "engines": { + "node": ">= 14" + } }, - "node_modules/aria-query": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz", - "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==", - "dev": true, + "node_modules/@octokit/core": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/@octokit/core/-/core-4.2.4.tgz", + "integrity": "sha512-rYKilwgzQ7/imScn3M9/pFfUf4I1AZEH3KhyJmtPdE2zfaXAn2mFfUy4FbKewzc2We5y/LlKLj36fWJLKC2SIQ==", "dependencies": { - "dequal": "^2.0.3" + "@octokit/auth-token": "^3.0.0", + "@octokit/graphql": "^5.0.0", + "@octokit/request": "^6.0.0", + "@octokit/request-error": "^3.0.0", + "@octokit/types": "^9.0.0", + "before-after-hook": "^2.2.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 14" } }, - "node_modules/array-buffer-byte-length": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz", - "integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==", - "dev": true, + "node_modules/@octokit/endpoint": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-7.0.6.tgz", + "integrity": "sha512-5L4fseVRUsDFGR00tMWD/Trdeeihn999rTMGRMC1G/Ldi1uWlWJzI98H4Iak5DB/RVvQuyMYKqSK/R6mbSOQyg==", "dependencies": { - "call-bind": "^1.0.2", - "is-array-buffer": "^3.0.1" + "@octokit/types": "^9.0.0", + "is-plain-object": "^5.0.0", + "universal-user-agent": "^6.0.0" }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "engines": { + "node": ">= 14" } }, - "node_modules/array-includes": { - "version": "3.1.7", - "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.7.tgz", - "integrity": "sha512-dlcsNBIiWhPkHdOEEKnehA+RNUWDc4UqFtnIXU4uuYDPtA4LDkr7qip2p0VvFAEXNDr0yWZ9PJyIRiGjRLQzwQ==", - "dev": true, + "node_modules/@octokit/graphql": { + "version": "5.0.6", + "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-5.0.6.tgz", + "integrity": "sha512-Fxyxdy/JH0MnIB5h+UQ3yCoh1FG4kWXfFKkpWqjZHw/p+Kc8Y44Hu/kCgNBT6nU1shNumEchmW/sUO1JuQnPcw==", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "get-intrinsic": "^1.2.1", - "is-string": "^1.0.7" + "@octokit/request": "^6.0.0", + "@octokit/types": "^9.0.0", + "universal-user-agent": "^6.0.0" }, "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "node": ">= 14" } }, - "node_modules/array-iterate": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/array-iterate/-/array-iterate-2.0.1.tgz", - "integrity": "sha512-I1jXZMjAgCMmxT4qxXfPXa6SthSoE8h6gkSI9BGGNv8mP8G/v0blc+qFnZu6K42vTOiuME596QaLO0TP3Lk0xg==", - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" - } + "node_modules/@octokit/openapi-types": { + "version": "18.1.1", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-18.1.1.tgz", + "integrity": "sha512-VRaeH8nCDtF5aXWnjPuEMIYf1itK/s3JYyJcWFJT8X9pSNnBtriDf7wlEWsGuhPLl4QIH4xM8fqTXDwJ3Mu6sw==" }, - "node_modules/array-union": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", - "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", - "dev": true, + "node_modules/@octokit/plugin-paginate-rest": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-6.1.2.tgz", + "integrity": "sha512-qhrmtQeHU/IivxucOV1bbI/xZyC/iOBhclokv7Sut5vnejAIAEXVcGQeRpQlU39E0WwK9lNvJHphHri/DB6lbQ==", + "dependencies": { + "@octokit/tsconfig": "^1.0.2", + "@octokit/types": "^9.2.3" + }, "engines": { - "node": ">=8" + "node": ">= 14" + }, + "peerDependencies": { + "@octokit/core": ">=4" } }, - "node_modules/array.prototype.flat": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.2.tgz", - "integrity": "sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==", - "dev": true, + "node_modules/@octokit/plugin-request-log": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz", + "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA==", + "peerDependencies": { + "@octokit/core": ">=3" + } + }, + "node_modules/@octokit/plugin-rest-endpoint-methods": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-7.2.3.tgz", + "integrity": "sha512-I5Gml6kTAkzVlN7KCtjOM+Ruwe/rQppp0QU372K1GP7kNOYEKe8Xn5BW4sE62JAHdwpq95OQK/qGNyKQMUzVgA==", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "es-shim-unscopables": "^1.0.0" + "@octokit/types": "^10.0.0" }, "engines": { - "node": ">= 0.4" + "node": ">= 14" }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "peerDependencies": { + "@octokit/core": ">=3" } }, - "node_modules/array.prototype.flatmap": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.2.tgz", - "integrity": "sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==", - "dev": true, + "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/types": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-10.0.0.tgz", + "integrity": "sha512-Vm8IddVmhCgU1fxC1eyinpwqzXPEYu0NrYzD3YZjlGjyftdLBTeqNblRC0jmJmgxbJIsQlyogVeGnrNaaMVzIg==", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "es-shim-unscopables": "^1.0.0" + "@octokit/openapi-types": "^18.0.0" + } + }, + "node_modules/@octokit/request": { + "version": "6.2.8", + "resolved": "https://registry.npmjs.org/@octokit/request/-/request-6.2.8.tgz", + "integrity": "sha512-ow4+pkVQ+6XVVsekSYBzJC0VTVvh/FCTUUgTsboGq+DTeWdyIFV8WSCdo0RIxk6wSkBTHqIK1mYuY7nOBXOchw==", + "dependencies": { + "@octokit/endpoint": "^7.0.0", + "@octokit/request-error": "^3.0.0", + "@octokit/types": "^9.0.0", + "is-plain-object": "^5.0.0", + "node-fetch": "^2.6.7", + "universal-user-agent": "^6.0.0" }, "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "node": ">= 14" } }, - "node_modules/arraybuffer.prototype.slice": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.2.tgz", - "integrity": "sha512-yMBKppFur/fbHu9/6USUe03bZ4knMYiwFBcyiaXB8Go0qNehwX6inYPzK9U0NeQvGxKthcmHcaR8P5MStSRBAw==", - "dev": true, + "node_modules/@octokit/request-error": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-3.0.3.tgz", + "integrity": "sha512-crqw3V5Iy2uOU5Np+8M/YexTlT8zxCfI+qu+LxUB7SZpje4Qmx3mub5DfEKSO8Ylyk0aogi6TYdf6kxzh2BguQ==", "dependencies": { - "array-buffer-byte-length": "^1.0.0", - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "get-intrinsic": "^1.2.1", - "is-array-buffer": "^3.0.2", - "is-shared-array-buffer": "^1.0.2" + "@octokit/types": "^9.0.0", + "deprecation": "^2.0.0", + "once": "^1.4.0" }, "engines": { - "node": ">= 0.4" + "node": ">= 14" + } + }, + "node_modules/@octokit/rest": { + "version": "19.0.13", + "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-19.0.13.tgz", + "integrity": "sha512-/EzVox5V9gYGdbAI+ovYj3nXQT1TtTHRT+0eZPcuC05UFSWO3mdO9UY1C0i2eLF9Un1ONJkAk+IEtYGAC+TahA==", + "dependencies": { + "@octokit/core": "^4.2.1", + "@octokit/plugin-paginate-rest": "^6.1.2", + "@octokit/plugin-request-log": "^1.0.4", + "@octokit/plugin-rest-endpoint-methods": "^7.1.2" }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "engines": { + "node": ">= 14" } }, - "node_modules/ast-types-flow": { - "version": "0.0.7", - "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.7.tgz", - "integrity": "sha512-eBvWn1lvIApYMhzQMsu9ciLfkBY499mFZlNqG+/9WR7PVlroQw0vG30cOQQbaKz3sCEc44TAOu2ykzqXSNnwag==", - "dev": true + "node_modules/@octokit/tsconfig": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@octokit/tsconfig/-/tsconfig-1.0.2.tgz", + "integrity": "sha512-I0vDR0rdtP8p2lGMzvsJzbhdOWy405HcGovrspJ8RRibHnyRgggUSNO5AIox5LmqiwmatHKYsvj6VGFHkqS7lA==" }, - "node_modules/astring": { - "version": "1.8.6", - "resolved": "https://registry.npmjs.org/astring/-/astring-1.8.6.tgz", - "integrity": "sha512-ISvCdHdlTDlH5IpxQJIex7BWBywFWgjJSVdwst+/iQCoEYnyOaQ95+X1JGshuBjGp6nxKUy1jMgE3zPqN7fQdg==", - "bin": { - "astring": "bin/astring" + "node_modules/@octokit/types": { + "version": "9.3.2", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-9.3.2.tgz", + "integrity": "sha512-D4iHGTdAnEEVsB8fl95m1hiz7D5YiRdQ9b/OEb3BYRVwbLsGHcRVPz+u+BgRLNk0Q0/4iZCBqDN96j2XNxfXrA==", + "dependencies": { + "@octokit/openapi-types": "^18.0.0" } }, - "node_modules/astro": { - "version": "3.6.5", - "resolved": "https://registry.npmjs.org/astro/-/astro-3.6.5.tgz", - "integrity": "sha512-fyVubQfb6+Bc2/XigXNeJ06HHwNFB9EnAQohJcrja6RB1PhIcZRusyIamywHWjoJ4a1T0HxMkzBLNW96DBqpNw==", + "node_modules/@pkgr/utils": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/@pkgr/utils/-/utils-2.4.2.tgz", + "integrity": "sha512-POgTXhjrTfbTV63DiFXav4lBHiICLKKwDeaKn9Nphwj7WH6m0hMMCaJkMyRWjgtPFyRKRVoMXXjczsTQRDEhYw==", + "dev": true, "dependencies": { - "@astrojs/compiler": "^2.3.0", - "@astrojs/internal-helpers": "0.2.1", - "@astrojs/markdown-remark": "3.5.0", - "@astrojs/telemetry": "3.0.4", - "@babel/core": "^7.22.10", - "@babel/generator": "^7.22.10", - "@babel/parser": "^7.22.10", - "@babel/plugin-transform-react-jsx": "^7.22.5", - "@babel/traverse": "^7.22.10", - "@babel/types": "^7.22.10", - "@types/babel__core": "^7.20.1", - "acorn": "^8.10.0", - "boxen": "^7.1.1", - "chokidar": "^3.5.3", - "ci-info": "^3.8.0", - "clsx": "^2.0.0", - "common-ancestor-path": "^1.0.1", - "cookie": "^0.5.0", - "debug": "^4.3.4", - "deterministic-object-hash": "^1.3.1", - "devalue": "^4.3.2", - "diff": "^5.1.0", - "es-module-lexer": "^1.3.0", - "esbuild": "^0.19.2", - "estree-walker": "^3.0.3", - "execa": "^8.0.1", - "fast-glob": "^3.3.1", - "github-slugger": "^2.0.0", - "gray-matter": "^4.0.3", - "html-escaper": "^3.0.3", - "http-cache-semantics": "^4.1.1", - "js-yaml": "^4.1.0", - "kleur": "^4.1.4", - "magic-string": "^0.30.3", - "mdast-util-to-hast": "12.3.0", - "mime": "^3.0.0", - "ora": "^7.0.1", - "p-limit": "^4.0.0", - "p-queue": "^7.4.1", - "path-to-regexp": "^6.2.1", - "preferred-pm": "^3.1.2", - "probe-image-size": "^7.2.3", - "prompts": "^2.4.2", - "rehype": "^12.0.1", - "resolve": "^1.22.4", - "semver": "^7.5.4", - "server-destroy": "^1.0.1", - "shikiji": "^0.6.8", - "string-width": "^6.1.0", - "strip-ansi": "^7.1.0", - "tsconfck": "^3.0.0", - "unist-util-visit": "^4.1.2", - "vfile": "^5.3.7", - "vite": "^4.4.9", - "vitefu": "^0.2.4", - "which-pm": "^2.1.1", - "yargs-parser": "^21.1.1", - "zod": "^3.22.4" - }, - "bin": { - "astro": "astro.js" + "cross-spawn": "^7.0.3", + "fast-glob": "^3.3.0", + "is-glob": "^4.0.3", + "open": "^9.1.0", + "picocolors": "^1.0.0", + "tslib": "^2.6.0" }, "engines": { - "node": ">=18.14.1", - "npm": ">=6.14.0" + "node": "^12.20.0 || ^14.18.0 || >=16.0.0" }, - "optionalDependencies": { - "sharp": "^0.32.5" + "funding": { + "url": "https://opencollective.com/unts" } }, - "node_modules/astro-eslint-parser": { - "version": "0.16.0", - "resolved": "https://registry.npmjs.org/astro-eslint-parser/-/astro-eslint-parser-0.16.0.tgz", - "integrity": "sha512-k9ASvY8pa6qttM+fvNJCILxxjftfNg/ou5cjd25SVHsc7moplezGGM9fgMUyf24SRYt8ShO603oHRDn2KqwxMg==", + "node_modules/@rollup/plugin-babel": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-6.0.4.tgz", + "integrity": "sha512-YF7Y52kFdFT/xVSuVdjkV5ZdX/3YtmX0QulG+x0taQOtJdHYzVU61aSSkAgVJ7NOv6qPkIYiJSgSWWN/DM5sGw==", "dev": true, + "license": "MIT", "dependencies": { - "@astrojs/compiler": "^2.0.0", - "@typescript-eslint/scope-manager": "^5.0.0", - "@typescript-eslint/types": "^5.0.0", - "astrojs-compiler-sync": "^0.3.0", - "debug": "^4.3.4", - "eslint-visitor-keys": "^3.0.0", - "espree": "^9.0.0", - "semver": "^7.3.8" + "@babel/helper-module-imports": "^7.18.6", + "@rollup/pluginutils": "^5.0.1" }, "engines": { - "node": "^14.18.0 || >=16.0.0" + "node": ">=14.0.0" }, - "funding": { - "url": "https://github.com/sponsors/ota-meshi" + "peerDependencies": { + "@babel/core": "^7.0.0", + "@types/babel__core": "^7.1.9", + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "@types/babel__core": { + "optional": true + }, + "rollup": { + "optional": true + } } }, - "node_modules/astro-eslint-parser/node_modules/@typescript-eslint/scope-manager": { - "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz", - "integrity": "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==", + "node_modules/@rollup/plugin-commonjs": { + "version": "28.0.1", + "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-28.0.1.tgz", + "integrity": "sha512-+tNWdlWKbpB3WgBN7ijjYkq9X5uhjmcvyjEght4NmH5fAU++zfQzAJ6wumLS+dNcvwEZhKx2Z+skY8m7v0wGSA==", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/types": "5.62.0", - "@typescript-eslint/visitor-keys": "5.62.0" + "@rollup/pluginutils": "^5.0.1", + "commondir": "^1.0.1", + "estree-walker": "^2.0.2", + "fdir": "^6.2.0", + "is-reference": "1.2.1", + "magic-string": "^0.30.3", + "picomatch": "^4.0.2" }, "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": ">=16.0.0 || 14 >= 14.17" }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" + "peerDependencies": { + "rollup": "^2.68.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } } }, - "node_modules/astro-eslint-parser/node_modules/@typescript-eslint/types": { - "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz", - "integrity": "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==", + "node_modules/@rollup/plugin-commonjs/node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", "dev": true, - "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "license": "MIT" + }, + "node_modules/@rollup/plugin-commonjs/node_modules/fdir": { + "version": "6.4.2", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.2.tgz", + "integrity": "sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "picomatch": "^3 || ^4" }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } } }, - "node_modules/astro-eslint-parser/node_modules/@typescript-eslint/visitor-keys": { - "version": "5.62.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz", - "integrity": "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==", + "node_modules/@rollup/plugin-commonjs/node_modules/is-reference": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz", + "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/types": "5.62.0", - "eslint-visitor-keys": "^3.3.0" - }, + "@types/estree": "*" + } + }, + "node_modules/@rollup/plugin-commonjs/node_modules/picomatch": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", + "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", + "dev": true, + "license": "MIT", "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": ">=12" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/typescript-eslint" + "url": "https://github.com/sponsors/jonschlinkert" } }, - "node_modules/astro/node_modules/@astrojs/markdown-remark": { - "version": "3.5.0", - "resolved": "https://registry.npmjs.org/@astrojs/markdown-remark/-/markdown-remark-3.5.0.tgz", - "integrity": "sha512-q7vdIqzYhxpsfghg2YmkmSXCfp4w7lBTYP+SSHw89wVhC5Riltr3u8w2otBRxNLSByNi+ht/gGkFC23Shetytw==", + "node_modules/@rollup/plugin-node-resolve": { + "version": "15.3.0", + "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.3.0.tgz", + "integrity": "sha512-9eO5McEICxMzJpDW9OnMYSv4Sta3hmt7VtBFz5zR9273suNOydOyq/FrGeGy+KsTRFm8w0SLVhzig2ILFT63Ag==", + "dev": true, + "license": "MIT", "dependencies": { - "@astrojs/prism": "^3.0.0", - "github-slugger": "^2.0.0", - "import-meta-resolve": "^3.0.0", - "mdast-util-definitions": "^6.0.0", - "rehype-raw": "^6.1.1", - "rehype-stringify": "^9.0.4", - "remark-gfm": "^3.0.1", - "remark-parse": "^10.0.2", - "remark-rehype": "^10.1.0", - "remark-smartypants": "^2.0.0", - "shikiji": "^0.6.8", - "unified": "^10.1.2", - "unist-util-visit": "^4.1.2", - "vfile": "^5.3.7" + "@rollup/pluginutils": "^5.0.1", + "@types/resolve": "1.20.2", + "deepmerge": "^4.2.2", + "is-module": "^1.0.0", + "resolve": "^1.22.1" + }, + "engines": { + "node": ">=14.0.0" }, "peerDependencies": { - "astro": "^3.0.0" + "rollup": "^2.78.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } } }, - "node_modules/astrojs-compiler-sync": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/astrojs-compiler-sync/-/astrojs-compiler-sync-0.3.3.tgz", - "integrity": "sha512-LbhchWgsvjvRBb5n5ez8/Q/f9ZKViuox27VxMDOdTUm8MRv9U7phzOiLue5KluqTmC0z1LId4gY2SekvoDrkuw==", + "node_modules/@rollup/plugin-typescript": { + "version": "12.1.1", + "resolved": "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-12.1.1.tgz", + "integrity": "sha512-t7O653DpfB5MbFrqPe/VcKFFkvRuFNp9qId3xq4Eth5xlyymzxNpye2z8Hrl0RIMuXTSr5GGcFpkdlMeacUiFQ==", "dev": true, + "license": "MIT", "dependencies": { - "synckit": "^0.8.0" + "@rollup/pluginutils": "^5.1.0", + "resolve": "^1.22.1" }, "engines": { - "node": "^14.18.0 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/sponsors/ota-meshi" + "node": ">=14.0.0" }, "peerDependencies": { - "@astrojs/compiler": ">=0.27.0" - } - }, - "node_modules/asynckit": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", - "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" - }, - "node_modules/autoprefixer": { - "version": "10.4.16", - "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.16.tgz", - "integrity": "sha512-7vd3UC6xKp0HLfua5IjZlcXvGAGy7cBAXTg2lyQ/8WpNhd6SiZ8Be+xm3FyBSYJx5GKcpRCzBh7RH4/0dnY+uQ==", - "funding": [ - { - "type": "opencollective", - "url": "https://opencollective.com/postcss/" - }, - { - "type": "tidelift", - "url": "https://tidelift.com/funding/github/npm/autoprefixer" + "rollup": "^2.14.0||^3.0.0||^4.0.0", + "tslib": "*", + "typescript": ">=3.7.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true }, - { - "type": "github", - "url": "https://github.com/sponsors/ai" + "tslib": { + "optional": true } - ], + } + }, + "node_modules/@rollup/pluginutils": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.3.tgz", + "integrity": "sha512-Pnsb6f32CD2W3uCaLZIzDmeFyQ2b8UWMFI7xtwUezpcGBDVDW6y9XgAWIlARiGAo6eNF5FK5aQTr0LFyNyqq5A==", + "dev": true, + "license": "MIT", "dependencies": { - "browserslist": "^4.21.10", - "caniuse-lite": "^1.0.30001538", - "fraction.js": "^4.3.6", - "normalize-range": "^0.1.2", - "picocolors": "^1.0.0", - "postcss-value-parser": "^4.2.0" - }, - "bin": { - "autoprefixer": "bin/autoprefixer" + "@types/estree": "^1.0.0", + "estree-walker": "^2.0.2", + "picomatch": "^4.0.2" }, "engines": { - "node": "^10 || ^12 || >=14" + "node": ">=14.0.0" }, "peerDependencies": { - "postcss": "^8.1.0" + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } } }, - "node_modules/available-typed-arrays": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", - "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "node_modules/@rollup/pluginutils/node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/pluginutils/node_modules/picomatch": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", + "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", "dev": true, + "license": "MIT", "engines": { - "node": ">= 0.4" + "node": ">=12" }, "funding": { - "url": "https://github.com/sponsors/ljharb" + "url": "https://github.com/sponsors/jonschlinkert" } }, - "node_modules/axe-core": { - "version": "4.8.2", - "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.8.2.tgz", - "integrity": "sha512-/dlp0fxyM3R8YW7MFzaHWXrf4zzbr0vaYb23VBFCl83R7nWNPg/yaQw2Dc8jzCMmDVLhSdzH8MjrsuIUuvX+6g==", + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.28.1.tgz", + "integrity": "sha512-fzgeABz7rrAlKYB0y2kSEiURrI0691CSL0+KXwKwhxvj92VULEDQLpBYLHpF49MSiPG4sq5CK3qHMnb9tlCjBw==", + "cpu": [ + "x64" + ], "dev": true, - "engines": { - "node": ">=4" - } - }, - "node_modules/axios": { - "version": "1.7.2", - "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.2.tgz", - "integrity": "sha512-2A8QhOMrbomlDuiLeK9XibIBzuHeRcqqNOHp0Cyp5EoJ1IFDh+XZH3A6BkXtv0K4gFGCI0Y4BM7B1wOEi0Rmgw==", - "dependencies": { - "follow-redirects": "^1.15.6", - "form-data": "^4.0.0", - "proxy-from-env": "^1.1.0" - } + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] }, - "node_modules/axobject-query": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-3.2.1.tgz", - "integrity": "sha512-jsyHu61e6N4Vbz/v18DHwWYKK0bSWLqn47eeDSKPB7m8tqMHF9YJ+mhIk2lVteyZrY8tnSj/jHOv4YiTCuCJgg==", + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.28.1.tgz", + "integrity": "sha512-xQTDVzSGiMlSshpJCtudbWyRfLaNiVPXt1WgdWTwWz9n0U12cI2ZVtWe/Jgwyv/6wjL7b66uu61Vg0POWVfz4g==", + "cpu": [ + "x64" + ], "dev": true, - "dependencies": { - "dequal": "^2.0.3" - } - }, - "node_modules/b4a": { - "version": "1.6.4", - "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.4.tgz", - "integrity": "sha512-fpWrvyVHEKyeEvbKZTVOeZF3VSKKWtJxFIxX/jaVPf+cLbGUSitjb49pHLqPV2BUNNZ0LcoeEGfE/YCpyDYHIw==", - "optional": true + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] }, - "node_modules/babel-plugin-jsx-dom-expressions": { - "version": "0.36.18", - "resolved": "https://registry.npmjs.org/babel-plugin-jsx-dom-expressions/-/babel-plugin-jsx-dom-expressions-0.36.18.tgz", - "integrity": "sha512-8K0CHgzNMB0+1OC+GQf1O49Nc6DfHAoWDjY4YTW3W/3il5KrDKAj65723oPmya68kKKOkqDKuz+Zh1u7VFHthw==", + "node_modules/@tailwindcss/forms": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/@tailwindcss/forms/-/forms-0.5.6.tgz", + "integrity": "sha512-Fw+2BJ0tmAwK/w01tEFL5TiaJBX1NLT1/YbWgvm7ws3Qcn11kiXxzNTEQDMs5V3mQemhB56l3u0i9dwdzSQldA==", "dependencies": { - "@babel/helper-module-imports": "7.18.6", - "@babel/plugin-syntax-jsx": "^7.18.6", - "@babel/types": "^7.20.7", - "html-entities": "2.3.3", - "validate-html-nesting": "^1.2.1" + "mini-svg-data-uri": "^1.2.3" }, "peerDependencies": { - "@babel/core": "^7.20.12" + "tailwindcss": ">=3.0.0 || >= 3.0.0-alpha.1" } }, - "node_modules/babel-plugin-jsx-dom-expressions/node_modules/@babel/helper-module-imports": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", - "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", + "node_modules/@tailwindcss/typography": { + "version": "0.5.10", + "resolved": "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.10.tgz", + "integrity": "sha512-Pe8BuPJQJd3FfRnm6H0ulKIGoMEQS+Vq01R6M5aCrFB/ccR/shT+0kXLjouGC1gFLm9hopTFN+DMP0pfwRWzPw==", "dependencies": { - "@babel/types": "^7.18.6" + "lodash.castarray": "^4.4.0", + "lodash.isplainobject": "^4.0.6", + "lodash.merge": "^4.6.2", + "postcss-selector-parser": "6.0.10" }, - "engines": { - "node": ">=6.9.0" + "peerDependencies": { + "tailwindcss": ">=3.0.0 || insiders" } }, - "node_modules/babel-preset-solid": { - "version": "1.7.12", - "resolved": "https://registry.npmjs.org/babel-preset-solid/-/babel-preset-solid-1.7.12.tgz", - "integrity": "sha512-vNZn34Dv6IsWK/F59HhZlN8gP0ihZfkhPp8Lx/nxlY+rKtSZEAmmYlXWtds6EDKSiXoj2TEHuCcuqp6cO7oLSg==", + "node_modules/@types/acorn": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz", + "integrity": "sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==", "dependencies": { - "babel-plugin-jsx-dom-expressions": "^0.36.18" - }, - "peerDependencies": { - "@babel/core": "^7.0.0" + "@types/estree": "*" } }, - "node_modules/bail": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz", - "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==", - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" + "node_modules/@types/audioworklet": { + "version": "0.0.50", + "resolved": "https://registry.npmjs.org/@types/audioworklet/-/audioworklet-0.0.50.tgz", + "integrity": "sha512-Wic6k+tczhJZz4yq2ianEowIF/xH10wI9ac8sBDh27Jvs+WIvXIeM+nWPPRITFwSKuLZKlvVjfLiNmUjfy4koA==", + "dev": true + }, + "node_modules/@types/babel__core": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.2.tgz", + "integrity": "sha512-pNpr1T1xLUc2l3xJKuPtsEky3ybxN3m4fJkknfIpTCTfIZCDW57oAg+EfCgIIp2rvCe0Wn++/FfodDS4YXxBwA==", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" } }, - "node_modules/balanced-match": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "node_modules/@types/babel__generator": { + "version": "7.6.5", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.5.tgz", + "integrity": "sha512-h9yIuWbJKdOPLJTbmSpPzkF67e659PbQDba7ifWm5BJ8xTv+sDmS7rFmywkWOvXedGTivCdeGSIIX8WLcRTz8w==", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.2", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.2.tgz", + "integrity": "sha512-/AVzPICMhMOMYoSx9MoKpGDKdBRsIXMNByh1PXSZoa+v6ZoLa8xxtsT/uLQ/NJm0XVAWl/BvId4MlDeXJaeIZQ==", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.20.2", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.2.tgz", + "integrity": "sha512-ojlGK1Hsfce93J0+kn3H5R73elidKUaZonirN33GSmgTUMpzI/MIFfSpF3haANe3G1bEBS9/9/QEqwTzwqFsKw==", + "dependencies": { + "@babel/types": "^7.20.7" + } + }, + "node_modules/@types/debug": { + "version": "4.1.9", + "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.9.tgz", + "integrity": "sha512-8Hz50m2eoS56ldRlepxSBa6PWEVCtzUo/92HgLc2qTMnotJNIm7xP+UZhyWoYsyOdd5dxZ+NZLb24rsKyFs2ow==", + "dependencies": { + "@types/ms": "*" + } + }, + "node_modules/@types/dom-mediacapture-transform": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/@types/dom-mediacapture-transform/-/dom-mediacapture-transform-0.1.7.tgz", + "integrity": "sha512-xrFtEIDCn+VeMEYm4JdjLEOeho3dsTxOxx4hDqCA0WRrENF4DMTF9JaTzTRUVc5rI58j9nRTxIZlU1Wqfr08PA==", + "dev": true, + "dependencies": { + "@types/dom-webcodecs": "*" + } + }, + "node_modules/@types/dom-webcodecs": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/@types/dom-webcodecs/-/dom-webcodecs-0.1.8.tgz", + "integrity": "sha512-KThTPaGQJLITk8Q0XkEkz+GqFdoWDyQfbyeJmfEUagB15TZQdNx5AqP2b7GP6vkVM6X/6T1Z8EHxA8RgHfY9BA==" + }, + "node_modules/@types/estree": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz", + "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==", + "license": "MIT" + }, + "node_modules/@types/estree-jsx": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.1.tgz", + "integrity": "sha512-sHyakZlAezNFxmYRo0fopDZW+XvK6ipeZkkp5EAOLjdPfZp8VjZBJ67vSRI99RSCAoqXVmXOHS4fnWoxpuGQtQ==", + "dependencies": { + "@types/estree": "*" + } + }, + "node_modules/@types/hast": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.6.tgz", + "integrity": "sha512-47rJE80oqPmFdVDCD7IheXBrVdwuBgsYwoczFvKmwfo2Mzsnt+V9OONsYauFmICb6lQPpCuXYJWejBNs4pDJRg==", + "dependencies": { + "@types/unist": "^2" + } + }, + "node_modules/@types/json-schema": { + "version": "7.0.13", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.13.tgz", + "integrity": "sha512-RbSSoHliUbnXj3ny0CNFOoxrIDV6SUGyStHsvDqosw6CkdPV8TtWGlfecuK4ToyMEAql6pzNxgCFKanovUzlgQ==", + "dev": true + }, + "node_modules/@types/mdast": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.1.tgz", + "integrity": "sha512-IlKct1rUTJ1T81d8OHzyop15kGv9A/ff7Gz7IJgrk6jDb4Udw77pCJ+vq8oxZf4Ghpm+616+i1s/LNg/Vh7d+g==", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/mdx": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.8.tgz", + "integrity": "sha512-r7/zWe+f9x+zjXqGxf821qz++ld8tp6Z4jUS6qmPZUXH6tfh4riXOhAqb12tWGWAevCFtMt1goLWkQMqIJKpsA==" + }, + "node_modules/@types/ms": { + "version": "0.7.32", + "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.32.tgz", + "integrity": "sha512-xPSg0jm4mqgEkNhowKgZFBNtwoEwF6gJ4Dhww+GFpm3IgtNseHQZ5IqdNwnquZEoANxyDAKDRAdVo4Z72VvD/g==" + }, + "node_modules/@types/nlcst": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@types/nlcst/-/nlcst-1.0.2.tgz", + "integrity": "sha512-ykxL/GDDUhqikjU0LIywZvEwb1NTYXTEWf+XgMSS2o6IXIakafPccxZmxgZcvJPZ3yFl2kdL1gJZz3U3iZF3QA==", + "dependencies": { + "@types/unist": "^2" + } + }, + "node_modules/@types/parse5": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/@types/parse5/-/parse5-6.0.3.tgz", + "integrity": "sha512-SuT16Q1K51EAVPz1K29DJ/sXjhSQ0zjvsypYJ6tlwVsRV9jwW5Adq2ch8Dq8kDBCkYnELS7N7VNCSB5nC56t/g==" + }, + "node_modules/@types/resolve": { + "version": "1.20.2", + "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz", + "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/semver": { + "version": "7.5.3", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.3.tgz", + "integrity": "sha512-OxepLK9EuNEIPxWNME+C6WwbRAOOI2o2BaQEGzz5Lu2e4Z5eDnEo+/aVEDMIXywoJitJ7xWd641wrGLZdtwRyw==", + "dev": true + }, + "node_modules/@types/unist": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.8.tgz", + "integrity": "sha512-d0XxK3YTObnWVp6rZuev3c49+j4Lo8g4L1ZRm9z5L0xpoZycUPshHgczK5gsUMaZOstjVYYi09p5gYvUtfChYw==" + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "6.7.4", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.7.4.tgz", + "integrity": "sha512-DAbgDXwtX+pDkAHwiGhqP3zWUGpW49B7eqmgpPtg+BKJXwdct79ut9+ifqOFPJGClGKSHXn2PTBatCnldJRUoA==", + "dev": true, + "dependencies": { + "@eslint-community/regexpp": "^4.5.1", + "@typescript-eslint/scope-manager": "6.7.4", + "@typescript-eslint/type-utils": "6.7.4", + "@typescript-eslint/utils": "6.7.4", + "@typescript-eslint/visitor-keys": "6.7.4", + "debug": "^4.3.4", + "graphemer": "^1.4.0", + "ignore": "^5.2.4", + "natural-compare": "^1.4.0", + "semver": "^7.5.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^6.0.0 || ^6.0.0-alpha", + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "6.7.4", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.7.4.tgz", + "integrity": "sha512-I5zVZFY+cw4IMZUeNCU7Sh2PO5O57F7Lr0uyhgCJmhN/BuTlnc55KxPonR4+EM3GBdfiCyGZye6DgMjtubQkmA==", + "dev": true, + "dependencies": { + "@typescript-eslint/scope-manager": "6.7.4", + "@typescript-eslint/types": "6.7.4", + "@typescript-eslint/typescript-estree": "6.7.4", + "@typescript-eslint/visitor-keys": "6.7.4", + "debug": "^4.3.4" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "6.7.4", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.7.4.tgz", + "integrity": "sha512-SdGqSLUPTXAXi7c3Ob7peAGVnmMoGzZ361VswK2Mqf8UOYcODiYvs8rs5ILqEdfvX1lE7wEZbLyELCW+Yrql1A==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.7.4", + "@typescript-eslint/visitor-keys": "6.7.4" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "6.7.4", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.7.4.tgz", + "integrity": "sha512-n+g3zi1QzpcAdHFP9KQF+rEFxMb2KxtnJGID3teA/nxKHOVi3ylKovaqEzGBbVY2pBttU6z85gp0D00ufLzViQ==", + "dev": true, + "dependencies": { + "@typescript-eslint/typescript-estree": "6.7.4", + "@typescript-eslint/utils": "6.7.4", + "debug": "^4.3.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/types": { + "version": "6.7.4", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.7.4.tgz", + "integrity": "sha512-o9XWK2FLW6eSS/0r/tgjAGsYasLAnOWg7hvZ/dGYSSNjCh+49k5ocPN8OmG5aZcSJ8pclSOyVKP2x03Sj+RrCA==", + "dev": true, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "6.7.4", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.7.4.tgz", + "integrity": "sha512-ty8b5qHKatlNYd9vmpHooQz3Vki3gG+3PchmtsA4TgrZBKWHNjWfkQid7K7xQogBqqc7/BhGazxMD5vr6Ha+iQ==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.7.4", + "@typescript-eslint/visitor-keys": "6.7.4", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "semver": "^7.5.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "6.7.4", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.7.4.tgz", + "integrity": "sha512-PRQAs+HUn85Qdk+khAxsVV+oULy3VkbH3hQ8hxLRJXWBEd7iI+GbQxH5SEUSH7kbEoTp6oT1bOwyga24ELALTA==", + "dev": true, + "dependencies": { + "@eslint-community/eslint-utils": "^4.4.0", + "@types/json-schema": "^7.0.12", + "@types/semver": "^7.5.0", + "@typescript-eslint/scope-manager": "6.7.4", + "@typescript-eslint/types": "6.7.4", + "@typescript-eslint/typescript-estree": "6.7.4", + "semver": "^7.5.4" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "6.7.4", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.7.4.tgz", + "integrity": "sha512-pOW37DUhlTZbvph50x5zZCkFn3xzwkGtNoJHzIM3svpiSkJzwOYr/kVBaXmf+RAQiUDs1AHEZVNPg6UJCJpwRA==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.7.4", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript/lib-dom": { + "name": "@types/web", + "version": "0.0.115", + "resolved": "https://registry.npmjs.org/@types/web/-/web-0.0.115.tgz", + "integrity": "sha512-IBtUgtxnITC7WTCg4tv6kCnSP0T+fM+3PzQPIzLzJY1DDlhBFKM/9+uMURw14YweWPDiFNIZ94Gc1bJtwow97g==", + "dev": true + }, + "node_modules/@ungap/structured-clone": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz", + "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==" + }, + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "license": "MIT", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/acorn": { + "version": "8.10.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.10.0.tgz", + "integrity": "sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-align": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.1.tgz", + "integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==", + "dependencies": { + "string-width": "^4.1.0" + } + }, + "node_modules/ansi-align/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-align/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "node_modules/ansi-align/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-align/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-regex": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/ansi-sequence-parser": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ansi-sequence-parser/-/ansi-sequence-parser-1.1.1.tgz", + "integrity": "sha512-vJXt3yiaUL4UU546s3rPXlsry/RnM730G1+HkpKE012AN0sx1eOrxSu95oKDIonskeLTijMgqWZ3uDEe3NFvyg==" + }, + "node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/any-promise": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", + "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==" + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/arg": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz", + "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==" + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "node_modules/aria-query": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz", + "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==", + "dev": true, + "dependencies": { + "dequal": "^2.0.3" + } + }, + "node_modules/array-buffer-byte-length": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.1.tgz", + "integrity": "sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.5", + "is-array-buffer": "^3.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==", + "license": "MIT" + }, + "node_modules/array-includes": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.7.tgz", + "integrity": "sha512-dlcsNBIiWhPkHdOEEKnehA+RNUWDc4UqFtnIXU4uuYDPtA4LDkr7qip2p0VvFAEXNDr0yWZ9PJyIRiGjRLQzwQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "get-intrinsic": "^1.2.1", + "is-string": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-iterate": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/array-iterate/-/array-iterate-2.0.1.tgz", + "integrity": "sha512-I1jXZMjAgCMmxT4qxXfPXa6SthSoE8h6gkSI9BGGNv8mP8G/v0blc+qFnZu6K42vTOiuME596QaLO0TP3Lk0xg==", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/array.prototype.flat": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.2.tgz", + "integrity": "sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "es-shim-unscopables": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.flatmap": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.2.tgz", + "integrity": "sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "es-shim-unscopables": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/arraybuffer.prototype.slice": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.3.tgz", + "integrity": "sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.1", + "call-bind": "^1.0.5", + "define-properties": "^1.2.1", + "es-abstract": "^1.22.3", + "es-errors": "^1.2.1", + "get-intrinsic": "^1.2.3", + "is-array-buffer": "^3.0.4", + "is-shared-array-buffer": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/ast-types-flow": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.7.tgz", + "integrity": "sha512-eBvWn1lvIApYMhzQMsu9ciLfkBY499mFZlNqG+/9WR7PVlroQw0vG30cOQQbaKz3sCEc44TAOu2ykzqXSNnwag==", + "dev": true + }, + "node_modules/astring": { + "version": "1.8.6", + "resolved": "https://registry.npmjs.org/astring/-/astring-1.8.6.tgz", + "integrity": "sha512-ISvCdHdlTDlH5IpxQJIex7BWBywFWgjJSVdwst+/iQCoEYnyOaQ95+X1JGshuBjGp6nxKUy1jMgE3zPqN7fQdg==", + "bin": { + "astring": "bin/astring" + } + }, + "node_modules/astro": { + "version": "3.6.5", + "resolved": "https://registry.npmjs.org/astro/-/astro-3.6.5.tgz", + "integrity": "sha512-fyVubQfb6+Bc2/XigXNeJ06HHwNFB9EnAQohJcrja6RB1PhIcZRusyIamywHWjoJ4a1T0HxMkzBLNW96DBqpNw==", + "dependencies": { + "@astrojs/compiler": "^2.3.0", + "@astrojs/internal-helpers": "0.2.1", + "@astrojs/markdown-remark": "3.5.0", + "@astrojs/telemetry": "3.0.4", + "@babel/core": "^7.22.10", + "@babel/generator": "^7.22.10", + "@babel/parser": "^7.22.10", + "@babel/plugin-transform-react-jsx": "^7.22.5", + "@babel/traverse": "^7.22.10", + "@babel/types": "^7.22.10", + "@types/babel__core": "^7.20.1", + "acorn": "^8.10.0", + "boxen": "^7.1.1", + "chokidar": "^3.5.3", + "ci-info": "^3.8.0", + "clsx": "^2.0.0", + "common-ancestor-path": "^1.0.1", + "cookie": "^0.5.0", + "debug": "^4.3.4", + "deterministic-object-hash": "^1.3.1", + "devalue": "^4.3.2", + "diff": "^5.1.0", + "es-module-lexer": "^1.3.0", + "esbuild": "^0.19.2", + "estree-walker": "^3.0.3", + "execa": "^8.0.1", + "fast-glob": "^3.3.1", + "github-slugger": "^2.0.0", + "gray-matter": "^4.0.3", + "html-escaper": "^3.0.3", + "http-cache-semantics": "^4.1.1", + "js-yaml": "^4.1.0", + "kleur": "^4.1.4", + "magic-string": "^0.30.3", + "mdast-util-to-hast": "12.3.0", + "mime": "^3.0.0", + "ora": "^7.0.1", + "p-limit": "^4.0.0", + "p-queue": "^7.4.1", + "path-to-regexp": "^6.2.1", + "preferred-pm": "^3.1.2", + "probe-image-size": "^7.2.3", + "prompts": "^2.4.2", + "rehype": "^12.0.1", + "resolve": "^1.22.4", + "semver": "^7.5.4", + "server-destroy": "^1.0.1", + "shikiji": "^0.6.8", + "string-width": "^6.1.0", + "strip-ansi": "^7.1.0", + "tsconfck": "^3.0.0", + "unist-util-visit": "^4.1.2", + "vfile": "^5.3.7", + "vite": "^4.4.9", + "vitefu": "^0.2.4", + "which-pm": "^2.1.1", + "yargs-parser": "^21.1.1", + "zod": "^3.22.4" + }, + "bin": { + "astro": "astro.js" + }, + "engines": { + "node": ">=18.14.1", + "npm": ">=6.14.0" + }, + "optionalDependencies": { + "sharp": "^0.32.5" + } + }, + "node_modules/astro-eslint-parser": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/astro-eslint-parser/-/astro-eslint-parser-0.16.0.tgz", + "integrity": "sha512-k9ASvY8pa6qttM+fvNJCILxxjftfNg/ou5cjd25SVHsc7moplezGGM9fgMUyf24SRYt8ShO603oHRDn2KqwxMg==", + "dev": true, + "dependencies": { + "@astrojs/compiler": "^2.0.0", + "@typescript-eslint/scope-manager": "^5.0.0", + "@typescript-eslint/types": "^5.0.0", + "astrojs-compiler-sync": "^0.3.0", + "debug": "^4.3.4", + "eslint-visitor-keys": "^3.0.0", + "espree": "^9.0.0", + "semver": "^7.3.8" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ota-meshi" + } + }, + "node_modules/astro-eslint-parser/node_modules/@typescript-eslint/scope-manager": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz", + "integrity": "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/visitor-keys": "5.62.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/astro-eslint-parser/node_modules/@typescript-eslint/types": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz", + "integrity": "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==", + "dev": true, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/astro-eslint-parser/node_modules/@typescript-eslint/visitor-keys": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz", + "integrity": "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "5.62.0", + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/astro/node_modules/@astrojs/markdown-remark": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/@astrojs/markdown-remark/-/markdown-remark-3.5.0.tgz", + "integrity": "sha512-q7vdIqzYhxpsfghg2YmkmSXCfp4w7lBTYP+SSHw89wVhC5Riltr3u8w2otBRxNLSByNi+ht/gGkFC23Shetytw==", + "dependencies": { + "@astrojs/prism": "^3.0.0", + "github-slugger": "^2.0.0", + "import-meta-resolve": "^3.0.0", + "mdast-util-definitions": "^6.0.0", + "rehype-raw": "^6.1.1", + "rehype-stringify": "^9.0.4", + "remark-gfm": "^3.0.1", + "remark-parse": "^10.0.2", + "remark-rehype": "^10.1.0", + "remark-smartypants": "^2.0.0", + "shikiji": "^0.6.8", + "unified": "^10.1.2", + "unist-util-visit": "^4.1.2", + "vfile": "^5.3.7" + }, + "peerDependencies": { + "astro": "^3.0.0" + } + }, + "node_modules/astrojs-compiler-sync": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/astrojs-compiler-sync/-/astrojs-compiler-sync-0.3.3.tgz", + "integrity": "sha512-LbhchWgsvjvRBb5n5ez8/Q/f9ZKViuox27VxMDOdTUm8MRv9U7phzOiLue5KluqTmC0z1LId4gY2SekvoDrkuw==", + "dev": true, + "dependencies": { + "synckit": "^0.8.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ota-meshi" + }, + "peerDependencies": { + "@astrojs/compiler": ">=0.27.0" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" + }, + "node_modules/atob": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz", + "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==", + "dev": true, + "license": "(MIT OR Apache-2.0)", + "bin": { + "atob": "bin/atob.js" + }, + "engines": { + "node": ">= 4.5.0" + } + }, + "node_modules/autoprefixer": { + "version": "10.4.16", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.16.tgz", + "integrity": "sha512-7vd3UC6xKp0HLfua5IjZlcXvGAGy7cBAXTg2lyQ/8WpNhd6SiZ8Be+xm3FyBSYJx5GKcpRCzBh7RH4/0dnY+uQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "browserslist": "^4.21.10", + "caniuse-lite": "^1.0.30001538", + "fraction.js": "^4.3.6", + "normalize-range": "^0.1.2", + "picocolors": "^1.0.0", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz", + "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "possible-typed-array-names": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/axe-core": { + "version": "4.8.2", + "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.8.2.tgz", + "integrity": "sha512-/dlp0fxyM3R8YW7MFzaHWXrf4zzbr0vaYb23VBFCl83R7nWNPg/yaQw2Dc8jzCMmDVLhSdzH8MjrsuIUuvX+6g==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/axios": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.2.tgz", + "integrity": "sha512-2A8QhOMrbomlDuiLeK9XibIBzuHeRcqqNOHp0Cyp5EoJ1IFDh+XZH3A6BkXtv0K4gFGCI0Y4BM7B1wOEi0Rmgw==", + "dependencies": { + "follow-redirects": "^1.15.6", + "form-data": "^4.0.0", + "proxy-from-env": "^1.1.0" + } + }, + "node_modules/axobject-query": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-3.2.1.tgz", + "integrity": "sha512-jsyHu61e6N4Vbz/v18DHwWYKK0bSWLqn47eeDSKPB7m8tqMHF9YJ+mhIk2lVteyZrY8tnSj/jHOv4YiTCuCJgg==", + "dev": true, + "dependencies": { + "dequal": "^2.0.3" + } + }, + "node_modules/b4a": { + "version": "1.6.4", + "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.4.tgz", + "integrity": "sha512-fpWrvyVHEKyeEvbKZTVOeZF3VSKKWtJxFIxX/jaVPf+cLbGUSitjb49pHLqPV2BUNNZ0LcoeEGfE/YCpyDYHIw==", + "optional": true + }, + "node_modules/babel-plugin-jsx-dom-expressions": { + "version": "0.36.18", + "resolved": "https://registry.npmjs.org/babel-plugin-jsx-dom-expressions/-/babel-plugin-jsx-dom-expressions-0.36.18.tgz", + "integrity": "sha512-8K0CHgzNMB0+1OC+GQf1O49Nc6DfHAoWDjY4YTW3W/3il5KrDKAj65723oPmya68kKKOkqDKuz+Zh1u7VFHthw==", + "dependencies": { + "@babel/helper-module-imports": "7.18.6", + "@babel/plugin-syntax-jsx": "^7.18.6", + "@babel/types": "^7.20.7", + "html-entities": "2.3.3", + "validate-html-nesting": "^1.2.1" + }, + "peerDependencies": { + "@babel/core": "^7.20.12" + } + }, + "node_modules/babel-plugin-jsx-dom-expressions/node_modules/@babel/helper-module-imports": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", + "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", + "dependencies": { + "@babel/types": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2": { + "version": "0.4.12", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.12.tgz", + "integrity": "sha512-CPWT6BwvhrTO2d8QVorhTCQw9Y43zOu7G9HigcfxvepOU6b8o3tcWad6oVgZIsZCTt42FFv97aA7ZJsbM4+8og==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.22.6", + "@babel/helper-define-polyfill-provider": "^0.6.3", + "semver": "^6.3.1" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/babel-plugin-polyfill-corejs3": { + "version": "0.10.6", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.10.6.tgz", + "integrity": "sha512-b37+KR2i/khY5sKmWNVQAnitvquQbNdWy6lJdsr0kmquCKEEUgMKK4SboVM3HtfnZilfjr4MMQ7vY58FVWDtIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.2", + "core-js-compat": "^3.38.0" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-regenerator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.3.tgz", + "integrity": "sha512-LiWSbl4CRSIa5x/JAU6jZiG9eit9w6mz+yVMFwDE83LAWvt0AfGBoZ7HS/mkhrKuh2ZlzfVZYKoLjXdqw6Yt7Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.3" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-preset-solid": { + "version": "1.7.12", + "resolved": "https://registry.npmjs.org/babel-preset-solid/-/babel-preset-solid-1.7.12.tgz", + "integrity": "sha512-vNZn34Dv6IsWK/F59HhZlN8gP0ihZfkhPp8Lx/nxlY+rKtSZEAmmYlXWtds6EDKSiXoj2TEHuCcuqp6cO7oLSg==", + "dependencies": { + "babel-plugin-jsx-dom-expressions": "^0.36.18" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/bail": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz", + "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" }, "node_modules/base64-js": { @@ -2424,6 +3597,45 @@ "readable-stream": "^3.4.0" } }, + "node_modules/body-parser": { + "version": "1.20.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz", + "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.13.0", + "raw-body": "2.5.2", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/body-parser/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/body-parser/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, "node_modules/boxen": { "version": "7.1.1", "resolved": "https://registry.npmjs.org/boxen/-/boxen-7.1.1.tgz", @@ -2505,9 +3717,9 @@ } }, "node_modules/browserslist": { - "version": "4.22.1", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.22.1.tgz", - "integrity": "sha512-FEVc202+2iuClEhZhrWy6ZiAcRLvNMyYcxZ8raemul1DYVOVdFsbqckWLdsixQZCpJlwe77Z3UTalE7jsjnKfQ==", + "version": "4.24.2", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.2.tgz", + "integrity": "sha512-ZIc+Q62revdMcqC6aChtW4jz3My3klmCO1fEmINZY/8J3EpBg5/A/D0AKmBveUh6pgoeycoMkVMko84tuYS+Gg==", "funding": [ { "type": "opencollective", @@ -2522,11 +3734,12 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "dependencies": { - "caniuse-lite": "^1.0.30001541", - "electron-to-chromium": "^1.4.535", - "node-releases": "^2.0.13", - "update-browserslist-db": "^1.0.13" + "caniuse-lite": "^1.0.30001669", + "electron-to-chromium": "^1.5.41", + "node-releases": "^2.0.18", + "update-browserslist-db": "^1.1.1" }, "bin": { "browserslist": "cli.js" @@ -2573,19 +3786,46 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, "node_modules/call-bind": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", - "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", - "dev": true, + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz", + "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==", + "license": "MIT", "dependencies": { - "function-bind": "^1.1.1", - "get-intrinsic": "^1.0.2" + "call-bind-apply-helpers": "^1.0.0", + "es-define-property": "^1.0.0", + "get-intrinsic": "^1.2.4", + "set-function-length": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.1.tgz", + "integrity": "sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/callsites": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", @@ -2615,9 +3855,9 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001542", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001542.tgz", - "integrity": "sha512-UrtAXVcj1mvPBFQ4sKd38daP8dEcXXr5sQe6QNNinaPd0iA/cxg9/l3VrSdL73jgw5sKyuQ6jNgiKO12W3SsVA==", + "version": "1.0.30001687", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001687.tgz", + "integrity": "sha512-0S/FDhf4ZiqrTUiQ39dKeUjYRjkv7lOZU1Dgif2rIqrTzX/1wV2hfKu9TOm1IHkdSijfLswxTFzl/cvir+SLSQ==", "funding": [ { "type": "opencollective", @@ -2631,7 +3871,8 @@ "type": "github", "url": "https://github.com/sponsors/ai" } - ] + ], + "license": "CC-BY-4.0" }, "node_modules/ccount": { "version": "2.0.1", @@ -2646,6 +3887,7 @@ "version": "2.4.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, "dependencies": { "ansi-styles": "^3.2.1", "escape-string-regexp": "^1.0.5", @@ -2798,6 +4040,7 @@ "version": "1.9.3", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, "dependencies": { "color-name": "1.1.3" } @@ -2805,7 +4048,8 @@ "node_modules/color-name": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", - "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==" + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "devOptional": true }, "node_modules/color-string": { "version": "1.9.1", @@ -2868,22 +4112,102 @@ "resolved": "https://registry.npmjs.org/common-ancestor-path/-/common-ancestor-path-1.0.1.tgz", "integrity": "sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==" }, + "node_modules/commondir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", + "integrity": "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==", + "dev": true, + "license": "MIT" + }, "node_modules/concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==" }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, "node_modules/convert-source-map": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==" }, - "node_modules/cookie": { - "version": "0.5.0", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz", - "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==", + "node_modules/cookie": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz", + "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==", + "license": "MIT" + }, + "node_modules/core-js-compat": { + "version": "3.39.0", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.39.0.tgz", + "integrity": "sha512-VgEUx3VwlExr5no0tXlBt+silBvhTryPwCXRI2Id1PN8WTKu7MreethvddqOubrYxkFdv/RnYrqlv1sFNAUelw==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.24.2" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/cors": { + "version": "2.8.5", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz", + "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==", + "license": "MIT", + "dependencies": { + "object-assign": "^4", + "vary": "^1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/cross-env": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-env/-/cross-env-7.0.3.tgz", + "integrity": "sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "cross-spawn": "^7.0.1" + }, + "bin": { + "cross-env": "src/bin/cross-env.js", + "cross-env-shell": "src/bin/cross-env-shell.js" + }, "engines": { - "node": ">= 0.6" + "node": ">=10.14", + "npm": ">=6", + "yarn": ">=1" } }, "node_modules/cross-spawn": { @@ -2921,6 +4245,60 @@ "integrity": "sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==", "dev": true }, + "node_modules/data-view-buffer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.1.tgz", + "integrity": "sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.6", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/data-view-byte-length": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.1.tgz", + "integrity": "sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/data-view-byte-offset": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.0.tgz", + "integrity": "sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.6", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/debug": { "version": "4.3.4", "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", @@ -2949,6 +4327,16 @@ "url": "https://github.com/sponsors/wooorm" } }, + "node_modules/decode-uri-component": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.2.tgz", + "integrity": "sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10" + } + }, "node_modules/decompress-response": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", @@ -2979,6 +4367,16 @@ "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", "dev": true }, + "node_modules/deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/default-browser": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-4.0.0.tgz", @@ -3064,17 +4462,20 @@ "dev": true }, "node_modules/define-data-property": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.0.tgz", - "integrity": "sha512-UzGwzcjyv3OtAvolTj1GoyNYzfFR+iqbGjcnBEENZVCpM4/Ng1yhGNvS3lR/xDS74Tb2wGG9WzNSNIOS9UVb2g==", - "dev": true, + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "license": "MIT", "dependencies": { - "get-intrinsic": "^1.2.1", - "gopd": "^1.0.1", - "has-property-descriptors": "^1.0.0" + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" }, "engines": { "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" } }, "node_modules/define-lazy-prop": { @@ -3225,6 +4626,20 @@ "node": ">=4" } }, + "node_modules/dunder-proto": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.0.tgz", + "integrity": "sha512-9+Sj30DIu+4KvHqMfLUGLFYL2PkURSYMVXJyXe92nFRvlYq5hBjLEhblKB+vkd/WVlUYMWigiY07T91Fkk0+4A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/eastasianwidth": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", @@ -3236,9 +4651,10 @@ "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" }, "node_modules/electron-to-chromium": { - "version": "1.4.539", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.539.tgz", - "integrity": "sha512-wRmWJ8F7rgmINuI32S6r2SLrw/h/bJQsDSvBiq9GBfvc2Lh73qTOwn73r3Cf67mjVgFGJYcYtmERzySa5jIWlg==" + "version": "1.5.71", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.71.tgz", + "integrity": "sha512-dB68l59BI75W1BUGVTAEJy45CEVuEGy9qPVVQ8pnHyHMn36PLPPoE1mjLH+lo9rKulO3HC2OhbACI/8tCqJBcA==", + "license": "ISC" }, "node_modules/emoji-regex": { "version": "9.2.2", @@ -3273,51 +4689,76 @@ "url": "https://github.com/fb55/entities?sponsor=1" } }, - "node_modules/es-abstract": { - "version": "1.22.2", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.22.2.tgz", - "integrity": "sha512-YoxfFcDmhjOgWPWsV13+2RNjq1F6UQnfs+8TftwNqtzlmFzEXvlUwdrNrYeaizfjQzRMxkZ6ElWMOJIFKdVqwA==", + "node_modules/error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", "dev": true, + "license": "MIT", "dependencies": { - "array-buffer-byte-length": "^1.0.0", - "arraybuffer.prototype.slice": "^1.0.2", - "available-typed-arrays": "^1.0.5", - "call-bind": "^1.0.2", - "es-set-tostringtag": "^2.0.1", + "is-arrayish": "^0.2.1" + } + }, + "node_modules/error-ex/node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true, + "license": "MIT" + }, + "node_modules/es-abstract": { + "version": "1.23.5", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.23.5.tgz", + "integrity": "sha512-vlmniQ0WNPwXqA0BnmwV3Ng7HxiGlh6r5U6JcTMNx8OilcAGqVJBHJcPjqOMaczU9fRuRK5Px2BdVyPRnKMMVQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.1", + "arraybuffer.prototype.slice": "^1.0.3", + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.7", + "data-view-buffer": "^1.0.1", + "data-view-byte-length": "^1.0.1", + "data-view-byte-offset": "^1.0.0", + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "es-set-tostringtag": "^2.0.3", "es-to-primitive": "^1.2.1", "function.prototype.name": "^1.1.6", - "get-intrinsic": "^1.2.1", - "get-symbol-description": "^1.0.0", - "globalthis": "^1.0.3", + "get-intrinsic": "^1.2.4", + "get-symbol-description": "^1.0.2", + "globalthis": "^1.0.4", "gopd": "^1.0.1", - "has": "^1.0.3", - "has-property-descriptors": "^1.0.0", - "has-proto": "^1.0.1", + "has-property-descriptors": "^1.0.2", + "has-proto": "^1.0.3", "has-symbols": "^1.0.3", - "internal-slot": "^1.0.5", - "is-array-buffer": "^3.0.2", + "hasown": "^2.0.2", + "internal-slot": "^1.0.7", + "is-array-buffer": "^3.0.4", "is-callable": "^1.2.7", - "is-negative-zero": "^2.0.2", + "is-data-view": "^1.0.1", + "is-negative-zero": "^2.0.3", "is-regex": "^1.1.4", - "is-shared-array-buffer": "^1.0.2", + "is-shared-array-buffer": "^1.0.3", "is-string": "^1.0.7", - "is-typed-array": "^1.1.12", + "is-typed-array": "^1.1.13", "is-weakref": "^1.0.2", - "object-inspect": "^1.12.3", + "object-inspect": "^1.13.3", "object-keys": "^1.1.1", - "object.assign": "^4.1.4", - "regexp.prototype.flags": "^1.5.1", - "safe-array-concat": "^1.0.1", - "safe-regex-test": "^1.0.0", - "string.prototype.trim": "^1.2.8", - "string.prototype.trimend": "^1.0.7", - "string.prototype.trimstart": "^1.0.7", - "typed-array-buffer": "^1.0.0", - "typed-array-byte-length": "^1.0.0", - "typed-array-byte-offset": "^1.0.0", - "typed-array-length": "^1.0.4", + "object.assign": "^4.1.5", + "regexp.prototype.flags": "^1.5.3", + "safe-array-concat": "^1.1.2", + "safe-regex-test": "^1.0.3", + "string.prototype.trim": "^1.2.9", + "string.prototype.trimend": "^1.0.8", + "string.prototype.trimstart": "^1.0.8", + "typed-array-buffer": "^1.0.2", + "typed-array-byte-length": "^1.0.1", + "typed-array-byte-offset": "^1.0.2", + "typed-array-length": "^1.0.6", "unbox-primitive": "^1.0.2", - "which-typed-array": "^1.1.11" + "which-typed-array": "^1.1.15" }, "engines": { "node": ">= 0.4" @@ -3326,20 +4767,52 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/es-module-lexer": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.3.1.tgz", "integrity": "sha512-JUFAyicQV9mXc3YRxPnDlrfBKpqt6hUYzz9/boprUJHs4e4KVr3XwOF70doO6gwXUor6EWZJAyWAfKki84t20Q==" }, + "node_modules/es-object-atoms": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz", + "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/es-set-tostringtag": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", - "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.3.tgz", + "integrity": "sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==", "dev": true, + "license": "MIT", "dependencies": { - "get-intrinsic": "^1.1.3", - "has": "^1.0.3", - "has-tostringtag": "^1.0.0" + "get-intrinsic": "^1.2.4", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.1" }, "engines": { "node": ">= 0.4" @@ -3408,9 +4881,10 @@ } }, "node_modules/escalade": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", - "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", "engines": { "node": ">=6" } @@ -3424,6 +4898,7 @@ "version": "1.0.5", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, "engines": { "node": ">=0.8.0" } @@ -3973,6 +5448,142 @@ "node": ">=6" } }, + "node_modules/express": { + "version": "4.21.2", + "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz", + "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "1.20.3", + "content-disposition": "0.5.4", + "content-type": "~1.0.4", + "cookie": "0.7.1", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.3.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "0.1.12", + "proxy-addr": "~2.0.7", + "qs": "6.13.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "0.19.0", + "serve-static": "1.16.2", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express/node_modules/cookie": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz", + "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/express/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/express/node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/express/node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/express/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/express/node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", + "license": "MIT" + }, + "node_modules/express/node_modules/send": { + "version": "0.19.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", + "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/express/node_modules/send/node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/express/node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, "node_modules/extend": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", @@ -4065,6 +5676,48 @@ "node": ">=8" } }, + "node_modules/finalhandler": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz", + "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "statuses": "2.0.1", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/finalhandler/node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, "node_modules/find-up": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", @@ -4133,6 +5786,7 @@ "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", "dev": true, + "license": "MIT", "dependencies": { "is-callable": "^1.1.3" } @@ -4150,6 +5804,15 @@ "node": ">= 6" } }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, "node_modules/fraction.js": { "version": "4.3.6", "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.6.tgz", @@ -4181,23 +5844,14 @@ "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==" }, - "node_modules/fsevents": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", - "hasInstallScript": true, - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, "node_modules/function-bind": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", - "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } }, "node_modules/function.prototype.name": { "version": "1.1.6", @@ -4235,15 +5889,22 @@ } }, "node_modules/get-intrinsic": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz", - "integrity": "sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==", - "dev": true, + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.5.tgz", + "integrity": "sha512-Y4+pKa7XeRUPWFNvOOYHkRYrfzW07oraURSvjDmRVOJ748OrVmeXtpE4+GCEHncjCjkTxPNRt8kEbxDhsn6VTg==", + "license": "MIT", "dependencies": { - "function-bind": "^1.1.1", - "has": "^1.0.3", - "has-proto": "^1.0.1", - "has-symbols": "^1.0.3" + "call-bind-apply-helpers": "^1.0.0", + "dunder-proto": "^1.0.0", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -4261,13 +5922,15 @@ } }, "node_modules/get-symbol-description": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", - "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.2.tgz", + "integrity": "sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.1.1" + "call-bind": "^1.0.5", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.4" }, "engines": { "node": ">= 0.4" @@ -4327,12 +5990,14 @@ } }, "node_modules/globalthis": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", - "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz", + "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==", "dev": true, + "license": "MIT", "dependencies": { - "define-properties": "^1.1.3" + "define-properties": "^1.2.1", + "gopd": "^1.0.1" }, "engines": { "node": ">= 0.4" @@ -4362,12 +6027,12 @@ } }, "node_modules/gopd": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", - "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", - "dev": true, - "dependencies": { - "get-intrinsic": "^1.1.3" + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -4442,27 +6107,32 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, "engines": { "node": ">=4" } }, "node_modules/has-property-descriptors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", - "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", - "dev": true, + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", + "license": "MIT", "dependencies": { - "get-intrinsic": "^1.1.1" + "es-define-property": "^1.0.0" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/has-proto": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", - "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz", + "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==", "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.0" + }, "engines": { "node": ">= 0.4" }, @@ -4471,10 +6141,10 @@ } }, "node_modules/has-symbols": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", - "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", - "dev": true, + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -4483,12 +6153,13 @@ } }, "node_modules/has-tostringtag": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", - "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", "dev": true, + "license": "MIT", "dependencies": { - "has-symbols": "^1.0.2" + "has-symbols": "^1.0.3" }, "engines": { "node": ">= 0.4" @@ -4497,6 +6168,18 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/hast-util-from-parse5": { "version": "7.1.2", "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-7.1.2.tgz", @@ -4647,6 +6330,13 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/hosted-git-info": { + "version": "2.8.9", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz", + "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==", + "dev": true, + "license": "ISC" + }, "node_modules/html-entities": { "version": "2.3.3", "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.3.3.tgz", @@ -4745,6 +6435,13 @@ "node": ">= 4" } }, + "node_modules/ignore-by-default": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz", + "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==", + "dev": true, + "license": "ISC" + }, "node_modules/import-fresh": { "version": "3.3.0", "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", @@ -4805,19 +6502,29 @@ "integrity": "sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==" }, "node_modules/internal-slot": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", - "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.7.tgz", + "integrity": "sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==", "dev": true, + "license": "MIT", "dependencies": { - "get-intrinsic": "^1.2.0", - "has": "^1.0.3", + "es-errors": "^1.3.0", + "hasown": "^2.0.0", "side-channel": "^1.0.4" }, "engines": { "node": ">= 0.4" } }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, "node_modules/is-alphabetical": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz", @@ -4841,14 +6548,17 @@ } }, "node_modules/is-array-buffer": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", - "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.4.tgz", + "integrity": "sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==", "dev": true, + "license": "MIT", "dependencies": { "call-bind": "^1.0.2", - "get-intrinsic": "^1.2.0", - "is-typed-array": "^1.1.10" + "get-intrinsic": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -4860,6 +6570,22 @@ "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==", "optional": true }, + "node_modules/is-async-function": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.0.0.tgz", + "integrity": "sha512-Y1JXKrfykRJGdlDwdKlLpLyMIiWqWvuSd17TvZk68PLAOGOoF4Xyav1z0Xhoi+gCYjZVeC5SI+hYFOfvXmGRCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-bigint": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", @@ -4944,6 +6670,22 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/is-data-view": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.1.tgz", + "integrity": "sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-date-object": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", @@ -4998,6 +6740,22 @@ "node": ">=0.10.0" } }, + "node_modules/is-finalizationregistry": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.0.tgz", + "integrity": "sha512-qfMdqbAQEwBw78ZyReKnlA8ezmPdb9BemzIIip/JkjaZUhitfXDkkr+3QTboW0JrSXT1QWyYShpvnNHGZ4c4yA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-fullwidth-code-point": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", @@ -5006,6 +6764,22 @@ "node": ">=8" } }, + "node_modules/is-generator-function": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.10.tgz", + "integrity": "sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-glob": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", @@ -5066,11 +6840,32 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/is-map": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz", + "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz", + "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==", + "dev": true, + "license": "MIT" + }, "node_modules/is-negative-zero": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", - "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz", + "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==", "dev": true, + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -5138,14 +6933,30 @@ } }, "node_modules/is-regex": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", - "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.0.tgz", + "integrity": "sha512-B6ohK4ZmoftlUe+uvenXSbPJFo6U37BH7oO1B3nQH8f/7h27N56s85MhUtbFJAziz5dcmuR3i8ovUl35zp8pFA==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "has-tostringtag": "^1.0.0" + "call-bind": "^1.0.7", + "gopd": "^1.1.0", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-set": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz", + "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==", + "dev": true, + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -5154,12 +6965,16 @@ } }, "node_modules/is-shared-array-buffer": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", - "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.3.tgz", + "integrity": "sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2" + "call-bind": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -5207,12 +7022,13 @@ } }, "node_modules/is-typed-array": { - "version": "1.1.12", - "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.12.tgz", - "integrity": "sha512-Z14TF2JNG8Lss5/HMqt0//T9JeHXttXy5pH/DBU4vi98ozO2btxzq9MwYDZYnKwU8nRsz/+GVFVRDq3DkVuSPg==", + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz", + "integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==", "dev": true, + "license": "MIT", "dependencies": { - "which-typed-array": "^1.1.11" + "which-typed-array": "^1.1.14" }, "engines": { "node": ">= 0.4" @@ -5232,6 +7048,19 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/is-weakmap": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz", + "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-weakref": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", @@ -5244,6 +7073,23 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/is-weakset": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.3.tgz", + "integrity": "sha512-LvIm3/KWzS9oRFHugab7d+M/GcBXuXX5xZkzPmN+NxihdQlZUQ4dWuSV1xR/sq6upL1TJEDrfBgRepHFdBtSNQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "get-intrinsic": "^1.2.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-what": { "version": "4.1.15", "resolved": "https://registry.npmjs.org/is-what/-/is-what-4.1.15.tgz", @@ -5273,7 +7119,8 @@ "version": "2.0.5", "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/isexe": { "version": "2.0.0", @@ -5291,7 +7138,8 @@ "node_modules/js-tokens": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", - "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" }, "node_modules/js-yaml": { "version": "4.1.0", @@ -5305,14 +7153,15 @@ } }, "node_modules/jsesc": { - "version": "2.5.2", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", - "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz", + "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==", + "license": "MIT", "bin": { "jsesc": "bin/jsesc" }, "engines": { - "node": ">=4" + "node": ">=6" } }, "node_modules/json-buffer": { @@ -5321,6 +7170,13 @@ "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", "dev": true }, + "node_modules/json-parse-better-errors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz", + "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==", + "dev": true, + "license": "MIT" + }, "node_modules/json-schema-traverse": { "version": "0.4.1", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", @@ -5442,6 +7298,32 @@ "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==" }, + "node_modules/load-json-file": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz", + "integrity": "sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.1.2", + "parse-json": "^4.0.0", + "pify": "^3.0.0", + "strip-bom": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/load-json-file/node_modules/pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, "node_modules/load-yaml-file": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/load-yaml-file/-/load-yaml-file-0.2.0.tgz", @@ -5484,14 +7366,6 @@ "node": ">=6" } }, - "node_modules/load-yaml-file/node_modules/strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", - "engines": { - "node": ">=4" - } - }, "node_modules/locate-path": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", @@ -5511,6 +7385,13 @@ "resolved": "https://registry.npmjs.org/lodash.castarray/-/lodash.castarray-4.4.0.tgz", "integrity": "sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q==" }, + "node_modules/lodash.debounce": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz", + "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==", + "dev": true, + "license": "MIT" + }, "node_modules/lodash.isplainobject": { "version": "4.0.6", "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", @@ -5560,6 +7441,7 @@ "version": "5.1.1", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "license": "ISC", "dependencies": { "yallist": "^3.0.2" } @@ -6047,6 +7929,24 @@ "@types/unist": "^2" } }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/memorystream": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz", + "integrity": "sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==", + "dev": true, + "engines": { + "node": ">= 0.10.0" + } + }, "node_modules/merge-anything": { "version": "5.1.7", "resolved": "https://registry.npmjs.org/merge-anything/-/merge-anything-5.1.7.tgz", @@ -6061,6 +7961,15 @@ "url": "https://github.com/sponsors/mesqueeb" } }, + "node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/merge-stream": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", @@ -6074,6 +7983,15 @@ "node": ">= 8" } }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, "node_modules/micromark": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/micromark/-/micromark-3.2.0.tgz", @@ -6855,6 +8773,10 @@ "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==", "optional": true }, + "node_modules/moq-player": { + "resolved": "lib", + "link": true + }, "node_modules/mp4box": { "version": "0.5.2", "resolved": "https://registry.npmjs.org/mp4box/-/mp4box-0.5.2.tgz", @@ -6936,6 +8858,22 @@ "ms": "^2.1.1" } }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/nice-try": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz", + "integrity": "sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==", + "dev": true, + "license": "MIT" + }, "node_modules/nlcst-to-string": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/nlcst-to-string/-/nlcst-to-string-3.1.1.tgz", @@ -6986,9 +8924,62 @@ } }, "node_modules/node-releases": { - "version": "2.0.13", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.13.tgz", - "integrity": "sha512-uYr7J37ae/ORWdZeQ1xxMJe3NtdmqMC/JZK+geofDrkLUApKRHPd18/TxtBOJ4A0/+uUIliorNrfYV6s1b02eQ==" + "version": "2.0.18", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz", + "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==", + "license": "MIT" + }, + "node_modules/nodemon": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.7.tgz", + "integrity": "sha512-hLj7fuMow6f0lbB0cD14Lz2xNjwsyruH251Pk4t/yIitCFJbmY1myuLlHm/q06aST4jg6EgAh74PIBBrRqpVAQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "chokidar": "^3.5.2", + "debug": "^4", + "ignore-by-default": "^1.0.1", + "minimatch": "^3.1.2", + "pstree.remy": "^1.1.8", + "semver": "^7.5.3", + "simple-update-notifier": "^2.0.0", + "supports-color": "^5.5.0", + "touch": "^3.1.0", + "undefsafe": "^2.0.5" + }, + "bin": { + "nodemon": "bin/nodemon.js" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/nodemon" + } + }, + "node_modules/normalize-package-data": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", + "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "hosted-git-info": "^2.1.4", + "resolve": "^1.10.0", + "semver": "2 || 3 || 4 || 5", + "validate-npm-package-license": "^3.0.1" + } + }, + "node_modules/normalize-package-data/node_modules/semver": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver" + } }, "node_modules/normalize-path": { "version": "3.0.0", @@ -6998,14 +8989,113 @@ "node": ">=0.10.0" } }, - "node_modules/normalize-range": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", - "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==", + "node_modules/normalize-range": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", + "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/npm-run-all": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/npm-run-all/-/npm-run-all-4.1.5.tgz", + "integrity": "sha512-Oo82gJDAVcaMdi3nuoKFavkIHBRVqQ1qvMb+9LHk/cF4P6B2m8aP04hGf7oL6wZ9BuGwX1onlLhpuoofSyoQDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "chalk": "^2.4.1", + "cross-spawn": "^6.0.5", + "memorystream": "^0.3.1", + "minimatch": "^3.0.4", + "pidtree": "^0.3.0", + "read-pkg": "^3.0.0", + "shell-quote": "^1.6.1", + "string.prototype.padend": "^3.0.0" + }, + "bin": { + "npm-run-all": "bin/npm-run-all/index.js", + "run-p": "bin/run-p/index.js", + "run-s": "bin/run-s/index.js" + }, + "engines": { + "node": ">= 4" + } + }, + "node_modules/npm-run-all/node_modules/cross-spawn": { + "version": "6.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.6.tgz", + "integrity": "sha512-VqCUuhcd1iB+dsv8gxPttb5iZh/D0iubSP21g36KXdEuf6I5JiioesUVjpCdHV9MZRUfVFlvwtIUyPfxo5trtw==", + "dev": true, + "license": "MIT", + "dependencies": { + "nice-try": "^1.0.4", + "path-key": "^2.0.1", + "semver": "^5.5.0", + "shebang-command": "^1.2.0", + "which": "^1.2.9" + }, + "engines": { + "node": ">=4.8" + } + }, + "node_modules/npm-run-all/node_modules/path-key": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/npm-run-all/node_modules/semver": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver" + } + }, + "node_modules/npm-run-all/node_modules/shebang-command": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^1.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/npm-run-all/node_modules/shebang-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==", + "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } }, + "node_modules/npm-run-all/node_modules/which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "which": "bin/which" + } + }, "node_modules/npm-run-path": { "version": "5.1.0", "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.1.0.tgz", @@ -7048,10 +9138,13 @@ } }, "node_modules/object-inspect": { - "version": "1.12.3", - "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", - "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", - "dev": true, + "version": "1.13.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.3.tgz", + "integrity": "sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -7066,13 +9159,14 @@ } }, "node_modules/object.assign": { - "version": "4.1.4", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", - "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.5.tgz", + "integrity": "sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.1.4", + "call-bind": "^1.0.5", + "define-properties": "^1.2.1", "has-symbols": "^1.0.3", "object-keys": "^1.1.1" }, @@ -7377,6 +9471,20 @@ "url": "https://github.com/sponsors/wooorm" } }, + "node_modules/parse-json": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz", + "integrity": "sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==", + "dev": true, + "license": "MIT", + "dependencies": { + "error-ex": "^1.3.1", + "json-parse-better-errors": "^1.0.1" + }, + "engines": { + "node": ">=4" + } + }, "node_modules/parse-latin": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/parse-latin/-/parse-latin-5.0.1.tgz", @@ -7396,6 +9504,25 @@ "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz", "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==" }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path": { + "version": "0.12.7", + "resolved": "https://registry.npmjs.org/path/-/path-0.12.7.tgz", + "integrity": "sha512-aXXC6s+1w7otVF9UletFkFcDsJeO7lSZBPUQhtb5O0xJe8LtYhj/GxldoL09bBj9+ZmE2hNoHqQSFMN5fikh4Q==", + "license": "MIT", + "dependencies": { + "process": "^0.11.1", + "util": "^0.10.3" + } + }, "node_modules/path-exists": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", @@ -7450,9 +9577,10 @@ } }, "node_modules/picocolors": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", - "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==" + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "license": "ISC" }, "node_modules/picomatch": { "version": "2.3.1", @@ -7465,6 +9593,19 @@ "url": "https://github.com/sponsors/jonschlinkert" } }, + "node_modules/pidtree": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/pidtree/-/pidtree-0.3.1.tgz", + "integrity": "sha512-qQbW94hLHEqCg7nhby4yRC7G2+jYHY4Rguc2bjw7Uug4GIJuu1tvf2uHaZv5Q8zdt+WKJ6qK1FOI6amaWUo5FA==", + "dev": true, + "license": "MIT", + "bin": { + "pidtree": "bin/pidtree.js" + }, + "engines": { + "node": ">=0.10" + } + }, "node_modules/pify": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", @@ -7540,6 +9681,16 @@ "node": ">=8" } }, + "node_modules/possible-typed-array-names": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.0.0.tgz", + "integrity": "sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/postcss": { "version": "8.4.31", "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz", @@ -7946,6 +10097,15 @@ "stream-parser": "~0.3.1" } }, + "node_modules/process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==", + "license": "MIT", + "engines": { + "node": ">= 0.6.0" + } + }, "node_modules/prompts": { "version": "2.4.2", "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", @@ -7975,11 +10135,31 @@ "url": "https://github.com/sponsors/wooorm" } }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, "node_modules/proxy-from-env": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==" }, + "node_modules/pstree.remy": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz", + "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==", + "dev": true, + "license": "MIT" + }, "node_modules/pump": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz", @@ -7999,6 +10179,21 @@ "node": ">=6" } }, + "node_modules/qs": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz", + "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.0.6" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/queue-microtask": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", @@ -8032,6 +10227,21 @@ "node": ">= 0.6" } }, + "node_modules/raw-body": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", + "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, "node_modules/rc": { "version": "1.2.8", "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", @@ -8064,6 +10274,44 @@ "pify": "^2.3.0" } }, + "node_modules/read-pkg": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz", + "integrity": "sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "load-json-file": "^4.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/read-pkg/node_modules/path-type": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz", + "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==", + "dev": true, + "license": "MIT", + "dependencies": { + "pify": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/read-pkg/node_modules/pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, "node_modules/readable-stream": { "version": "3.6.2", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", @@ -8088,21 +10336,76 @@ "node": ">=8.10.0" } }, + "node_modules/reflect.getprototypeof": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.8.tgz", + "integrity": "sha512-B5dj6usc5dkk8uFliwjwDHM8To5/QwdKz9JcBZ8Ic4G1f0YmeeJTtE/ZTdgRFPAfxZFiUaPhZ1Jcs4qeagItGQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "dunder-proto": "^1.0.0", + "es-abstract": "^1.23.5", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.4", + "gopd": "^1.2.0", + "which-builtin-type": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/regenerate": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", + "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==", + "dev": true, + "license": "MIT" + }, + "node_modules/regenerate-unicode-properties": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.0.tgz", + "integrity": "sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==", + "dev": true, + "license": "MIT", + "dependencies": { + "regenerate": "^1.4.2" + }, + "engines": { + "node": ">=4" + } + }, "node_modules/regenerator-runtime": { "version": "0.14.0", "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.0.tgz", "integrity": "sha512-srw17NI0TUWHuGa5CFGGmhfNIeja30WMBfbslPNhf6JrqQlLN5gcrvig1oqPxiVaXb0oW0XRKtH6Nngs5lKCIA==", "dev": true }, + "node_modules/regenerator-transform": { + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.15.2.tgz", + "integrity": "sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.8.4" + } + }, "node_modules/regexp.prototype.flags": { - "version": "1.5.1", - "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.1.tgz", - "integrity": "sha512-sy6TXMN+hnP/wMy+ISxg3krXx7BAtWVO4UouuCN/ziM9UEne0euamVNafDfvC83bRNr95y0V5iijeDQFUNpvrg==", + "version": "1.5.3", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.3.tgz", + "integrity": "sha512-vqlC04+RQoFalODCbCumG2xIOvapzVMHwsyIGM/SIE8fRhFFsXeH8/QQ+s0T0kDAhKc4k30s73/0ydkHQz6HlQ==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "set-function-name": "^2.0.0" + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-errors": "^1.3.0", + "set-function-name": "^2.0.2" }, "engines": { "node": ">= 0.4" @@ -8111,6 +10414,44 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/regexpu-core": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.2.0.tgz", + "integrity": "sha512-H66BPQMrv+V16t8xtmq+UC0CBpiTBA60V8ibS1QVReIp8T1z8hwFxqcGzm9K6lgsN7sB5edVH8a+ze6Fqm4weA==", + "dev": true, + "license": "MIT", + "dependencies": { + "regenerate": "^1.4.2", + "regenerate-unicode-properties": "^10.2.0", + "regjsgen": "^0.8.0", + "regjsparser": "^0.12.0", + "unicode-match-property-ecmascript": "^2.0.0", + "unicode-match-property-value-ecmascript": "^2.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regjsgen": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz", + "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/regjsparser": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.12.0.tgz", + "integrity": "sha512-cnE+y8bz4NhMjISKbgeVJtqNbtf5QpjZP+Bslo+UqkIt9QPnX9q095eiRRASJG1/tz6dlNr6Z5NsBiWYokp6EQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "jsesc": "~3.0.2" + }, + "bin": { + "regjsparser": "bin/parser" + } + }, "node_modules/rehype": { "version": "12.0.1", "resolved": "https://registry.npmjs.org/rehype/-/rehype-12.0.1.tgz", @@ -8428,6 +10769,70 @@ "fsevents": "~2.3.2" } }, + "node_modules/rollup-plugin-sourcemaps": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/rollup-plugin-sourcemaps/-/rollup-plugin-sourcemaps-0.6.3.tgz", + "integrity": "sha512-paFu+nT1xvuO1tPFYXGe+XnQvg4Hjqv/eIhG8i5EspfYYPBKL57X7iVbfv55aNVASg3dzWvES9dmWsL2KhfByw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^3.0.9", + "source-map-resolve": "^0.6.0" + }, + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "@types/node": ">=10.0.0", + "rollup": ">=0.31.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/rollup-plugin-sourcemaps/node_modules/@rollup/pluginutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz", + "integrity": "sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "0.0.39", + "estree-walker": "^1.0.1", + "picomatch": "^2.2.2" + }, + "engines": { + "node": ">= 8.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0" + } + }, + "node_modules/rollup-plugin-sourcemaps/node_modules/@types/estree": { + "version": "0.0.39", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz", + "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==", + "dev": true, + "license": "MIT" + }, + "node_modules/rollup-plugin-sourcemaps/node_modules/estree-walker": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz", + "integrity": "sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==", + "dev": true, + "license": "MIT" + }, + "node_modules/rollup-plugin-web-worker-loader": { + "version": "1.6.1", + "resolved": "git+ssh://git@github.com/htoooth/rollup-plugin-web-worker-loader.git#f9c35e0cfd07bfedc38400e9163013a9e9265cbf", + "dev": true, + "license": "MIT", + "peerDependencies": { + "rollup": "^1.9.2 || ^2.0.0 || ^3.0.0 || ^4.0.0" + } + }, "node_modules/run-applescript": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-5.0.0.tgz", @@ -8590,13 +10995,14 @@ } }, "node_modules/safe-array-concat": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.0.1.tgz", - "integrity": "sha512-6XbUAseYE2KtOuGueyeobCySj9L4+66Tn6KQMOPQJrAJEowYKW/YR/MGJZl7FdydUdaFu4LYyDZjxf4/Nmo23Q==", + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.2.tgz", + "integrity": "sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.2.1", + "call-bind": "^1.0.7", + "get-intrinsic": "^1.2.4", "has-symbols": "^1.0.3", "isarray": "^2.0.5" }, @@ -8627,15 +11033,19 @@ ] }, "node_modules/safe-regex-test": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", - "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.3.tgz", + "integrity": "sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.1.3", + "call-bind": "^1.0.6", + "es-errors": "^1.3.0", "is-regex": "^1.1.4" }, + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -8761,20 +11171,129 @@ "node": ">=10" } }, + "node_modules/serve-static": { + "version": "1.16.2", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz", + "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "0.19.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/serve-static/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/serve-static/node_modules/debug/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/serve-static/node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/serve-static/node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/serve-static/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/serve-static/node_modules/send": { + "version": "0.19.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", + "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/serve-static/node_modules/send/node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, "node_modules/server-destroy": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/server-destroy/-/server-destroy-1.0.1.tgz", "integrity": "sha512-rb+9B5YBIEzYcD6x2VKidaa+cqYBJQKnU4oe4E3ANwRRN56yk/ua1YCJT1n21NTS8w6CcOclAKNP3PhdCXKYtQ==" }, + "node_modules/set-function-length": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", + "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/set-function-name": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.1.tgz", - "integrity": "sha512-tMNCiqYVkXIZgc2Hnoy2IvC/f8ezc5koaRFkCjrpWzGpCd3qbZXPzVy9MAZzK1ch/X0jvSkojys3oqJN0qCmdA==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz", + "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==", "dev": true, + "license": "MIT", "dependencies": { - "define-data-property": "^1.0.1", + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", "functions-have-names": "^1.2.3", - "has-property-descriptors": "^1.0.0" + "has-property-descriptors": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -8827,6 +11346,19 @@ "node": ">=8" } }, + "node_modules/shell-quote": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.2.tgz", + "integrity": "sha512-AzqKpGKjrj7EM6rKVQEPpB288oCfnrEIuyoT9cyF4nmGa7V8Zk6f7RRqYisX8X9m+Q7bd632aZW4ky7EhbQztA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/shiki": { "version": "0.14.4", "resolved": "https://registry.npmjs.org/shiki/-/shiki-0.14.4.tgz", @@ -9211,14 +11743,18 @@ } }, "node_modules/side-channel": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", - "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", - "dev": true, + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz", + "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==", + "license": "MIT", "dependencies": { - "call-bind": "^1.0.0", - "get-intrinsic": "^1.0.2", - "object-inspect": "^1.9.0" + "call-bind": "^1.0.7", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.4", + "object-inspect": "^1.13.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -9280,6 +11816,10 @@ "simple-concat": "^1.0.0" } }, + "node_modules/simple-moq-web": { + "resolved": "simple-web", + "link": true + }, "node_modules/simple-swizzle": { "version": "0.2.2", "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz", @@ -9289,6 +11829,19 @@ "is-arrayish": "^0.3.1" } }, + "node_modules/simple-update-notifier": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz", + "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/sisteransi": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", @@ -9341,6 +11894,18 @@ "node": ">=0.10.0" } }, + "node_modules/source-map-resolve": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.6.0.tgz", + "integrity": "sha512-KXBr9d/fO/bWo97NXsPIAW1bFSBOuCnjbNTBMO7N59hsv5i9yzRDfcYwwt0l04+VqnKC+EwzvJZIP/qkuMgR/w==", + "deprecated": "See https://github.com/lydell/source-map-resolve#deprecated", + "dev": true, + "license": "MIT", + "dependencies": { + "atob": "^2.1.2", + "decode-uri-component": "^0.2.0" + } + }, "node_modules/space-separated-tokens": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", @@ -9350,6 +11915,42 @@ "url": "https://github.com/sponsors/wooorm" } }, + "node_modules/spdx-correct": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz", + "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/spdx-exceptions": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz", + "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==", + "dev": true, + "license": "CC-BY-3.0" + }, + "node_modules/spdx-expression-parse": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/spdx-license-ids": { + "version": "3.0.20", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.20.tgz", + "integrity": "sha512-jg25NiDV/1fLtSgEgyvVyDunvaNHbuwF9lfNV17gSmPFAlYzdfNBlLtLzXTevwkPj7DhGbmN9VnmJIgLnhvaBw==", + "dev": true, + "license": "CC0-1.0" + }, "node_modules/sprintf-js": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", @@ -9437,15 +12038,36 @@ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.2.1.tgz", "integrity": "sha512-97g6QgOk8zlDRdgq1WxwgTMgEWGVAQvB5Fdpgc1MkNy56la5SKP9GsMXKDOdqwn90/41a8yPwIGk1Y6WVbeMQA==" }, + "node_modules/string.prototype.padend": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.1.6.tgz", + "integrity": "sha512-XZpspuSB7vJWhvJc9DLSlrXl1mcA2BdoY5jjnS135ydXqLoqhs96JjDtCkjJEQHvfqZIp9hBuBMgI589peyx9Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/string.prototype.trim": { - "version": "1.2.8", - "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.8.tgz", - "integrity": "sha512-lfjY4HcixfQXOfaqCvcBuOIapyaroTXhbkfJN3gcB1OtyupngWK4sEET9Knd0cXd28kTUqu/kHoV4HKSJdnjiQ==", + "version": "1.2.9", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.9.tgz", + "integrity": "sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1" + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.0", + "es-object-atoms": "^1.0.0" }, "engines": { "node": ">= 0.4" @@ -9455,28 +12077,33 @@ } }, "node_modules/string.prototype.trimend": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.7.tgz", - "integrity": "sha512-Ni79DqeB72ZFq1uH/L6zJ+DKZTkOtPIHovb3YZHQViE+HDouuU4mBrLOLDn5Dde3RF8qw5qVETEjhu9locMLvA==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.8.tgz", + "integrity": "sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1" + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/string.prototype.trimstart": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.7.tgz", - "integrity": "sha512-NGhtDFu3jCEm7B4Fy0DpLewdJQOZcQ0rGbwQ/+stjnrp2i+rlKeCvos9hOIeCmqwratM47OBxY7uFZzjxHXmrg==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz", + "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1" + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -9509,6 +12136,15 @@ "url": "https://github.com/chalk/strip-ansi?sponsor=1" } }, + "node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, "node_modules/strip-bom-string": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz", @@ -9602,6 +12238,7 @@ "version": "5.5.0", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, "dependencies": { "has-flag": "^3.0.0" }, @@ -9754,14 +12391,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/to-fast-properties": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", - "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", - "engines": { - "node": ">=4" - } - }, "node_modules/to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", @@ -9781,6 +12410,16 @@ "node": ">=0.6" } }, + "node_modules/touch": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz", + "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==", + "dev": true, + "license": "ISC", + "bin": { + "nodetouch": "bin/nodetouch.js" + } + }, "node_modules/tr46": { "version": "0.0.3", "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", @@ -9841,10 +12480,11 @@ } }, "node_modules/tslib": { - "version": "2.6.2", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", - "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==", - "dev": true + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true, + "license": "0BSD" }, "node_modules/tunnel-agent": { "version": "0.6.0", @@ -9881,787 +12521,604 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/typed-array-buffer": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.0.tgz", - "integrity": "sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==", - "dev": true, - "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.2.1", - "is-typed-array": "^1.1.10" - }, - "engines": { - "node": ">= 0.4" - } - }, - "node_modules/typed-array-byte-length": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.0.tgz", - "integrity": "sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==", - "dev": true, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "for-each": "^0.3.3", - "has-proto": "^1.0.1", - "is-typed-array": "^1.1.10" + "media-typer": "0.3.0", + "mime-types": "~2.1.24" }, "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "node": ">= 0.6" } }, - "node_modules/typed-array-byte-offset": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.0.tgz", - "integrity": "sha512-RD97prjEt9EL8YgAgpOkf3O4IF9lhJFr9g0htQkm0rchFp/Vx7LW5Q8fSXXub7BXAODyUQohRMyOc3faCPd0hg==", + "node_modules/typed-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.2.tgz", + "integrity": "sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==", "dev": true, + "license": "MIT", "dependencies": { - "available-typed-arrays": "^1.0.5", - "call-bind": "^1.0.2", - "for-each": "^0.3.3", - "has-proto": "^1.0.1", - "is-typed-array": "^1.1.10" + "call-bind": "^1.0.7", + "es-errors": "^1.3.0", + "is-typed-array": "^1.1.13" }, "engines": { "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/typed-array-length": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", - "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "node_modules/typed-array-byte-length": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.1.tgz", + "integrity": "sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", + "call-bind": "^1.0.7", "for-each": "^0.3.3", - "is-typed-array": "^1.1.9" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/typescript": { - "version": "5.2.2", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz", - "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==", - "devOptional": true, - "bin": { - "tsc": "bin/tsc", - "tsserver": "bin/tsserver" + "gopd": "^1.0.1", + "has-proto": "^1.0.3", + "is-typed-array": "^1.1.13" }, "engines": { - "node": ">=14.17" - } - }, - "node_modules/unbox-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", - "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", - "dev": true, - "dependencies": { - "call-bind": "^1.0.2", - "has-bigints": "^1.0.2", - "has-symbols": "^1.0.3", - "which-boxed-primitive": "^1.0.2" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "node_modules/unherit": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/unherit/-/unherit-3.0.1.tgz", - "integrity": "sha512-akOOQ/Yln8a2sgcLj4U0Jmx0R5jpIg2IUyRrWOzmEbjBtGzBdHtSeFKgoEcoH4KYIG/Pb8GQ/BwtYm0GCq1Sqg==", - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" - } - }, - "node_modules/unified": { - "version": "10.1.2", - "resolved": "https://registry.npmjs.org/unified/-/unified-10.1.2.tgz", - "integrity": "sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==", - "dependencies": { - "@types/unist": "^2.0.0", - "bail": "^2.0.0", - "extend": "^3.0.0", - "is-buffer": "^2.0.0", - "is-plain-obj": "^4.0.0", - "trough": "^2.0.0", - "vfile": "^5.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/unist-util-generated": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-2.0.1.tgz", - "integrity": "sha512-qF72kLmPxAw0oN2fwpWIqbXAVyEqUzDHMsbtPvOudIlUzXYFIeQIuxXQCRCFh22B7cixvU0MG7m3MW8FTq/S+A==", - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/unist-util-is": { - "version": "5.2.1", - "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz", - "integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==", - "dependencies": { - "@types/unist": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/unist-util-modify-children": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/unist-util-modify-children/-/unist-util-modify-children-3.1.1.tgz", - "integrity": "sha512-yXi4Lm+TG5VG+qvokP6tpnk+r1EPwyYL04JWDxLvgvPV40jANh7nm3udk65OOWquvbMDe+PL9+LmkxDpTv/7BA==", - "dependencies": { - "@types/unist": "^2.0.0", - "array-iterate": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/unist-util-position": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.4.tgz", - "integrity": "sha512-kUBE91efOWfIVBo8xzh/uZQ7p9ffYRtUbMRZBNFYwf0RK8koUMx6dGUfwylLOKmaT2cs4wSW96QoYUSXAyEtpg==", - "dependencies": { - "@types/unist": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/unist-util-position-from-estree": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-1.1.2.tgz", - "integrity": "sha512-poZa0eXpS+/XpoQwGwl79UUdea4ol2ZuCYguVaJS4qzIOMDzbqz8a3erUCOmubSZkaOuGamb3tX790iwOIROww==", - "dependencies": { - "@types/unist": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/unist-util-remove-position": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-4.0.2.tgz", - "integrity": "sha512-TkBb0HABNmxzAcfLf4qsIbFbaPDvMO6wa3b3j4VcEzFVaw1LBKwnW4/sRJ/atSLSzoIg41JWEdnE7N6DIhGDGQ==", - "dependencies": { - "@types/unist": "^2.0.0", - "unist-util-visit": "^4.0.0" + "node": ">= 0.4" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/unist-util-stringify-position": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz", - "integrity": "sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==", + "node_modules/typed-array-byte-offset": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.3.tgz", + "integrity": "sha512-GsvTyUHTriq6o/bHcTd0vM7OQ9JEdlvluu9YISaA7+KzDzPaIzEeDFNkTfhdE3MYcNhNi0vq/LlegYgIs5yPAw==", + "dev": true, + "license": "MIT", "dependencies": { - "@types/unist": "^2.0.0" + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.7", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-proto": "^1.0.3", + "is-typed-array": "^1.1.13", + "reflect.getprototypeof": "^1.0.6" + }, + "engines": { + "node": ">= 0.4" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/unist-util-visit": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz", - "integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==", + "node_modules/typed-array-length": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz", + "integrity": "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==", + "dev": true, + "license": "MIT", "dependencies": { - "@types/unist": "^2.0.0", - "unist-util-is": "^5.0.0", - "unist-util-visit-parents": "^5.1.1" + "call-bind": "^1.0.7", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "is-typed-array": "^1.1.13", + "possible-typed-array-names": "^1.0.0", + "reflect.getprototypeof": "^1.0.6" + }, + "engines": { + "node": ">= 0.4" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/unist-util-visit-children": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/unist-util-visit-children/-/unist-util-visit-children-2.0.2.tgz", - "integrity": "sha512-+LWpMFqyUwLGpsQxpumsQ9o9DG2VGLFrpz+rpVXYIEdPy57GSy5HioC0g3bg/8WP9oCLlapQtklOzQ8uLS496Q==", - "dependencies": { - "@types/unist": "^2.0.0" + "node_modules/typescript": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz", + "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==", + "devOptional": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "engines": { + "node": ">=14.17" } }, - "node_modules/unist-util-visit-parents": { - "version": "5.1.3", - "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz", - "integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==", + "node_modules/unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, "dependencies": { - "@types/unist": "^2.0.0", - "unist-util-is": "^5.0.0" + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/universal-user-agent": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz", - "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w==" + "node_modules/undefsafe": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz", + "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==", + "dev": true, + "license": "MIT" }, - "node_modules/untildify": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", - "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==", + "node_modules/unherit": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/unherit/-/unherit-3.0.1.tgz", + "integrity": "sha512-akOOQ/Yln8a2sgcLj4U0Jmx0R5jpIg2IUyRrWOzmEbjBtGzBdHtSeFKgoEcoH4KYIG/Pb8GQ/BwtYm0GCq1Sqg==", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/unicode-canonical-property-names-ecmascript": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz", + "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==", "dev": true, + "license": "MIT", "engines": { - "node": ">=8" + "node": ">=4" } }, - "node_modules/update-browserslist-db": { - "version": "1.0.13", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz", - "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==", - "funding": [ - { - "type": "opencollective", - "url": "https://opencollective.com/browserslist" - }, - { - "type": "tidelift", - "url": "https://tidelift.com/funding/github/npm/browserslist" - }, - { - "type": "github", - "url": "https://github.com/sponsors/ai" - } - ], + "node_modules/unicode-match-property-ecmascript": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz", + "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==", + "dev": true, + "license": "MIT", "dependencies": { - "escalade": "^3.1.1", - "picocolors": "^1.0.0" + "unicode-canonical-property-names-ecmascript": "^2.0.0", + "unicode-property-aliases-ecmascript": "^2.0.0" }, - "bin": { - "update-browserslist-db": "cli.js" - }, - "peerDependencies": { - "browserslist": ">= 4.21.0" + "engines": { + "node": ">=4" } }, - "node_modules/uri-js": { - "version": "4.4.1", - "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", - "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "node_modules/unicode-match-property-value-ecmascript": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.0.tgz", + "integrity": "sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg==", "dev": true, - "dependencies": { - "punycode": "^2.1.0" + "license": "MIT", + "engines": { + "node": ">=4" } }, - "node_modules/util-deprecate": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", - "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" - }, - "node_modules/uvu": { - "version": "0.5.6", - "resolved": "https://registry.npmjs.org/uvu/-/uvu-0.5.6.tgz", - "integrity": "sha512-+g8ENReyr8YsOc6fv/NVJs2vFdHBnBNdfE49rshrTzDWOlUx4Gq7KOS2GD8eqhy2j+Ejq29+SbKH8yjkAqXqoA==", - "dependencies": { - "dequal": "^2.0.0", - "diff": "^5.0.0", - "kleur": "^4.0.3", - "sade": "^1.7.3" - }, - "bin": { - "uvu": "bin.js" - }, + "node_modules/unicode-property-aliases-ecmascript": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz", + "integrity": "sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=8" + "node": ">=4" } }, - "node_modules/validate-html-nesting": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/validate-html-nesting/-/validate-html-nesting-1.2.2.tgz", - "integrity": "sha512-hGdgQozCsQJMyfK5urgFcWEqsSSrK63Awe0t/IMR0bZ0QMtnuaiHzThW81guu3qx9abLi99NEuiaN6P9gVYsNg==" - }, - "node_modules/vfile": { - "version": "5.3.7", - "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz", - "integrity": "sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==", + "node_modules/unified": { + "version": "10.1.2", + "resolved": "https://registry.npmjs.org/unified/-/unified-10.1.2.tgz", + "integrity": "sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==", "dependencies": { "@types/unist": "^2.0.0", + "bail": "^2.0.0", + "extend": "^3.0.0", "is-buffer": "^2.0.0", - "unist-util-stringify-position": "^3.0.0", - "vfile-message": "^3.0.0" + "is-plain-obj": "^4.0.0", + "trough": "^2.0.0", + "vfile": "^5.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, - "node_modules/vfile-location": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.1.0.tgz", - "integrity": "sha512-YF23YMyASIIJXpktBa4vIGLJ5Gs88UB/XePgqPmTa7cDA+JeO3yclbpheQYCHjVHBn/yePzrXuygIL+xbvRYHw==", - "dependencies": { - "@types/unist": "^2.0.0", - "vfile": "^5.0.0" - }, + "node_modules/unist-util-generated": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-2.0.1.tgz", + "integrity": "sha512-qF72kLmPxAw0oN2fwpWIqbXAVyEqUzDHMsbtPvOudIlUzXYFIeQIuxXQCRCFh22B7cixvU0MG7m3MW8FTq/S+A==", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, - "node_modules/vfile-message": { - "version": "3.1.4", - "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz", - "integrity": "sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==", + "node_modules/unist-util-is": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz", + "integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==", "dependencies": { - "@types/unist": "^2.0.0", - "unist-util-stringify-position": "^3.0.0" + "@types/unist": "^2.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, - "node_modules/vite": { - "version": "4.5.3", - "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.3.tgz", - "integrity": "sha512-kQL23kMeX92v3ph7IauVkXkikdDRsYMGTVl5KY2E9OY4ONLvkHf04MDTbnfo6NKxZiDLWzVpP5oTa8hQD8U3dg==", + "node_modules/unist-util-modify-children": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/unist-util-modify-children/-/unist-util-modify-children-3.1.1.tgz", + "integrity": "sha512-yXi4Lm+TG5VG+qvokP6tpnk+r1EPwyYL04JWDxLvgvPV40jANh7nm3udk65OOWquvbMDe+PL9+LmkxDpTv/7BA==", "dependencies": { - "esbuild": "^0.18.10", - "postcss": "^8.4.27", - "rollup": "^3.27.1" - }, - "bin": { - "vite": "bin/vite.js" - }, - "engines": { - "node": "^14.18.0 || >=16.0.0" + "@types/unist": "^2.0.0", + "array-iterate": "^2.0.0" }, "funding": { - "url": "https://github.com/vitejs/vite?sponsor=1" - }, - "optionalDependencies": { - "fsevents": "~2.3.2" - }, - "peerDependencies": { - "@types/node": ">= 14", - "less": "*", - "lightningcss": "^1.21.0", - "sass": "*", - "stylus": "*", - "sugarss": "*", - "terser": "^5.4.0" - }, - "peerDependenciesMeta": { - "@types/node": { - "optional": true - }, - "less": { - "optional": true - }, - "lightningcss": { - "optional": true - }, - "sass": { - "optional": true - }, - "stylus": { - "optional": true - }, - "sugarss": { - "optional": true - }, - "terser": { - "optional": true - } - } - }, - "node_modules/vite-plugin-cross-origin-isolation": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/vite-plugin-cross-origin-isolation/-/vite-plugin-cross-origin-isolation-0.1.6.tgz", - "integrity": "sha512-OY0naW9nPUDrKTffYnY7FRYXOgZdHoNwMGpPxUmj/n32mGZi01fcq+J536jkmwGWX7DLT95XBQVHHbrAJzTvrw==" + "type": "opencollective", + "url": "https://opencollective.com/unified" + } }, - "node_modules/vite-plugin-mkcert": { - "version": "1.16.0", - "resolved": "https://registry.npmjs.org/vite-plugin-mkcert/-/vite-plugin-mkcert-1.16.0.tgz", - "integrity": "sha512-5r+g8SB9wZzLNUFekGwZo3e0P6QlS6rbxK5p9z/itxNAimsYohgjK/YfVPVxM9EuglP9hjridq0lUejo9v1nVg==", + "node_modules/unist-util-position": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.4.tgz", + "integrity": "sha512-kUBE91efOWfIVBo8xzh/uZQ7p9ffYRtUbMRZBNFYwf0RK8koUMx6dGUfwylLOKmaT2cs4wSW96QoYUSXAyEtpg==", "dependencies": { - "@octokit/rest": "^19.0.5", - "axios": "^1.2.2", - "debug": "^4.3.4", - "picocolors": "^1.0.0" - }, - "engines": { - "node": ">=v16.7.0" + "@types/unist": "^2.0.0" }, - "peerDependencies": { - "vite": ">=3" + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite-plugin-solid": { - "version": "2.7.0", - "resolved": "https://registry.npmjs.org/vite-plugin-solid/-/vite-plugin-solid-2.7.0.tgz", - "integrity": "sha512-avp/Jl5zOp/Itfo67xtDB2O61U7idviaIp4mLsjhCa13PjKNasz+IID0jYTyqUp9SFx6/PmBr6v4KgDppqompg==", + "node_modules/unist-util-position-from-estree": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-1.1.2.tgz", + "integrity": "sha512-poZa0eXpS+/XpoQwGwl79UUdea4ol2ZuCYguVaJS4qzIOMDzbqz8a3erUCOmubSZkaOuGamb3tX790iwOIROww==", "dependencies": { - "@babel/core": "^7.20.5", - "@babel/preset-typescript": "^7.18.6", - "@types/babel__core": "^7.1.20", - "babel-preset-solid": "^1.7.2", - "merge-anything": "^5.1.4", - "solid-refresh": "^0.5.0", - "vitefu": "^0.2.3" + "@types/unist": "^2.0.0" }, - "peerDependencies": { - "solid-js": "^1.7.2", - "vite": "^3.0.0 || ^4.0.0" + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/android-arm": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz", - "integrity": "sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==", - "cpu": [ - "arm" - ], - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=12" + "node_modules/unist-util-remove-position": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-4.0.2.tgz", + "integrity": "sha512-TkBb0HABNmxzAcfLf4qsIbFbaPDvMO6wa3b3j4VcEzFVaw1LBKwnW4/sRJ/atSLSzoIg41JWEdnE7N6DIhGDGQ==", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-visit": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/android-arm64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz", - "integrity": "sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=12" + "node_modules/unist-util-stringify-position": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz", + "integrity": "sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==", + "dependencies": { + "@types/unist": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/android-x64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.20.tgz", - "integrity": "sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=12" + "node_modules/unist-util-visit": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz", + "integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-is": "^5.0.0", + "unist-util-visit-parents": "^5.1.1" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/darwin-arm64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz", - "integrity": "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=12" + "node_modules/unist-util-visit-children": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/unist-util-visit-children/-/unist-util-visit-children-2.0.2.tgz", + "integrity": "sha512-+LWpMFqyUwLGpsQxpumsQ9o9DG2VGLFrpz+rpVXYIEdPy57GSy5HioC0g3bg/8WP9oCLlapQtklOzQ8uLS496Q==", + "dependencies": { + "@types/unist": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/darwin-x64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.20.tgz", - "integrity": "sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=12" + "node_modules/unist-util-visit-parents": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz", + "integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-is": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/freebsd-arm64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.20.tgz", - "integrity": "sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "freebsd" - ], + "node_modules/universal-user-agent": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz", + "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w==" + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", "engines": { - "node": ">=12" + "node": ">= 0.8" } }, - "node_modules/vite/node_modules/@esbuild/freebsd-x64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.20.tgz", - "integrity": "sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "freebsd" - ], + "node_modules/untildify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", + "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==", + "dev": true, "engines": { - "node": ">=12" + "node": ">=8" } }, - "node_modules/vite/node_modules/@esbuild/linux-arm": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.20.tgz", - "integrity": "sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==", - "cpu": [ - "arm" - ], - "optional": true, - "os": [ - "linux" + "node_modules/update-browserslist-db": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz", + "integrity": "sha512-R8UzCaa9Az+38REPiJ1tXlImTJXlVfgHZsglwBD/k6nj76ctsH1E3q4doGrukiLQd3sGQYu56r5+lo5r94l29A==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } ], - "engines": { - "node": ">=12" + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.0" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" } }, - "node_modules/vite/node_modules/@esbuild/linux-arm64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.20.tgz", - "integrity": "sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=12" + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "dependencies": { + "punycode": "^2.1.0" } }, - "node_modules/vite/node_modules/@esbuild/linux-ia32": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.20.tgz", - "integrity": "sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==", - "cpu": [ - "ia32" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=12" + "node_modules/util": { + "version": "0.10.4", + "resolved": "https://registry.npmjs.org/util/-/util-0.10.4.tgz", + "integrity": "sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==", + "license": "MIT", + "dependencies": { + "inherits": "2.0.3" } }, - "node_modules/vite/node_modules/@esbuild/linux-loong64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.20.tgz", - "integrity": "sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==", - "cpu": [ - "loong64" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" + }, + "node_modules/util/node_modules/inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==", + "license": "ISC" + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "license": "MIT", "engines": { - "node": ">=12" + "node": ">= 0.4.0" } }, - "node_modules/vite/node_modules/@esbuild/linux-mips64el": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.20.tgz", - "integrity": "sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==", - "cpu": [ - "mips64el" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/uvu": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/uvu/-/uvu-0.5.6.tgz", + "integrity": "sha512-+g8ENReyr8YsOc6fv/NVJs2vFdHBnBNdfE49rshrTzDWOlUx4Gq7KOS2GD8eqhy2j+Ejq29+SbKH8yjkAqXqoA==", + "dependencies": { + "dequal": "^2.0.0", + "diff": "^5.0.0", + "kleur": "^4.0.3", + "sade": "^1.7.3" + }, + "bin": { + "uvu": "bin.js" + }, "engines": { - "node": ">=12" + "node": ">=8" } }, - "node_modules/vite/node_modules/@esbuild/linux-ppc64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.20.tgz", - "integrity": "sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==", - "cpu": [ - "ppc64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=12" - } + "node_modules/validate-html-nesting": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/validate-html-nesting/-/validate-html-nesting-1.2.2.tgz", + "integrity": "sha512-hGdgQozCsQJMyfK5urgFcWEqsSSrK63Awe0t/IMR0bZ0QMtnuaiHzThW81guu3qx9abLi99NEuiaN6P9gVYsNg==" }, - "node_modules/vite/node_modules/@esbuild/linux-riscv64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.20.tgz", - "integrity": "sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==", - "cpu": [ - "riscv64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=12" + "node_modules/validate-npm-package-license": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" } }, - "node_modules/vite/node_modules/@esbuild/linux-s390x": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.20.tgz", - "integrity": "sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==", - "cpu": [ - "s390x" - ], - "optional": true, - "os": [ - "linux" - ], + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", "engines": { - "node": ">=12" + "node": ">= 0.8" } }, - "node_modules/vite/node_modules/@esbuild/linux-x64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz", - "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=12" + "node_modules/vfile": { + "version": "5.3.7", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz", + "integrity": "sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==", + "dependencies": { + "@types/unist": "^2.0.0", + "is-buffer": "^2.0.0", + "unist-util-stringify-position": "^3.0.0", + "vfile-message": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/netbsd-x64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.20.tgz", - "integrity": "sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=12" + "node_modules/vfile-location": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.1.0.tgz", + "integrity": "sha512-YF23YMyASIIJXpktBa4vIGLJ5Gs88UB/XePgqPmTa7cDA+JeO3yclbpheQYCHjVHBn/yePzrXuygIL+xbvRYHw==", + "dependencies": { + "@types/unist": "^2.0.0", + "vfile": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/openbsd-x64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.20.tgz", - "integrity": "sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=12" + "node_modules/vfile-message": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz", + "integrity": "sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==", + "dependencies": { + "@types/unist": "^2.0.0", + "unist-util-stringify-position": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/vite/node_modules/@esbuild/sunos-x64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.20.tgz", - "integrity": "sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "sunos" - ], + "node_modules/vite": { + "version": "4.5.3", + "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.3.tgz", + "integrity": "sha512-kQL23kMeX92v3ph7IauVkXkikdDRsYMGTVl5KY2E9OY4ONLvkHf04MDTbnfo6NKxZiDLWzVpP5oTa8hQD8U3dg==", + "dependencies": { + "esbuild": "^0.18.10", + "postcss": "^8.4.27", + "rollup": "^3.27.1" + }, + "bin": { + "vite": "bin/vite.js" + }, "engines": { - "node": ">=12" + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + }, + "peerDependencies": { + "@types/node": ">= 14", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } } }, - "node_modules/vite/node_modules/@esbuild/win32-arm64": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.20.tgz", - "integrity": "sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "win32" - ], + "node_modules/vite-plugin-cross-origin-isolation": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/vite-plugin-cross-origin-isolation/-/vite-plugin-cross-origin-isolation-0.1.6.tgz", + "integrity": "sha512-OY0naW9nPUDrKTffYnY7FRYXOgZdHoNwMGpPxUmj/n32mGZi01fcq+J536jkmwGWX7DLT95XBQVHHbrAJzTvrw==" + }, + "node_modules/vite-plugin-mkcert": { + "version": "1.16.0", + "resolved": "https://registry.npmjs.org/vite-plugin-mkcert/-/vite-plugin-mkcert-1.16.0.tgz", + "integrity": "sha512-5r+g8SB9wZzLNUFekGwZo3e0P6QlS6rbxK5p9z/itxNAimsYohgjK/YfVPVxM9EuglP9hjridq0lUejo9v1nVg==", + "dependencies": { + "@octokit/rest": "^19.0.5", + "axios": "^1.2.2", + "debug": "^4.3.4", + "picocolors": "^1.0.0" + }, "engines": { - "node": ">=12" + "node": ">=v16.7.0" + }, + "peerDependencies": { + "vite": ">=3" } }, - "node_modules/vite/node_modules/@esbuild/win32-ia32": { - "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.20.tgz", - "integrity": "sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==", - "cpu": [ - "ia32" - ], - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=12" + "node_modules/vite-plugin-solid": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/vite-plugin-solid/-/vite-plugin-solid-2.7.0.tgz", + "integrity": "sha512-avp/Jl5zOp/Itfo67xtDB2O61U7idviaIp4mLsjhCa13PjKNasz+IID0jYTyqUp9SFx6/PmBr6v4KgDppqompg==", + "dependencies": { + "@babel/core": "^7.20.5", + "@babel/preset-typescript": "^7.18.6", + "@types/babel__core": "^7.1.20", + "babel-preset-solid": "^1.7.2", + "merge-anything": "^5.1.4", + "solid-refresh": "^0.5.0", + "vitefu": "^0.2.3" + }, + "peerDependencies": { + "solid-js": "^1.7.2", + "vite": "^3.0.0 || ^4.0.0" } }, - "node_modules/vite/node_modules/@esbuild/win32-x64": { + "node_modules/vite/node_modules/@esbuild/linux-x64": { "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.20.tgz", - "integrity": "sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz", + "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==", "cpu": [ "x64" ], "optional": true, "os": [ - "win32" + "linux" ], "engines": { "node": ">=12" @@ -10783,6 +13240,53 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/which-builtin-type": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.0.tgz", + "integrity": "sha512-I+qLGQ/vucCby4tf5HsLmGueEla4ZhwTBSqaooS+Y0BuxN4Cp+okmGuV+8mXZ84KDI9BA+oklo+RzKg0ONdSUA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "function.prototype.name": "^1.1.6", + "has-tostringtag": "^1.0.2", + "is-async-function": "^2.0.0", + "is-date-object": "^1.0.5", + "is-finalizationregistry": "^1.1.0", + "is-generator-function": "^1.0.10", + "is-regex": "^1.1.4", + "is-weakref": "^1.0.2", + "isarray": "^2.0.5", + "which-boxed-primitive": "^1.0.2", + "which-collection": "^1.0.2", + "which-typed-array": "^1.1.15" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-collection": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz", + "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-map": "^2.0.3", + "is-set": "^2.0.3", + "is-weakmap": "^2.0.2", + "is-weakset": "^2.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/which-pm": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/which-pm/-/which-pm-2.1.1.tgz", @@ -10804,16 +13308,17 @@ } }, "node_modules/which-typed-array": { - "version": "1.1.11", - "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.11.tgz", - "integrity": "sha512-qe9UWWpkeG5yzZ0tNYxDmd7vo58HDBc39mZ0xWWpolAGADdFOzkfamWLDxkOWcvHQKVmdTyQdLD4NOfjLWTKew==", + "version": "1.1.16", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.16.tgz", + "integrity": "sha512-g+N+GAWiRj66DngFwHvISJd+ITsyphZvD1vChfVg6cEdnzy53GzB3oy0fUNlvhz7H7+MiqhYr26qxQShCpKTTQ==", "dev": true, + "license": "MIT", "dependencies": { - "available-typed-arrays": "^1.0.5", - "call-bind": "^1.0.2", + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.7", "for-each": "^0.3.3", "gopd": "^1.0.1", - "has-tostringtag": "^1.0.0" + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -10903,7 +13408,8 @@ "node_modules/yallist": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", - "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==" + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "license": "ISC" }, "node_modules/yaml": { "version": "2.3.2", @@ -10949,6 +13455,19 @@ "url": "https://github.com/sponsors/wooorm" } }, + "simple-web": { + "name": "simple-moq-web", + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "cors": "^2.8.5", + "express": "^4.21.1", + "path": "^0.12.7" + }, + "devDependencies": { + "nodemon": "^3.0.1" + } + }, "web": { "version": "0.0.1", "dependencies": { @@ -10956,11 +13475,11 @@ "@astrojs/node": "^6.0.1", "@astrojs/solid-js": "^3.0.1", "@astrojs/tailwind": "^5.0.0", - "@kixelated/moq": "^0.1.4", "@tailwindcss/forms": "^0.5.6", "@tailwindcss/typography": "^0.5.10", "@types/dom-webcodecs": "^0.1.8", "astro": "^3.2.0", + "moq-player": "*", "solid-js": "^1.4.3", "tailwindcss": "^3.0.24", "vite-plugin-cross-origin-isolation": "^0.1.6", diff --git a/package.json b/package.json index 0bed20c..67513aa 100644 --- a/package.json +++ b/package.json @@ -8,10 +8,16 @@ "simple-web" ], "scripts": { - "dev": "npm run build --workspace moq-player && cp ./lib/dist/iife/* ./simple-web/public/ && npm run dev --workspace simple-moq-web", - "dev-web": "npm run dev --workspace web", + "dev:moq-player": "npm run dev --workspace=moq-player", + "dev:simple-moq-web": "npm run dev --workspace=simple-moq-web", + "dev": "npm-run-all --parallel dev:moq-player dev:simple-moq-web", "build": "npm run build --workspaces", + "build-web": "npm run build --workspace=web", + "dev-web": "npm run dev --workspace=web", "lint": "npm run lint --workspaces", "fmt": "npm run fmt --workspaces" + }, + "devDependencies": { + "npm-run-all": "^4.1.5" } } diff --git a/simple-web/index.js b/simple-web/index.js index ef1588d..4236539 100644 --- a/simple-web/index.js +++ b/simple-web/index.js @@ -15,6 +15,9 @@ app.use((req, res, next) => { app.use(express.static(path.join(__dirname, "public"))); +const moqPath = path.resolve(__dirname, "../lib/dist"); +app.use("/moq-player", express.static(moqPath)); + app.listen(PORT, () => { console.log(`Server running in http://localhost:${PORT}`); }); diff --git a/simple-web/public/index.html b/simple-web/public/index.html index 7827aa9..1c0f36e 100644 --- a/simple-web/public/index.html +++ b/simple-web/public/index.html @@ -1,5 +1,5 @@ - + diff --git a/simple-web/public/moq-player.iife.js b/simple-web/public/moq-player.iife.js deleted file mode 100644 index 7b20296..0000000 --- a/simple-web/public/moq-player.iife.js +++ /dev/null @@ -1,11321 +0,0 @@ -var moqplayer = (function () { - 'use strict'; - - // I hate javascript - function asError(e) { - if (e instanceof Error) { - return e; - } - else if (typeof e === "string") { - return new Error(e); - } - else { - return new Error(String(e)); - } - } - - function decode(raw) { - const decoder = new TextDecoder(); - const str = decoder.decode(raw); - const catalog = JSON.parse(str); - if (!isRoot(catalog)) { - throw new Error("invalid catalog"); - } - // Merge common track fields into each track. - for (const track of catalog.tracks) { - track.altGroup ??= catalog.commonTrackFields.altGroup; - track.namespace ??= catalog.commonTrackFields.namespace; - track.packaging ??= catalog.commonTrackFields.packaging; - track.renderGroup ??= catalog.commonTrackFields.renderGroup; - } - return catalog; - } - async function fetch$1(connection, namespace) { - const subscribe = await connection.subscribe(namespace, ".catalog"); - try { - const segment = await subscribe.data(); - if (!segment) - throw new Error("no catalog data"); - const chunk = await segment.read(); - if (!chunk) - throw new Error("no catalog chunk"); - await segment.close(); - await subscribe.close(); // we done - if (chunk.payload instanceof Uint8Array) { - return decode(chunk.payload); - } - else { - throw new Error("invalid catalog chunk"); - } - } - catch (e) { - const err = asError(e); - // Close the subscription after we're done. - await subscribe.close(1n, err.message); - throw err; - } - } - function isRoot(catalog) { - if (!isCatalogFieldValid(catalog, "packaging")) - return false; - if (!isCatalogFieldValid(catalog, "namespace")) - return false; - if (!Array.isArray(catalog.tracks)) - return false; - return catalog.tracks.every((track) => isTrack(track)); - } - function isTrack(track) { - if (typeof track.name !== "string") - return false; - return true; - } - function isVideoTrack(track) { - if (!isTrack(track)) - return false; - return isVideoSelectionParams(track.selectionParams); - } - function isVideoSelectionParams(params) { - if (typeof params.width !== "number") - return false; - if (typeof params.height !== "number") - return false; - return true; - } - function isAudioTrack(track) { - if (!isTrack(track)) - return false; - return isAudioSelectionParams(track.selectionParams); - } - function isAudioSelectionParams(params) { - if (typeof params.channelConfig !== "string") - return false; - if (typeof params.samplerate !== "number") - return false; - return true; - } - function isCatalogFieldValid(catalog, field) { - //packaging,namespace if common would be listed in commonTrackFields but if fields - //in commonTrackFields are mentiond in Tracks , the fields in Tracks precedes - function isValidPackaging(packaging) { - return packaging === "cmaf" || packaging === "loc"; - } - function isValidNamespace(namespace) { - return typeof namespace === "string"; - } - let isValidField; - if (field === "packaging") { - isValidField = isValidPackaging; - } - else if (field === "namespace") { - isValidField = isValidNamespace; - } - else { - throw new Error(`Invalid field: ${field}`); - } - if (catalog.commonTrackFields[field] !== undefined && !isValidField(catalog.commonTrackFields[field])) { - return false; - } - for (const track of catalog.tracks) { - if (track[field] !== undefined && !isValidField(track[field])) { - return false; - } - } - return true; - } - - function funcToSource(fn, sourcemapArg) { - var source = fn.toString(); - var lines = source.split('\n'); - lines.pop(); - lines.shift(); - var blankPrefixLength = lines[0].search(/\S/); - var regex = /(['"])__worker_loader_strict__(['"])/g; - for (var i = 0, n = lines.length; i < n; ++i) { - lines[i] = lines[i].substring(blankPrefixLength).replace(regex, '$1use strict$2') + '\n'; - } - return lines; - } - - function createURL$1(fn, sourcemapArg) { - var lines = funcToSource(fn); - var blob = new Blob(lines, { type: 'application/javascript' }); - return URL.createObjectURL(blob); - } - - function createInlineAudioWorkletFactory$1(fn, sourcemapArg) { - var url; - return async function AudioWorkletFactory(audioContext, options) { - url = url || createURL$1(fn); - return await audioContext.audioWorklet.addModule(url, options); - }; - } - - var kIsNodeJS = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'; - - function isNodeJS() { - return kIsNodeJS; - } - - function createInlineAudioWorkletFactory(fn, sourcemapArg) { - if (isNodeJS()) { - throw new Error('rollup-plugin-web-worker-loader does not support Audio Worklet in Node.JS'); - } - return createInlineAudioWorkletFactory$1(fn); - } - - var WorkerFactory$1 = /*#__PURE__*/createInlineAudioWorkletFactory(/* rollup-plugin-web-worker-loader */function () { - (function () { - '__worker_loader_strict__'; - - // Ring buffer with audio samples. - var STATE; - (function (STATE) { - STATE[STATE["READ_POS"] = 0] = "READ_POS"; - STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; - STATE[STATE["LENGTH"] = 2] = "LENGTH"; - })(STATE || (STATE = {})); - class Ring { - state; - channels; - capacity; - constructor(shared) { - this.state = new Int32Array(shared.state); - this.channels = []; - for (const channel of shared.channels) { - this.channels.push(new Float32Array(channel)); - } - this.capacity = shared.capacity; - } - // Write samples for single audio frame, returning the total number written. - write(frame) { - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - const startPos = writePos; - let endPos = writePos + frame.numberOfFrames; - if (endPos > readPos + this.capacity) { - endPos = readPos + this.capacity; - if (endPos <= startPos) { - // No space to write - return 0; - } - } - const startIndex = startPos % this.capacity; - const endIndex = endPos % this.capacity; - // Loop over each channel - for (let i = 0; i < this.channels.length; i += 1) { - const channel = this.channels[i]; - // If the AudioData doesn't have enough channels, duplicate it. - const planeIndex = Math.min(i, frame.numberOfChannels - 1); - if (startIndex < endIndex) { - // One continuous range to copy. - const full = channel.subarray(startIndex, endIndex); - frame.copyTo(full, { - planeIndex, - frameCount: endIndex - startIndex, - }); - } - else { - const first = channel.subarray(startIndex); - const second = channel.subarray(0, endIndex); - frame.copyTo(first, { - planeIndex, - frameCount: first.length, - }); - // We need this conditional when startIndex == 0 and endIndex == 0 - // When capacity=4410 and frameCount=1024, this was happening 52s into the audio. - if (second.length) { - frame.copyTo(second, { - planeIndex, - frameOffset: first.length, - frameCount: second.length, - }); - } - } - } - Atomics.store(this.state, STATE.WRITE_POS, endPos); - return endPos - startPos; - } - read(dst) { - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - const startPos = readPos; - let endPos = startPos + dst[0].length; - if (endPos > writePos) { - endPos = writePos; - if (endPos <= startPos) { - // Nothing to read - return 0; - } - } - const startIndex = startPos % this.capacity; - const endIndex = endPos % this.capacity; - // Loop over each channel - for (let i = 0; i < dst.length; i += 1) { - if (i >= this.channels.length) ; - const input = this.channels[i]; - const output = dst[i]; - if (startIndex < endIndex) { - const full = input.subarray(startIndex, endIndex); - output.set(full); - } - else { - const first = input.subarray(startIndex); - const second = input.subarray(0, endIndex); - output.set(first); - output.set(second, first.length); - } - } - Atomics.store(this.state, STATE.READ_POS, endPos); - return endPos - startPos; - } - clear() { - const pos = Atomics.load(this.state, STATE.WRITE_POS); - Atomics.store(this.state, STATE.READ_POS, pos); - } - size() { - // TODO is this thread safe? - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - return writePos - readPos; - } - } - - // TODO add support for @/ to avoid relative imports - class Renderer extends AudioWorkletProcessor { - ring; - base; - constructor() { - // The super constructor call is required. - super(); - this.base = 0; - this.port.onmessage = this.onMessage.bind(this); - } - onMessage(e) { - const msg = e.data; - if (msg.config) { - this.onConfig(msg.config); - } - } - onConfig(config) { - this.ring = new Ring(config.ring); - } - // Inputs and outputs in groups of 128 samples. - process(inputs, outputs, _parameters) { - if (!this.ring) { - // Paused - return true; - } - if (inputs.length != 1 && outputs.length != 1) { - throw new Error("only a single track is supported"); - } - if (this.ring.size() == this.ring.capacity) { - // This is a hack to clear any latency in the ring buffer. - // The proper solution is to play back slightly faster? - console.warn("resyncing ring buffer"); - this.ring.clear(); - return true; - } - const output = outputs[0]; - const size = this.ring.read(output); - if (size < output.length) ; - return true; - } - } - registerProcessor("renderer", Renderer); - - })(); - - }); - /* eslint-enable */ - - // NOTE: This must be on the main thread - class Audio { - context; - worklet; - constructor(config) { - this.context = new AudioContext({ - latencyHint: "interactive", - sampleRate: config.sampleRate, - }); - this.worklet = this.load(config); - } - async load(config) { - // Load the worklet source code. - await WorkerFactory$1(this.context); - const volume = this.context.createGain(); - volume.gain.value = 2.0; - // Create the worklet - const worklet = new AudioWorkletNode(this.context, "renderer"); - worklet.port.addEventListener("message", this.on.bind(this)); - worklet.onprocessorerror = (e) => { - console.error("Audio worklet error:", e); - }; - // Connect the worklet to the volume node and then to the speakers - worklet.connect(volume); - volume.connect(this.context.destination); - worklet.port.postMessage({ config }); - return worklet; - } - on(_event) { - // TODO - } - } - - var WorkerClass = null; - - try { - var WorkerThreads = - typeof module !== 'undefined' && typeof module.require === 'function' && module.require('worker_threads') || - typeof __non_webpack_require__ === 'function' && __non_webpack_require__('worker_threads') || - typeof require === 'function' && require('worker_threads'); - WorkerClass = WorkerThreads.Worker; - } catch(e) {} // eslint-disable-line - - function createInlineWorkerFactory$2(fn, sourcemapArg) { - var lines = funcToSource(fn); - var concat = lines.join('\n'); - return function WorkerFactory(options) { - return new WorkerClass(concat, Object.assign({}, options, { eval: true })); - }; - } - - function createURL(fn, sourcemapArg) { - var lines = funcToSource(fn); - var blob = new Blob(lines, { type: 'application/javascript' }); - return URL.createObjectURL(blob); - } - - function createInlineWorkerFactory$1(fn, sourcemapArg) { - var url; - return function WorkerFactory(options) { - url = url || createURL(fn); - return new Worker(url, options); - }; - } - - function createInlineWorkerFactory(fn, sourcemapArg) { - if (isNodeJS()) { - return createInlineWorkerFactory$2(fn); - } - return createInlineWorkerFactory$1(fn); - } - - var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-worker-loader */function () { - (function () { - '__worker_loader_strict__'; - - class Timeline { - // Maintain audio and video seprarately - audio; - video; - // Construct a timeline - constructor() { - this.audio = new Component(); - this.video = new Component(); - } - } - class Component { - #current; - frames; - #segments; - constructor() { - this.frames = new ReadableStream({ - pull: this.#pull.bind(this), - cancel: this.#cancel.bind(this), - }); - // This is a hack to have an async channel with 100 items. - this.#segments = new TransformStream({}, { highWaterMark: 100 }); - } - get segments() { - return this.#segments.writable; - } - async #pull(controller) { - for (;;) { - // Get the next segment to render. - const segments = this.#segments.readable.getReader(); - let res; - if (this.#current) { - // Get the next frame to render. - const frames = this.#current.frames.getReader(); - // Wait for either the frames or segments to be ready. - // NOTE: This assume that the first promise gets priority. - res = await Promise.race([frames.read(), segments.read()]); - frames.releaseLock(); - } - else { - res = await segments.read(); - } - segments.releaseLock(); - const { value, done } = res; - if (done) { - // We assume the current segment has been closed - // TODO support the segments stream closing - this.#current = undefined; - continue; - } - if (!isSegment(value)) { - // Return so the reader can decide when to get the next frame. - controller.enqueue(value); - return; - } - // We didn't get any frames, and instead got a new segment. - if (this.#current) { - if (value.sequence < this.#current.sequence) { - // Our segment is older than the current, abandon it. - await value.frames.cancel("skipping segment; too old"); - continue; - } - else { - // Our segment is newer than the current, cancel the old one. - await this.#current.frames.cancel("skipping segment; too slow"); - } - } - this.#current = value; - } - } - async #cancel(reason) { - if (this.#current) { - await this.#current.frames.cancel(reason); - } - const segments = this.#segments.readable.getReader(); - for (;;) { - const { value: segment, done } = await segments.read(); - if (done) - break; - await segment.frames.cancel(reason); - } - } - } - // Return if a type is a segment or frame - // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents - function isSegment(value) { - // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition - return value.frames !== undefined; - } - - // Ring buffer with audio samples. - var STATE; - (function (STATE) { - STATE[STATE["READ_POS"] = 0] = "READ_POS"; - STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; - STATE[STATE["LENGTH"] = 2] = "LENGTH"; - })(STATE || (STATE = {})); - class Ring { - state; - channels; - capacity; - constructor(shared) { - this.state = new Int32Array(shared.state); - this.channels = []; - for (const channel of shared.channels) { - this.channels.push(new Float32Array(channel)); - } - this.capacity = shared.capacity; - } - // Write samples for single audio frame, returning the total number written. - write(frame) { - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - const startPos = writePos; - let endPos = writePos + frame.numberOfFrames; - if (endPos > readPos + this.capacity) { - endPos = readPos + this.capacity; - if (endPos <= startPos) { - // No space to write - return 0; - } - } - const startIndex = startPos % this.capacity; - const endIndex = endPos % this.capacity; - // Loop over each channel - for (let i = 0; i < this.channels.length; i += 1) { - const channel = this.channels[i]; - // If the AudioData doesn't have enough channels, duplicate it. - const planeIndex = Math.min(i, frame.numberOfChannels - 1); - if (startIndex < endIndex) { - // One continuous range to copy. - const full = channel.subarray(startIndex, endIndex); - frame.copyTo(full, { - planeIndex, - frameCount: endIndex - startIndex, - }); - } - else { - const first = channel.subarray(startIndex); - const second = channel.subarray(0, endIndex); - frame.copyTo(first, { - planeIndex, - frameCount: first.length, - }); - // We need this conditional when startIndex == 0 and endIndex == 0 - // When capacity=4410 and frameCount=1024, this was happening 52s into the audio. - if (second.length) { - frame.copyTo(second, { - planeIndex, - frameOffset: first.length, - frameCount: second.length, - }); - } - } - } - Atomics.store(this.state, STATE.WRITE_POS, endPos); - return endPos - startPos; - } - read(dst) { - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - const startPos = readPos; - let endPos = startPos + dst[0].length; - if (endPos > writePos) { - endPos = writePos; - if (endPos <= startPos) { - // Nothing to read - return 0; - } - } - const startIndex = startPos % this.capacity; - const endIndex = endPos % this.capacity; - // Loop over each channel - for (let i = 0; i < dst.length; i += 1) { - if (i >= this.channels.length) ; - const input = this.channels[i]; - const output = dst[i]; - if (startIndex < endIndex) { - const full = input.subarray(startIndex, endIndex); - output.set(full); - } - else { - const first = input.subarray(startIndex); - const second = input.subarray(0, endIndex); - output.set(first); - output.set(second, first.length); - } - } - Atomics.store(this.state, STATE.READ_POS, endPos); - return endPos - startPos; - } - clear() { - const pos = Atomics.load(this.state, STATE.WRITE_POS); - Atomics.store(this.state, STATE.READ_POS, pos); - } - size() { - // TODO is this thread safe? - const readPos = Atomics.load(this.state, STATE.READ_POS); - const writePos = Atomics.load(this.state, STATE.WRITE_POS); - return writePos - readPos; - } - } - - var mp4box_all = {}; - - var hasRequiredMp4box_all; - function requireMp4box_all() { - if (hasRequiredMp4box_all) return mp4box_all; - hasRequiredMp4box_all = 1; - (function (exports) { - // file:src/log.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var Log = function () { - var start = new Date(); - var LOG_LEVEL_ERROR = 4; - var LOG_LEVEL_WARNING = 3; - var LOG_LEVEL_INFO = 2; - var LOG_LEVEL_DEBUG = 1; - var log_level = LOG_LEVEL_ERROR; - var logObject = { - setLogLevel: function (level) { - if (level == this.debug) log_level = LOG_LEVEL_DEBUG;else if (level == this.info) log_level = LOG_LEVEL_INFO;else if (level == this.warn) log_level = LOG_LEVEL_WARNING;else if (level == this.error) log_level = LOG_LEVEL_ERROR;else log_level = LOG_LEVEL_ERROR; - }, - debug: function (module, msg) { - if (console.debug === undefined) { - console.debug = console.log; - } - if (LOG_LEVEL_DEBUG >= log_level) { - console.debug("[" + Log.getDurationString(new Date() - start, 1000) + "]", "[" + module + "]", msg); - } - }, - log: function (module, msg) { - this.debug(module.msg); - }, - info: function (module, msg) { - if (LOG_LEVEL_INFO >= log_level) { - console.info("[" + Log.getDurationString(new Date() - start, 1000) + "]", "[" + module + "]", msg); - } - }, - warn: function (module, msg) { - if (LOG_LEVEL_WARNING >= log_level) { - console.warn("[" + Log.getDurationString(new Date() - start, 1000) + "]", "[" + module + "]", msg); - } - }, - error: function (module, msg) { - if (LOG_LEVEL_ERROR >= log_level) { - console.error("[" + Log.getDurationString(new Date() - start, 1000) + "]", "[" + module + "]", msg); - } - } - }; - return logObject; - }(); - - /* Helper function to print a duration value in the form H:MM:SS.MS */ - Log.getDurationString = function (duration, _timescale) { - var neg; - /* Helper function to print a number on a fixed number of digits */ - function pad(number, length) { - var str = '' + number; - var a = str.split('.'); - while (a[0].length < length) { - a[0] = '0' + a[0]; - } - return a.join('.'); - } - if (duration < 0) { - neg = true; - duration = -duration; - } else { - neg = false; - } - var timescale = _timescale || 1; - var duration_sec = duration / timescale; - var hours = Math.floor(duration_sec / 3600); - duration_sec -= hours * 3600; - var minutes = Math.floor(duration_sec / 60); - duration_sec -= minutes * 60; - var msec = duration_sec * 1000; - duration_sec = Math.floor(duration_sec); - msec -= duration_sec * 1000; - msec = Math.floor(msec); - return (neg ? "-" : "") + hours + ":" + pad(minutes, 2) + ":" + pad(duration_sec, 2) + "." + pad(msec, 3); - }; - - /* Helper function to stringify HTML5 TimeRanges objects */ - Log.printRanges = function (ranges) { - var length = ranges.length; - if (length > 0) { - var str = ""; - for (var i = 0; i < length; i++) { - if (i > 0) str += ","; - str += "[" + Log.getDurationString(ranges.start(i)) + "," + Log.getDurationString(ranges.end(i)) + "]"; - } - return str; - } else { - return "(empty)"; - } - }; - { - exports.Log = Log; - } - // file:src/stream.js - var MP4BoxStream = function (arrayBuffer) { - if (arrayBuffer instanceof ArrayBuffer) { - this.buffer = arrayBuffer; - this.dataview = new DataView(arrayBuffer); - } else { - throw "Needs an array buffer"; - } - this.position = 0; - }; - - /************************************************************************* - Common API between MultiBufferStream and SimpleStream - *************************************************************************/ - MP4BoxStream.prototype.getPosition = function () { - return this.position; - }; - MP4BoxStream.prototype.getEndPosition = function () { - return this.buffer.byteLength; - }; - MP4BoxStream.prototype.getLength = function () { - return this.buffer.byteLength; - }; - MP4BoxStream.prototype.seek = function (pos) { - var npos = Math.max(0, Math.min(this.buffer.byteLength, pos)); - this.position = isNaN(npos) || !isFinite(npos) ? 0 : npos; - return true; - }; - MP4BoxStream.prototype.isEos = function () { - return this.getPosition() >= this.getEndPosition(); - }; - - /************************************************************************* - Read methods, simimar to DataStream but simpler - *************************************************************************/ - MP4BoxStream.prototype.readAnyInt = function (size, signed) { - var res = 0; - if (this.position + size <= this.buffer.byteLength) { - switch (size) { - case 1: - if (signed) { - res = this.dataview.getInt8(this.position); - } else { - res = this.dataview.getUint8(this.position); - } - break; - case 2: - if (signed) { - res = this.dataview.getInt16(this.position); - } else { - res = this.dataview.getUint16(this.position); - } - break; - case 3: - if (signed) { - throw "No method for reading signed 24 bits values"; - } else { - res = this.dataview.getUint8(this.position) << 16; - res |= this.dataview.getUint8(this.position + 1) << 8; - res |= this.dataview.getUint8(this.position + 2); - } - break; - case 4: - if (signed) { - res = this.dataview.getInt32(this.position); - } else { - res = this.dataview.getUint32(this.position); - } - break; - case 8: - if (signed) { - throw "No method for reading signed 64 bits values"; - } else { - res = this.dataview.getUint32(this.position) << 32; - res |= this.dataview.getUint32(this.position + 4); - } - break; - default: - throw "readInt method not implemented for size: " + size; - } - this.position += size; - return res; - } else { - throw "Not enough bytes in buffer"; - } - }; - MP4BoxStream.prototype.readUint8 = function () { - return this.readAnyInt(1, false); - }; - MP4BoxStream.prototype.readUint16 = function () { - return this.readAnyInt(2, false); - }; - MP4BoxStream.prototype.readUint24 = function () { - return this.readAnyInt(3, false); - }; - MP4BoxStream.prototype.readUint32 = function () { - return this.readAnyInt(4, false); - }; - MP4BoxStream.prototype.readUint64 = function () { - return this.readAnyInt(8, false); - }; - MP4BoxStream.prototype.readString = function (length) { - if (this.position + length <= this.buffer.byteLength) { - var s = ""; - for (var i = 0; i < length; i++) { - s += String.fromCharCode(this.readUint8()); - } - return s; - } else { - throw "Not enough bytes in buffer"; - } - }; - MP4BoxStream.prototype.readCString = function () { - var arr = []; - while (true) { - var b = this.readUint8(); - if (b !== 0) { - arr.push(b); - } else { - break; - } - } - return String.fromCharCode.apply(null, arr); - }; - MP4BoxStream.prototype.readInt8 = function () { - return this.readAnyInt(1, true); - }; - MP4BoxStream.prototype.readInt16 = function () { - return this.readAnyInt(2, true); - }; - MP4BoxStream.prototype.readInt32 = function () { - return this.readAnyInt(4, true); - }; - MP4BoxStream.prototype.readInt64 = function () { - return this.readAnyInt(8, false); - }; - MP4BoxStream.prototype.readUint8Array = function (length) { - var arr = new Uint8Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readUint8(); - } - return arr; - }; - MP4BoxStream.prototype.readInt16Array = function (length) { - var arr = new Int16Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readInt16(); - } - return arr; - }; - MP4BoxStream.prototype.readUint16Array = function (length) { - var arr = new Int16Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readUint16(); - } - return arr; - }; - MP4BoxStream.prototype.readUint32Array = function (length) { - var arr = new Uint32Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readUint32(); - } - return arr; - }; - MP4BoxStream.prototype.readInt32Array = function (length) { - var arr = new Int32Array(length); - for (var i = 0; i < length; i++) { - arr[i] = this.readInt32(); - } - return arr; - }; - { - exports.MP4BoxStream = MP4BoxStream; - } // file:src/DataStream.js - /** - DataStream reads scalars, arrays and structs of data from an ArrayBuffer. - It's like a file-like DataView on steroids. - @param {ArrayBuffer} arrayBuffer ArrayBuffer to read from. - @param {?Number} byteOffset Offset from arrayBuffer beginning for the DataStream. - @param {?Boolean} endianness DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN (the default). - */ - var DataStream = function (arrayBuffer, byteOffset, endianness) { - this._byteOffset = byteOffset || 0; - if (arrayBuffer instanceof ArrayBuffer) { - this.buffer = arrayBuffer; - } else if (typeof arrayBuffer == "object") { - this.dataView = arrayBuffer; - if (byteOffset) { - this._byteOffset += byteOffset; - } - } else { - this.buffer = new ArrayBuffer(arrayBuffer || 0); - } - this.position = 0; - this.endianness = endianness == null ? DataStream.LITTLE_ENDIAN : endianness; - }; - DataStream.prototype = {}; - DataStream.prototype.getPosition = function () { - return this.position; - }; - - /** - Internal function to resize the DataStream buffer when required. - @param {number} extra Number of bytes to add to the buffer allocation. - @return {null} - */ - DataStream.prototype._realloc = function (extra) { - if (!this._dynamicSize) { - return; - } - var req = this._byteOffset + this.position + extra; - var blen = this._buffer.byteLength; - if (req <= blen) { - if (req > this._byteLength) { - this._byteLength = req; - } - return; - } - if (blen < 1) { - blen = 1; - } - while (req > blen) { - blen *= 2; - } - var buf = new ArrayBuffer(blen); - var src = new Uint8Array(this._buffer); - var dst = new Uint8Array(buf, 0, src.length); - dst.set(src); - this.buffer = buf; - this._byteLength = req; - }; - - /** - Internal function to trim the DataStream buffer when required. - Used for stripping out the extra bytes from the backing buffer when - the virtual byteLength is smaller than the buffer byteLength (happens after - growing the buffer with writes and not filling the extra space completely). - @return {null} - */ - DataStream.prototype._trimAlloc = function () { - if (this._byteLength == this._buffer.byteLength) { - return; - } - var buf = new ArrayBuffer(this._byteLength); - var dst = new Uint8Array(buf); - var src = new Uint8Array(this._buffer, 0, dst.length); - dst.set(src); - this.buffer = buf; - }; - - /** - Big-endian const to use as default endianness. - @type {boolean} - */ - DataStream.BIG_ENDIAN = false; - - /** - Little-endian const to use as default endianness. - @type {boolean} - */ - DataStream.LITTLE_ENDIAN = true; - - /** - Virtual byte length of the DataStream backing buffer. - Updated to be max of original buffer size and last written size. - If dynamicSize is false is set to buffer size. - @type {number} - */ - DataStream.prototype._byteLength = 0; - - /** - Returns the byte length of the DataStream object. - @type {number} - */ - Object.defineProperty(DataStream.prototype, 'byteLength', { - get: function () { - return this._byteLength - this._byteOffset; - } - }); - - /** - Set/get the backing ArrayBuffer of the DataStream object. - The setter updates the DataView to point to the new buffer. - @type {Object} - */ - Object.defineProperty(DataStream.prototype, 'buffer', { - get: function () { - this._trimAlloc(); - return this._buffer; - }, - set: function (v) { - this._buffer = v; - this._dataView = new DataView(this._buffer, this._byteOffset); - this._byteLength = this._buffer.byteLength; - } - }); - - /** - Set/get the byteOffset of the DataStream object. - The setter updates the DataView to point to the new byteOffset. - @type {number} - */ - Object.defineProperty(DataStream.prototype, 'byteOffset', { - get: function () { - return this._byteOffset; - }, - set: function (v) { - this._byteOffset = v; - this._dataView = new DataView(this._buffer, this._byteOffset); - this._byteLength = this._buffer.byteLength; - } - }); - - /** - Set/get the backing DataView of the DataStream object. - The setter updates the buffer and byteOffset to point to the DataView values. - @type {Object} - */ - Object.defineProperty(DataStream.prototype, 'dataView', { - get: function () { - return this._dataView; - }, - set: function (v) { - this._byteOffset = v.byteOffset; - this._buffer = v.buffer; - this._dataView = new DataView(this._buffer, this._byteOffset); - this._byteLength = this._byteOffset + v.byteLength; - } - }); - - /** - Sets the DataStream read/write position to given position. - Clamps between 0 and DataStream length. - @param {number} pos Position to seek to. - @return {null} - */ - DataStream.prototype.seek = function (pos) { - var npos = Math.max(0, Math.min(this.byteLength, pos)); - this.position = isNaN(npos) || !isFinite(npos) ? 0 : npos; - }; - - /** - Returns true if the DataStream seek pointer is at the end of buffer and - there's no more data to read. - @return {boolean} True if the seek pointer is at the end of the buffer. - */ - DataStream.prototype.isEof = function () { - return this.position >= this._byteLength; - }; - - /** - Maps a Uint8Array into the DataStream buffer. - Nice for quickly reading in data. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Uint8Array to the DataStream backing buffer. - */ - DataStream.prototype.mapUint8Array = function (length) { - this._realloc(length * 1); - var arr = new Uint8Array(this._buffer, this.byteOffset + this.position, length); - this.position += length * 1; - return arr; - }; - - /** - Reads an Int32Array of desired length and endianness from the DataStream. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Int32Array. - */ - DataStream.prototype.readInt32Array = function (length, e) { - length = length == null ? this.byteLength - this.position / 4 : length; - var arr = new Int32Array(length); - DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads an Int16Array of desired length and endianness from the DataStream. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Int16Array. - */ - DataStream.prototype.readInt16Array = function (length, e) { - length = length == null ? this.byteLength - this.position / 2 : length; - var arr = new Int16Array(length); - DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads an Int8Array of desired length from the DataStream. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Int8Array. - */ - DataStream.prototype.readInt8Array = function (length) { - length = length == null ? this.byteLength - this.position : length; - var arr = new Int8Array(length); - DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Uint32Array of desired length and endianness from the DataStream. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Uint32Array. - */ - DataStream.prototype.readUint32Array = function (length, e) { - length = length == null ? this.byteLength - this.position / 4 : length; - var arr = new Uint32Array(length); - DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Uint16Array of desired length and endianness from the DataStream. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Uint16Array. - */ - DataStream.prototype.readUint16Array = function (length, e) { - length = length == null ? this.byteLength - this.position / 2 : length; - var arr = new Uint16Array(length); - DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Uint8Array of desired length from the DataStream. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Uint8Array. - */ - DataStream.prototype.readUint8Array = function (length) { - length = length == null ? this.byteLength - this.position : length; - var arr = new Uint8Array(length); - DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Float64Array of desired length and endianness from the DataStream. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Float64Array. - */ - DataStream.prototype.readFloat64Array = function (length, e) { - length = length == null ? this.byteLength - this.position / 8 : length; - var arr = new Float64Array(length); - DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a Float32Array of desired length and endianness from the DataStream. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} The read Float32Array. - */ - DataStream.prototype.readFloat32Array = function (length, e) { - length = length == null ? this.byteLength - this.position / 4 : length; - var arr = new Float32Array(length); - DataStream.memcpy(arr.buffer, 0, this.buffer, this.byteOffset + this.position, length * arr.BYTES_PER_ELEMENT); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += arr.byteLength; - return arr; - }; - - /** - Reads a 32-bit int from the DataStream with the desired endianness. - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readInt32 = function (e) { - var v = this._dataView.getInt32(this.position, e == null ? this.endianness : e); - this.position += 4; - return v; - }; - - /** - Reads a 16-bit int from the DataStream with the desired endianness. - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readInt16 = function (e) { - var v = this._dataView.getInt16(this.position, e == null ? this.endianness : e); - this.position += 2; - return v; - }; - - /** - Reads an 8-bit int from the DataStream. - @return {number} The read number. - */ - DataStream.prototype.readInt8 = function () { - var v = this._dataView.getInt8(this.position); - this.position += 1; - return v; - }; - - /** - Reads a 32-bit unsigned int from the DataStream with the desired endianness. - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readUint32 = function (e) { - var v = this._dataView.getUint32(this.position, e == null ? this.endianness : e); - this.position += 4; - return v; - }; - - /** - Reads a 16-bit unsigned int from the DataStream with the desired endianness. - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readUint16 = function (e) { - var v = this._dataView.getUint16(this.position, e == null ? this.endianness : e); - this.position += 2; - return v; - }; - - /** - Reads an 8-bit unsigned int from the DataStream. - @return {number} The read number. - */ - DataStream.prototype.readUint8 = function () { - var v = this._dataView.getUint8(this.position); - this.position += 1; - return v; - }; - - /** - Reads a 32-bit float from the DataStream with the desired endianness. - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readFloat32 = function (e) { - var v = this._dataView.getFloat32(this.position, e == null ? this.endianness : e); - this.position += 4; - return v; - }; - - /** - Reads a 64-bit float from the DataStream with the desired endianness. - @param {?boolean} e Endianness of the number. - @return {number} The read number. - */ - DataStream.prototype.readFloat64 = function (e) { - var v = this._dataView.getFloat64(this.position, e == null ? this.endianness : e); - this.position += 8; - return v; - }; - - /** - Native endianness. Either DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN - depending on the platform endianness. - @type {boolean} - */ - DataStream.endianness = new Int8Array(new Int16Array([1]).buffer)[0] > 0; - - /** - Copies byteLength bytes from the src buffer at srcOffset to the - dst buffer at dstOffset. - @param {Object} dst Destination ArrayBuffer to write to. - @param {number} dstOffset Offset to the destination ArrayBuffer. - @param {Object} src Source ArrayBuffer to read from. - @param {number} srcOffset Offset to the source ArrayBuffer. - @param {number} byteLength Number of bytes to copy. - */ - DataStream.memcpy = function (dst, dstOffset, src, srcOffset, byteLength) { - var dstU8 = new Uint8Array(dst, dstOffset, byteLength); - var srcU8 = new Uint8Array(src, srcOffset, byteLength); - dstU8.set(srcU8); - }; - - /** - Converts array to native endianness in-place. - @param {Object} array Typed array to convert. - @param {boolean} arrayIsLittleEndian True if the data in the array is - little-endian. Set false for big-endian. - @return {Object} The converted typed array. - */ - DataStream.arrayToNative = function (array, arrayIsLittleEndian) { - if (arrayIsLittleEndian == this.endianness) { - return array; - } else { - return this.flipArrayEndianness(array); - } - }; - - /** - Converts native endianness array to desired endianness in-place. - @param {Object} array Typed array to convert. - @param {boolean} littleEndian True if the converted array should be - little-endian. Set false for big-endian. - @return {Object} The converted typed array. - */ - DataStream.nativeToEndian = function (array, littleEndian) { - if (this.endianness == littleEndian) { - return array; - } else { - return this.flipArrayEndianness(array); - } - }; - - /** - Flips typed array endianness in-place. - @param {Object} array Typed array to flip. - @return {Object} The converted typed array. - */ - DataStream.flipArrayEndianness = function (array) { - var u8 = new Uint8Array(array.buffer, array.byteOffset, array.byteLength); - for (var i = 0; i < array.byteLength; i += array.BYTES_PER_ELEMENT) { - for (var j = i + array.BYTES_PER_ELEMENT - 1, k = i; j > k; j--, k++) { - var tmp = u8[k]; - u8[k] = u8[j]; - u8[j] = tmp; - } - } - return array; - }; - - /** - Seek position where DataStream#readStruct ran into a problem. - Useful for debugging struct parsing. - @type {number} - */ - DataStream.prototype.failurePosition = 0; - String.fromCharCodeUint8 = function (uint8arr) { - var arr = []; - for (var i = 0; i < uint8arr.length; i++) { - arr[i] = uint8arr[i]; - } - return String.fromCharCode.apply(null, arr); - }; - /** - Read a string of desired length and encoding from the DataStream. - @param {number} length The length of the string to read in bytes. - @param {?string} encoding The encoding of the string data in the DataStream. - Defaults to ASCII. - @return {string} The read string. - */ - DataStream.prototype.readString = function (length, encoding) { - if (encoding == null || encoding == "ASCII") { - return String.fromCharCodeUint8.apply(null, [this.mapUint8Array(length == null ? this.byteLength - this.position : length)]); - } else { - return new TextDecoder(encoding).decode(this.mapUint8Array(length)); - } - }; - - /** - Read null-terminated string of desired length from the DataStream. Truncates - the returned string so that the null byte is not a part of it. - @param {?number} length The length of the string to read. - @return {string} The read string. - */ - DataStream.prototype.readCString = function (length) { - var blen = this.byteLength - this.position; - var u8 = new Uint8Array(this._buffer, this._byteOffset + this.position); - var len = blen; - if (length != null) { - len = Math.min(length, blen); - } - for (var i = 0; i < len && u8[i] !== 0; i++); // find first zero byte - var s = String.fromCharCodeUint8.apply(null, [this.mapUint8Array(i)]); - if (length != null) { - this.position += len - i; - } else if (i != blen) { - this.position += 1; // trailing zero if not at end of buffer - } - return s; - }; - - /* - TODO: fix endianness for 24/64-bit fields - TODO: check range/support for 64-bits numbers in JavaScript - */ - var MAX_SIZE = Math.pow(2, 32); - DataStream.prototype.readInt64 = function () { - return this.readInt32() * MAX_SIZE + this.readUint32(); - }; - DataStream.prototype.readUint64 = function () { - return this.readUint32() * MAX_SIZE + this.readUint32(); - }; - DataStream.prototype.readInt64 = function () { - return this.readUint32() * MAX_SIZE + this.readUint32(); - }; - DataStream.prototype.readUint24 = function () { - return (this.readUint8() << 16) + (this.readUint8() << 8) + this.readUint8(); - }; - { - exports.DataStream = DataStream; - } - // file:src/DataStream-write.js - /** - Saves the DataStream contents to the given filename. - Uses Chrome's anchor download property to initiate download. - - @param {string} filename Filename to save as. - @return {null} - */ - DataStream.prototype.save = function (filename) { - var blob = new Blob([this.buffer]); - if (window.URL && URL.createObjectURL) { - var url = window.URL.createObjectURL(blob); - var a = document.createElement('a'); - // Required in Firefox: - document.body.appendChild(a); - a.setAttribute('href', url); - a.setAttribute('download', filename); - // Required in Firefox: - a.setAttribute('target', '_self'); - a.click(); - window.URL.revokeObjectURL(url); - } else { - throw "DataStream.save: Can't create object URL."; - } - }; - - /** - Whether to extend DataStream buffer when trying to write beyond its size. - If set, the buffer is reallocated to twice its current size until the - requested write fits the buffer. - @type {boolean} - */ - DataStream.prototype._dynamicSize = true; - Object.defineProperty(DataStream.prototype, 'dynamicSize', { - get: function () { - return this._dynamicSize; - }, - set: function (v) { - if (!v) { - this._trimAlloc(); - } - this._dynamicSize = v; - } - }); - - /** - Internal function to trim the DataStream buffer when required. - Used for stripping out the first bytes when not needed anymore. - @return {null} - */ - DataStream.prototype.shift = function (offset) { - var buf = new ArrayBuffer(this._byteLength - offset); - var dst = new Uint8Array(buf); - var src = new Uint8Array(this._buffer, offset, dst.length); - dst.set(src); - this.buffer = buf; - this.position -= offset; - }; - - /** - Writes an Int32Array of specified endianness to the DataStream. - @param {Object} arr The array to write. - @param {?boolean} e Endianness of the data to write. - */ - DataStream.prototype.writeInt32Array = function (arr, e) { - this._realloc(arr.length * 4); - if (arr instanceof Int32Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); - this.mapInt32Array(arr.length, e); - } else { - for (var i = 0; i < arr.length; i++) { - this.writeInt32(arr[i], e); - } - } - }; - - /** - Writes an Int16Array of specified endianness to the DataStream. - @param {Object} arr The array to write. - @param {?boolean} e Endianness of the data to write. - */ - DataStream.prototype.writeInt16Array = function (arr, e) { - this._realloc(arr.length * 2); - if (arr instanceof Int16Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); - this.mapInt16Array(arr.length, e); - } else { - for (var i = 0; i < arr.length; i++) { - this.writeInt16(arr[i], e); - } - } - }; - - /** - Writes an Int8Array to the DataStream. - @param {Object} arr The array to write. - */ - DataStream.prototype.writeInt8Array = function (arr) { - this._realloc(arr.length * 1); - if (arr instanceof Int8Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); - this.mapInt8Array(arr.length); - } else { - for (var i = 0; i < arr.length; i++) { - this.writeInt8(arr[i]); - } - } - }; - - /** - Writes a Uint32Array of specified endianness to the DataStream. - @param {Object} arr The array to write. - @param {?boolean} e Endianness of the data to write. - */ - DataStream.prototype.writeUint32Array = function (arr, e) { - this._realloc(arr.length * 4); - if (arr instanceof Uint32Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); - this.mapUint32Array(arr.length, e); - } else { - for (var i = 0; i < arr.length; i++) { - this.writeUint32(arr[i], e); - } - } - }; - - /** - Writes a Uint16Array of specified endianness to the DataStream. - @param {Object} arr The array to write. - @param {?boolean} e Endianness of the data to write. - */ - DataStream.prototype.writeUint16Array = function (arr, e) { - this._realloc(arr.length * 2); - if (arr instanceof Uint16Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); - this.mapUint16Array(arr.length, e); - } else { - for (var i = 0; i < arr.length; i++) { - this.writeUint16(arr[i], e); - } - } - }; - - /** - Writes a Uint8Array to the DataStream. - @param {Object} arr The array to write. - */ - DataStream.prototype.writeUint8Array = function (arr) { - this._realloc(arr.length * 1); - if (arr instanceof Uint8Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); - this.mapUint8Array(arr.length); - } else { - for (var i = 0; i < arr.length; i++) { - this.writeUint8(arr[i]); - } - } - }; - - /** - Writes a Float64Array of specified endianness to the DataStream. - @param {Object} arr The array to write. - @param {?boolean} e Endianness of the data to write. - */ - DataStream.prototype.writeFloat64Array = function (arr, e) { - this._realloc(arr.length * 8); - if (arr instanceof Float64Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); - this.mapFloat64Array(arr.length, e); - } else { - for (var i = 0; i < arr.length; i++) { - this.writeFloat64(arr[i], e); - } - } - }; - - /** - Writes a Float32Array of specified endianness to the DataStream. - @param {Object} arr The array to write. - @param {?boolean} e Endianness of the data to write. - */ - DataStream.prototype.writeFloat32Array = function (arr, e) { - this._realloc(arr.length * 4); - if (arr instanceof Float32Array && this.byteOffset + this.position % arr.BYTES_PER_ELEMENT === 0) { - DataStream.memcpy(this._buffer, this.byteOffset + this.position, arr.buffer, 0, arr.byteLength); - this.mapFloat32Array(arr.length, e); - } else { - for (var i = 0; i < arr.length; i++) { - this.writeFloat32(arr[i], e); - } - } - }; - - /** - Writes a 32-bit int to the DataStream with the desired endianness. - @param {number} v Number to write. - @param {?boolean} e Endianness of the number. - */ - DataStream.prototype.writeInt32 = function (v, e) { - this._realloc(4); - this._dataView.setInt32(this.position, v, e == null ? this.endianness : e); - this.position += 4; - }; - - /** - Writes a 16-bit int to the DataStream with the desired endianness. - @param {number} v Number to write. - @param {?boolean} e Endianness of the number. - */ - DataStream.prototype.writeInt16 = function (v, e) { - this._realloc(2); - this._dataView.setInt16(this.position, v, e == null ? this.endianness : e); - this.position += 2; - }; - - /** - Writes an 8-bit int to the DataStream. - @param {number} v Number to write. - */ - DataStream.prototype.writeInt8 = function (v) { - this._realloc(1); - this._dataView.setInt8(this.position, v); - this.position += 1; - }; - - /** - Writes a 32-bit unsigned int to the DataStream with the desired endianness. - @param {number} v Number to write. - @param {?boolean} e Endianness of the number. - */ - DataStream.prototype.writeUint32 = function (v, e) { - this._realloc(4); - this._dataView.setUint32(this.position, v, e == null ? this.endianness : e); - this.position += 4; - }; - - /** - Writes a 16-bit unsigned int to the DataStream with the desired endianness. - @param {number} v Number to write. - @param {?boolean} e Endianness of the number. - */ - DataStream.prototype.writeUint16 = function (v, e) { - this._realloc(2); - this._dataView.setUint16(this.position, v, e == null ? this.endianness : e); - this.position += 2; - }; - - /** - Writes an 8-bit unsigned int to the DataStream. - @param {number} v Number to write. - */ - DataStream.prototype.writeUint8 = function (v) { - this._realloc(1); - this._dataView.setUint8(this.position, v); - this.position += 1; - }; - - /** - Writes a 32-bit float to the DataStream with the desired endianness. - @param {number} v Number to write. - @param {?boolean} e Endianness of the number. - */ - DataStream.prototype.writeFloat32 = function (v, e) { - this._realloc(4); - this._dataView.setFloat32(this.position, v, e == null ? this.endianness : e); - this.position += 4; - }; - - /** - Writes a 64-bit float to the DataStream with the desired endianness. - @param {number} v Number to write. - @param {?boolean} e Endianness of the number. - */ - DataStream.prototype.writeFloat64 = function (v, e) { - this._realloc(8); - this._dataView.setFloat64(this.position, v, e == null ? this.endianness : e); - this.position += 8; - }; - - /** - Write a UCS-2 string of desired endianness to the DataStream. The - lengthOverride argument lets you define the number of characters to write. - If the string is shorter than lengthOverride, the extra space is padded with - zeroes. - @param {string} str The string to write. - @param {?boolean} endianness The endianness to use for the written string data. - @param {?number} lengthOverride The number of characters to write. - */ - DataStream.prototype.writeUCS2String = function (str, endianness, lengthOverride) { - if (lengthOverride == null) { - lengthOverride = str.length; - } - for (var i = 0; i < str.length && i < lengthOverride; i++) { - this.writeUint16(str.charCodeAt(i), endianness); - } - for (; i < lengthOverride; i++) { - this.writeUint16(0); - } - }; - - /** - Writes a string of desired length and encoding to the DataStream. - @param {string} s The string to write. - @param {?string} encoding The encoding for the written string data. - Defaults to ASCII. - @param {?number} length The number of characters to write. - */ - DataStream.prototype.writeString = function (s, encoding, length) { - var i = 0; - if (encoding == null || encoding == "ASCII") { - if (length != null) { - var len = Math.min(s.length, length); - for (i = 0; i < len; i++) { - this.writeUint8(s.charCodeAt(i)); - } - for (; i < length; i++) { - this.writeUint8(0); - } - } else { - for (i = 0; i < s.length; i++) { - this.writeUint8(s.charCodeAt(i)); - } - } - } else { - this.writeUint8Array(new TextEncoder(encoding).encode(s.substring(0, length))); - } - }; - - /** - Writes a null-terminated string to DataStream and zero-pads it to length - bytes. If length is not given, writes the string followed by a zero. - If string is longer than length, the written part of the string does not have - a trailing zero. - @param {string} s The string to write. - @param {?number} length The number of characters to write. - */ - DataStream.prototype.writeCString = function (s, length) { - var i = 0; - if (length != null) { - var len = Math.min(s.length, length); - for (i = 0; i < len; i++) { - this.writeUint8(s.charCodeAt(i)); - } - for (; i < length; i++) { - this.writeUint8(0); - } - } else { - for (i = 0; i < s.length; i++) { - this.writeUint8(s.charCodeAt(i)); - } - this.writeUint8(0); - } - }; - - /** - Writes a struct to the DataStream. Takes a structDefinition that gives the - types and a struct object that gives the values. Refer to readStruct for the - structure of structDefinition. - @param {Object} structDefinition Type definition of the struct. - @param {Object} struct The struct data object. - */ - DataStream.prototype.writeStruct = function (structDefinition, struct) { - for (var i = 0; i < structDefinition.length; i += 2) { - var t = structDefinition[i + 1]; - this.writeType(t, struct[structDefinition[i]], struct); - } - }; - - /** - Writes object v of type t to the DataStream. - @param {Object} t Type of data to write. - @param {Object} v Value of data to write. - @param {Object} struct Struct to pass to write callback functions. - */ - DataStream.prototype.writeType = function (t, v, struct) { - var tp; - if (typeof t == "function") { - return t(this, v); - } else if (typeof t == "object" && !(t instanceof Array)) { - return t.set(this, v, struct); - } - var lengthOverride = null; - var charset = "ASCII"; - var pos = this.position; - if (typeof t == 'string' && /:/.test(t)) { - tp = t.split(":"); - t = tp[0]; - lengthOverride = parseInt(tp[1]); - } - if (typeof t == 'string' && /,/.test(t)) { - tp = t.split(","); - t = tp[0]; - charset = parseInt(tp[1]); - } - switch (t) { - case 'uint8': - this.writeUint8(v); - break; - case 'int8': - this.writeInt8(v); - break; - case 'uint16': - this.writeUint16(v, this.endianness); - break; - case 'int16': - this.writeInt16(v, this.endianness); - break; - case 'uint32': - this.writeUint32(v, this.endianness); - break; - case 'int32': - this.writeInt32(v, this.endianness); - break; - case 'float32': - this.writeFloat32(v, this.endianness); - break; - case 'float64': - this.writeFloat64(v, this.endianness); - break; - case 'uint16be': - this.writeUint16(v, DataStream.BIG_ENDIAN); - break; - case 'int16be': - this.writeInt16(v, DataStream.BIG_ENDIAN); - break; - case 'uint32be': - this.writeUint32(v, DataStream.BIG_ENDIAN); - break; - case 'int32be': - this.writeInt32(v, DataStream.BIG_ENDIAN); - break; - case 'float32be': - this.writeFloat32(v, DataStream.BIG_ENDIAN); - break; - case 'float64be': - this.writeFloat64(v, DataStream.BIG_ENDIAN); - break; - case 'uint16le': - this.writeUint16(v, DataStream.LITTLE_ENDIAN); - break; - case 'int16le': - this.writeInt16(v, DataStream.LITTLE_ENDIAN); - break; - case 'uint32le': - this.writeUint32(v, DataStream.LITTLE_ENDIAN); - break; - case 'int32le': - this.writeInt32(v, DataStream.LITTLE_ENDIAN); - break; - case 'float32le': - this.writeFloat32(v, DataStream.LITTLE_ENDIAN); - break; - case 'float64le': - this.writeFloat64(v, DataStream.LITTLE_ENDIAN); - break; - case 'cstring': - this.writeCString(v, lengthOverride); - break; - case 'string': - this.writeString(v, charset, lengthOverride); - break; - case 'u16string': - this.writeUCS2String(v, this.endianness, lengthOverride); - break; - case 'u16stringle': - this.writeUCS2String(v, DataStream.LITTLE_ENDIAN, lengthOverride); - break; - case 'u16stringbe': - this.writeUCS2String(v, DataStream.BIG_ENDIAN, lengthOverride); - break; - default: - if (t.length == 3) { - var ta = t[1]; - for (var i = 0; i < v.length; i++) { - this.writeType(ta, v[i]); - } - break; - } else { - this.writeStruct(t, v); - break; - } - } - if (lengthOverride != null) { - this.position = pos; - this._realloc(lengthOverride); - this.position = pos + lengthOverride; - } - }; - DataStream.prototype.writeUint64 = function (v) { - var h = Math.floor(v / MAX_SIZE); - this.writeUint32(h); - this.writeUint32(v & 0xFFFFFFFF); - }; - DataStream.prototype.writeUint24 = function (v) { - this.writeUint8((v & 0x00FF0000) >> 16); - this.writeUint8((v & 0x0000FF00) >> 8); - this.writeUint8(v & 0x000000FF); - }; - DataStream.prototype.adjustUint32 = function (position, value) { - var pos = this.position; - this.seek(position); - this.writeUint32(value); - this.seek(pos); - }; - // file:src/DataStream-map.js - /** - Maps an Int32Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Int32Array to the DataStream backing buffer. - */ - DataStream.prototype.mapInt32Array = function (length, e) { - this._realloc(length * 4); - var arr = new Int32Array(this._buffer, this.byteOffset + this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 4; - return arr; - }; - - /** - Maps an Int16Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Int16Array to the DataStream backing buffer. - */ - DataStream.prototype.mapInt16Array = function (length, e) { - this._realloc(length * 2); - var arr = new Int16Array(this._buffer, this.byteOffset + this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 2; - return arr; - }; - - /** - Maps an Int8Array into the DataStream buffer. - Nice for quickly reading in data. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Int8Array to the DataStream backing buffer. - */ - DataStream.prototype.mapInt8Array = function (length) { - this._realloc(length * 1); - var arr = new Int8Array(this._buffer, this.byteOffset + this.position, length); - this.position += length * 1; - return arr; - }; - - /** - Maps a Uint32Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Uint32Array to the DataStream backing buffer. - */ - DataStream.prototype.mapUint32Array = function (length, e) { - this._realloc(length * 4); - var arr = new Uint32Array(this._buffer, this.byteOffset + this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 4; - return arr; - }; - - /** - Maps a Uint16Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Uint16Array to the DataStream backing buffer. - */ - DataStream.prototype.mapUint16Array = function (length, e) { - this._realloc(length * 2); - var arr = new Uint16Array(this._buffer, this.byteOffset + this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 2; - return arr; - }; - - /** - Maps a Float64Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Float64Array to the DataStream backing buffer. - */ - DataStream.prototype.mapFloat64Array = function (length, e) { - this._realloc(length * 8); - var arr = new Float64Array(this._buffer, this.byteOffset + this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 8; - return arr; - }; - - /** - Maps a Float32Array into the DataStream buffer, swizzling it to native - endianness in-place. The current offset from the start of the buffer needs to - be a multiple of element size, just like with typed array views. - Nice for quickly reading in data. Warning: potentially modifies the buffer - contents. - @param {number} length Number of elements to map. - @param {?boolean} e Endianness of the data to read. - @return {Object} Float32Array to the DataStream backing buffer. - */ - DataStream.prototype.mapFloat32Array = function (length, e) { - this._realloc(length * 4); - var arr = new Float32Array(this._buffer, this.byteOffset + this.position, length); - DataStream.arrayToNative(arr, e == null ? this.endianness : e); - this.position += length * 4; - return arr; - }; - // file:src/buffer.js - /** - * MultiBufferStream is a class that acts as a SimpleStream for parsing - * It holds several, possibly non-contiguous ArrayBuffer objects, each with a fileStart property - * containing the offset for the buffer data in an original/virtual file - * - * It inherits also from DataStream for all read/write/alloc operations - */ - - /** - * Constructor - */ - var MultiBufferStream = function (buffer) { - /* List of ArrayBuffers, with a fileStart property, sorted in fileStart order and non overlapping */ - this.buffers = []; - this.bufferIndex = -1; - if (buffer) { - this.insertBuffer(buffer); - this.bufferIndex = 0; - } - }; - MultiBufferStream.prototype = new DataStream(new ArrayBuffer(), 0, DataStream.BIG_ENDIAN); - - /************************************************************************************ - Methods for the managnement of the buffers (insertion, removal, concatenation, ...) - ***********************************************************************************/ - - MultiBufferStream.prototype.initialized = function () { - var firstBuffer; - if (this.bufferIndex > -1) { - return true; - } else if (this.buffers.length > 0) { - firstBuffer = this.buffers[0]; - if (firstBuffer.fileStart === 0) { - this.buffer = firstBuffer; - this.bufferIndex = 0; - Log.debug("MultiBufferStream", "Stream ready for parsing"); - return true; - } else { - Log.warn("MultiBufferStream", "The first buffer should have a fileStart of 0"); - this.logBufferLevel(); - return false; - } - } else { - Log.warn("MultiBufferStream", "No buffer to start parsing from"); - this.logBufferLevel(); - return false; - } - }; - - /** - * helper functions to concatenate two ArrayBuffer objects - * @param {ArrayBuffer} buffer1 - * @param {ArrayBuffer} buffer2 - * @return {ArrayBuffer} the concatenation of buffer1 and buffer2 in that order - */ - ArrayBuffer.concat = function (buffer1, buffer2) { - Log.debug("ArrayBuffer", "Trying to create a new buffer of size: " + (buffer1.byteLength + buffer2.byteLength)); - var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength); - tmp.set(new Uint8Array(buffer1), 0); - tmp.set(new Uint8Array(buffer2), buffer1.byteLength); - return tmp.buffer; - }; - - /** - * Reduces the size of a given buffer, but taking the part between offset and offset+newlength - * @param {ArrayBuffer} buffer - * @param {Number} offset the start of new buffer - * @param {Number} newLength the length of the new buffer - * @return {ArrayBuffer} the new buffer - */ - MultiBufferStream.prototype.reduceBuffer = function (buffer, offset, newLength) { - var smallB; - smallB = new Uint8Array(newLength); - smallB.set(new Uint8Array(buffer, offset, newLength)); - smallB.buffer.fileStart = buffer.fileStart + offset; - smallB.buffer.usedBytes = 0; - return smallB.buffer; - }; - - /** - * Inserts the new buffer in the sorted list of buffers, - * making sure, it is not overlapping with existing ones (possibly reducing its size). - * if the new buffer overrides/replaces the 0-th buffer (for instance because it is bigger), - * updates the DataStream buffer for parsing - */ - MultiBufferStream.prototype.insertBuffer = function (ab) { - var to_add = true; - /* TODO: improve insertion if many buffers */ - for (var i = 0; i < this.buffers.length; i++) { - var b = this.buffers[i]; - if (ab.fileStart <= b.fileStart) { - /* the insertion position is found */ - if (ab.fileStart === b.fileStart) { - /* The new buffer overlaps with an existing buffer */ - if (ab.byteLength > b.byteLength) { - /* the new buffer is bigger than the existing one - remove the existing buffer and try again to insert - the new buffer to check overlap with the next ones */ - this.buffers.splice(i, 1); - i--; - continue; - } else { - /* the new buffer is smaller than the existing one, just drop it */ - Log.warn("MultiBufferStream", "Buffer (fileStart: " + ab.fileStart + " - Length: " + ab.byteLength + ") already appended, ignoring"); - } - } else { - /* The beginning of the new buffer is not overlapping with an existing buffer - let's check the end of it */ - if (ab.fileStart + ab.byteLength <= b.fileStart) ; else { - /* There is some overlap, cut the new buffer short, and add it*/ - ab = this.reduceBuffer(ab, 0, b.fileStart - ab.fileStart); - } - Log.debug("MultiBufferStream", "Appending new buffer (fileStart: " + ab.fileStart + " - Length: " + ab.byteLength + ")"); - this.buffers.splice(i, 0, ab); - /* if this new buffer is inserted in the first place in the list of the buffer, - and the DataStream is initialized, make it the buffer used for parsing */ - if (i === 0) { - this.buffer = ab; - } - } - to_add = false; - break; - } else if (ab.fileStart < b.fileStart + b.byteLength) { - /* the new buffer overlaps its beginning with the end of the current buffer */ - var offset = b.fileStart + b.byteLength - ab.fileStart; - var newLength = ab.byteLength - offset; - if (newLength > 0) { - /* the new buffer is bigger than the current overlap, drop the overlapping part and try again inserting the remaining buffer */ - ab = this.reduceBuffer(ab, offset, newLength); - } else { - /* the content of the new buffer is entirely contained in the existing buffer, drop it entirely */ - to_add = false; - break; - } - } - } - /* if the buffer has not been added, we can add it at the end */ - if (to_add) { - Log.debug("MultiBufferStream", "Appending new buffer (fileStart: " + ab.fileStart + " - Length: " + ab.byteLength + ")"); - this.buffers.push(ab); - /* if this new buffer is inserted in the first place in the list of the buffer, - and the DataStream is initialized, make it the buffer used for parsing */ - if (i === 0) { - this.buffer = ab; - } - } - }; - - /** - * Displays the status of the buffers (number and used bytes) - * @param {Object} info callback method for display - */ - MultiBufferStream.prototype.logBufferLevel = function (info) { - var i; - var buffer; - var used, total; - var ranges = []; - var range; - var bufferedString = ""; - used = 0; - total = 0; - for (i = 0; i < this.buffers.length; i++) { - buffer = this.buffers[i]; - if (i === 0) { - range = {}; - ranges.push(range); - range.start = buffer.fileStart; - range.end = buffer.fileStart + buffer.byteLength; - bufferedString += "[" + range.start + "-"; - } else if (range.end === buffer.fileStart) { - range.end = buffer.fileStart + buffer.byteLength; - } else { - range = {}; - range.start = buffer.fileStart; - bufferedString += ranges[ranges.length - 1].end - 1 + "], [" + range.start + "-"; - range.end = buffer.fileStart + buffer.byteLength; - ranges.push(range); - } - used += buffer.usedBytes; - total += buffer.byteLength; - } - if (ranges.length > 0) { - bufferedString += range.end - 1 + "]"; - } - var log = info ? Log.info : Log.debug; - if (this.buffers.length === 0) { - log("MultiBufferStream", "No more buffer in memory"); - } else { - log("MultiBufferStream", "" + this.buffers.length + " stored buffer(s) (" + used + "/" + total + " bytes), continuous ranges: " + bufferedString); - } - }; - MultiBufferStream.prototype.cleanBuffers = function () { - var i; - var buffer; - for (i = 0; i < this.buffers.length; i++) { - buffer = this.buffers[i]; - if (buffer.usedBytes === buffer.byteLength) { - Log.debug("MultiBufferStream", "Removing buffer #" + i); - this.buffers.splice(i, 1); - i--; - } - } - }; - MultiBufferStream.prototype.mergeNextBuffer = function () { - var next_buffer; - if (this.bufferIndex + 1 < this.buffers.length) { - next_buffer = this.buffers[this.bufferIndex + 1]; - if (next_buffer.fileStart === this.buffer.fileStart + this.buffer.byteLength) { - var oldLength = this.buffer.byteLength; - var oldUsedBytes = this.buffer.usedBytes; - var oldFileStart = this.buffer.fileStart; - this.buffers[this.bufferIndex] = ArrayBuffer.concat(this.buffer, next_buffer); - this.buffer = this.buffers[this.bufferIndex]; - this.buffers.splice(this.bufferIndex + 1, 1); - this.buffer.usedBytes = oldUsedBytes; /* TODO: should it be += ? */ - this.buffer.fileStart = oldFileStart; - Log.debug("ISOFile", "Concatenating buffer for box parsing (length: " + oldLength + "->" + this.buffer.byteLength + ")"); - return true; - } else { - return false; - } - } else { - return false; - } - }; - - /************************************************************************* - Seek-related functions - *************************************************************************/ - - /** - * Finds the buffer that holds the given file position - * @param {Boolean} fromStart indicates if the search should start from the current buffer (false) - * or from the first buffer (true) - * @param {Number} filePosition position in the file to seek to - * @param {Boolean} markAsUsed indicates if the bytes in between the current position and the seek position - * should be marked as used for garbage collection - * @return {Number} the index of the buffer holding the seeked file position, -1 if not found. - */ - MultiBufferStream.prototype.findPosition = function (fromStart, filePosition, markAsUsed) { - var i; - var abuffer = null; - var index = -1; - - /* find the buffer with the largest position smaller than the given position */ - if (fromStart === true) { - /* the reposition can be in the past, we need to check from the beginning of the list of buffers */ - i = 0; - } else { - i = this.bufferIndex; - } - while (i < this.buffers.length) { - abuffer = this.buffers[i]; - if (abuffer.fileStart <= filePosition) { - index = i; - if (markAsUsed) { - if (abuffer.fileStart + abuffer.byteLength <= filePosition) { - abuffer.usedBytes = abuffer.byteLength; - } else { - abuffer.usedBytes = filePosition - abuffer.fileStart; - } - this.logBufferLevel(); - } - } else { - break; - } - i++; - } - if (index !== -1) { - abuffer = this.buffers[index]; - if (abuffer.fileStart + abuffer.byteLength >= filePosition) { - Log.debug("MultiBufferStream", "Found position in existing buffer #" + index); - return index; - } else { - return -1; - } - } else { - return -1; - } - }; - - /** - * Finds the largest file position contained in a buffer or in the next buffers if they are contiguous (no gap) - * starting from the given buffer index or from the current buffer if the index is not given - * - * @param {Number} inputindex Index of the buffer to start from - * @return {Number} The largest file position found in the buffers - */ - MultiBufferStream.prototype.findEndContiguousBuf = function (inputindex) { - var i; - var currentBuf; - var nextBuf; - var index = inputindex !== undefined ? inputindex : this.bufferIndex; - currentBuf = this.buffers[index]; - /* find the end of the contiguous range of data */ - if (this.buffers.length > index + 1) { - for (i = index + 1; i < this.buffers.length; i++) { - nextBuf = this.buffers[i]; - if (nextBuf.fileStart === currentBuf.fileStart + currentBuf.byteLength) { - currentBuf = nextBuf; - } else { - break; - } - } - } - /* return the position of last byte in the file that we have */ - return currentBuf.fileStart + currentBuf.byteLength; - }; - - /** - * Returns the largest file position contained in the buffers, larger than the given position - * @param {Number} pos the file position to start from - * @return {Number} the largest position in the current buffer or in the buffer and the next contiguous - * buffer that holds the given position - */ - MultiBufferStream.prototype.getEndFilePositionAfter = function (pos) { - var index = this.findPosition(true, pos, false); - if (index !== -1) { - return this.findEndContiguousBuf(index); - } else { - return pos; - } - }; - - /************************************************************************* - Garbage collection related functions - *************************************************************************/ - - /** - * Marks a given number of bytes as used in the current buffer for garbage collection - * @param {Number} nbBytes - */ - MultiBufferStream.prototype.addUsedBytes = function (nbBytes) { - this.buffer.usedBytes += nbBytes; - this.logBufferLevel(); - }; - - /** - * Marks the entire current buffer as used, ready for garbage collection - */ - MultiBufferStream.prototype.setAllUsedBytes = function () { - this.buffer.usedBytes = this.buffer.byteLength; - this.logBufferLevel(); - }; - - /************************************************************************* - Common API between MultiBufferStream and SimpleStream - *************************************************************************/ - - /** - * Tries to seek to a given file position - * if possible, repositions the parsing from there and returns true - * if not possible, does not change anything and returns false - * @param {Number} filePosition position in the file to seek to - * @param {Boolean} fromStart indicates if the search should start from the current buffer (false) - * or from the first buffer (true) - * @param {Boolean} markAsUsed indicates if the bytes in between the current position and the seek position - * should be marked as used for garbage collection - * @return {Boolean} true if the seek succeeded, false otherwise - */ - MultiBufferStream.prototype.seek = function (filePosition, fromStart, markAsUsed) { - var index; - index = this.findPosition(fromStart, filePosition, markAsUsed); - if (index !== -1) { - this.buffer = this.buffers[index]; - this.bufferIndex = index; - this.position = filePosition - this.buffer.fileStart; - Log.debug("MultiBufferStream", "Repositioning parser at buffer position: " + this.position); - return true; - } else { - Log.debug("MultiBufferStream", "Position " + filePosition + " not found in buffered data"); - return false; - } - }; - - /** - * Returns the current position in the file - * @return {Number} the position in the file - */ - MultiBufferStream.prototype.getPosition = function () { - if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null) { - throw "Error accessing position in the MultiBufferStream"; - } - return this.buffers[this.bufferIndex].fileStart + this.position; - }; - - /** - * Returns the length of the current buffer - * @return {Number} the length of the current buffer - */ - MultiBufferStream.prototype.getLength = function () { - return this.byteLength; - }; - MultiBufferStream.prototype.getEndPosition = function () { - if (this.bufferIndex === -1 || this.buffers[this.bufferIndex] === null) { - throw "Error accessing position in the MultiBufferStream"; - } - return this.buffers[this.bufferIndex].fileStart + this.byteLength; - }; - { - exports.MultiBufferStream = MultiBufferStream; - } // file:src/descriptor.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var MPEG4DescriptorParser = function () { - var ES_DescrTag = 0x03; - var DecoderConfigDescrTag = 0x04; - var DecSpecificInfoTag = 0x05; - var SLConfigDescrTag = 0x06; - var descTagToName = []; - descTagToName[ES_DescrTag] = "ES_Descriptor"; - descTagToName[DecoderConfigDescrTag] = "DecoderConfigDescriptor"; - descTagToName[DecSpecificInfoTag] = "DecoderSpecificInfo"; - descTagToName[SLConfigDescrTag] = "SLConfigDescriptor"; - this.getDescriptorName = function (tag) { - return descTagToName[tag]; - }; - var that = this; - var classes = {}; - this.parseOneDescriptor = function (stream) { - var size = 0; - var tag; - var desc; - var byteRead; - tag = stream.readUint8(); - byteRead = stream.readUint8(); - while (byteRead & 0x80) { - size = (size << 7) + (byteRead & 0x7F); - byteRead = stream.readUint8(); - } - size = (size << 7) + (byteRead & 0x7F); - Log.debug("MPEG4DescriptorParser", "Found " + (descTagToName[tag] || "Descriptor " + tag) + ", size " + size + " at position " + stream.getPosition()); - if (descTagToName[tag]) { - desc = new classes[descTagToName[tag]](size); - } else { - desc = new classes.Descriptor(size); - } - desc.parse(stream); - return desc; - }; - classes.Descriptor = function (_tag, _size) { - this.tag = _tag; - this.size = _size; - this.descs = []; - }; - classes.Descriptor.prototype.parse = function (stream) { - this.data = stream.readUint8Array(this.size); - }; - classes.Descriptor.prototype.findDescriptor = function (tag) { - for (var i = 0; i < this.descs.length; i++) { - if (this.descs[i].tag == tag) { - return this.descs[i]; - } - } - return null; - }; - classes.Descriptor.prototype.parseRemainingDescriptors = function (stream) { - var start = stream.position; - while (stream.position < start + this.size) { - var desc = that.parseOneDescriptor(stream); - this.descs.push(desc); - } - }; - classes.ES_Descriptor = function (size) { - classes.Descriptor.call(this, ES_DescrTag, size); - }; - classes.ES_Descriptor.prototype = new classes.Descriptor(); - classes.ES_Descriptor.prototype.parse = function (stream) { - this.ES_ID = stream.readUint16(); - this.flags = stream.readUint8(); - this.size -= 3; - if (this.flags & 0x80) { - this.dependsOn_ES_ID = stream.readUint16(); - this.size -= 2; - } else { - this.dependsOn_ES_ID = 0; - } - if (this.flags & 0x40) { - var l = stream.readUint8(); - this.URL = stream.readString(l); - this.size -= l + 1; - } else { - this.URL = ""; - } - if (this.flags & 0x20) { - this.OCR_ES_ID = stream.readUint16(); - this.size -= 2; - } else { - this.OCR_ES_ID = 0; - } - this.parseRemainingDescriptors(stream); - }; - classes.ES_Descriptor.prototype.getOTI = function (stream) { - var dcd = this.findDescriptor(DecoderConfigDescrTag); - if (dcd) { - return dcd.oti; - } else { - return 0; - } - }; - classes.ES_Descriptor.prototype.getAudioConfig = function (stream) { - var dcd = this.findDescriptor(DecoderConfigDescrTag); - if (!dcd) return null; - var dsi = dcd.findDescriptor(DecSpecificInfoTag); - if (dsi && dsi.data) { - var audioObjectType = (dsi.data[0] & 0xF8) >> 3; - if (audioObjectType === 31 && dsi.data.length >= 2) { - audioObjectType = 32 + ((dsi.data[0] & 0x7) << 3) + ((dsi.data[1] & 0xE0) >> 5); - } - return audioObjectType; - } else { - return null; - } - }; - classes.DecoderConfigDescriptor = function (size) { - classes.Descriptor.call(this, DecoderConfigDescrTag, size); - }; - classes.DecoderConfigDescriptor.prototype = new classes.Descriptor(); - classes.DecoderConfigDescriptor.prototype.parse = function (stream) { - this.oti = stream.readUint8(); - this.streamType = stream.readUint8(); - this.upStream = (this.streamType >> 1 & 1) !== 0; - this.streamType = this.streamType >>> 2; - this.bufferSize = stream.readUint24(); - this.maxBitrate = stream.readUint32(); - this.avgBitrate = stream.readUint32(); - this.size -= 13; - this.parseRemainingDescriptors(stream); - }; - classes.DecoderSpecificInfo = function (size) { - classes.Descriptor.call(this, DecSpecificInfoTag, size); - }; - classes.DecoderSpecificInfo.prototype = new classes.Descriptor(); - classes.SLConfigDescriptor = function (size) { - classes.Descriptor.call(this, SLConfigDescrTag, size); - }; - classes.SLConfigDescriptor.prototype = new classes.Descriptor(); - return this; - }; - { - exports.MPEG4DescriptorParser = MPEG4DescriptorParser; - } - // file:src/box.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var BoxParser = { - ERR_INVALID_DATA: -1, - ERR_NOT_ENOUGH_DATA: 0, - OK: 1, - // Boxes to be created with default parsing - BASIC_BOXES: ["mdat", "idat", "free", "skip", "meco", "strk"], - FULL_BOXES: ["hmhd", "nmhd", "iods", "xml ", "bxml", "ipro", "mere"], - CONTAINER_BOXES: [["moov", ["trak", "pssh"]], ["trak"], ["edts"], ["mdia"], ["minf"], ["dinf"], ["stbl", ["sgpd", "sbgp"]], ["mvex", ["trex"]], ["moof", ["traf"]], ["traf", ["trun", "sgpd", "sbgp"]], ["vttc"], ["tref"], ["iref"], ["mfra", ["tfra"]], ["meco"], ["hnti"], ["hinf"], ["strk"], ["strd"], ["sinf"], ["rinf"], ["schi"], ["trgr"], ["udta", ["kind"]], ["iprp", ["ipma"]], ["ipco"], ["grpl"], ["j2kH"], ["etyp", ["tyco"]]], - // Boxes effectively created - boxCodes: [], - fullBoxCodes: [], - containerBoxCodes: [], - sampleEntryCodes: {}, - sampleGroupEntryCodes: [], - trackGroupTypes: [], - UUIDBoxes: {}, - UUIDs: [], - initialize: function () { - BoxParser.FullBox.prototype = new BoxParser.Box(); - BoxParser.ContainerBox.prototype = new BoxParser.Box(); - BoxParser.SampleEntry.prototype = new BoxParser.Box(); - BoxParser.TrackGroupTypeBox.prototype = new BoxParser.FullBox(); - - /* creating constructors for simple boxes */ - BoxParser.BASIC_BOXES.forEach(function (type) { - BoxParser.createBoxCtor(type); - }); - BoxParser.FULL_BOXES.forEach(function (type) { - BoxParser.createFullBoxCtor(type); - }); - BoxParser.CONTAINER_BOXES.forEach(function (types) { - BoxParser.createContainerBoxCtor(types[0], null, types[1]); - }); - }, - Box: function (_type, _size, _uuid) { - this.type = _type; - this.size = _size; - this.uuid = _uuid; - }, - FullBox: function (type, size, uuid) { - BoxParser.Box.call(this, type, size, uuid); - this.flags = 0; - this.version = 0; - }, - ContainerBox: function (type, size, uuid) { - BoxParser.Box.call(this, type, size, uuid); - this.boxes = []; - }, - SampleEntry: function (type, size, hdr_size, start) { - BoxParser.ContainerBox.call(this, type, size); - this.hdr_size = hdr_size; - this.start = start; - }, - SampleGroupEntry: function (type) { - this.grouping_type = type; - }, - TrackGroupTypeBox: function (type, size) { - BoxParser.FullBox.call(this, type, size); - }, - createBoxCtor: function (type, parseMethod) { - BoxParser.boxCodes.push(type); - BoxParser[type + "Box"] = function (size) { - BoxParser.Box.call(this, type, size); - }; - BoxParser[type + "Box"].prototype = new BoxParser.Box(); - if (parseMethod) BoxParser[type + "Box"].prototype.parse = parseMethod; - }, - createFullBoxCtor: function (type, parseMethod) { - //BoxParser.fullBoxCodes.push(type); - BoxParser[type + "Box"] = function (size) { - BoxParser.FullBox.call(this, type, size); - }; - BoxParser[type + "Box"].prototype = new BoxParser.FullBox(); - BoxParser[type + "Box"].prototype.parse = function (stream) { - this.parseFullHeader(stream); - if (parseMethod) { - parseMethod.call(this, stream); - } - }; - }, - addSubBoxArrays: function (subBoxNames) { - if (subBoxNames) { - this.subBoxNames = subBoxNames; - var nbSubBoxes = subBoxNames.length; - for (var k = 0; k < nbSubBoxes; k++) { - this[subBoxNames[k] + "s"] = []; - } - } - }, - createContainerBoxCtor: function (type, parseMethod, subBoxNames) { - //BoxParser.containerBoxCodes.push(type); - BoxParser[type + "Box"] = function (size) { - BoxParser.ContainerBox.call(this, type, size); - BoxParser.addSubBoxArrays.call(this, subBoxNames); - }; - BoxParser[type + "Box"].prototype = new BoxParser.ContainerBox(); - if (parseMethod) BoxParser[type + "Box"].prototype.parse = parseMethod; - }, - createMediaSampleEntryCtor: function (mediaType, parseMethod, subBoxNames) { - BoxParser.sampleEntryCodes[mediaType] = []; - BoxParser[mediaType + "SampleEntry"] = function (type, size) { - BoxParser.SampleEntry.call(this, type, size); - BoxParser.addSubBoxArrays.call(this, subBoxNames); - }; - BoxParser[mediaType + "SampleEntry"].prototype = new BoxParser.SampleEntry(); - if (parseMethod) BoxParser[mediaType + "SampleEntry"].prototype.parse = parseMethod; - }, - createSampleEntryCtor: function (mediaType, type, parseMethod, subBoxNames) { - BoxParser.sampleEntryCodes[mediaType].push(type); - BoxParser[type + "SampleEntry"] = function (size) { - BoxParser[mediaType + "SampleEntry"].call(this, type, size); - BoxParser.addSubBoxArrays.call(this, subBoxNames); - }; - BoxParser[type + "SampleEntry"].prototype = new BoxParser[mediaType + "SampleEntry"](); - if (parseMethod) BoxParser[type + "SampleEntry"].prototype.parse = parseMethod; - }, - createEncryptedSampleEntryCtor: function (mediaType, type, parseMethod) { - BoxParser.createSampleEntryCtor.call(this, mediaType, type, parseMethod, ["sinf"]); - }, - createSampleGroupCtor: function (type, parseMethod) { - //BoxParser.sampleGroupEntryCodes.push(type); - BoxParser[type + "SampleGroupEntry"] = function (size) { - BoxParser.SampleGroupEntry.call(this, type, size); - }; - BoxParser[type + "SampleGroupEntry"].prototype = new BoxParser.SampleGroupEntry(); - if (parseMethod) BoxParser[type + "SampleGroupEntry"].prototype.parse = parseMethod; - }, - createTrackGroupCtor: function (type, parseMethod) { - //BoxParser.trackGroupTypes.push(type); - BoxParser[type + "TrackGroupTypeBox"] = function (size) { - BoxParser.TrackGroupTypeBox.call(this, type, size); - }; - BoxParser[type + "TrackGroupTypeBox"].prototype = new BoxParser.TrackGroupTypeBox(); - if (parseMethod) BoxParser[type + "TrackGroupTypeBox"].prototype.parse = parseMethod; - }, - createUUIDBox: function (uuid, isFullBox, isContainerBox, parseMethod) { - BoxParser.UUIDs.push(uuid); - BoxParser.UUIDBoxes[uuid] = function (size) { - if (isFullBox) { - BoxParser.FullBox.call(this, "uuid", size, uuid); - } else { - if (isContainerBox) { - BoxParser.ContainerBox.call(this, "uuid", size, uuid); - } else { - BoxParser.Box.call(this, "uuid", size, uuid); - } - } - }; - BoxParser.UUIDBoxes[uuid].prototype = isFullBox ? new BoxParser.FullBox() : isContainerBox ? new BoxParser.ContainerBox() : new BoxParser.Box(); - if (parseMethod) { - if (isFullBox) { - BoxParser.UUIDBoxes[uuid].prototype.parse = function (stream) { - this.parseFullHeader(stream); - if (parseMethod) { - parseMethod.call(this, stream); - } - }; - } else { - BoxParser.UUIDBoxes[uuid].prototype.parse = parseMethod; - } - } - } - }; - BoxParser.initialize(); - BoxParser.TKHD_FLAG_ENABLED = 0x000001; - BoxParser.TKHD_FLAG_IN_MOVIE = 0x000002; - BoxParser.TKHD_FLAG_IN_PREVIEW = 0x000004; - BoxParser.TFHD_FLAG_BASE_DATA_OFFSET = 0x01; - BoxParser.TFHD_FLAG_SAMPLE_DESC = 0x02; - BoxParser.TFHD_FLAG_SAMPLE_DUR = 0x08; - BoxParser.TFHD_FLAG_SAMPLE_SIZE = 0x10; - BoxParser.TFHD_FLAG_SAMPLE_FLAGS = 0x20; - BoxParser.TFHD_FLAG_DUR_EMPTY = 0x10000; - BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF = 0x20000; - BoxParser.TRUN_FLAGS_DATA_OFFSET = 0x01; - BoxParser.TRUN_FLAGS_FIRST_FLAG = 0x04; - BoxParser.TRUN_FLAGS_DURATION = 0x100; - BoxParser.TRUN_FLAGS_SIZE = 0x200; - BoxParser.TRUN_FLAGS_FLAGS = 0x400; - BoxParser.TRUN_FLAGS_CTS_OFFSET = 0x800; - BoxParser.Box.prototype.add = function (name) { - return this.addBox(new BoxParser[name + "Box"]()); - }; - BoxParser.Box.prototype.addBox = function (box) { - this.boxes.push(box); - if (this[box.type + "s"]) { - this[box.type + "s"].push(box); - } else { - this[box.type] = box; - } - return box; - }; - BoxParser.Box.prototype.set = function (prop, value) { - this[prop] = value; - return this; - }; - BoxParser.Box.prototype.addEntry = function (value, _prop) { - var prop = _prop || "entries"; - if (!this[prop]) { - this[prop] = []; - } - this[prop].push(value); - return this; - }; - { - exports.BoxParser = BoxParser; - } - // file:src/box-parse.js - /* - * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - BoxParser.parseUUID = function (stream) { - return BoxParser.parseHex16(stream); - }; - BoxParser.parseHex16 = function (stream) { - var hex16 = ""; - for (var i = 0; i < 16; i++) { - var hex = stream.readUint8().toString(16); - hex16 += hex.length === 1 ? "0" + hex : hex; - } - return hex16; - }; - BoxParser.parseOneBox = function (stream, headerOnly, parentSize) { - var box; - var start = stream.getPosition(); - var hdr_size = 0; - var diff; - var uuid; - if (stream.getEndPosition() - start < 8) { - Log.debug("BoxParser", "Not enough data in stream to parse the type and size of the box"); - return { - code: BoxParser.ERR_NOT_ENOUGH_DATA - }; - } - if (parentSize && parentSize < 8) { - Log.debug("BoxParser", "Not enough bytes left in the parent box to parse a new box"); - return { - code: BoxParser.ERR_NOT_ENOUGH_DATA - }; - } - var size = stream.readUint32(); - var type = stream.readString(4); - var box_type = type; - Log.debug("BoxParser", "Found box of type '" + type + "' and size " + size + " at position " + start); - hdr_size = 8; - if (type == "uuid") { - if (stream.getEndPosition() - stream.getPosition() < 16 || parentSize - hdr_size < 16) { - stream.seek(start); - Log.debug("BoxParser", "Not enough bytes left in the parent box to parse a UUID box"); - return { - code: BoxParser.ERR_NOT_ENOUGH_DATA - }; - } - uuid = BoxParser.parseUUID(stream); - hdr_size += 16; - box_type = uuid; - } - if (size == 1) { - if (stream.getEndPosition() - stream.getPosition() < 8 || parentSize && parentSize - hdr_size < 8) { - stream.seek(start); - Log.warn("BoxParser", "Not enough data in stream to parse the extended size of the \"" + type + "\" box"); - return { - code: BoxParser.ERR_NOT_ENOUGH_DATA - }; - } - size = stream.readUint64(); - hdr_size += 8; - } else if (size === 0) { - /* box extends till the end of file or invalid file */ - if (parentSize) { - size = parentSize; - } else { - /* box extends till the end of file */ - if (type !== "mdat") { - Log.error("BoxParser", "Unlimited box size not supported for type: '" + type + "'"); - box = new BoxParser.Box(type, size); - return { - code: BoxParser.OK, - box: box, - size: box.size - }; - } - } - } - if (size !== 0 && size < hdr_size) { - Log.error("BoxParser", "Box of type " + type + " has an invalid size " + size + " (too small to be a box)"); - return { - code: BoxParser.ERR_NOT_ENOUGH_DATA, - type: type, - size: size, - hdr_size: hdr_size, - start: start - }; - } - if (size !== 0 && parentSize && size > parentSize) { - Log.error("BoxParser", "Box of type '" + type + "' has a size " + size + " greater than its container size " + parentSize); - return { - code: BoxParser.ERR_NOT_ENOUGH_DATA, - type: type, - size: size, - hdr_size: hdr_size, - start: start - }; - } - if (size !== 0 && start + size > stream.getEndPosition()) { - stream.seek(start); - Log.info("BoxParser", "Not enough data in stream to parse the entire '" + type + "' box"); - return { - code: BoxParser.ERR_NOT_ENOUGH_DATA, - type: type, - size: size, - hdr_size: hdr_size, - start: start - }; - } - if (headerOnly) { - return { - code: BoxParser.OK, - type: type, - size: size, - hdr_size: hdr_size, - start: start - }; - } else { - if (BoxParser[type + "Box"]) { - box = new BoxParser[type + "Box"](size); - } else { - if (type !== "uuid") { - Log.warn("BoxParser", "Unknown box type: '" + type + "'"); - box = new BoxParser.Box(type, size); - box.has_unparsed_data = true; - } else { - if (BoxParser.UUIDBoxes[uuid]) { - box = new BoxParser.UUIDBoxes[uuid](size); - } else { - Log.warn("BoxParser", "Unknown uuid type: '" + uuid + "'"); - box = new BoxParser.Box(type, size); - box.uuid = uuid; - box.has_unparsed_data = true; - } - } - } - } - box.hdr_size = hdr_size; - /* recording the position of the box in the input stream */ - box.start = start; - if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { - Log.info("BoxParser", "'" + box_type + "' box writing not yet implemented, keeping unparsed data in memory for later write"); - box.parseDataAndRewind(stream); - } - box.parse(stream); - diff = stream.getPosition() - (box.start + box.size); - if (diff < 0) { - Log.warn("BoxParser", "Parsing of box '" + box_type + "' did not read the entire indicated box data size (missing " + -diff + " bytes), seeking forward"); - stream.seek(box.start + box.size); - } else if (diff > 0) { - Log.error("BoxParser", "Parsing of box '" + box_type + "' read " + diff + " more bytes than the indicated box data size, seeking backwards"); - if (box.size !== 0) stream.seek(box.start + box.size); - } - return { - code: BoxParser.OK, - box: box, - size: box.size - }; - }; - BoxParser.Box.prototype.parse = function (stream) { - if (this.type != "mdat") { - this.data = stream.readUint8Array(this.size - this.hdr_size); - } else { - if (this.size === 0) { - stream.seek(stream.getEndPosition()); - } else { - stream.seek(this.start + this.size); - } - } - }; - - /* Used to parse a box without consuming its data, to allow detailled parsing - Useful for boxes for which a write method is not yet implemented */ - BoxParser.Box.prototype.parseDataAndRewind = function (stream) { - this.data = stream.readUint8Array(this.size - this.hdr_size); - // rewinding - stream.position -= this.size - this.hdr_size; - }; - BoxParser.FullBox.prototype.parseDataAndRewind = function (stream) { - this.parseFullHeader(stream); - this.data = stream.readUint8Array(this.size - this.hdr_size); - // restore the header size as if the full header had not been parsed - this.hdr_size -= 4; - // rewinding - stream.position -= this.size - this.hdr_size; - }; - BoxParser.FullBox.prototype.parseFullHeader = function (stream) { - this.version = stream.readUint8(); - this.flags = stream.readUint24(); - this.hdr_size += 4; - }; - BoxParser.FullBox.prototype.parse = function (stream) { - this.parseFullHeader(stream); - this.data = stream.readUint8Array(this.size - this.hdr_size); - }; - BoxParser.ContainerBox.prototype.parse = function (stream) { - var ret; - var box; - while (stream.getPosition() < this.start + this.size) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = ret.box; - /* store the box in the 'boxes' array to preserve box order (for offset) but also store box in a property for more direct access */ - this.boxes.push(box); - if (this.subBoxNames && this.subBoxNames.indexOf(box.type) != -1) { - this[this.subBoxNames[this.subBoxNames.indexOf(box.type)] + "s"].push(box); - } else { - var box_type = box.type !== "uuid" ? box.type : box.uuid; - if (this[box_type]) { - Log.warn("Box of type " + box_type + " already stored in field of this type"); - } else { - this[box_type] = box; - } - } - } else { - return; - } - } - }; - BoxParser.Box.prototype.parseLanguage = function (stream) { - this.language = stream.readUint16(); - var chars = []; - chars[0] = this.language >> 10 & 0x1F; - chars[1] = this.language >> 5 & 0x1F; - chars[2] = this.language & 0x1F; - this.languageString = String.fromCharCode(chars[0] + 0x60, chars[1] + 0x60, chars[2] + 0x60); - }; - - // file:src/parsing/sampleentries/sampleentry.js - BoxParser.SAMPLE_ENTRY_TYPE_VISUAL = "Visual"; - BoxParser.SAMPLE_ENTRY_TYPE_AUDIO = "Audio"; - BoxParser.SAMPLE_ENTRY_TYPE_HINT = "Hint"; - BoxParser.SAMPLE_ENTRY_TYPE_METADATA = "Metadata"; - BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE = "Subtitle"; - BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM = "System"; - BoxParser.SAMPLE_ENTRY_TYPE_TEXT = "Text"; - BoxParser.SampleEntry.prototype.parseHeader = function (stream) { - stream.readUint8Array(6); - this.data_reference_index = stream.readUint16(); - this.hdr_size += 8; - }; - BoxParser.SampleEntry.prototype.parse = function (stream) { - this.parseHeader(stream); - this.data = stream.readUint8Array(this.size - this.hdr_size); - }; - BoxParser.SampleEntry.prototype.parseDataAndRewind = function (stream) { - this.parseHeader(stream); - this.data = stream.readUint8Array(this.size - this.hdr_size); - // restore the header size as if the sample entry header had not been parsed - this.hdr_size -= 8; - // rewinding - stream.position -= this.size - this.hdr_size; - }; - BoxParser.SampleEntry.prototype.parseFooter = function (stream) { - BoxParser.ContainerBox.prototype.parse.call(this, stream); - }; - - // Base SampleEntry types with default parsing - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_HINT); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_TEXT); - - //Base SampleEntry types for Audio and Video with specific parsing - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, function (stream) { - var compressorname_length; - this.parseHeader(stream); - stream.readUint16(); - stream.readUint16(); - stream.readUint32Array(3); - this.width = stream.readUint16(); - this.height = stream.readUint16(); - this.horizresolution = stream.readUint32(); - this.vertresolution = stream.readUint32(); - stream.readUint32(); - this.frame_count = stream.readUint16(); - compressorname_length = Math.min(31, stream.readUint8()); - this.compressorname = stream.readString(compressorname_length); - if (compressorname_length < 31) { - stream.readString(31 - compressorname_length); - } - this.depth = stream.readUint16(); - stream.readUint16(); - this.parseFooter(stream); - }); - BoxParser.createMediaSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, function (stream) { - this.parseHeader(stream); - stream.readUint32Array(2); - this.channel_count = stream.readUint16(); - this.samplesize = stream.readUint16(); - stream.readUint16(); - stream.readUint16(); - this.samplerate = stream.readUint32() / (1 << 16); - this.parseFooter(stream); - }); - - // Sample entries inheriting from Audio and Video - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc2"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc3"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avc4"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "av01"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dav1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hvc1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hev1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "hvt1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "lhe1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dvh1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "dvhe"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvc1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvi1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvs1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vvcN"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vp08"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "vp09"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "avs3"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "j2ki"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "mjp2"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "mjpg"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "uncv"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mp4a"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ac-3"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ac-4"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "ec-3"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "Opus"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mha1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mha2"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mhm1"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "mhm2"); - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "fLaC"); - - // Encrypted sample entries - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_VISUAL, "encv"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_AUDIO, "enca"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "encu"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SYSTEM, "encs"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_TEXT, "enct"); - BoxParser.createEncryptedSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "encm"); - // file:src/parsing/a1lx.js - BoxParser.createBoxCtor("a1lx", function (stream) { - var large_size = stream.readUint8() & 1; - var FieldLength = ((large_size & 1) + 1) * 16; - this.layer_size = []; - for (var i = 0; i < 3; i++) { - if (FieldLength == 16) { - this.layer_size[i] = stream.readUint16(); - } else { - this.layer_size[i] = stream.readUint32(); - } - } - }); // file:src/parsing/a1op.js - BoxParser.createBoxCtor("a1op", function (stream) { - this.op_index = stream.readUint8(); - }); // file:src/parsing/auxC.js - BoxParser.createFullBoxCtor("auxC", function (stream) { - this.aux_type = stream.readCString(); - var aux_subtype_length = this.size - this.hdr_size - (this.aux_type.length + 1); - this.aux_subtype = stream.readUint8Array(aux_subtype_length); - }); // file:src/parsing/av1C.js - BoxParser.createBoxCtor("av1C", function (stream) { - var tmp = stream.readUint8(); - if (tmp >> 7 & 0x1 !== 1) { - Log.error("av1C marker problem"); - return; - } - this.version = tmp & 0x7F; - if (this.version !== 1) { - Log.error("av1C version " + this.version + " not supported"); - return; - } - tmp = stream.readUint8(); - this.seq_profile = tmp >> 5 & 0x7; - this.seq_level_idx_0 = tmp & 0x1F; - tmp = stream.readUint8(); - this.seq_tier_0 = tmp >> 7 & 0x1; - this.high_bitdepth = tmp >> 6 & 0x1; - this.twelve_bit = tmp >> 5 & 0x1; - this.monochrome = tmp >> 4 & 0x1; - this.chroma_subsampling_x = tmp >> 3 & 0x1; - this.chroma_subsampling_y = tmp >> 2 & 0x1; - this.chroma_sample_position = tmp & 0x3; - tmp = stream.readUint8(); - this.reserved_1 = tmp >> 5 & 0x7; - if (this.reserved_1 !== 0) { - Log.error("av1C reserved_1 parsing problem"); - return; - } - this.initial_presentation_delay_present = tmp >> 4 & 0x1; - if (this.initial_presentation_delay_present === 1) { - this.initial_presentation_delay_minus_one = tmp & 0xF; - } else { - this.reserved_2 = tmp & 0xF; - if (this.reserved_2 !== 0) { - Log.error("av1C reserved_2 parsing problem"); - return; - } - } - var configOBUs_length = this.size - this.hdr_size - 4; - this.configOBUs = stream.readUint8Array(configOBUs_length); - }); - - // file:src/parsing/avcC.js - BoxParser.createBoxCtor("avcC", function (stream) { - var i; - var toparse; - this.configurationVersion = stream.readUint8(); - this.AVCProfileIndication = stream.readUint8(); - this.profile_compatibility = stream.readUint8(); - this.AVCLevelIndication = stream.readUint8(); - this.lengthSizeMinusOne = stream.readUint8() & 0x3; - this.nb_SPS_nalus = stream.readUint8() & 0x1F; - toparse = this.size - this.hdr_size - 6; - this.SPS = []; - for (i = 0; i < this.nb_SPS_nalus; i++) { - this.SPS[i] = {}; - this.SPS[i].length = stream.readUint16(); - this.SPS[i].nalu = stream.readUint8Array(this.SPS[i].length); - toparse -= 2 + this.SPS[i].length; - } - this.nb_PPS_nalus = stream.readUint8(); - toparse--; - this.PPS = []; - for (i = 0; i < this.nb_PPS_nalus; i++) { - this.PPS[i] = {}; - this.PPS[i].length = stream.readUint16(); - this.PPS[i].nalu = stream.readUint8Array(this.PPS[i].length); - toparse -= 2 + this.PPS[i].length; - } - if (toparse > 0) { - this.ext = stream.readUint8Array(toparse); - } - }); - - // file:src/parsing/btrt.js - BoxParser.createBoxCtor("btrt", function (stream) { - this.bufferSizeDB = stream.readUint32(); - this.maxBitrate = stream.readUint32(); - this.avgBitrate = stream.readUint32(); - }); - - // file:src/parsing/ccst.js - BoxParser.createFullBoxCtor("ccst", function (stream) { - var flags = stream.readUint8(); - this.all_ref_pics_intra = (flags & 0x80) == 0x80; - this.intra_pred_used = (flags & 0x40) == 0x40; - this.max_ref_per_pic = (flags & 0x3f) >> 2; - stream.readUint24(); - }); - - // file:src/parsing/cdef.js - BoxParser.createBoxCtor("cdef", function (stream) { - var i; - this.channel_count = stream.readUint16(); - this.channel_indexes = []; - this.channel_types = []; - this.channel_associations = []; - for (i = 0; i < this.channel_count; i++) { - this.channel_indexes.push(stream.readUint16()); - this.channel_types.push(stream.readUint16()); - this.channel_associations.push(stream.readUint16()); - } - }); - - // file:src/parsing/clap.js - BoxParser.createBoxCtor("clap", function (stream) { - this.cleanApertureWidthN = stream.readUint32(); - this.cleanApertureWidthD = stream.readUint32(); - this.cleanApertureHeightN = stream.readUint32(); - this.cleanApertureHeightD = stream.readUint32(); - this.horizOffN = stream.readUint32(); - this.horizOffD = stream.readUint32(); - this.vertOffN = stream.readUint32(); - this.vertOffD = stream.readUint32(); - }); // file:src/parsing/clli.js - BoxParser.createBoxCtor("clli", function (stream) { - this.max_content_light_level = stream.readUint16(); - this.max_pic_average_light_level = stream.readUint16(); - }); - - // file:src/parsing/cmex.js - BoxParser.createFullBoxCtor("cmex", function (stream) { - if (this.flags & 0x1) { - this.pos_x = stream.readInt32(); - } - if (this.flags & 0x2) { - this.pos_y = stream.readInt32(); - } - if (this.flags & 0x4) { - this.pos_z = stream.readInt32(); - } - if (this.flags & 0x8) { - if (this.version == 0) { - if (this.flags & 0x10) { - this.quat_x = stream.readInt32(); - this.quat_y = stream.readInt32(); - this.quat_z = stream.readInt32(); - } else { - this.quat_x = stream.readInt16(); - this.quat_y = stream.readInt16(); - this.quat_z = stream.readInt16(); - } - } else if (this.version == 1) ; - } - if (this.flags & 0x20) { - this.id = stream.readUint32(); - } - }); - // file:src/parsing/cmin.js - BoxParser.createFullBoxCtor("cmin", function (stream) { - this.focal_length_x = stream.readInt32(); - this.principal_point_x = stream.readInt32(); - this.principal_point_y = stream.readInt32(); - if (this.flags & 0x1) { - this.focal_length_y = stream.readInt32(); - this.skew_factor = stream.readInt32(); - } - }); // file:src/parsing/cmpd.js - BoxParser.createBoxCtor("cmpd", function (stream) { - this.component_count = stream.readUint32(); - this.component_types = []; - this.component_type_urls = []; - for (i = 0; i < this.component_count; i++) { - var component_type = stream.readUint16(); - this.component_types.push(component_type); - if (component_type >= 0x8000) { - this.component_type_urls.push(stream.readCString()); - } - } - }); // file:src/parsing/co64.js - BoxParser.createFullBoxCtor("co64", function (stream) { - var entry_count; - var i; - entry_count = stream.readUint32(); - this.chunk_offsets = []; - if (this.version === 0) { - for (i = 0; i < entry_count; i++) { - this.chunk_offsets.push(stream.readUint64()); - } - } - }); - - // file:src/parsing/CoLL.js - BoxParser.createFullBoxCtor("CoLL", function (stream) { - this.maxCLL = stream.readUint16(); - this.maxFALL = stream.readUint16(); - }); - - // file:src/parsing/colr.js - BoxParser.createBoxCtor("colr", function (stream) { - this.colour_type = stream.readString(4); - if (this.colour_type === 'nclx') { - this.colour_primaries = stream.readUint16(); - this.transfer_characteristics = stream.readUint16(); - this.matrix_coefficients = stream.readUint16(); - var tmp = stream.readUint8(); - this.full_range_flag = tmp >> 7; - } else if (this.colour_type === 'rICC') { - this.ICC_profile = stream.readUint8Array(this.size - 4); - } else if (this.colour_type === 'prof') { - this.ICC_profile = stream.readUint8Array(this.size - 4); - } - }); // file:src/parsing/cprt.js - BoxParser.createFullBoxCtor("cprt", function (stream) { - this.parseLanguage(stream); - this.notice = stream.readCString(); - }); - - // file:src/parsing/cslg.js - BoxParser.createFullBoxCtor("cslg", function (stream) { - if (this.version === 0) { - this.compositionToDTSShift = stream.readInt32(); /* signed */ - this.leastDecodeToDisplayDelta = stream.readInt32(); /* signed */ - this.greatestDecodeToDisplayDelta = stream.readInt32(); /* signed */ - this.compositionStartTime = stream.readInt32(); /* signed */ - this.compositionEndTime = stream.readInt32(); /* signed */ - } - }); - - // file:src/parsing/ctts.js - BoxParser.createFullBoxCtor("ctts", function (stream) { - var entry_count; - var i; - entry_count = stream.readUint32(); - this.sample_counts = []; - this.sample_offsets = []; - if (this.version === 0) { - for (i = 0; i < entry_count; i++) { - this.sample_counts.push(stream.readUint32()); - /* some files are buggy and declare version=0 while using signed offsets. - The likelyhood of using the most significant bit in a 32-bits time offset is very low, - so using signed value here as well */ - var value = stream.readInt32(); - if (value < 0) { - Log.warn("BoxParser", "ctts box uses negative values without using version 1"); - } - this.sample_offsets.push(value); - } - } else if (this.version == 1) { - for (i = 0; i < entry_count; i++) { - this.sample_counts.push(stream.readUint32()); - this.sample_offsets.push(stream.readInt32()); /* signed */ - } - } - }); - - // file:src/parsing/dac3.js - BoxParser.createBoxCtor("dac3", function (stream) { - var tmp_byte1 = stream.readUint8(); - var tmp_byte2 = stream.readUint8(); - var tmp_byte3 = stream.readUint8(); - this.fscod = tmp_byte1 >> 6; - this.bsid = tmp_byte1 >> 1 & 0x1F; - this.bsmod = (tmp_byte1 & 0x1) << 2 | tmp_byte2 >> 6 & 0x3; - this.acmod = tmp_byte2 >> 3 & 0x7; - this.lfeon = tmp_byte2 >> 2 & 0x1; - this.bit_rate_code = tmp_byte2 & 0x3 | tmp_byte3 >> 5 & 0x7; - }); - - // file:src/parsing/dec3.js - BoxParser.createBoxCtor("dec3", function (stream) { - var tmp_16 = stream.readUint16(); - this.data_rate = tmp_16 >> 3; - this.num_ind_sub = tmp_16 & 0x7; - this.ind_subs = []; - for (var i = 0; i < this.num_ind_sub + 1; i++) { - var ind_sub = {}; - this.ind_subs.push(ind_sub); - var tmp_byte1 = stream.readUint8(); - var tmp_byte2 = stream.readUint8(); - var tmp_byte3 = stream.readUint8(); - ind_sub.fscod = tmp_byte1 >> 6; - ind_sub.bsid = tmp_byte1 >> 1 & 0x1F; - ind_sub.bsmod = (tmp_byte1 & 0x1) << 4 | tmp_byte2 >> 4 & 0xF; - ind_sub.acmod = tmp_byte2 >> 1 & 0x7; - ind_sub.lfeon = tmp_byte2 & 0x1; - ind_sub.num_dep_sub = tmp_byte3 >> 1 & 0xF; - if (ind_sub.num_dep_sub > 0) { - ind_sub.chan_loc = (tmp_byte3 & 0x1) << 8 | stream.readUint8(); - } - } - }); - - // file:src/parsing/dfLa.js - BoxParser.createFullBoxCtor("dfLa", function (stream) { - var BLOCKTYPE_MASK = 0x7F; - var LASTMETADATABLOCKFLAG_MASK = 0x80; - var boxesFound = []; - var knownBlockTypes = ["STREAMINFO", "PADDING", "APPLICATION", "SEEKTABLE", "VORBIS_COMMENT", "CUESHEET", "PICTURE", "RESERVED"]; - - // for (i=0; ; i++) { // to end of box - do { - var flagAndType = stream.readUint8(); - var type = Math.min(flagAndType & BLOCKTYPE_MASK, knownBlockTypes.length - 1); - - // if this is a STREAMINFO block, read the true samplerate since this - // can be different to the AudioSampleEntry samplerate. - if (!type) { - // read past all the other stuff - stream.readUint8Array(13); - - // extract samplerate - this.samplerate = stream.readUint32() >> 12; - - // read to end of STREAMINFO - stream.readUint8Array(20); - } else { - // not interested in other block types so just discard length bytes - stream.readUint8Array(stream.readUint24()); - } - boxesFound.push(knownBlockTypes[type]); - if (!!(flagAndType & LASTMETADATABLOCKFLAG_MASK)) { - break; - } - } while (true); - this.numMetadataBlocks = boxesFound.length + " (" + boxesFound.join(", ") + ")"; - }); - // file:src/parsing/dimm.js - BoxParser.createBoxCtor("dimm", function (stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/dmax.js - BoxParser.createBoxCtor("dmax", function (stream) { - this.time = stream.readUint32(); - }); - - // file:src/parsing/dmed.js - BoxParser.createBoxCtor("dmed", function (stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/dOps.js - BoxParser.createBoxCtor("dOps", function (stream) { - this.Version = stream.readUint8(); - this.OutputChannelCount = stream.readUint8(); - this.PreSkip = stream.readUint16(); - this.InputSampleRate = stream.readUint32(); - this.OutputGain = stream.readInt16(); - this.ChannelMappingFamily = stream.readUint8(); - if (this.ChannelMappingFamily !== 0) { - this.StreamCount = stream.readUint8(); - this.CoupledCount = stream.readUint8(); - this.ChannelMapping = []; - for (var i = 0; i < this.OutputChannelCount; i++) { - this.ChannelMapping[i] = stream.readUint8(); - } - } - }); - - // file:src/parsing/dref.js - BoxParser.createFullBoxCtor("dref", function (stream) { - var ret; - var box; - this.entries = []; - var entry_count = stream.readUint32(); - for (var i = 0; i < entry_count; i++) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = ret.box; - this.entries.push(box); - } else { - return; - } - } - }); - - // file:src/parsing/drep.js - BoxParser.createBoxCtor("drep", function (stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/elng.js - BoxParser.createFullBoxCtor("elng", function (stream) { - this.extended_language = stream.readString(this.size - this.hdr_size); - }); - - // file:src/parsing/elst.js - BoxParser.createFullBoxCtor("elst", function (stream) { - this.entries = []; - var entry_count = stream.readUint32(); - for (var i = 0; i < entry_count; i++) { - var entry = {}; - this.entries.push(entry); - if (this.version === 1) { - entry.segment_duration = stream.readUint64(); - entry.media_time = stream.readInt64(); - } else { - entry.segment_duration = stream.readUint32(); - entry.media_time = stream.readInt32(); - } - entry.media_rate_integer = stream.readInt16(); - entry.media_rate_fraction = stream.readInt16(); - } - }); - - // file:src/parsing/emsg.js - BoxParser.createFullBoxCtor("emsg", function (stream) { - if (this.version == 1) { - this.timescale = stream.readUint32(); - this.presentation_time = stream.readUint64(); - this.event_duration = stream.readUint32(); - this.id = stream.readUint32(); - this.scheme_id_uri = stream.readCString(); - this.value = stream.readCString(); - } else { - this.scheme_id_uri = stream.readCString(); - this.value = stream.readCString(); - this.timescale = stream.readUint32(); - this.presentation_time_delta = stream.readUint32(); - this.event_duration = stream.readUint32(); - this.id = stream.readUint32(); - } - var message_size = this.size - this.hdr_size - (4 * 4 + (this.scheme_id_uri.length + 1) + (this.value.length + 1)); - if (this.version == 1) { - message_size -= 4; - } - this.message_data = stream.readUint8Array(message_size); - }); - - // file:src/parsing/EntityToGroup.js - // ISO/IEC 14496-12:2022 Section 8.18.3 Entity to group box - BoxParser.createEntityToGroupCtor = function (type, parseMethod) { - BoxParser[type + "Box"] = function (size) { - BoxParser.FullBox.call(this, type, size); - }; - BoxParser[type + "Box"].prototype = new BoxParser.FullBox(); - BoxParser[type + "Box"].prototype.parse = function (stream) { - this.parseFullHeader(stream); - if (parseMethod) { - parseMethod.call(this, stream); - } else { - this.group_id = stream.readUint32(); - this.num_entities_in_group = stream.readUint32(); - this.entity_ids = []; - for (i = 0; i < this.num_entities_in_group; i++) { - var entity_id = stream.readUint32(); - this.entity_ids.push(entity_id); - } - } - }; - }; - - // Auto exposure bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.2.1) - BoxParser.createEntityToGroupCtor("aebr"); - - // Flash exposure bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.5.1) - BoxParser.createEntityToGroupCtor("afbr"); - - // Album collection (ISO/IEC 23008-12:2022 Section 6.8.7.1) - BoxParser.createEntityToGroupCtor("albc"); - - // Alternative entity (ISO/IEC 14496-12:2022 Section 8.18.3.1) - BoxParser.createEntityToGroupCtor("altr"); - - // Burst image entity group (ISO/IEC 23008-12:2022 Section 6.8.2.2) - BoxParser.createEntityToGroupCtor("brst"); - - // Depth of field bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.6.1) - BoxParser.createEntityToGroupCtor("dobr"); - - // Equivalent entity (ISO/IEC 23008-12:2022 Section 6.8.1.1) - BoxParser.createEntityToGroupCtor("eqiv"); - - // Favourites collection (ISO/IEC 23008-12:2022 Section 6.8.7.2) - BoxParser.createEntityToGroupCtor("favc"); - - // Focus bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.4.1) - BoxParser.createEntityToGroupCtor("fobr"); - - // Audio to image entity group (ISO/IEC 23008-12:2022 Section 6.8.4) - BoxParser.createEntityToGroupCtor("iaug"); - - // Panorama (ISO/IEC 23008-12:2022 Section 6.8.8.1) - BoxParser.createEntityToGroupCtor("pano"); - - // Slideshow (ISO/IEC 23008-12:2022 Section 6.8.9.1) - BoxParser.createEntityToGroupCtor("slid"); - - // Stereo pair (ISO/IEC 23008-12:2022 Section 6.8.5) - BoxParser.createEntityToGroupCtor("ster"); - - // Time-synchronised capture entity group (ISO/IEC 23008-12:2022 Section 6.8.3) - BoxParser.createEntityToGroupCtor("tsyn"); - - // White balance bracketing (ISO/IEC 23008-12:2022 Section 6.8.6.3.1) - BoxParser.createEntityToGroupCtor("wbbr"); - - // Alternative entity (ISO/IEC 23008-12:2022 AMD1 Section 6.8.10) - BoxParser.createEntityToGroupCtor("prgr"); - - // Image Pyramid entity group (ISO/IEC 23008-12:20xx Section 6.8.11) - BoxParser.createEntityToGroupCtor("pymd", function (stream) { - this.group_id = stream.readUint32(); - this.num_entities_in_group = stream.readUint32(); - this.entity_ids = []; - for (var i = 0; i < this.num_entities_in_group; i++) { - var entity_id = stream.readUint32(); - this.entity_ids.push(entity_id); - } - this.tile_size_x = stream.readUint16(); - this.tile_size_y = stream.readUint16(); - this.layer_binning = []; - this.tiles_in_layer_column_minus1 = []; - this.tiles_in_layer_row_minus1 = []; - for (i = 0; i < this.num_entities_in_group; i++) { - this.layer_binning[i] = stream.readUint16(); - this.tiles_in_layer_row_minus1[i] = stream.readUint16(); - this.tiles_in_layer_column_minus1[i] = stream.readUint16(); - } - }); - - // file:src/parsing/esds.js - BoxParser.createFullBoxCtor("esds", function (stream) { - var esd_data = stream.readUint8Array(this.size - this.hdr_size); - if (typeof MPEG4DescriptorParser !== "undefined") { - var esd_parser = new MPEG4DescriptorParser(); - this.esd = esd_parser.parseOneDescriptor(new DataStream(esd_data.buffer, 0, DataStream.BIG_ENDIAN)); - } - }); - - // file:src/parsing/fiel.js - BoxParser.createBoxCtor("fiel", function (stream) { - this.fieldCount = stream.readUint8(); - this.fieldOrdering = stream.readUint8(); - }); - - // file:src/parsing/frma.js - BoxParser.createBoxCtor("frma", function (stream) { - this.data_format = stream.readString(4); - }); - - // file:src/parsing/ftyp.js - BoxParser.createBoxCtor("ftyp", function (stream) { - var toparse = this.size - this.hdr_size; - this.major_brand = stream.readString(4); - this.minor_version = stream.readUint32(); - toparse -= 8; - this.compatible_brands = []; - var i = 0; - while (toparse >= 4) { - this.compatible_brands[i] = stream.readString(4); - toparse -= 4; - i++; - } - }); - - // file:src/parsing/hdlr.js - BoxParser.createFullBoxCtor("hdlr", function (stream) { - if (this.version === 0) { - stream.readUint32(); - this.handler = stream.readString(4); - stream.readUint32Array(3); - this.name = stream.readString(this.size - this.hdr_size - 20); - if (this.name[this.name.length - 1] === '\0') { - this.name = this.name.slice(0, -1); - } - } - }); - - // file:src/parsing/hvcC.js - BoxParser.createBoxCtor("hvcC", function (stream) { - var i, j; - var length; - var tmp_byte; - this.configurationVersion = stream.readUint8(); - tmp_byte = stream.readUint8(); - this.general_profile_space = tmp_byte >> 6; - this.general_tier_flag = (tmp_byte & 0x20) >> 5; - this.general_profile_idc = tmp_byte & 0x1F; - this.general_profile_compatibility = stream.readUint32(); - this.general_constraint_indicator = stream.readUint8Array(6); - this.general_level_idc = stream.readUint8(); - this.min_spatial_segmentation_idc = stream.readUint16() & 0xFFF; - this.parallelismType = stream.readUint8() & 0x3; - this.chroma_format_idc = stream.readUint8() & 0x3; - this.bit_depth_luma_minus8 = stream.readUint8() & 0x7; - this.bit_depth_chroma_minus8 = stream.readUint8() & 0x7; - this.avgFrameRate = stream.readUint16(); - tmp_byte = stream.readUint8(); - this.constantFrameRate = tmp_byte >> 6; - this.numTemporalLayers = (tmp_byte & 0XD) >> 3; - this.temporalIdNested = (tmp_byte & 0X4) >> 2; - this.lengthSizeMinusOne = tmp_byte & 0X3; - this.nalu_arrays = []; - var numOfArrays = stream.readUint8(); - for (i = 0; i < numOfArrays; i++) { - var nalu_array = []; - this.nalu_arrays.push(nalu_array); - tmp_byte = stream.readUint8(); - nalu_array.completeness = (tmp_byte & 0x80) >> 7; - nalu_array.nalu_type = tmp_byte & 0x3F; - var numNalus = stream.readUint16(); - for (j = 0; j < numNalus; j++) { - var nalu = {}; - nalu_array.push(nalu); - length = stream.readUint16(); - nalu.data = stream.readUint8Array(length); - } - } - }); - - // file:src/parsing/iinf.js - BoxParser.createFullBoxCtor("iinf", function (stream) { - var ret; - if (this.version === 0) { - this.entry_count = stream.readUint16(); - } else { - this.entry_count = stream.readUint32(); - } - this.item_infos = []; - for (var i = 0; i < this.entry_count; i++) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - if (ret.box.type !== "infe") { - Log.error("BoxParser", "Expected 'infe' box, got " + ret.box.type); - } - this.item_infos[i] = ret.box; - } else { - return; - } - } - }); - - // file:src/parsing/iloc.js - BoxParser.createFullBoxCtor("iloc", function (stream) { - var byte; - byte = stream.readUint8(); - this.offset_size = byte >> 4 & 0xF; - this.length_size = byte & 0xF; - byte = stream.readUint8(); - this.base_offset_size = byte >> 4 & 0xF; - if (this.version === 1 || this.version === 2) { - this.index_size = byte & 0xF; - } else { - this.index_size = 0; - // reserved = byte & 0xF; - } - this.items = []; - var item_count = 0; - if (this.version < 2) { - item_count = stream.readUint16(); - } else if (this.version === 2) { - item_count = stream.readUint32(); - } else { - throw "version of iloc box not supported"; - } - for (var i = 0; i < item_count; i++) { - var item = {}; - this.items.push(item); - if (this.version < 2) { - item.item_ID = stream.readUint16(); - } else if (this.version === 2) { - item.item_ID = stream.readUint32(); - } else { - throw "version of iloc box not supported"; - } - if (this.version === 1 || this.version === 2) { - item.construction_method = stream.readUint16() & 0xF; - } else { - item.construction_method = 0; - } - item.data_reference_index = stream.readUint16(); - switch (this.base_offset_size) { - case 0: - item.base_offset = 0; - break; - case 4: - item.base_offset = stream.readUint32(); - break; - case 8: - item.base_offset = stream.readUint64(); - break; - default: - throw "Error reading base offset size"; - } - var extent_count = stream.readUint16(); - item.extents = []; - for (var j = 0; j < extent_count; j++) { - var extent = {}; - item.extents.push(extent); - if (this.version === 1 || this.version === 2) { - switch (this.index_size) { - case 0: - extent.extent_index = 0; - break; - case 4: - extent.extent_index = stream.readUint32(); - break; - case 8: - extent.extent_index = stream.readUint64(); - break; - default: - throw "Error reading extent index"; - } - } - switch (this.offset_size) { - case 0: - extent.extent_offset = 0; - break; - case 4: - extent.extent_offset = stream.readUint32(); - break; - case 8: - extent.extent_offset = stream.readUint64(); - break; - default: - throw "Error reading extent index"; - } - switch (this.length_size) { - case 0: - extent.extent_length = 0; - break; - case 4: - extent.extent_length = stream.readUint32(); - break; - case 8: - extent.extent_length = stream.readUint64(); - break; - default: - throw "Error reading extent index"; - } - } - } - }); - - // file:src/parsing/imir.js - BoxParser.createBoxCtor("imir", function (stream) { - var tmp = stream.readUint8(); - this.reserved = tmp >> 7; - this.axis = tmp & 1; - }); // file:src/parsing/infe.js - BoxParser.createFullBoxCtor("infe", function (stream) { - if (this.version === 0 || this.version === 1) { - this.item_ID = stream.readUint16(); - this.item_protection_index = stream.readUint16(); - this.item_name = stream.readCString(); - this.content_type = stream.readCString(); - this.content_encoding = stream.readCString(); - } - if (this.version === 1) { - this.extension_type = stream.readString(4); - Log.warn("BoxParser", "Cannot parse extension type"); - stream.seek(this.start + this.size); - return; - } - if (this.version >= 2) { - if (this.version === 2) { - this.item_ID = stream.readUint16(); - } else if (this.version === 3) { - this.item_ID = stream.readUint32(); - } - this.item_protection_index = stream.readUint16(); - this.item_type = stream.readString(4); - this.item_name = stream.readCString(); - if (this.item_type === "mime") { - this.content_type = stream.readCString(); - this.content_encoding = stream.readCString(); - } else if (this.item_type === "uri ") { - this.item_uri_type = stream.readCString(); - } - } - }); - // file:src/parsing/ipma.js - BoxParser.createFullBoxCtor("ipma", function (stream) { - var i, j; - entry_count = stream.readUint32(); - this.associations = []; - for (i = 0; i < entry_count; i++) { - var item_assoc = {}; - this.associations.push(item_assoc); - if (this.version < 1) { - item_assoc.id = stream.readUint16(); - } else { - item_assoc.id = stream.readUint32(); - } - var association_count = stream.readUint8(); - item_assoc.props = []; - for (j = 0; j < association_count; j++) { - var tmp = stream.readUint8(); - var p = {}; - item_assoc.props.push(p); - p.essential = (tmp & 0x80) >> 7 === 1; - if (this.flags & 0x1) { - p.property_index = (tmp & 0x7F) << 8 | stream.readUint8(); - } else { - p.property_index = tmp & 0x7F; - } - } - } - }); - - // file:src/parsing/iref.js - BoxParser.createFullBoxCtor("iref", function (stream) { - var ret; - var box; - this.references = []; - while (stream.getPosition() < this.start + this.size) { - ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - if (this.version === 0) { - box = new BoxParser.SingleItemTypeReferenceBox(ret.type, ret.size, ret.hdr_size, ret.start); - } else { - box = new BoxParser.SingleItemTypeReferenceBoxLarge(ret.type, ret.size, ret.hdr_size, ret.start); - } - if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { - Log.warn("BoxParser", box.type + " box writing not yet implemented, keeping unparsed data in memory for later write"); - box.parseDataAndRewind(stream); - } - box.parse(stream); - this.references.push(box); - } else { - return; - } - } - }); - // file:src/parsing/irot.js - BoxParser.createBoxCtor("irot", function (stream) { - this.angle = stream.readUint8() & 0x3; - }); - - // file:src/parsing/ispe.js - BoxParser.createFullBoxCtor("ispe", function (stream) { - this.image_width = stream.readUint32(); - this.image_height = stream.readUint32(); - }); // file:src/parsing/kind.js - BoxParser.createFullBoxCtor("kind", function (stream) { - this.schemeURI = stream.readCString(); - this.value = stream.readCString(); - }); - // file:src/parsing/leva.js - BoxParser.createFullBoxCtor("leva", function (stream) { - var count = stream.readUint8(); - this.levels = []; - for (var i = 0; i < count; i++) { - var level = {}; - this.levels[i] = level; - level.track_ID = stream.readUint32(); - var tmp_byte = stream.readUint8(); - level.padding_flag = tmp_byte >> 7; - level.assignment_type = tmp_byte & 0x7F; - switch (level.assignment_type) { - case 0: - level.grouping_type = stream.readString(4); - break; - case 1: - level.grouping_type = stream.readString(4); - level.grouping_type_parameter = stream.readUint32(); - break; - case 2: - break; - case 3: - break; - case 4: - level.sub_track_id = stream.readUint32(); - break; - default: - Log.warn("BoxParser", "Unknown leva assignement type"); - } - } - }); - - // file:src/parsing/lhvC.js - BoxParser.createBoxCtor("lhvC", function (stream) { - var i, j; - var tmp_byte; - this.configurationVersion = stream.readUint8(); - this.min_spatial_segmentation_idc = stream.readUint16() & 0xFFF; - this.parallelismType = stream.readUint8() & 0x3; - tmp_byte = stream.readUint8(); - this.numTemporalLayers = (tmp_byte & 0XD) >> 3; - this.temporalIdNested = (tmp_byte & 0X4) >> 2; - this.lengthSizeMinusOne = tmp_byte & 0X3; - this.nalu_arrays = []; - var numOfArrays = stream.readUint8(); - for (i = 0; i < numOfArrays; i++) { - var nalu_array = []; - this.nalu_arrays.push(nalu_array); - tmp_byte = stream.readUint8(); - nalu_array.completeness = (tmp_byte & 0x80) >> 7; - nalu_array.nalu_type = tmp_byte & 0x3F; - var numNalus = stream.readUint16(); - for (j = 0; j < numNalus; j++) { - var nalu = {}; - nalu_array.push(nalu); - var length = stream.readUint16(); - nalu.data = stream.readUint8Array(length); - } - } - }); - - // file:src/parsing/lsel.js - BoxParser.createBoxCtor("lsel", function (stream) { - this.layer_id = stream.readUint16(); - }); // file:src/parsing/maxr.js - BoxParser.createBoxCtor("maxr", function (stream) { - this.period = stream.readUint32(); - this.bytes = stream.readUint32(); - }); - - // file:src/parsing/mdcv.js - function ColorPoint(x, y) { - this.x = x; - this.y = y; - } - ColorPoint.prototype.toString = function () { - return "(" + this.x + "," + this.y + ")"; - }; - BoxParser.createBoxCtor("mdcv", function (stream) { - this.display_primaries = []; - this.display_primaries[0] = new ColorPoint(stream.readUint16(), stream.readUint16()); - this.display_primaries[1] = new ColorPoint(stream.readUint16(), stream.readUint16()); - this.display_primaries[2] = new ColorPoint(stream.readUint16(), stream.readUint16()); - this.white_point = new ColorPoint(stream.readUint16(), stream.readUint16()); - this.max_display_mastering_luminance = stream.readUint32(); - this.min_display_mastering_luminance = stream.readUint32(); - }); - - // file:src/parsing/mdhd.js - BoxParser.createFullBoxCtor("mdhd", function (stream) { - if (this.version == 1) { - this.creation_time = stream.readUint64(); - this.modification_time = stream.readUint64(); - this.timescale = stream.readUint32(); - this.duration = stream.readUint64(); - } else { - this.creation_time = stream.readUint32(); - this.modification_time = stream.readUint32(); - this.timescale = stream.readUint32(); - this.duration = stream.readUint32(); - } - this.parseLanguage(stream); - stream.readUint16(); - }); - - // file:src/parsing/mehd.js - BoxParser.createFullBoxCtor("mehd", function (stream) { - if (this.flags & 0x1) { - Log.warn("BoxParser", "mehd box incorrectly uses flags set to 1, converting version to 1"); - this.version = 1; - } - if (this.version == 1) { - this.fragment_duration = stream.readUint64(); - } else { - this.fragment_duration = stream.readUint32(); - } - }); - - // file:src/parsing/meta.js - BoxParser.createFullBoxCtor("meta", function (stream) { - this.boxes = []; - BoxParser.ContainerBox.prototype.parse.call(this, stream); - }); - // file:src/parsing/mfhd.js - BoxParser.createFullBoxCtor("mfhd", function (stream) { - this.sequence_number = stream.readUint32(); - }); - - // file:src/parsing/mfro.js - BoxParser.createFullBoxCtor("mfro", function (stream) { - this._size = stream.readUint32(); - }); - - // file:src/parsing/mskC.js - BoxParser.createFullBoxCtor("mskC", function (stream) { - this.bits_per_pixel = stream.readUint8(); - }); - - // file:src/parsing/mvhd.js - BoxParser.createFullBoxCtor("mvhd", function (stream) { - if (this.version == 1) { - this.creation_time = stream.readUint64(); - this.modification_time = stream.readUint64(); - this.timescale = stream.readUint32(); - this.duration = stream.readUint64(); - } else { - this.creation_time = stream.readUint32(); - this.modification_time = stream.readUint32(); - this.timescale = stream.readUint32(); - this.duration = stream.readUint32(); - } - this.rate = stream.readUint32(); - this.volume = stream.readUint16() >> 8; - stream.readUint16(); - stream.readUint32Array(2); - this.matrix = stream.readUint32Array(9); - stream.readUint32Array(6); - this.next_track_id = stream.readUint32(); - }); - // file:src/parsing/npck.js - BoxParser.createBoxCtor("npck", function (stream) { - this.packetssent = stream.readUint32(); - }); - - // file:src/parsing/nump.js - BoxParser.createBoxCtor("nump", function (stream) { - this.packetssent = stream.readUint64(); - }); - - // file:src/parsing/padb.js - BoxParser.createFullBoxCtor("padb", function (stream) { - var sample_count = stream.readUint32(); - this.padbits = []; - for (var i = 0; i < Math.floor((sample_count + 1) / 2); i++) { - this.padbits = stream.readUint8(); - } - }); - - // file:src/parsing/pasp.js - BoxParser.createBoxCtor("pasp", function (stream) { - this.hSpacing = stream.readUint32(); - this.vSpacing = stream.readUint32(); - }); // file:src/parsing/payl.js - BoxParser.createBoxCtor("payl", function (stream) { - this.text = stream.readString(this.size - this.hdr_size); - }); - - // file:src/parsing/payt.js - BoxParser.createBoxCtor("payt", function (stream) { - this.payloadID = stream.readUint32(); - var count = stream.readUint8(); - this.rtpmap_string = stream.readString(count); - }); - - // file:src/parsing/pdin.js - BoxParser.createFullBoxCtor("pdin", function (stream) { - var count = (this.size - this.hdr_size) / 8; - this.rate = []; - this.initial_delay = []; - for (var i = 0; i < count; i++) { - this.rate[i] = stream.readUint32(); - this.initial_delay[i] = stream.readUint32(); - } - }); - - // file:src/parsing/pitm.js - BoxParser.createFullBoxCtor("pitm", function (stream) { - if (this.version === 0) { - this.item_id = stream.readUint16(); - } else { - this.item_id = stream.readUint32(); - } - }); - - // file:src/parsing/pixi.js - BoxParser.createFullBoxCtor("pixi", function (stream) { - var i; - this.num_channels = stream.readUint8(); - this.bits_per_channels = []; - for (i = 0; i < this.num_channels; i++) { - this.bits_per_channels[i] = stream.readUint8(); - } - }); - - // file:src/parsing/pmax.js - BoxParser.createBoxCtor("pmax", function (stream) { - this.bytes = stream.readUint32(); - }); - - // file:src/parsing/prdi.js - BoxParser.createFullBoxCtor("prdi", function (stream) { - this.step_count = stream.readUint16(); - this.item_count = []; - if (this.flags & 0x2) { - for (var i = 0; i < this.step_count; i++) { - this.item_count[i] = stream.readUint16(); - } - } - }); // file:src/parsing/prft.js - BoxParser.createFullBoxCtor("prft", function (stream) { - this.ref_track_id = stream.readUint32(); - this.ntp_timestamp = stream.readUint64(); - if (this.version === 0) { - this.media_time = stream.readUint32(); - } else { - this.media_time = stream.readUint64(); - } - }); - - // file:src/parsing/pssh.js - BoxParser.createFullBoxCtor("pssh", function (stream) { - this.system_id = BoxParser.parseHex16(stream); - if (this.version > 0) { - var count = stream.readUint32(); - this.kid = []; - for (var i = 0; i < count; i++) { - this.kid[i] = BoxParser.parseHex16(stream); - } - } - var datasize = stream.readUint32(); - if (datasize > 0) { - this.data = stream.readUint8Array(datasize); - } - }); - - // file:src/parsing/qt/clef.js - BoxParser.createFullBoxCtor("clef", function (stream) { - this.width = stream.readUint32(); - this.height = stream.readUint32(); - }); // file:src/parsing/qt/enof.js - BoxParser.createFullBoxCtor("enof", function (stream) { - this.width = stream.readUint32(); - this.height = stream.readUint32(); - }); // file:src/parsing/qt/prof.js - BoxParser.createFullBoxCtor("prof", function (stream) { - this.width = stream.readUint32(); - this.height = stream.readUint32(); - }); // file:src/parsing/qt/tapt.js - BoxParser.createContainerBoxCtor("tapt", null, ["clef", "prof", "enof"]); // file:src/parsing/rtp.js - BoxParser.createBoxCtor("rtp ", function (stream) { - this.descriptionformat = stream.readString(4); - this.sdptext = stream.readString(this.size - this.hdr_size - 4); - }); - - // file:src/parsing/saio.js - BoxParser.createFullBoxCtor("saio", function (stream) { - if (this.flags & 0x1) { - this.aux_info_type = stream.readString(4); - this.aux_info_type_parameter = stream.readUint32(); - } - var count = stream.readUint32(); - this.offset = []; - for (var i = 0; i < count; i++) { - if (this.version === 0) { - this.offset[i] = stream.readUint32(); - } else { - this.offset[i] = stream.readUint64(); - } - } - }); - // file:src/parsing/saiz.js - BoxParser.createFullBoxCtor("saiz", function (stream) { - if (this.flags & 0x1) { - this.aux_info_type = stream.readString(4); - this.aux_info_type_parameter = stream.readUint32(); - } - this.default_sample_info_size = stream.readUint8(); - this.sample_count = stream.readUint32(); - this.sample_info_size = []; - if (this.default_sample_info_size === 0) { - for (var i = 0; i < this.sample_count; i++) { - this.sample_info_size[i] = stream.readUint8(); - } - } - }); - - // file:src/parsing/sampleentries/mett.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "mett", function (stream) { - this.parseHeader(stream); - this.content_encoding = stream.readCString(); - this.mime_format = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/metx.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "metx", function (stream) { - this.parseHeader(stream); - this.content_encoding = stream.readCString(); - this.namespace = stream.readCString(); - this.schema_location = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/sbtt.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "sbtt", function (stream) { - this.parseHeader(stream); - this.content_encoding = stream.readCString(); - this.mime_format = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/stpp.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "stpp", function (stream) { - this.parseHeader(stream); - this.namespace = stream.readCString(); - this.schema_location = stream.readCString(); - this.auxiliary_mime_types = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/stxt.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "stxt", function (stream) { - this.parseHeader(stream); - this.content_encoding = stream.readCString(); - this.mime_format = stream.readCString(); - this.parseFooter(stream); - }); - - // file:src/parsing/sampleentries/tx3g.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_SUBTITLE, "tx3g", function (stream) { - this.parseHeader(stream); - this.displayFlags = stream.readUint32(); - this.horizontal_justification = stream.readInt8(); - this.vertical_justification = stream.readInt8(); - this.bg_color_rgba = stream.readUint8Array(4); - this.box_record = stream.readInt16Array(4); - this.style_record = stream.readUint8Array(12); - this.parseFooter(stream); - }); - // file:src/parsing/sampleentries/wvtt.js - BoxParser.createSampleEntryCtor(BoxParser.SAMPLE_ENTRY_TYPE_METADATA, "wvtt", function (stream) { - this.parseHeader(stream); - this.parseFooter(stream); - }); - - // file:src/parsing/samplegroups/alst.js - BoxParser.createSampleGroupCtor("alst", function (stream) { - var i; - var roll_count = stream.readUint16(); - this.first_output_sample = stream.readUint16(); - this.sample_offset = []; - for (i = 0; i < roll_count; i++) { - this.sample_offset[i] = stream.readUint32(); - } - var remaining = this.description_length - 4 - 4 * roll_count; - this.num_output_samples = []; - this.num_total_samples = []; - for (i = 0; i < remaining / 4; i++) { - this.num_output_samples[i] = stream.readUint16(); - this.num_total_samples[i] = stream.readUint16(); - } - }); - - // file:src/parsing/samplegroups/avll.js - BoxParser.createSampleGroupCtor("avll", function (stream) { - this.layerNumber = stream.readUint8(); - this.accurateStatisticsFlag = stream.readUint8(); - this.avgBitRate = stream.readUint16(); - this.avgFrameRate = stream.readUint16(); - }); - - // file:src/parsing/samplegroups/avss.js - BoxParser.createSampleGroupCtor("avss", function (stream) { - this.subSequenceIdentifier = stream.readUint16(); - this.layerNumber = stream.readUint8(); - var tmp_byte = stream.readUint8(); - this.durationFlag = tmp_byte >> 7; - this.avgRateFlag = tmp_byte >> 6 & 0x1; - if (this.durationFlag) { - this.duration = stream.readUint32(); - } - if (this.avgRateFlag) { - this.accurateStatisticsFlag = stream.readUint8(); - this.avgBitRate = stream.readUint16(); - this.avgFrameRate = stream.readUint16(); - } - this.dependency = []; - var numReferences = stream.readUint8(); - for (var i = 0; i < numReferences; i++) { - var dependencyInfo = {}; - this.dependency.push(dependencyInfo); - dependencyInfo.subSeqDirectionFlag = stream.readUint8(); - dependencyInfo.layerNumber = stream.readUint8(); - dependencyInfo.subSequenceIdentifier = stream.readUint16(); - } - }); - - // file:src/parsing/samplegroups/dtrt.js - BoxParser.createSampleGroupCtor("dtrt", function (stream) { - Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); - }); - - // file:src/parsing/samplegroups/mvif.js - BoxParser.createSampleGroupCtor("mvif", function (stream) { - Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); - }); - - // file:src/parsing/samplegroups/prol.js - BoxParser.createSampleGroupCtor("prol", function (stream) { - this.roll_distance = stream.readInt16(); - }); - - // file:src/parsing/samplegroups/rap.js - BoxParser.createSampleGroupCtor("rap ", function (stream) { - var tmp_byte = stream.readUint8(); - this.num_leading_samples_known = tmp_byte >> 7; - this.num_leading_samples = tmp_byte & 0x7F; - }); - - // file:src/parsing/samplegroups/rash.js - BoxParser.createSampleGroupCtor("rash", function (stream) { - this.operation_point_count = stream.readUint16(); - if (this.description_length !== 2 + (this.operation_point_count === 1 ? 2 : this.operation_point_count * 6) + 9) { - Log.warn("BoxParser", "Mismatch in " + this.grouping_type + " sample group length"); - this.data = stream.readUint8Array(this.description_length - 2); - } else { - if (this.operation_point_count === 1) { - this.target_rate_share = stream.readUint16(); - } else { - this.target_rate_share = []; - this.available_bitrate = []; - for (var i = 0; i < this.operation_point_count; i++) { - this.available_bitrate[i] = stream.readUint32(); - this.target_rate_share[i] = stream.readUint16(); - } - } - this.maximum_bitrate = stream.readUint32(); - this.minimum_bitrate = stream.readUint32(); - this.discard_priority = stream.readUint8(); - } - }); - - // file:src/parsing/samplegroups/roll.js - BoxParser.createSampleGroupCtor("roll", function (stream) { - this.roll_distance = stream.readInt16(); - }); - - // file:src/parsing/samplegroups/samplegroup.js - BoxParser.SampleGroupEntry.prototype.parse = function (stream) { - Log.warn("BoxParser", "Unknown Sample Group type: " + this.grouping_type); - this.data = stream.readUint8Array(this.description_length); - }; - - // file:src/parsing/samplegroups/scif.js - BoxParser.createSampleGroupCtor("scif", function (stream) { - Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); - }); - - // file:src/parsing/samplegroups/scnm.js - BoxParser.createSampleGroupCtor("scnm", function (stream) { - Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); - }); - - // file:src/parsing/samplegroups/seig.js - BoxParser.createSampleGroupCtor("seig", function (stream) { - this.reserved = stream.readUint8(); - var tmp = stream.readUint8(); - this.crypt_byte_block = tmp >> 4; - this.skip_byte_block = tmp & 0xF; - this.isProtected = stream.readUint8(); - this.Per_Sample_IV_Size = stream.readUint8(); - this.KID = BoxParser.parseHex16(stream); - this.constant_IV_size = 0; - this.constant_IV = 0; - if (this.isProtected === 1 && this.Per_Sample_IV_Size === 0) { - this.constant_IV_size = stream.readUint8(); - this.constant_IV = stream.readUint8Array(this.constant_IV_size); - } - }); - - // file:src/parsing/samplegroups/stsa.js - BoxParser.createSampleGroupCtor("stsa", function (stream) { - Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); - }); - - // file:src/parsing/samplegroups/sync.js - BoxParser.createSampleGroupCtor("sync", function (stream) { - var tmp_byte = stream.readUint8(); - this.NAL_unit_type = tmp_byte & 0x3F; - }); - - // file:src/parsing/samplegroups/tele.js - BoxParser.createSampleGroupCtor("tele", function (stream) { - var tmp_byte = stream.readUint8(); - this.level_independently_decodable = tmp_byte >> 7; - }); - - // file:src/parsing/samplegroups/tsas.js - BoxParser.createSampleGroupCtor("tsas", function (stream) { - Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); - }); - - // file:src/parsing/samplegroups/tscl.js - BoxParser.createSampleGroupCtor("tscl", function (stream) { - Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); - }); - - // file:src/parsing/samplegroups/vipr.js - BoxParser.createSampleGroupCtor("vipr", function (stream) { - Log.warn("BoxParser", "Sample Group type: " + this.grouping_type + " not fully parsed"); - }); - - // file:src/parsing/sbgp.js - BoxParser.createFullBoxCtor("sbgp", function (stream) { - this.grouping_type = stream.readString(4); - if (this.version === 1) { - this.grouping_type_parameter = stream.readUint32(); - } else { - this.grouping_type_parameter = 0; - } - this.entries = []; - var entry_count = stream.readUint32(); - for (var i = 0; i < entry_count; i++) { - var entry = {}; - this.entries.push(entry); - entry.sample_count = stream.readInt32(); - entry.group_description_index = stream.readInt32(); - } - }); - - // file:src/parsing/sbpm.js - function Pixel(row, col) { - this.bad_pixel_row = row; - this.bad_pixel_column = col; - } - Pixel.prototype.toString = function pixelToString() { - return "[row: " + this.bad_pixel_row + ", column: " + this.bad_pixel_column + "]"; - }; - BoxParser.createFullBoxCtor("sbpm", function (stream) { - var i; - this.component_count = stream.readUint16(); - this.component_index = []; - for (i = 0; i < this.component_count; i++) { - this.component_index.push(stream.readUint16()); - } - var flags = stream.readUint8(); - this.correction_applied = 0x80 == (flags & 0x80); - this.num_bad_rows = stream.readUint32(); - this.num_bad_cols = stream.readUint32(); - this.num_bad_pixels = stream.readUint32(); - this.bad_rows = []; - this.bad_columns = []; - this.bad_pixels = []; - for (i = 0; i < this.num_bad_rows; i++) { - this.bad_rows.push(stream.readUint32()); - } - for (i = 0; i < this.num_bad_cols; i++) { - this.bad_columns.push(stream.readUint32()); - } - for (i = 0; i < this.num_bad_pixels; i++) { - var row = stream.readUint32(); - var col = stream.readUint32(); - this.bad_pixels.push(new Pixel(row, col)); - } - }); - - // file:src/parsing/schm.js - BoxParser.createFullBoxCtor("schm", function (stream) { - this.scheme_type = stream.readString(4); - this.scheme_version = stream.readUint32(); - if (this.flags & 0x000001) { - this.scheme_uri = stream.readString(this.size - this.hdr_size - 8); - } - }); - - // file:src/parsing/sdp.js - BoxParser.createBoxCtor("sdp ", function (stream) { - this.sdptext = stream.readString(this.size - this.hdr_size); - }); - - // file:src/parsing/sdtp.js - BoxParser.createFullBoxCtor("sdtp", function (stream) { - var tmp_byte; - var count = this.size - this.hdr_size; - this.is_leading = []; - this.sample_depends_on = []; - this.sample_is_depended_on = []; - this.sample_has_redundancy = []; - for (var i = 0; i < count; i++) { - tmp_byte = stream.readUint8(); - this.is_leading[i] = tmp_byte >> 6; - this.sample_depends_on[i] = tmp_byte >> 4 & 0x3; - this.sample_is_depended_on[i] = tmp_byte >> 2 & 0x3; - this.sample_has_redundancy[i] = tmp_byte & 0x3; - } - }); - - // file:src/parsing/senc.js - // Cannot be fully parsed because Per_Sample_IV_Size needs to be known - BoxParser.createFullBoxCtor("senc" /*, function(stream) { - this.parseFullHeader(stream); - var sample_count = stream.readUint32(); - this.samples = []; - for (var i = 0; i < sample_count; i++) { - var sample = {}; - // tenc.default_Per_Sample_IV_Size or seig.Per_Sample_IV_Size - sample.InitializationVector = this.readUint8Array(Per_Sample_IV_Size*8); - if (this.flags & 0x2) { - sample.subsamples = []; - subsample_count = stream.readUint16(); - for (var j = 0; j < subsample_count; j++) { - var subsample = {}; - subsample.BytesOfClearData = stream.readUint16(); - subsample.BytesOfProtectedData = stream.readUint32(); - sample.subsamples.push(subsample); - } - } - // TODO - this.samples.push(sample); - } - }*/); - // file:src/parsing/sgpd.js - BoxParser.createFullBoxCtor("sgpd", function (stream) { - this.grouping_type = stream.readString(4); - Log.debug("BoxParser", "Found Sample Groups of type " + this.grouping_type); - if (this.version === 1) { - this.default_length = stream.readUint32(); - } else { - this.default_length = 0; - } - if (this.version >= 2) { - this.default_group_description_index = stream.readUint32(); - } - this.entries = []; - var entry_count = stream.readUint32(); - for (var i = 0; i < entry_count; i++) { - var entry; - if (BoxParser[this.grouping_type + "SampleGroupEntry"]) { - entry = new BoxParser[this.grouping_type + "SampleGroupEntry"](this.grouping_type); - } else { - entry = new BoxParser.SampleGroupEntry(this.grouping_type); - } - this.entries.push(entry); - if (this.version === 1) { - if (this.default_length === 0) { - entry.description_length = stream.readUint32(); - } else { - entry.description_length = this.default_length; - } - } else { - entry.description_length = this.default_length; - } - if (entry.write === BoxParser.SampleGroupEntry.prototype.write) { - Log.info("BoxParser", "SampleGroup for type " + this.grouping_type + " writing not yet implemented, keeping unparsed data in memory for later write"); - // storing data - entry.data = stream.readUint8Array(entry.description_length); - // rewinding - stream.position -= entry.description_length; - } - entry.parse(stream); - } - }); - - // file:src/parsing/sidx.js - BoxParser.createFullBoxCtor("sidx", function (stream) { - this.reference_ID = stream.readUint32(); - this.timescale = stream.readUint32(); - if (this.version === 0) { - this.earliest_presentation_time = stream.readUint32(); - this.first_offset = stream.readUint32(); - } else { - this.earliest_presentation_time = stream.readUint64(); - this.first_offset = stream.readUint64(); - } - stream.readUint16(); - this.references = []; - var count = stream.readUint16(); - for (var i = 0; i < count; i++) { - var ref = {}; - this.references.push(ref); - var tmp_32 = stream.readUint32(); - ref.reference_type = tmp_32 >> 31 & 0x1; - ref.referenced_size = tmp_32 & 0x7FFFFFFF; - ref.subsegment_duration = stream.readUint32(); - tmp_32 = stream.readUint32(); - ref.starts_with_SAP = tmp_32 >> 31 & 0x1; - ref.SAP_type = tmp_32 >> 28 & 0x7; - ref.SAP_delta_time = tmp_32 & 0xFFFFFFF; - } - }); - - // file:src/parsing/singleitemtypereference.js - BoxParser.SingleItemTypeReferenceBox = function (type, size, hdr_size, start) { - BoxParser.Box.call(this, type, size); - this.hdr_size = hdr_size; - this.start = start; - }; - BoxParser.SingleItemTypeReferenceBox.prototype = new BoxParser.Box(); - BoxParser.SingleItemTypeReferenceBox.prototype.parse = function (stream) { - this.from_item_ID = stream.readUint16(); - var count = stream.readUint16(); - this.references = []; - for (var i = 0; i < count; i++) { - this.references[i] = {}; - this.references[i].to_item_ID = stream.readUint16(); - } - }; - - // file:src/parsing/singleitemtypereferencelarge.js - BoxParser.SingleItemTypeReferenceBoxLarge = function (type, size, hdr_size, start) { - BoxParser.Box.call(this, type, size); - this.hdr_size = hdr_size; - this.start = start; - }; - BoxParser.SingleItemTypeReferenceBoxLarge.prototype = new BoxParser.Box(); - BoxParser.SingleItemTypeReferenceBoxLarge.prototype.parse = function (stream) { - this.from_item_ID = stream.readUint32(); - var count = stream.readUint16(); - this.references = []; - for (var i = 0; i < count; i++) { - this.references[i] = {}; - this.references[i].to_item_ID = stream.readUint32(); - } - }; - - // file:src/parsing/SmDm.js - BoxParser.createFullBoxCtor("SmDm", function (stream) { - this.primaryRChromaticity_x = stream.readUint16(); - this.primaryRChromaticity_y = stream.readUint16(); - this.primaryGChromaticity_x = stream.readUint16(); - this.primaryGChromaticity_y = stream.readUint16(); - this.primaryBChromaticity_x = stream.readUint16(); - this.primaryBChromaticity_y = stream.readUint16(); - this.whitePointChromaticity_x = stream.readUint16(); - this.whitePointChromaticity_y = stream.readUint16(); - this.luminanceMax = stream.readUint32(); - this.luminanceMin = stream.readUint32(); - }); - - // file:src/parsing/smhd.js - BoxParser.createFullBoxCtor("smhd", function (stream) { - this.balance = stream.readUint16(); - stream.readUint16(); - }); - - // file:src/parsing/ssix.js - BoxParser.createFullBoxCtor("ssix", function (stream) { - this.subsegments = []; - var subsegment_count = stream.readUint32(); - for (var i = 0; i < subsegment_count; i++) { - var subsegment = {}; - this.subsegments.push(subsegment); - subsegment.ranges = []; - var range_count = stream.readUint32(); - for (var j = 0; j < range_count; j++) { - var range = {}; - subsegment.ranges.push(range); - range.level = stream.readUint8(); - range.range_size = stream.readUint24(); - } - } - }); - - // file:src/parsing/stco.js - BoxParser.createFullBoxCtor("stco", function (stream) { - var entry_count; - entry_count = stream.readUint32(); - this.chunk_offsets = []; - if (this.version === 0) { - for (var i = 0; i < entry_count; i++) { - this.chunk_offsets.push(stream.readUint32()); - } - } - }); - - // file:src/parsing/stdp.js - BoxParser.createFullBoxCtor("stdp", function (stream) { - var count = (this.size - this.hdr_size) / 2; - this.priority = []; - for (var i = 0; i < count; i++) { - this.priority[i] = stream.readUint16(); - } - }); - - // file:src/parsing/sthd.js - BoxParser.createFullBoxCtor("sthd"); - - // file:src/parsing/stri.js - BoxParser.createFullBoxCtor("stri", function (stream) { - this.switch_group = stream.readUint16(); - this.alternate_group = stream.readUint16(); - this.sub_track_id = stream.readUint32(); - var count = (this.size - this.hdr_size - 8) / 4; - this.attribute_list = []; - for (var i = 0; i < count; i++) { - this.attribute_list[i] = stream.readUint32(); - } - }); - - // file:src/parsing/stsc.js - BoxParser.createFullBoxCtor("stsc", function (stream) { - var entry_count; - var i; - entry_count = stream.readUint32(); - this.first_chunk = []; - this.samples_per_chunk = []; - this.sample_description_index = []; - if (this.version === 0) { - for (i = 0; i < entry_count; i++) { - this.first_chunk.push(stream.readUint32()); - this.samples_per_chunk.push(stream.readUint32()); - this.sample_description_index.push(stream.readUint32()); - } - } - }); - - // file:src/parsing/stsd.js - BoxParser.createFullBoxCtor("stsd", function (stream) { - var i; - var ret; - var entryCount; - var box; - this.entries = []; - entryCount = stream.readUint32(); - for (i = 1; i <= entryCount; i++) { - ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - if (BoxParser[ret.type + "SampleEntry"]) { - box = new BoxParser[ret.type + "SampleEntry"](ret.size); - box.hdr_size = ret.hdr_size; - box.start = ret.start; - } else { - Log.warn("BoxParser", "Unknown sample entry type: " + ret.type); - box = new BoxParser.SampleEntry(ret.type, ret.size, ret.hdr_size, ret.start); - } - if (box.write === BoxParser.SampleEntry.prototype.write) { - Log.info("BoxParser", "SampleEntry " + box.type + " box writing not yet implemented, keeping unparsed data in memory for later write"); - box.parseDataAndRewind(stream); - } - box.parse(stream); - this.entries.push(box); - } else { - return; - } - } - }); - - // file:src/parsing/stsg.js - BoxParser.createFullBoxCtor("stsg", function (stream) { - this.grouping_type = stream.readUint32(); - var count = stream.readUint16(); - this.group_description_index = []; - for (var i = 0; i < count; i++) { - this.group_description_index[i] = stream.readUint32(); - } - }); - - // file:src/parsing/stsh.js - BoxParser.createFullBoxCtor("stsh", function (stream) { - var entry_count; - var i; - entry_count = stream.readUint32(); - this.shadowed_sample_numbers = []; - this.sync_sample_numbers = []; - if (this.version === 0) { - for (i = 0; i < entry_count; i++) { - this.shadowed_sample_numbers.push(stream.readUint32()); - this.sync_sample_numbers.push(stream.readUint32()); - } - } - }); - - // file:src/parsing/stss.js - BoxParser.createFullBoxCtor("stss", function (stream) { - var i; - var entry_count; - entry_count = stream.readUint32(); - if (this.version === 0) { - this.sample_numbers = []; - for (i = 0; i < entry_count; i++) { - this.sample_numbers.push(stream.readUint32()); - } - } - }); - - // file:src/parsing/stsz.js - BoxParser.createFullBoxCtor("stsz", function (stream) { - var i; - this.sample_sizes = []; - if (this.version === 0) { - this.sample_size = stream.readUint32(); - this.sample_count = stream.readUint32(); - for (i = 0; i < this.sample_count; i++) { - if (this.sample_size === 0) { - this.sample_sizes.push(stream.readUint32()); - } else { - this.sample_sizes[i] = this.sample_size; - } - } - } - }); - - // file:src/parsing/stts.js - BoxParser.createFullBoxCtor("stts", function (stream) { - var entry_count; - var i; - var delta; - entry_count = stream.readUint32(); - this.sample_counts = []; - this.sample_deltas = []; - if (this.version === 0) { - for (i = 0; i < entry_count; i++) { - this.sample_counts.push(stream.readUint32()); - delta = stream.readInt32(); - if (delta < 0) { - Log.warn("BoxParser", "File uses negative stts sample delta, using value 1 instead, sync may be lost!"); - delta = 1; - } - this.sample_deltas.push(delta); - } - } - }); - - // file:src/parsing/stvi.js - BoxParser.createFullBoxCtor("stvi", function (stream) { - var tmp32 = stream.readUint32(); - this.single_view_allowed = tmp32 & 0x3; - this.stereo_scheme = stream.readUint32(); - var length = stream.readUint32(); - this.stereo_indication_type = stream.readString(length); - var ret; - var box; - this.boxes = []; - while (stream.getPosition() < this.start + this.size) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = ret.box; - this.boxes.push(box); - this[box.type] = box; - } else { - return; - } - } - }); - - // file:src/parsing/styp.js - BoxParser.createBoxCtor("styp", function (stream) { - BoxParser.ftypBox.prototype.parse.call(this, stream); - }); - - // file:src/parsing/stz2.js - BoxParser.createFullBoxCtor("stz2", function (stream) { - var i; - var sample_count; - this.sample_sizes = []; - if (this.version === 0) { - this.reserved = stream.readUint24(); - this.field_size = stream.readUint8(); - sample_count = stream.readUint32(); - if (this.field_size === 4) { - for (i = 0; i < sample_count; i += 2) { - var tmp = stream.readUint8(); - this.sample_sizes[i] = tmp >> 4 & 0xF; - this.sample_sizes[i + 1] = tmp & 0xF; - } - } else if (this.field_size === 8) { - for (i = 0; i < sample_count; i++) { - this.sample_sizes[i] = stream.readUint8(); - } - } else if (this.field_size === 16) { - for (i = 0; i < sample_count; i++) { - this.sample_sizes[i] = stream.readUint16(); - } - } else { - Log.error("BoxParser", "Error in length field in stz2 box"); - } - } - }); - - // file:src/parsing/subs.js - BoxParser.createFullBoxCtor("subs", function (stream) { - var i, j; - var entry_count; - var subsample_count; - entry_count = stream.readUint32(); - this.entries = []; - for (i = 0; i < entry_count; i++) { - var sampleInfo = {}; - this.entries[i] = sampleInfo; - sampleInfo.sample_delta = stream.readUint32(); - sampleInfo.subsamples = []; - subsample_count = stream.readUint16(); - if (subsample_count > 0) { - for (j = 0; j < subsample_count; j++) { - var subsample = {}; - sampleInfo.subsamples.push(subsample); - if (this.version == 1) { - subsample.size = stream.readUint32(); - } else { - subsample.size = stream.readUint16(); - } - subsample.priority = stream.readUint8(); - subsample.discardable = stream.readUint8(); - subsample.codec_specific_parameters = stream.readUint32(); - } - } - } - }); - - // file:src/parsing/tenc.js - BoxParser.createFullBoxCtor("tenc", function (stream) { - stream.readUint8(); // reserved - if (this.version === 0) { - stream.readUint8(); - } else { - var tmp = stream.readUint8(); - this.default_crypt_byte_block = tmp >> 4 & 0xF; - this.default_skip_byte_block = tmp & 0xF; - } - this.default_isProtected = stream.readUint8(); - this.default_Per_Sample_IV_Size = stream.readUint8(); - this.default_KID = BoxParser.parseHex16(stream); - if (this.default_isProtected === 1 && this.default_Per_Sample_IV_Size === 0) { - this.default_constant_IV_size = stream.readUint8(); - this.default_constant_IV = stream.readUint8Array(this.default_constant_IV_size); - } - }); // file:src/parsing/tfdt.js - BoxParser.createFullBoxCtor("tfdt", function (stream) { - if (this.version == 1) { - this.baseMediaDecodeTime = stream.readUint64(); - } else { - this.baseMediaDecodeTime = stream.readUint32(); - } - }); - - // file:src/parsing/tfhd.js - BoxParser.createFullBoxCtor("tfhd", function (stream) { - var readBytes = 0; - this.track_id = stream.readUint32(); - if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { - this.base_data_offset = stream.readUint64(); - readBytes += 8; - } else { - this.base_data_offset = 0; - } - if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { - this.default_sample_description_index = stream.readUint32(); - readBytes += 4; - } else { - this.default_sample_description_index = 0; - } - if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { - this.default_sample_duration = stream.readUint32(); - readBytes += 4; - } else { - this.default_sample_duration = 0; - } - if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { - this.default_sample_size = stream.readUint32(); - readBytes += 4; - } else { - this.default_sample_size = 0; - } - if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { - this.default_sample_flags = stream.readUint32(); - readBytes += 4; - } else { - this.default_sample_flags = 0; - } - }); - - // file:src/parsing/tfra.js - BoxParser.createFullBoxCtor("tfra", function (stream) { - this.track_ID = stream.readUint32(); - stream.readUint24(); - var tmp_byte = stream.readUint8(); - this.length_size_of_traf_num = tmp_byte >> 4 & 0x3; - this.length_size_of_trun_num = tmp_byte >> 2 & 0x3; - this.length_size_of_sample_num = tmp_byte & 0x3; - this.entries = []; - var number_of_entries = stream.readUint32(); - for (var i = 0; i < number_of_entries; i++) { - if (this.version === 1) { - this.time = stream.readUint64(); - this.moof_offset = stream.readUint64(); - } else { - this.time = stream.readUint32(); - this.moof_offset = stream.readUint32(); - } - this.traf_number = stream["readUint" + 8 * (this.length_size_of_traf_num + 1)](); - this.trun_number = stream["readUint" + 8 * (this.length_size_of_trun_num + 1)](); - this.sample_number = stream["readUint" + 8 * (this.length_size_of_sample_num + 1)](); - } - }); - - // file:src/parsing/tkhd.js - BoxParser.createFullBoxCtor("tkhd", function (stream) { - if (this.version == 1) { - this.creation_time = stream.readUint64(); - this.modification_time = stream.readUint64(); - this.track_id = stream.readUint32(); - stream.readUint32(); - this.duration = stream.readUint64(); - } else { - this.creation_time = stream.readUint32(); - this.modification_time = stream.readUint32(); - this.track_id = stream.readUint32(); - stream.readUint32(); - this.duration = stream.readUint32(); - } - stream.readUint32Array(2); - this.layer = stream.readInt16(); - this.alternate_group = stream.readInt16(); - this.volume = stream.readInt16() >> 8; - stream.readUint16(); - this.matrix = stream.readInt32Array(9); - this.width = stream.readUint32(); - this.height = stream.readUint32(); - }); - - // file:src/parsing/tmax.js - BoxParser.createBoxCtor("tmax", function (stream) { - this.time = stream.readUint32(); - }); - - // file:src/parsing/tmin.js - BoxParser.createBoxCtor("tmin", function (stream) { - this.time = stream.readUint32(); - }); - - // file:src/parsing/totl.js - BoxParser.createBoxCtor("totl", function (stream) { - this.bytessent = stream.readUint32(); - }); - - // file:src/parsing/tpay.js - BoxParser.createBoxCtor("tpay", function (stream) { - this.bytessent = stream.readUint32(); - }); - - // file:src/parsing/tpyl.js - BoxParser.createBoxCtor("tpyl", function (stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/TrackGroup.js - BoxParser.TrackGroupTypeBox.prototype.parse = function (stream) { - this.parseFullHeader(stream); - this.track_group_id = stream.readUint32(); - }; - - // file:src/parsing/trackgroups/msrc.js - BoxParser.createTrackGroupCtor("msrc"); // file:src/parsing/TrakReference.js - BoxParser.TrackReferenceTypeBox = function (type, size, hdr_size, start) { - BoxParser.Box.call(this, type, size); - this.hdr_size = hdr_size; - this.start = start; - }; - BoxParser.TrackReferenceTypeBox.prototype = new BoxParser.Box(); - BoxParser.TrackReferenceTypeBox.prototype.parse = function (stream) { - this.track_ids = stream.readUint32Array((this.size - this.hdr_size) / 4); - }; - - // file:src/parsing/tref.js - BoxParser.trefBox.prototype.parse = function (stream) { - var ret; - var box; - while (stream.getPosition() < this.start + this.size) { - ret = BoxParser.parseOneBox(stream, true, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = new BoxParser.TrackReferenceTypeBox(ret.type, ret.size, ret.hdr_size, ret.start); - if (box.write === BoxParser.Box.prototype.write && box.type !== "mdat") { - Log.info("BoxParser", "TrackReference " + box.type + " box writing not yet implemented, keeping unparsed data in memory for later write"); - box.parseDataAndRewind(stream); - } - box.parse(stream); - this.boxes.push(box); - } else { - return; - } - } - }; - - // file:src/parsing/trep.js - BoxParser.createFullBoxCtor("trep", function (stream) { - this.track_ID = stream.readUint32(); - this.boxes = []; - while (stream.getPosition() < this.start + this.size) { - ret = BoxParser.parseOneBox(stream, false, this.size - (stream.getPosition() - this.start)); - if (ret.code === BoxParser.OK) { - box = ret.box; - this.boxes.push(box); - } else { - return; - } - } - }); - - // file:src/parsing/trex.js - BoxParser.createFullBoxCtor("trex", function (stream) { - this.track_id = stream.readUint32(); - this.default_sample_description_index = stream.readUint32(); - this.default_sample_duration = stream.readUint32(); - this.default_sample_size = stream.readUint32(); - this.default_sample_flags = stream.readUint32(); - }); - - // file:src/parsing/trpy.js - BoxParser.createBoxCtor("trpy", function (stream) { - this.bytessent = stream.readUint64(); - }); - - // file:src/parsing/trun.js - BoxParser.createFullBoxCtor("trun", function (stream) { - var readBytes = 0; - this.sample_count = stream.readUint32(); - readBytes += 4; - if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { - this.data_offset = stream.readInt32(); //signed - readBytes += 4; - } else { - this.data_offset = 0; - } - if (this.size - this.hdr_size > readBytes && this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { - this.first_sample_flags = stream.readUint32(); - readBytes += 4; - } else { - this.first_sample_flags = 0; - } - this.sample_duration = []; - this.sample_size = []; - this.sample_flags = []; - this.sample_composition_time_offset = []; - if (this.size - this.hdr_size > readBytes) { - for (var i = 0; i < this.sample_count; i++) { - if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { - this.sample_duration[i] = stream.readUint32(); - } - if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { - this.sample_size[i] = stream.readUint32(); - } - if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { - this.sample_flags[i] = stream.readUint32(); - } - if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { - if (this.version === 0) { - this.sample_composition_time_offset[i] = stream.readUint32(); - } else { - this.sample_composition_time_offset[i] = stream.readInt32(); //signed - } - } - } - } - }); - - // file:src/parsing/tsel.js - BoxParser.createFullBoxCtor("tsel", function (stream) { - this.switch_group = stream.readUint32(); - var count = (this.size - this.hdr_size - 4) / 4; - this.attribute_list = []; - for (var i = 0; i < count; i++) { - this.attribute_list[i] = stream.readUint32(); - } - }); - - // file:src/parsing/txtC.js - BoxParser.createFullBoxCtor("txtC", function (stream) { - this.config = stream.readCString(); - }); - - // file:src/parsing/tyco.js - BoxParser.createBoxCtor("tyco", function (stream) { - var count = (this.size - this.hdr_size) / 4; - this.compatible_brands = []; - for (var i = 0; i < count; i++) { - this.compatible_brands[i] = stream.readString(4); - } - }); - - // file:src/parsing/udes.js - BoxParser.createFullBoxCtor("udes", function (stream) { - this.lang = stream.readCString(); - this.name = stream.readCString(); - this.description = stream.readCString(); - this.tags = stream.readCString(); - }); - - // file:src/parsing/uncC.js - BoxParser.createFullBoxCtor("uncC", function (stream) { - var i; - this.profile = stream.readUint32(); - if (this.version == 1) ; else if (this.version == 0) { - this.component_count = stream.readUint32(); - this.component_index = []; - this.component_bit_depth_minus_one = []; - this.component_format = []; - this.component_align_size = []; - for (i = 0; i < this.component_count; i++) { - this.component_index.push(stream.readUint16()); - this.component_bit_depth_minus_one.push(stream.readUint8()); - this.component_format.push(stream.readUint8()); - this.component_align_size.push(stream.readUint8()); - } - this.sampling_type = stream.readUint8(); - this.interleave_type = stream.readUint8(); - this.block_size = stream.readUint8(); - var flags = stream.readUint8(); - this.component_little_endian = flags >> 7 & 0x1; - this.block_pad_lsb = flags >> 6 & 0x1; - this.block_little_endian = flags >> 5 & 0x1; - this.block_reversed = flags >> 4 & 0x1; - this.pad_unknown = flags >> 3 & 0x1; - this.pixel_size = stream.readUint32(); - this.row_align_size = stream.readUint32(); - this.tile_align_size = stream.readUint32(); - this.num_tile_cols_minus_one = stream.readUint32(); - this.num_tile_rows_minus_one = stream.readUint32(); - } - }); - - // file:src/parsing/url.js - BoxParser.createFullBoxCtor("url ", function (stream) { - if (this.flags !== 0x000001) { - this.location = stream.readCString(); - } - }); - - // file:src/parsing/urn.js - BoxParser.createFullBoxCtor("urn ", function (stream) { - this.name = stream.readCString(); - if (this.size - this.hdr_size - this.name.length - 1 > 0) { - this.location = stream.readCString(); - } - }); - - // file:src/parsing/uuid/piff/piffLsm.js - BoxParser.createUUIDBox("a5d40b30e81411ddba2f0800200c9a66", true, false, function (stream) { - this.LiveServerManifest = stream.readString(this.size - this.hdr_size).replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'"); - }); // file:src/parsing/uuid/piff/piffPssh.js - BoxParser.createUUIDBox("d08a4f1810f34a82b6c832d8aba183d3", true, false, function (stream) { - this.system_id = BoxParser.parseHex16(stream); - var datasize = stream.readUint32(); - if (datasize > 0) { - this.data = stream.readUint8Array(datasize); - } - }); - - // file:src/parsing/uuid/piff/piffSenc.js - BoxParser.createUUIDBox("a2394f525a9b4f14a2446c427c648df4", true, false /*, function(stream) { - if (this.flags & 0x1) { - this.AlgorithmID = stream.readUint24(); - this.IV_size = stream.readUint8(); - this.KID = BoxParser.parseHex16(stream); - } - var sample_count = stream.readUint32(); - this.samples = []; - for (var i = 0; i < sample_count; i++) { - var sample = {}; - sample.InitializationVector = this.readUint8Array(this.IV_size*8); - if (this.flags & 0x2) { - sample.subsamples = []; - sample.NumberOfEntries = stream.readUint16(); - for (var j = 0; j < sample.NumberOfEntries; j++) { - var subsample = {}; - subsample.BytesOfClearData = stream.readUint16(); - subsample.BytesOfProtectedData = stream.readUint32(); - sample.subsamples.push(subsample); - } - } - this.samples.push(sample); - } - }*/); - // file:src/parsing/uuid/piff/piffTenc.js - BoxParser.createUUIDBox("8974dbce7be74c5184f97148f9882554", true, false, function (stream) { - this.default_AlgorithmID = stream.readUint24(); - this.default_IV_size = stream.readUint8(); - this.default_KID = BoxParser.parseHex16(stream); - }); // file:src/parsing/uuid/piff/piffTfrf.js - BoxParser.createUUIDBox("d4807ef2ca3946958e5426cb9e46a79f", true, false, function (stream) { - this.fragment_count = stream.readUint8(); - this.entries = []; - for (var i = 0; i < this.fragment_count; i++) { - var entry = {}; - var absolute_time = 0; - var absolute_duration = 0; - if (this.version === 1) { - absolute_time = stream.readUint64(); - absolute_duration = stream.readUint64(); - } else { - absolute_time = stream.readUint32(); - absolute_duration = stream.readUint32(); - } - entry.absolute_time = absolute_time; - entry.absolute_duration = absolute_duration; - this.entries.push(entry); - } - }); // file:src/parsing/uuid/piff/piffTfxd.js - BoxParser.createUUIDBox("6d1d9b0542d544e680e2141daff757b2", true, false, function (stream) { - if (this.version === 1) { - this.absolute_time = stream.readUint64(); - this.duration = stream.readUint64(); - } else { - this.absolute_time = stream.readUint32(); - this.duration = stream.readUint32(); - } - }); // file:src/parsing/vmhd.js - BoxParser.createFullBoxCtor("vmhd", function (stream) { - this.graphicsmode = stream.readUint16(); - this.opcolor = stream.readUint16Array(3); - }); - - // file:src/parsing/vpcC.js - BoxParser.createFullBoxCtor("vpcC", function (stream) { - var tmp; - if (this.version === 1) { - this.profile = stream.readUint8(); - this.level = stream.readUint8(); - tmp = stream.readUint8(); - this.bitDepth = tmp >> 4; - this.chromaSubsampling = tmp >> 1 & 0x7; - this.videoFullRangeFlag = tmp & 0x1; - this.colourPrimaries = stream.readUint8(); - this.transferCharacteristics = stream.readUint8(); - this.matrixCoefficients = stream.readUint8(); - this.codecIntializationDataSize = stream.readUint16(); - this.codecIntializationData = stream.readUint8Array(this.codecIntializationDataSize); - } else { - this.profile = stream.readUint8(); - this.level = stream.readUint8(); - tmp = stream.readUint8(); - this.bitDepth = tmp >> 4 & 0xF; - this.colorSpace = tmp & 0xF; - tmp = stream.readUint8(); - this.chromaSubsampling = tmp >> 4 & 0xF; - this.transferFunction = tmp >> 1 & 0x7; - this.videoFullRangeFlag = tmp & 0x1; - this.codecIntializationDataSize = stream.readUint16(); - this.codecIntializationData = stream.readUint8Array(this.codecIntializationDataSize); - } - }); // file:src/parsing/vttC.js - BoxParser.createBoxCtor("vttC", function (stream) { - this.text = stream.readString(this.size - this.hdr_size); - }); - - // file:src/parsing/vvcC.js - BoxParser.createFullBoxCtor("vvcC", function (stream) { - var i, j; - - // helper object to simplify extracting individual bits - var bitReader = { - held_bits: undefined, - num_held_bits: 0, - stream_read_1_bytes: function (strm) { - this.held_bits = strm.readUint8(); - this.num_held_bits = 1 * 8; - }, - stream_read_2_bytes: function (strm) { - this.held_bits = strm.readUint16(); - this.num_held_bits = 2 * 8; - }, - extract_bits: function (num_bits) { - var ret = this.held_bits >> this.num_held_bits - num_bits & (1 << num_bits) - 1; - this.num_held_bits -= num_bits; - return ret; - } - }; - - // VvcDecoderConfigurationRecord - bitReader.stream_read_1_bytes(stream); - bitReader.extract_bits(5); // reserved - this.lengthSizeMinusOne = bitReader.extract_bits(2); - this.ptl_present_flag = bitReader.extract_bits(1); - if (this.ptl_present_flag) { - bitReader.stream_read_2_bytes(stream); - this.ols_idx = bitReader.extract_bits(9); - this.num_sublayers = bitReader.extract_bits(3); - this.constant_frame_rate = bitReader.extract_bits(2); - this.chroma_format_idc = bitReader.extract_bits(2); - bitReader.stream_read_1_bytes(stream); - this.bit_depth_minus8 = bitReader.extract_bits(3); - bitReader.extract_bits(5); // reserved - - // VvcPTLRecord - { - bitReader.stream_read_2_bytes(stream); - bitReader.extract_bits(2); // reserved - this.num_bytes_constraint_info = bitReader.extract_bits(6); - this.general_profile_idc = bitReader.extract_bits(7); - this.general_tier_flag = bitReader.extract_bits(1); - this.general_level_idc = stream.readUint8(); - bitReader.stream_read_1_bytes(stream); - this.ptl_frame_only_constraint_flag = bitReader.extract_bits(1); - this.ptl_multilayer_enabled_flag = bitReader.extract_bits(1); - this.general_constraint_info = new Uint8Array(this.num_bytes_constraint_info); - if (this.num_bytes_constraint_info) { - for (i = 0; i < this.num_bytes_constraint_info - 1; i++) { - var cnstr1 = bitReader.extract_bits(6); - bitReader.stream_read_1_bytes(stream); - var cnstr2 = bitReader.extract_bits(2); - this.general_constraint_info[i] = cnstr1 << 2 | cnstr2; - } - this.general_constraint_info[this.num_bytes_constraint_info - 1] = bitReader.extract_bits(6); - } else { - //forbidden in spec! - bitReader.extract_bits(6); - } - if (this.num_sublayers > 1) { - bitReader.stream_read_1_bytes(stream); - this.ptl_sublayer_present_mask = 0; - for (j = this.num_sublayers - 2; j >= 0; --j) { - var val = bitReader.extract_bits(1); - this.ptl_sublayer_present_mask |= val << j; - } - for (j = this.num_sublayers; j <= 8 && this.num_sublayers > 1; ++j) { - bitReader.extract_bits(1); // ptl_reserved_zero_bit - } - this.sublayer_level_idc = []; - for (j = this.num_sublayers - 2; j >= 0; --j) { - if (this.ptl_sublayer_present_mask & 1 << j) { - this.sublayer_level_idc[j] = stream.readUint8(); - } - } - } - this.ptl_num_sub_profiles = stream.readUint8(); - this.general_sub_profile_idc = []; - if (this.ptl_num_sub_profiles) { - for (i = 0; i < this.ptl_num_sub_profiles; i++) { - this.general_sub_profile_idc.push(stream.readUint32()); - } - } - } // end VvcPTLRecord - - this.max_picture_width = stream.readUint16(); - this.max_picture_height = stream.readUint16(); - this.avg_frame_rate = stream.readUint16(); - } - var VVC_NALU_OPI = 12; - var VVC_NALU_DEC_PARAM = 13; - this.nalu_arrays = []; - var num_of_arrays = stream.readUint8(); - for (i = 0; i < num_of_arrays; i++) { - var nalu_array = []; - this.nalu_arrays.push(nalu_array); - bitReader.stream_read_1_bytes(stream); - nalu_array.completeness = bitReader.extract_bits(1); - bitReader.extract_bits(2); // reserved - nalu_array.nalu_type = bitReader.extract_bits(5); - var numNalus = 1; - if (nalu_array.nalu_type != VVC_NALU_DEC_PARAM && nalu_array.nalu_type != VVC_NALU_OPI) { - numNalus = stream.readUint16(); - } - for (j = 0; j < numNalus; j++) { - var len = stream.readUint16(); - nalu_array.push({ - data: stream.readUint8Array(len), - length: len - }); - } - } - }); - // file:src/parsing/vvnC.js - BoxParser.createFullBoxCtor("vvnC", function (stream) { - // VvcNALUConfigBox - var tmp = strm.readUint8(); - this.lengthSizeMinusOne = tmp & 0x3; - }); - // file:src/box-codecs.js - BoxParser.SampleEntry.prototype.isVideo = function () { - return false; - }; - BoxParser.SampleEntry.prototype.isAudio = function () { - return false; - }; - BoxParser.SampleEntry.prototype.isSubtitle = function () { - return false; - }; - BoxParser.SampleEntry.prototype.isMetadata = function () { - return false; - }; - BoxParser.SampleEntry.prototype.isHint = function () { - return false; - }; - BoxParser.SampleEntry.prototype.getCodec = function () { - return this.type.replace('.', ''); - }; - BoxParser.SampleEntry.prototype.getWidth = function () { - return ""; - }; - BoxParser.SampleEntry.prototype.getHeight = function () { - return ""; - }; - BoxParser.SampleEntry.prototype.getChannelCount = function () { - return ""; - }; - BoxParser.SampleEntry.prototype.getSampleRate = function () { - return ""; - }; - BoxParser.SampleEntry.prototype.getSampleSize = function () { - return ""; - }; - BoxParser.VisualSampleEntry.prototype.isVideo = function () { - return true; - }; - BoxParser.VisualSampleEntry.prototype.getWidth = function () { - return this.width; - }; - BoxParser.VisualSampleEntry.prototype.getHeight = function () { - return this.height; - }; - BoxParser.AudioSampleEntry.prototype.isAudio = function () { - return true; - }; - BoxParser.AudioSampleEntry.prototype.getChannelCount = function () { - return this.channel_count; - }; - BoxParser.AudioSampleEntry.prototype.getSampleRate = function () { - return this.samplerate; - }; - BoxParser.AudioSampleEntry.prototype.getSampleSize = function () { - return this.samplesize; - }; - BoxParser.SubtitleSampleEntry.prototype.isSubtitle = function () { - return true; - }; - BoxParser.MetadataSampleEntry.prototype.isMetadata = function () { - return true; - }; - BoxParser.decimalToHex = function (d, padding) { - var hex = Number(d).toString(16); - padding = typeof padding === "undefined" || padding === null ? padding = 2 : padding; - while (hex.length < padding) { - hex = "0" + hex; - } - return hex; - }; - BoxParser.avc1SampleEntry.prototype.getCodec = BoxParser.avc2SampleEntry.prototype.getCodec = BoxParser.avc3SampleEntry.prototype.getCodec = BoxParser.avc4SampleEntry.prototype.getCodec = function () { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.avcC) { - return baseCodec + "." + BoxParser.decimalToHex(this.avcC.AVCProfileIndication) + "" + BoxParser.decimalToHex(this.avcC.profile_compatibility) + "" + BoxParser.decimalToHex(this.avcC.AVCLevelIndication); - } else { - return baseCodec; - } - }; - BoxParser.hev1SampleEntry.prototype.getCodec = BoxParser.hvc1SampleEntry.prototype.getCodec = function () { - var i; - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.hvcC) { - baseCodec += '.'; - switch (this.hvcC.general_profile_space) { - case 0: - baseCodec += ''; - break; - case 1: - baseCodec += 'A'; - break; - case 2: - baseCodec += 'B'; - break; - case 3: - baseCodec += 'C'; - break; - } - baseCodec += this.hvcC.general_profile_idc; - baseCodec += '.'; - var val = this.hvcC.general_profile_compatibility; - var reversed = 0; - for (i = 0; i < 32; i++) { - reversed |= val & 1; - if (i == 31) break; - reversed <<= 1; - val >>= 1; - } - baseCodec += BoxParser.decimalToHex(reversed, 0); - baseCodec += '.'; - if (this.hvcC.general_tier_flag === 0) { - baseCodec += 'L'; - } else { - baseCodec += 'H'; - } - baseCodec += this.hvcC.general_level_idc; - var hasByte = false; - var constraint_string = ""; - for (i = 5; i >= 0; i--) { - if (this.hvcC.general_constraint_indicator[i] || hasByte) { - constraint_string = "." + BoxParser.decimalToHex(this.hvcC.general_constraint_indicator[i], 0) + constraint_string; - hasByte = true; - } - } - baseCodec += constraint_string; - } - return baseCodec; - }; - BoxParser.vvc1SampleEntry.prototype.getCodec = BoxParser.vvi1SampleEntry.prototype.getCodec = function () { - var i; - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.vvcC) { - baseCodec += '.' + this.vvcC.general_profile_idc; - if (this.vvcC.general_tier_flag) { - baseCodec += '.H'; - } else { - baseCodec += '.L'; - } - baseCodec += this.vvcC.general_level_idc; - var constraint_string = ""; - if (this.vvcC.general_constraint_info) { - var bytes = []; - var byte = 0; - byte |= this.vvcC.ptl_frame_only_constraint << 7; - byte |= this.vvcC.ptl_multilayer_enabled << 6; - var last_nonzero; - for (i = 0; i < this.vvcC.general_constraint_info.length; ++i) { - byte |= this.vvcC.general_constraint_info[i] >> 2 & 0x3f; - bytes.push(byte); - if (byte) { - last_nonzero = i; - } - byte = this.vvcC.general_constraint_info[i] >> 2 & 0x03; - } - if (last_nonzero === undefined) { - constraint_string = ".CA"; - } else { - constraint_string = ".C"; - var base32_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; - var held_bits = 0; - var num_held_bits = 0; - for (i = 0; i <= last_nonzero; ++i) { - held_bits = held_bits << 8 | bytes[i]; - num_held_bits += 8; - while (num_held_bits >= 5) { - var val = held_bits >> num_held_bits - 5 & 0x1f; - constraint_string += base32_chars[val]; - num_held_bits -= 5; - held_bits &= (1 << num_held_bits) - 1; - } - } - if (num_held_bits) { - held_bits <<= 5 - num_held_bits; // right-pad with zeros to 5 bits (is this correct?) - constraint_string += base32_chars[held_bits & 0x1f]; - } - } - } - baseCodec += constraint_string; - } - return baseCodec; - }; - BoxParser.mp4aSampleEntry.prototype.getCodec = function () { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.esds && this.esds.esd) { - var oti = this.esds.esd.getOTI(); - var dsi = this.esds.esd.getAudioConfig(); - return baseCodec + "." + BoxParser.decimalToHex(oti) + (dsi ? "." + dsi : ""); - } else { - return baseCodec; - } - }; - BoxParser.stxtSampleEntry.prototype.getCodec = function () { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - if (this.mime_format) { - return baseCodec + "." + this.mime_format; - } else { - return baseCodec; - } - }; - BoxParser.vp08SampleEntry.prototype.getCodec = BoxParser.vp09SampleEntry.prototype.getCodec = function () { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - var level = this.vpcC.level; - if (level == 0) { - level = "00"; - } - var bitDepth = this.vpcC.bitDepth; - if (bitDepth == 8) { - bitDepth = "08"; - } - return baseCodec + ".0" + this.vpcC.profile + "." + level + "." + bitDepth; - }; - BoxParser.av01SampleEntry.prototype.getCodec = function () { - var baseCodec = BoxParser.SampleEntry.prototype.getCodec.call(this); - var level = this.av1C.seq_level_idx_0; - if (level < 10) { - level = "0" + level; - } - var bitdepth; - if (this.av1C.seq_profile === 2 && this.av1C.high_bitdepth === 1) { - bitdepth = this.av1C.twelve_bit === 1 ? "12" : "10"; - } else if (this.av1C.seq_profile <= 2) { - bitdepth = this.av1C.high_bitdepth === 1 ? "10" : "08"; - } - // TODO need to parse the SH to find color config - return baseCodec + "." + this.av1C.seq_profile + "." + level + (this.av1C.seq_tier_0 ? "H" : "M") + "." + bitdepth; //+"."+this.av1C.monochrome+"."+this.av1C.chroma_subsampling_x+""+this.av1C.chroma_subsampling_y+""+this.av1C.chroma_sample_position; - }; - // file:src/box-write.js - /* - * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - BoxParser.Box.prototype.writeHeader = function (stream, msg) { - this.size += 8; - if (this.size > MAX_SIZE) { - this.size += 8; - } - if (this.type === "uuid") { - this.size += 16; - } - Log.debug("BoxWriter", "Writing box " + this.type + " of size: " + this.size + " at position " + stream.getPosition() + (msg || "")); - if (this.size > MAX_SIZE) { - stream.writeUint32(1); - } else { - this.sizePosition = stream.getPosition(); - stream.writeUint32(this.size); - } - stream.writeString(this.type, null, 4); - if (this.type === "uuid") { - stream.writeUint8Array(this.uuid); - } - if (this.size > MAX_SIZE) { - stream.writeUint64(this.size); - } - }; - BoxParser.FullBox.prototype.writeHeader = function (stream) { - this.size += 4; - BoxParser.Box.prototype.writeHeader.call(this, stream, " v=" + this.version + " f=" + this.flags); - stream.writeUint8(this.version); - stream.writeUint24(this.flags); - }; - BoxParser.Box.prototype.write = function (stream) { - if (this.type === "mdat") { - /* TODO: fix this */ - if (this.data) { - this.size = this.data.length; - this.writeHeader(stream); - stream.writeUint8Array(this.data); - } - } else { - this.size = this.data ? this.data.length : 0; - this.writeHeader(stream); - if (this.data) { - stream.writeUint8Array(this.data); - } - } - }; - BoxParser.ContainerBox.prototype.write = function (stream) { - this.size = 0; - this.writeHeader(stream); - for (var i = 0; i < this.boxes.length; i++) { - if (this.boxes[i]) { - this.boxes[i].write(stream); - this.size += this.boxes[i].size; - } - } - /* adjusting the size, now that all sub-boxes are known */ - Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); - stream.adjustUint32(this.sizePosition, this.size); - }; - BoxParser.TrackReferenceTypeBox.prototype.write = function (stream) { - this.size = this.track_ids.length * 4; - this.writeHeader(stream); - stream.writeUint32Array(this.track_ids); - }; - - // file:src/writing/avcC.js - BoxParser.avcCBox.prototype.write = function (stream) { - var i; - this.size = 7; - for (i = 0; i < this.SPS.length; i++) { - this.size += 2 + this.SPS[i].length; - } - for (i = 0; i < this.PPS.length; i++) { - this.size += 2 + this.PPS[i].length; - } - if (this.ext) { - this.size += this.ext.length; - } - this.writeHeader(stream); - stream.writeUint8(this.configurationVersion); - stream.writeUint8(this.AVCProfileIndication); - stream.writeUint8(this.profile_compatibility); - stream.writeUint8(this.AVCLevelIndication); - stream.writeUint8(this.lengthSizeMinusOne + (63 << 2)); - stream.writeUint8(this.SPS.length + (7 << 5)); - for (i = 0; i < this.SPS.length; i++) { - stream.writeUint16(this.SPS[i].length); - stream.writeUint8Array(this.SPS[i].nalu); - } - stream.writeUint8(this.PPS.length); - for (i = 0; i < this.PPS.length; i++) { - stream.writeUint16(this.PPS[i].length); - stream.writeUint8Array(this.PPS[i].nalu); - } - if (this.ext) { - stream.writeUint8Array(this.ext); - } - }; - - // file:src/writing/co64.js - BoxParser.co64Box.prototype.write = function (stream) { - var i; - this.version = 0; - this.flags = 0; - this.size = 4 + 8 * this.chunk_offsets.length; - this.writeHeader(stream); - stream.writeUint32(this.chunk_offsets.length); - for (i = 0; i < this.chunk_offsets.length; i++) { - stream.writeUint64(this.chunk_offsets[i]); - } - }; - - // file:src/writing/cslg.js - BoxParser.cslgBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4 * 5; - this.writeHeader(stream); - stream.writeInt32(this.compositionToDTSShift); - stream.writeInt32(this.leastDecodeToDisplayDelta); - stream.writeInt32(this.greatestDecodeToDisplayDelta); - stream.writeInt32(this.compositionStartTime); - stream.writeInt32(this.compositionEndTime); - }; - - // file:src/writing/ctts.js - BoxParser.cttsBox.prototype.write = function (stream) { - var i; - this.version = 0; - this.flags = 0; - this.size = 4 + 8 * this.sample_counts.length; - this.writeHeader(stream); - stream.writeUint32(this.sample_counts.length); - for (i = 0; i < this.sample_counts.length; i++) { - stream.writeUint32(this.sample_counts[i]); - if (this.version === 1) { - stream.writeInt32(this.sample_offsets[i]); /* signed */ - } else { - stream.writeUint32(this.sample_offsets[i]); /* unsigned */ - } - } - }; - - // file:src/writing/dref.js - BoxParser.drefBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4; // - this.writeHeader(stream); - stream.writeUint32(this.entries.length); - for (var i = 0; i < this.entries.length; i++) { - this.entries[i].write(stream); - this.size += this.entries[i].size; - } - /* adjusting the size, now that all sub-boxes are known */ - Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); - stream.adjustUint32(this.sizePosition, this.size); - }; - - // file:src/writing/elng.js - BoxParser.elngBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = this.extended_language.length; - this.writeHeader(stream); - stream.writeString(this.extended_language); - }; - - // file:src/writing/elst.js - BoxParser.elstBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4 + 12 * this.entries.length; - this.writeHeader(stream); - stream.writeUint32(this.entries.length); - for (var i = 0; i < this.entries.length; i++) { - var entry = this.entries[i]; - stream.writeUint32(entry.segment_duration); - stream.writeInt32(entry.media_time); - stream.writeInt16(entry.media_rate_integer); - stream.writeInt16(entry.media_rate_fraction); - } - }; - - // file:src/writing/emsg.js - BoxParser.emsgBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4 * 4 + this.message_data.length + (this.scheme_id_uri.length + 1) + (this.value.length + 1); - this.writeHeader(stream); - stream.writeCString(this.scheme_id_uri); - stream.writeCString(this.value); - stream.writeUint32(this.timescale); - stream.writeUint32(this.presentation_time_delta); - stream.writeUint32(this.event_duration); - stream.writeUint32(this.id); - stream.writeUint8Array(this.message_data); - }; - - // file:src/writing/ftyp.js - BoxParser.ftypBox.prototype.write = function (stream) { - this.size = 8 + 4 * this.compatible_brands.length; - this.writeHeader(stream); - stream.writeString(this.major_brand, null, 4); - stream.writeUint32(this.minor_version); - for (var i = 0; i < this.compatible_brands.length; i++) { - stream.writeString(this.compatible_brands[i], null, 4); - } - }; - - // file:src/writing/hdlr.js - BoxParser.hdlrBox.prototype.write = function (stream) { - this.size = 5 * 4 + this.name.length + 1; - this.version = 0; - this.flags = 0; - this.writeHeader(stream); - stream.writeUint32(0); - stream.writeString(this.handler, null, 4); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeCString(this.name); - }; - - // file:src/writing/hvcC.js - BoxParser.hvcCBox.prototype.write = function (stream) { - var i, j; - this.size = 23; - for (i = 0; i < this.nalu_arrays.length; i++) { - this.size += 3; - for (j = 0; j < this.nalu_arrays[i].length; j++) { - this.size += 2 + this.nalu_arrays[i][j].data.length; - } - } - this.writeHeader(stream); - stream.writeUint8(this.configurationVersion); - stream.writeUint8((this.general_profile_space << 6) + (this.general_tier_flag << 5) + this.general_profile_idc); - stream.writeUint32(this.general_profile_compatibility); - stream.writeUint8Array(this.general_constraint_indicator); - stream.writeUint8(this.general_level_idc); - stream.writeUint16(this.min_spatial_segmentation_idc + (15 << 24)); - stream.writeUint8(this.parallelismType + (63 << 2)); - stream.writeUint8(this.chroma_format_idc + (63 << 2)); - stream.writeUint8(this.bit_depth_luma_minus8 + (31 << 3)); - stream.writeUint8(this.bit_depth_chroma_minus8 + (31 << 3)); - stream.writeUint16(this.avgFrameRate); - stream.writeUint8((this.constantFrameRate << 6) + (this.numTemporalLayers << 3) + (this.temporalIdNested << 2) + this.lengthSizeMinusOne); - stream.writeUint8(this.nalu_arrays.length); - for (i = 0; i < this.nalu_arrays.length; i++) { - // bit(1) array_completeness + bit(1) reserved = 0 + bit(6) nal_unit_type - stream.writeUint8((this.nalu_arrays[i].completeness << 7) + this.nalu_arrays[i].nalu_type); - stream.writeUint16(this.nalu_arrays[i].length); - for (j = 0; j < this.nalu_arrays[i].length; j++) { - stream.writeUint16(this.nalu_arrays[i][j].data.length); - stream.writeUint8Array(this.nalu_arrays[i][j].data); - } - } - }; - // file:src/writing/kind.js - BoxParser.kindBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = this.schemeURI.length + 1 + (this.value.length + 1); - this.writeHeader(stream); - stream.writeCString(this.schemeURI); - stream.writeCString(this.value); - }; - - // file:src/writing/mdhd.js - BoxParser.mdhdBox.prototype.write = function (stream) { - this.size = 4 * 4 + 2 * 2; - this.flags = 0; - this.version = 0; - this.writeHeader(stream); - stream.writeUint32(this.creation_time); - stream.writeUint32(this.modification_time); - stream.writeUint32(this.timescale); - stream.writeUint32(this.duration); - stream.writeUint16(this.language); - stream.writeUint16(0); - }; - - // file:src/writing/mehd.js - BoxParser.mehdBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4; - this.writeHeader(stream); - stream.writeUint32(this.fragment_duration); - }; - - // file:src/writing/mfhd.js - BoxParser.mfhdBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4; - this.writeHeader(stream); - stream.writeUint32(this.sequence_number); - }; - - // file:src/writing/mvhd.js - BoxParser.mvhdBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 23 * 4 + 2 * 2; - this.writeHeader(stream); - stream.writeUint32(this.creation_time); - stream.writeUint32(this.modification_time); - stream.writeUint32(this.timescale); - stream.writeUint32(this.duration); - stream.writeUint32(this.rate); - stream.writeUint16(this.volume << 8); - stream.writeUint16(0); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint32Array(this.matrix); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint32(this.next_track_id); - }; - - // file:src/writing/sampleentry.js - BoxParser.SampleEntry.prototype.writeHeader = function (stream) { - this.size = 8; - BoxParser.Box.prototype.writeHeader.call(this, stream); - stream.writeUint8(0); - stream.writeUint8(0); - stream.writeUint8(0); - stream.writeUint8(0); - stream.writeUint8(0); - stream.writeUint8(0); - stream.writeUint16(this.data_reference_index); - }; - BoxParser.SampleEntry.prototype.writeFooter = function (stream) { - for (var i = 0; i < this.boxes.length; i++) { - this.boxes[i].write(stream); - this.size += this.boxes[i].size; - } - Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); - stream.adjustUint32(this.sizePosition, this.size); - }; - BoxParser.SampleEntry.prototype.write = function (stream) { - this.writeHeader(stream); - stream.writeUint8Array(this.data); - this.size += this.data.length; - Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); - stream.adjustUint32(this.sizePosition, this.size); - }; - BoxParser.VisualSampleEntry.prototype.write = function (stream) { - this.writeHeader(stream); - this.size += 2 * 7 + 6 * 4 + 32; - stream.writeUint16(0); - stream.writeUint16(0); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint16(this.width); - stream.writeUint16(this.height); - stream.writeUint32(this.horizresolution); - stream.writeUint32(this.vertresolution); - stream.writeUint32(0); - stream.writeUint16(this.frame_count); - stream.writeUint8(Math.min(31, this.compressorname.length)); - stream.writeString(this.compressorname, null, 31); - stream.writeUint16(this.depth); - stream.writeInt16(-1); - this.writeFooter(stream); - }; - BoxParser.AudioSampleEntry.prototype.write = function (stream) { - this.writeHeader(stream); - this.size += 2 * 4 + 3 * 4; - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeUint16(this.channel_count); - stream.writeUint16(this.samplesize); - stream.writeUint16(0); - stream.writeUint16(0); - stream.writeUint32(this.samplerate << 16); - this.writeFooter(stream); - }; - BoxParser.stppSampleEntry.prototype.write = function (stream) { - this.writeHeader(stream); - this.size += this.namespace.length + 1 + this.schema_location.length + 1 + this.auxiliary_mime_types.length + 1; - stream.writeCString(this.namespace); - stream.writeCString(this.schema_location); - stream.writeCString(this.auxiliary_mime_types); - this.writeFooter(stream); - }; - - // file:src/writing/samplegroups/samplegroup.js - BoxParser.SampleGroupEntry.prototype.write = function (stream) { - stream.writeUint8Array(this.data); - }; - - // file:src/writing/sbgp.js - BoxParser.sbgpBox.prototype.write = function (stream) { - this.version = 1; - this.flags = 0; - this.size = 12 + 8 * this.entries.length; - this.writeHeader(stream); - stream.writeString(this.grouping_type, null, 4); - stream.writeUint32(this.grouping_type_parameter); - stream.writeUint32(this.entries.length); - for (var i = 0; i < this.entries.length; i++) { - var entry = this.entries[i]; - stream.writeInt32(entry.sample_count); - stream.writeInt32(entry.group_description_index); - } - }; - - // file:src/writing/sgpd.js - BoxParser.sgpdBox.prototype.write = function (stream) { - var i; - var entry; - // leave version as read - // this.version; - this.flags = 0; - this.size = 12; - for (i = 0; i < this.entries.length; i++) { - entry = this.entries[i]; - if (this.version === 1) { - if (this.default_length === 0) { - this.size += 4; - } - this.size += entry.data.length; - } - } - this.writeHeader(stream); - stream.writeString(this.grouping_type, null, 4); - if (this.version === 1) { - stream.writeUint32(this.default_length); - } - if (this.version >= 2) { - stream.writeUint32(this.default_sample_description_index); - } - stream.writeUint32(this.entries.length); - for (i = 0; i < this.entries.length; i++) { - entry = this.entries[i]; - if (this.version === 1) { - if (this.default_length === 0) { - stream.writeUint32(entry.description_length); - } - } - entry.write(stream); - } - }; - - // file:src/writing/sidx.js - BoxParser.sidxBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4 * 4 + 2 + 2 + 12 * this.references.length; - this.writeHeader(stream); - stream.writeUint32(this.reference_ID); - stream.writeUint32(this.timescale); - stream.writeUint32(this.earliest_presentation_time); - stream.writeUint32(this.first_offset); - stream.writeUint16(0); - stream.writeUint16(this.references.length); - for (var i = 0; i < this.references.length; i++) { - var ref = this.references[i]; - stream.writeUint32(ref.reference_type << 31 | ref.referenced_size); - stream.writeUint32(ref.subsegment_duration); - stream.writeUint32(ref.starts_with_SAP << 31 | ref.SAP_type << 28 | ref.SAP_delta_time); - } - }; - - // file:src/writing/smhd.js - BoxParser.smhdBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 1; - this.size = 4; - this.writeHeader(stream); - stream.writeUint16(this.balance); - stream.writeUint16(0); - }; - // file:src/writing/stco.js - BoxParser.stcoBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4 + 4 * this.chunk_offsets.length; - this.writeHeader(stream); - stream.writeUint32(this.chunk_offsets.length); - stream.writeUint32Array(this.chunk_offsets); - }; - - // file:src/writing/stsc.js - BoxParser.stscBox.prototype.write = function (stream) { - var i; - this.version = 0; - this.flags = 0; - this.size = 4 + 12 * this.first_chunk.length; - this.writeHeader(stream); - stream.writeUint32(this.first_chunk.length); - for (i = 0; i < this.first_chunk.length; i++) { - stream.writeUint32(this.first_chunk[i]); - stream.writeUint32(this.samples_per_chunk[i]); - stream.writeUint32(this.sample_description_index[i]); - } - }; - - // file:src/writing/stsd.js - BoxParser.stsdBox.prototype.write = function (stream) { - var i; - this.version = 0; - this.flags = 0; - this.size = 0; - this.writeHeader(stream); - stream.writeUint32(this.entries.length); - this.size += 4; - for (i = 0; i < this.entries.length; i++) { - this.entries[i].write(stream); - this.size += this.entries[i].size; - } - /* adjusting the size, now that all sub-boxes are known */ - Log.debug("BoxWriter", "Adjusting box " + this.type + " with new size " + this.size); - stream.adjustUint32(this.sizePosition, this.size); - }; - - // file:src/writing/stsh.js - BoxParser.stshBox.prototype.write = function (stream) { - var i; - this.version = 0; - this.flags = 0; - this.size = 4 + 8 * this.shadowed_sample_numbers.length; - this.writeHeader(stream); - stream.writeUint32(this.shadowed_sample_numbers.length); - for (i = 0; i < this.shadowed_sample_numbers.length; i++) { - stream.writeUint32(this.shadowed_sample_numbers[i]); - stream.writeUint32(this.sync_sample_numbers[i]); - } - }; - - // file:src/writing/stss.js - BoxParser.stssBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4 + 4 * this.sample_numbers.length; - this.writeHeader(stream); - stream.writeUint32(this.sample_numbers.length); - stream.writeUint32Array(this.sample_numbers); - }; - - // file:src/writing/stsz.js - BoxParser.stszBox.prototype.write = function (stream) { - var i; - var constant = true; - this.version = 0; - this.flags = 0; - if (this.sample_sizes.length > 0) { - i = 0; - while (i + 1 < this.sample_sizes.length) { - if (this.sample_sizes[i + 1] !== this.sample_sizes[0]) { - constant = false; - break; - } else { - i++; - } - } - } else { - constant = false; - } - this.size = 8; - if (!constant) { - this.size += 4 * this.sample_sizes.length; - } - this.writeHeader(stream); - if (!constant) { - stream.writeUint32(0); - } else { - stream.writeUint32(this.sample_sizes[0]); - } - stream.writeUint32(this.sample_sizes.length); - if (!constant) { - stream.writeUint32Array(this.sample_sizes); - } - }; - - // file:src/writing/stts.js - BoxParser.sttsBox.prototype.write = function (stream) { - var i; - this.version = 0; - this.flags = 0; - this.size = 4 + 8 * this.sample_counts.length; - this.writeHeader(stream); - stream.writeUint32(this.sample_counts.length); - for (i = 0; i < this.sample_counts.length; i++) { - stream.writeUint32(this.sample_counts[i]); - stream.writeUint32(this.sample_deltas[i]); - } - }; - - // file:src/writing/tfdt.js - BoxParser.tfdtBox.prototype.write = function (stream) { - var UINT32_MAX = Math.pow(2, 32) - 1; - // use version 1 if baseMediaDecodeTime does not fit 32 bits - this.version = this.baseMediaDecodeTime > UINT32_MAX ? 1 : 0; - this.flags = 0; - this.size = 4; - if (this.version === 1) { - this.size += 4; - } - this.writeHeader(stream); - if (this.version === 1) { - stream.writeUint64(this.baseMediaDecodeTime); - } else { - stream.writeUint32(this.baseMediaDecodeTime); - } - }; - - // file:src/writing/tfhd.js - BoxParser.tfhdBox.prototype.write = function (stream) { - this.version = 0; - this.size = 4; - if (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { - this.size += 8; - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { - this.size += 4; - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { - this.size += 4; - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { - this.size += 4; - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { - this.size += 4; - } - this.writeHeader(stream); - stream.writeUint32(this.track_id); - if (this.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET) { - stream.writeUint64(this.base_data_offset); - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { - stream.writeUint32(this.default_sample_description_index); - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { - stream.writeUint32(this.default_sample_duration); - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { - stream.writeUint32(this.default_sample_size); - } - if (this.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { - stream.writeUint32(this.default_sample_flags); - } - }; - - // file:src/writing/tkhd.js - BoxParser.tkhdBox.prototype.write = function (stream) { - this.version = 0; - //this.flags = 0; - this.size = 4 * 18 + 2 * 4; - this.writeHeader(stream); - stream.writeUint32(this.creation_time); - stream.writeUint32(this.modification_time); - stream.writeUint32(this.track_id); - stream.writeUint32(0); - stream.writeUint32(this.duration); - stream.writeUint32(0); - stream.writeUint32(0); - stream.writeInt16(this.layer); - stream.writeInt16(this.alternate_group); - stream.writeInt16(this.volume << 8); - stream.writeUint16(0); - stream.writeInt32Array(this.matrix); - stream.writeUint32(this.width); - stream.writeUint32(this.height); - }; - - // file:src/writing/trex.js - BoxParser.trexBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = 4 * 5; - this.writeHeader(stream); - stream.writeUint32(this.track_id); - stream.writeUint32(this.default_sample_description_index); - stream.writeUint32(this.default_sample_duration); - stream.writeUint32(this.default_sample_size); - stream.writeUint32(this.default_sample_flags); - }; - - // file:src/writing/trun.js - BoxParser.trunBox.prototype.write = function (stream) { - this.version = 0; - this.size = 4; - if (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { - this.size += 4; - } - if (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { - this.size += 4; - } - if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { - this.size += 4 * this.sample_duration.length; - } - if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { - this.size += 4 * this.sample_size.length; - } - if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { - this.size += 4 * this.sample_flags.length; - } - if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { - this.size += 4 * this.sample_composition_time_offset.length; - } - this.writeHeader(stream); - stream.writeUint32(this.sample_count); - if (this.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET) { - this.data_offset_position = stream.getPosition(); - stream.writeInt32(this.data_offset); //signed - } - if (this.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { - stream.writeUint32(this.first_sample_flags); - } - for (var i = 0; i < this.sample_count; i++) { - if (this.flags & BoxParser.TRUN_FLAGS_DURATION) { - stream.writeUint32(this.sample_duration[i]); - } - if (this.flags & BoxParser.TRUN_FLAGS_SIZE) { - stream.writeUint32(this.sample_size[i]); - } - if (this.flags & BoxParser.TRUN_FLAGS_FLAGS) { - stream.writeUint32(this.sample_flags[i]); - } - if (this.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { - if (this.version === 0) { - stream.writeUint32(this.sample_composition_time_offset[i]); - } else { - stream.writeInt32(this.sample_composition_time_offset[i]); //signed - } - } - } - }; - - // file:src/writing/url.js - BoxParser["url Box"].prototype.write = function (stream) { - this.version = 0; - if (this.location) { - this.flags = 0; - this.size = this.location.length + 1; - } else { - this.flags = 0x000001; - this.size = 0; - } - this.writeHeader(stream); - if (this.location) { - stream.writeCString(this.location); - } - }; - - // file:src/writing/urn.js - BoxParser["urn Box"].prototype.write = function (stream) { - this.version = 0; - this.flags = 0; - this.size = this.name.length + 1 + (this.location ? this.location.length + 1 : 0); - this.writeHeader(stream); - stream.writeCString(this.name); - if (this.location) { - stream.writeCString(this.location); - } - }; - - // file:src/writing/vmhd.js - BoxParser.vmhdBox.prototype.write = function (stream) { - this.version = 0; - this.flags = 1; - this.size = 8; - this.writeHeader(stream); - stream.writeUint16(this.graphicsmode); - stream.writeUint16Array(this.opcolor); - }; - - // file:src/box-unpack.js - /* - * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - BoxParser.cttsBox.prototype.unpack = function (samples) { - var i, j, k; - k = 0; - for (i = 0; i < this.sample_counts.length; i++) { - for (j = 0; j < this.sample_counts[i]; j++) { - samples[k].pts = samples[k].dts + this.sample_offsets[i]; - k++; - } - } - }; - BoxParser.sttsBox.prototype.unpack = function (samples) { - var i, j, k; - k = 0; - for (i = 0; i < this.sample_counts.length; i++) { - for (j = 0; j < this.sample_counts[i]; j++) { - if (k === 0) { - samples[k].dts = 0; - } else { - samples[k].dts = samples[k - 1].dts + this.sample_deltas[i]; - } - k++; - } - } - }; - BoxParser.stcoBox.prototype.unpack = function (samples) { - var i; - for (i = 0; i < this.chunk_offsets.length; i++) { - samples[i].offset = this.chunk_offsets[i]; - } - }; - BoxParser.stscBox.prototype.unpack = function (samples) { - var i, j, k, l, m; - l = 0; - m = 0; - for (i = 0; i < this.first_chunk.length; i++) { - for (j = 0; j < (i + 1 < this.first_chunk.length ? this.first_chunk[i + 1] : Infinity); j++) { - m++; - for (k = 0; k < this.samples_per_chunk[i]; k++) { - if (samples[l]) { - samples[l].description_index = this.sample_description_index[i]; - samples[l].chunk_index = m; - } else { - return; - } - l++; - } - } - } - }; - BoxParser.stszBox.prototype.unpack = function (samples) { - var i; - for (i = 0; i < this.sample_sizes.length; i++) { - samples[i].size = this.sample_sizes[i]; - } - }; - // file:src/box-diff.js - - BoxParser.DIFF_BOXES_PROP_NAMES = ["boxes", "entries", "references", "subsamples", "items", "item_infos", "extents", "associations", "subsegments", "ranges", "seekLists", "seekPoints", "esd", "levels"]; - BoxParser.DIFF_PRIMITIVE_ARRAY_PROP_NAMES = ["compatible_brands", "matrix", "opcolor", "sample_counts", "sample_counts", "sample_deltas", "first_chunk", "samples_per_chunk", "sample_sizes", "chunk_offsets", "sample_offsets", "sample_description_index", "sample_duration"]; - BoxParser.boxEqualFields = function (box_a, box_b) { - if (box_a && !box_b) return false; - var prop; - for (prop in box_a) { - if (BoxParser.DIFF_BOXES_PROP_NAMES.indexOf(prop) > -1) { - continue; - // } else if (excluded_fields && excluded_fields.indexOf(prop) > -1) { - // continue; - } else if (box_a[prop] instanceof BoxParser.Box || box_b[prop] instanceof BoxParser.Box) { - continue; - } else if (typeof box_a[prop] === "undefined" || typeof box_b[prop] === "undefined") { - continue; - } else if (typeof box_a[prop] === "function" || typeof box_b[prop] === "function") { - continue; - } else if (box_a.subBoxNames && box_a.subBoxNames.indexOf(prop.slice(0, 4)) > -1 || box_b.subBoxNames && box_b.subBoxNames.indexOf(prop.slice(0, 4)) > -1) { - continue; - } else { - if (prop === "data" || prop === "start" || prop === "size" || prop === "creation_time" || prop === "modification_time") { - continue; - } else if (BoxParser.DIFF_PRIMITIVE_ARRAY_PROP_NAMES.indexOf(prop) > -1) { - continue; - } else { - if (box_a[prop] !== box_b[prop]) { - return false; - } - } - } - } - return true; - }; - BoxParser.boxEqual = function (box_a, box_b) { - if (!BoxParser.boxEqualFields(box_a, box_b)) { - return false; - } - for (var j = 0; j < BoxParser.DIFF_BOXES_PROP_NAMES.length; j++) { - var name = BoxParser.DIFF_BOXES_PROP_NAMES[j]; - if (box_a[name] && box_b[name]) { - if (!BoxParser.boxEqual(box_a[name], box_b[name])) { - return false; - } - } - } - return true; - }; // file:src/text-mp4.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var VTTin4Parser = function () {}; - VTTin4Parser.prototype.parseSample = function (data) { - var cues, cue; - var stream = new MP4BoxStream(data.buffer); - cues = []; - while (!stream.isEos()) { - cue = BoxParser.parseOneBox(stream, false); - if (cue.code === BoxParser.OK && cue.box.type === "vttc") { - cues.push(cue.box); - } - } - return cues; - }; - VTTin4Parser.prototype.getText = function (startTime, endTime, data) { - function pad(n, width, z) { - z = z || '0'; - n = n + ''; - return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n; - } - function secToTimestamp(insec) { - var h = Math.floor(insec / 3600); - var m = Math.floor((insec - h * 3600) / 60); - var s = Math.floor(insec - h * 3600 - m * 60); - var ms = Math.floor((insec - h * 3600 - m * 60 - s) * 1000); - return "" + pad(h, 2) + ":" + pad(m, 2) + ":" + pad(s, 2) + "." + pad(ms, 3); - } - var cues = this.parseSample(data); - var string = ""; - for (var i = 0; i < cues.length; i++) { - var cueIn4 = cues[i]; - string += secToTimestamp(startTime) + " --> " + secToTimestamp(endTime) + "\r\n"; - string += cueIn4.payl.text; - } - return string; - }; - var XMLSubtitlein4Parser = function () {}; - XMLSubtitlein4Parser.prototype.parseSample = function (sample) { - var res = {}; - var i; - res.resources = []; - var stream = new MP4BoxStream(sample.data.buffer); - if (!sample.subsamples || sample.subsamples.length === 0) { - res.documentString = stream.readString(sample.data.length); - } else { - res.documentString = stream.readString(sample.subsamples[0].size); - if (sample.subsamples.length > 1) { - for (i = 1; i < sample.subsamples.length; i++) { - res.resources[i] = stream.readUint8Array(sample.subsamples[i].size); - } - } - } - if (typeof DOMParser !== "undefined") { - res.document = new DOMParser().parseFromString(res.documentString, "application/xml"); - } - return res; - }; - var Textin4Parser = function () {}; - Textin4Parser.prototype.parseSample = function (sample) { - var textString; - var stream = new MP4BoxStream(sample.data.buffer); - textString = stream.readString(sample.data.length); - return textString; - }; - Textin4Parser.prototype.parseConfig = function (data) { - var textString; - var stream = new MP4BoxStream(data.buffer); - stream.readUint32(); // version & flags - textString = stream.readCString(); - return textString; - }; - { - exports.VTTin4Parser = VTTin4Parser; - exports.XMLSubtitlein4Parser = XMLSubtitlein4Parser; - exports.Textin4Parser = Textin4Parser; - } - // file:src/isofile.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var ISOFile = function (stream) { - /* MutiBufferStream object used to parse boxes */ - this.stream = stream || new MultiBufferStream(); - /* Array of all boxes (in order) found in the file */ - this.boxes = []; - /* Array of all mdats */ - this.mdats = []; - /* Array of all moofs */ - this.moofs = []; - /* Boolean indicating if the file is compatible with progressive parsing (moov first) */ - this.isProgressive = false; - /* Boolean used to fire moov start event only once */ - this.moovStartFound = false; - /* Callback called when the moov parsing starts */ - this.onMoovStart = null; - /* Boolean keeping track of the call to onMoovStart, to avoid double calls */ - this.moovStartSent = false; - /* Callback called when the moov is entirely parsed */ - this.onReady = null; - /* Boolean keeping track of the call to onReady, to avoid double calls */ - this.readySent = false; - /* Callback to call when segments are ready */ - this.onSegment = null; - /* Callback to call when samples are ready */ - this.onSamples = null; - /* Callback to call when there is an error in the parsing or processing of samples */ - this.onError = null; - /* Boolean indicating if the moov box run-length encoded tables of sample information have been processed */ - this.sampleListBuilt = false; - /* Array of Track objects for which fragmentation of samples is requested */ - this.fragmentedTracks = []; - /* Array of Track objects for which extraction of samples is requested */ - this.extractedTracks = []; - /* Boolean indicating that fragmention is ready */ - this.isFragmentationInitialized = false; - /* Boolean indicating that fragmented has started */ - this.sampleProcessingStarted = false; - /* Number of the next 'moof' to generate when fragmenting */ - this.nextMoofNumber = 0; - /* Boolean indicating if the initial list of items has been produced */ - this.itemListBuilt = false; - /* Array of items */ - this.items = []; - /* Array of entity groups */ - this.entity_groups = []; - /* Callback called when the sidx box is entirely parsed */ - this.onSidx = null; - /* Boolean keeping track of the call to onSidx, to avoid double calls */ - this.sidxSent = false; - }; - ISOFile.prototype.setSegmentOptions = function (id, user, options) { - var trak = this.getTrackById(id); - if (trak) { - var fragTrack = {}; - this.fragmentedTracks.push(fragTrack); - fragTrack.id = id; - fragTrack.user = user; - fragTrack.trak = trak; - trak.nextSample = 0; - fragTrack.segmentStream = null; - fragTrack.nb_samples = 1000; - fragTrack.rapAlignement = true; - if (options) { - if (options.nbSamples) fragTrack.nb_samples = options.nbSamples; - if (options.rapAlignement) fragTrack.rapAlignement = options.rapAlignement; - } - } - }; - ISOFile.prototype.unsetSegmentOptions = function (id) { - var index = -1; - for (var i = 0; i < this.fragmentedTracks.length; i++) { - var fragTrack = this.fragmentedTracks[i]; - if (fragTrack.id == id) { - index = i; - } - } - if (index > -1) { - this.fragmentedTracks.splice(index, 1); - } - }; - ISOFile.prototype.setExtractionOptions = function (id, user, options) { - var trak = this.getTrackById(id); - if (trak) { - var extractTrack = {}; - this.extractedTracks.push(extractTrack); - extractTrack.id = id; - extractTrack.user = user; - extractTrack.trak = trak; - trak.nextSample = 0; - extractTrack.nb_samples = 1000; - extractTrack.samples = []; - if (options) { - if (options.nbSamples) extractTrack.nb_samples = options.nbSamples; - } - } - }; - ISOFile.prototype.unsetExtractionOptions = function (id) { - var index = -1; - for (var i = 0; i < this.extractedTracks.length; i++) { - var extractTrack = this.extractedTracks[i]; - if (extractTrack.id == id) { - index = i; - } - } - if (index > -1) { - this.extractedTracks.splice(index, 1); - } - }; - ISOFile.prototype.parse = function () { - var ret; - var box; - var parseBoxHeadersOnly = false; - if (this.restoreParsePosition) { - if (!this.restoreParsePosition()) { - return; - } - } - while (true) { - if (this.hasIncompleteMdat && this.hasIncompleteMdat()) { - if (this.processIncompleteMdat()) { - continue; - } else { - return; - } - } else { - if (this.saveParsePosition) { - this.saveParsePosition(); - } - ret = BoxParser.parseOneBox(this.stream, parseBoxHeadersOnly); - if (ret.code === BoxParser.ERR_NOT_ENOUGH_DATA) { - if (this.processIncompleteBox) { - if (this.processIncompleteBox(ret)) { - continue; - } else { - return; - } - } else { - return; - } - } else { - var box_type; - /* the box is entirely parsed */ - box = ret.box; - box_type = box.type !== "uuid" ? box.type : box.uuid; - /* store the box in the 'boxes' array to preserve box order (for file rewrite if needed) */ - this.boxes.push(box); - /* but also store box in a property for more direct access */ - switch (box_type) { - case "mdat": - this.mdats.push(box); - break; - case "moof": - this.moofs.push(box); - break; - case "moov": - this.moovStartFound = true; - if (this.mdats.length === 0) { - this.isProgressive = true; - } - /* no break */ - /* falls through */ - default: - if (this[box_type] !== undefined) { - Log.warn("ISOFile", "Duplicate Box of type: " + box_type + ", overriding previous occurrence"); - } - this[box_type] = box; - break; - } - if (this.updateUsedBytes) { - this.updateUsedBytes(box, ret); - } - } - } - } - }; - ISOFile.prototype.checkBuffer = function (ab) { - if (ab === null || ab === undefined) { - throw "Buffer must be defined and non empty"; - } - if (ab.fileStart === undefined) { - throw "Buffer must have a fileStart property"; - } - if (ab.byteLength === 0) { - Log.warn("ISOFile", "Ignoring empty buffer (fileStart: " + ab.fileStart + ")"); - this.stream.logBufferLevel(); - return false; - } - Log.info("ISOFile", "Processing buffer (fileStart: " + ab.fileStart + ")"); - - /* mark the bytes in the buffer as not being used yet */ - ab.usedBytes = 0; - this.stream.insertBuffer(ab); - this.stream.logBufferLevel(); - if (!this.stream.initialized()) { - Log.warn("ISOFile", "Not ready to start parsing"); - return false; - } - return true; - }; - - /* Processes a new ArrayBuffer (with a fileStart property) - Returns the next expected file position, or undefined if not ready to parse */ - ISOFile.prototype.appendBuffer = function (ab, last) { - var nextFileStart; - if (!this.checkBuffer(ab)) { - return; - } - - /* Parse whatever is in the existing buffers */ - this.parse(); - - /* Check if the moovStart callback needs to be called */ - if (this.moovStartFound && !this.moovStartSent) { - this.moovStartSent = true; - if (this.onMoovStart) this.onMoovStart(); - } - if (this.moov) { - /* A moov box has been entirely parsed */ - - /* if this is the first call after the moov is found we initialize the list of samples (may be empty in fragmented files) */ - if (!this.sampleListBuilt) { - this.buildSampleLists(); - this.sampleListBuilt = true; - } - - /* We update the sample information if there are any new moof boxes */ - this.updateSampleLists(); - - /* If the application needs to be informed that the 'moov' has been found, - we create the information object and callback the application */ - if (this.onReady && !this.readySent) { - this.readySent = true; - this.onReady(this.getInfo()); - } - - /* See if any sample extraction or segment creation needs to be done with the available samples */ - this.processSamples(last); - - /* Inform about the best range to fetch next */ - if (this.nextSeekPosition) { - nextFileStart = this.nextSeekPosition; - this.nextSeekPosition = undefined; - } else { - nextFileStart = this.nextParsePosition; - } - if (this.stream.getEndFilePositionAfter) { - nextFileStart = this.stream.getEndFilePositionAfter(nextFileStart); - } - } else { - if (this.nextParsePosition) { - /* moov has not been parsed but the first buffer was received, - the next fetch should probably be the next box start */ - nextFileStart = this.nextParsePosition; - } else { - /* No valid buffer has been parsed yet, we cannot know what to parse next */ - nextFileStart = 0; - } - } - if (this.sidx) { - if (this.onSidx && !this.sidxSent) { - this.onSidx(this.sidx); - this.sidxSent = true; - } - } - if (this.meta) { - if (this.flattenItemInfo && !this.itemListBuilt) { - this.flattenItemInfo(); - this.itemListBuilt = true; - } - if (this.processItems) { - this.processItems(this.onItem); - } - } - if (this.stream.cleanBuffers) { - Log.info("ISOFile", "Done processing buffer (fileStart: " + ab.fileStart + ") - next buffer to fetch should have a fileStart position of " + nextFileStart); - this.stream.logBufferLevel(); - this.stream.cleanBuffers(); - this.stream.logBufferLevel(true); - Log.info("ISOFile", "Sample data size in memory: " + this.getAllocatedSampleDataSize()); - } - return nextFileStart; - }; - ISOFile.prototype.getInfo = function () { - var i, j; - var movie = {}; - var trak; - var track; - var ref; - var sample_desc; - var _1904 = new Date('1904-01-01T00:00:00Z').getTime(); - if (this.moov) { - movie.hasMoov = true; - movie.duration = this.moov.mvhd.duration; - movie.timescale = this.moov.mvhd.timescale; - movie.isFragmented = this.moov.mvex != null; - if (movie.isFragmented && this.moov.mvex.mehd) { - movie.fragment_duration = this.moov.mvex.mehd.fragment_duration; - } - movie.isProgressive = this.isProgressive; - movie.hasIOD = this.moov.iods != null; - movie.brands = []; - movie.brands.push(this.ftyp.major_brand); - movie.brands = movie.brands.concat(this.ftyp.compatible_brands); - movie.created = new Date(_1904 + this.moov.mvhd.creation_time * 1000); - movie.modified = new Date(_1904 + this.moov.mvhd.modification_time * 1000); - movie.tracks = []; - movie.audioTracks = []; - movie.videoTracks = []; - movie.subtitleTracks = []; - movie.metadataTracks = []; - movie.hintTracks = []; - movie.otherTracks = []; - for (i = 0; i < this.moov.traks.length; i++) { - trak = this.moov.traks[i]; - sample_desc = trak.mdia.minf.stbl.stsd.entries[0]; - track = {}; - movie.tracks.push(track); - track.id = trak.tkhd.track_id; - track.name = trak.mdia.hdlr.name; - track.references = []; - if (trak.tref) { - for (j = 0; j < trak.tref.boxes.length; j++) { - ref = {}; - track.references.push(ref); - ref.type = trak.tref.boxes[j].type; - ref.track_ids = trak.tref.boxes[j].track_ids; - } - } - if (trak.edts) { - track.edits = trak.edts.elst.entries; - } - track.created = new Date(_1904 + trak.tkhd.creation_time * 1000); - track.modified = new Date(_1904 + trak.tkhd.modification_time * 1000); - track.movie_duration = trak.tkhd.duration; - track.movie_timescale = movie.timescale; - track.layer = trak.tkhd.layer; - track.alternate_group = trak.tkhd.alternate_group; - track.volume = trak.tkhd.volume; - track.matrix = trak.tkhd.matrix; - track.track_width = trak.tkhd.width / (1 << 16); - track.track_height = trak.tkhd.height / (1 << 16); - track.timescale = trak.mdia.mdhd.timescale; - track.cts_shift = trak.mdia.minf.stbl.cslg; - track.duration = trak.mdia.mdhd.duration; - track.samples_duration = trak.samples_duration; - track.codec = sample_desc.getCodec(); - track.kind = trak.udta && trak.udta.kinds.length ? trak.udta.kinds[0] : { - schemeURI: "", - value: "" - }; - track.language = trak.mdia.elng ? trak.mdia.elng.extended_language : trak.mdia.mdhd.languageString; - track.nb_samples = trak.samples.length; - track.size = trak.samples_size; - track.bitrate = track.size * 8 * track.timescale / track.samples_duration; - if (sample_desc.isAudio()) { - track.type = "audio"; - movie.audioTracks.push(track); - track.audio = {}; - track.audio.sample_rate = sample_desc.getSampleRate(); - track.audio.channel_count = sample_desc.getChannelCount(); - track.audio.sample_size = sample_desc.getSampleSize(); - } else if (sample_desc.isVideo()) { - track.type = "video"; - movie.videoTracks.push(track); - track.video = {}; - track.video.width = sample_desc.getWidth(); - track.video.height = sample_desc.getHeight(); - } else if (sample_desc.isSubtitle()) { - track.type = "subtitles"; - movie.subtitleTracks.push(track); - } else if (sample_desc.isHint()) { - track.type = "metadata"; - movie.hintTracks.push(track); - } else if (sample_desc.isMetadata()) { - track.type = "metadata"; - movie.metadataTracks.push(track); - } else { - track.type = "metadata"; - movie.otherTracks.push(track); - } - } - } else { - movie.hasMoov = false; - } - movie.mime = ""; - if (movie.hasMoov && movie.tracks) { - if (movie.videoTracks && movie.videoTracks.length > 0) { - movie.mime += 'video/mp4; codecs=\"'; - } else if (movie.audioTracks && movie.audioTracks.length > 0) { - movie.mime += 'audio/mp4; codecs=\"'; - } else { - movie.mime += 'application/mp4; codecs=\"'; - } - for (i = 0; i < movie.tracks.length; i++) { - if (i !== 0) movie.mime += ','; - movie.mime += movie.tracks[i].codec; - } - movie.mime += '\"; profiles=\"'; - movie.mime += this.ftyp.compatible_brands.join(); - movie.mime += '\"'; - } - return movie; - }; - ISOFile.prototype.setNextSeekPositionFromSample = function (sample) { - if (!sample) { - return; - } - if (this.nextSeekPosition) { - this.nextSeekPosition = Math.min(sample.offset + sample.alreadyRead, this.nextSeekPosition); - } else { - this.nextSeekPosition = sample.offset + sample.alreadyRead; - } - }; - ISOFile.prototype.processSamples = function (last) { - var i; - var trak; - if (!this.sampleProcessingStarted) return; - - /* For each track marked for fragmentation, - check if the next sample is there (i.e. if the sample information is known (i.e. moof has arrived) and if it has been downloaded) - and create a fragment with it */ - if (this.isFragmentationInitialized && this.onSegment !== null) { - for (i = 0; i < this.fragmentedTracks.length; i++) { - var fragTrak = this.fragmentedTracks[i]; - trak = fragTrak.trak; - while (trak.nextSample < trak.samples.length && this.sampleProcessingStarted) { - /* The sample information is there (either because the file is not fragmented and this is not the last sample, - or because the file is fragmented and the moof for that sample has been received */ - Log.debug("ISOFile", "Creating media fragment on track #" + fragTrak.id + " for sample " + trak.nextSample); - var result = this.createFragment(fragTrak.id, trak.nextSample, fragTrak.segmentStream); - if (result) { - fragTrak.segmentStream = result; - trak.nextSample++; - } else { - /* The fragment could not be created because the media data is not there (not downloaded), wait for it */ - break; - } - /* A fragment is created by sample, but the segment is the accumulation in the buffer of these fragments. - It is flushed only as requested by the application (nb_samples) to avoid too many callbacks */ - if (trak.nextSample % fragTrak.nb_samples === 0 || last || trak.nextSample >= trak.samples.length) { - Log.info("ISOFile", "Sending fragmented data on track #" + fragTrak.id + " for samples [" + Math.max(0, trak.nextSample - fragTrak.nb_samples) + "," + (trak.nextSample - 1) + "]"); - Log.info("ISOFile", "Sample data size in memory: " + this.getAllocatedSampleDataSize()); - if (this.onSegment) { - this.onSegment(fragTrak.id, fragTrak.user, fragTrak.segmentStream.buffer, trak.nextSample, last || trak.nextSample >= trak.samples.length); - } - /* force the creation of a new buffer */ - fragTrak.segmentStream = null; - if (fragTrak !== this.fragmentedTracks[i]) { - /* make sure we can stop fragmentation if needed */ - break; - } - } - } - } - } - if (this.onSamples !== null) { - /* For each track marked for data export, - check if the next sample is there (i.e. has been downloaded) and send it */ - for (i = 0; i < this.extractedTracks.length; i++) { - var extractTrak = this.extractedTracks[i]; - trak = extractTrak.trak; - while (trak.nextSample < trak.samples.length && this.sampleProcessingStarted) { - Log.debug("ISOFile", "Exporting on track #" + extractTrak.id + " sample #" + trak.nextSample); - var sample = this.getSample(trak, trak.nextSample); - if (sample) { - trak.nextSample++; - extractTrak.samples.push(sample); - } else { - this.setNextSeekPositionFromSample(trak.samples[trak.nextSample]); - break; - } - if (trak.nextSample % extractTrak.nb_samples === 0 || trak.nextSample >= trak.samples.length) { - Log.debug("ISOFile", "Sending samples on track #" + extractTrak.id + " for sample " + trak.nextSample); - if (this.onSamples) { - this.onSamples(extractTrak.id, extractTrak.user, extractTrak.samples); - } - extractTrak.samples = []; - if (extractTrak !== this.extractedTracks[i]) { - /* check if the extraction needs to be stopped */ - break; - } - } - } - } - } - }; - - /* Find and return specific boxes using recursion and early return */ - ISOFile.prototype.getBox = function (type) { - var result = this.getBoxes(type, true); - return result.length ? result[0] : null; - }; - ISOFile.prototype.getBoxes = function (type, returnEarly) { - var result = []; - ISOFile._sweep.call(this, type, result, returnEarly); - return result; - }; - ISOFile._sweep = function (type, result, returnEarly) { - if (this.type && this.type == type) result.push(this); - for (var box in this.boxes) { - if (result.length && returnEarly) return; - ISOFile._sweep.call(this.boxes[box], type, result, returnEarly); - } - }; - ISOFile.prototype.getTrackSamplesInfo = function (track_id) { - var track = this.getTrackById(track_id); - if (track) { - return track.samples; - } else { - return; - } - }; - ISOFile.prototype.getTrackSample = function (track_id, number) { - var track = this.getTrackById(track_id); - var sample = this.getSample(track, number); - return sample; - }; - - /* Called by the application to release the resources associated to samples already forwarded to the application */ - ISOFile.prototype.releaseUsedSamples = function (id, sampleNum) { - var size = 0; - var trak = this.getTrackById(id); - if (!trak.lastValidSample) trak.lastValidSample = 0; - for (var i = trak.lastValidSample; i < sampleNum; i++) { - size += this.releaseSample(trak, i); - } - Log.info("ISOFile", "Track #" + id + " released samples up to " + sampleNum + " (released size: " + size + ", remaining: " + this.samplesDataSize + ")"); - trak.lastValidSample = sampleNum; - }; - ISOFile.prototype.start = function () { - this.sampleProcessingStarted = true; - this.processSamples(false); - }; - ISOFile.prototype.stop = function () { - this.sampleProcessingStarted = false; - }; - - /* Called by the application to flush the remaining samples (e.g. once the download is finished or when no more samples will be added) */ - ISOFile.prototype.flush = function () { - Log.info("ISOFile", "Flushing remaining samples"); - this.updateSampleLists(); - this.processSamples(true); - this.stream.cleanBuffers(); - this.stream.logBufferLevel(true); - }; - - /* Finds the byte offset for a given time on a given track - also returns the time of the previous rap */ - ISOFile.prototype.seekTrack = function (time, useRap, trak) { - var j; - var sample; - var seek_offset = Infinity; - var rap_seek_sample_num = 0; - var seek_sample_num = 0; - var timescale; - if (trak.samples.length === 0) { - Log.info("ISOFile", "No sample in track, cannot seek! Using time " + Log.getDurationString(0, 1) + " and offset: " + 0); - return { - offset: 0, - time: 0 - }; - } - for (j = 0; j < trak.samples.length; j++) { - sample = trak.samples[j]; - if (j === 0) { - seek_sample_num = 0; - timescale = sample.timescale; - } else if (sample.cts > time * sample.timescale) { - seek_sample_num = j - 1; - break; - } - if (useRap && sample.is_sync) { - rap_seek_sample_num = j; - } - } - if (useRap) { - seek_sample_num = rap_seek_sample_num; - } - time = trak.samples[seek_sample_num].cts; - trak.nextSample = seek_sample_num; - while (trak.samples[seek_sample_num].alreadyRead === trak.samples[seek_sample_num].size) { - // No remaining samples to look for, all are downloaded. - if (!trak.samples[seek_sample_num + 1]) { - break; - } - seek_sample_num++; - } - seek_offset = trak.samples[seek_sample_num].offset + trak.samples[seek_sample_num].alreadyRead; - Log.info("ISOFile", "Seeking to " + (useRap ? "RAP" : "") + " sample #" + trak.nextSample + " on track " + trak.tkhd.track_id + ", time " + Log.getDurationString(time, timescale) + " and offset: " + seek_offset); - return { - offset: seek_offset, - time: time / timescale - }; - }; - ISOFile.prototype.getTrackDuration = function (trak) { - var sample; - if (!trak.samples) { - return Infinity; - } - sample = trak.samples[trak.samples.length - 1]; - return (sample.cts + sample.duration) / sample.timescale; - }; - - /* Finds the byte offset in the file corresponding to the given time or to the time of the previous RAP */ - ISOFile.prototype.seek = function (time, useRap) { - var moov = this.moov; - var trak; - var trak_seek_info; - var i; - var seek_info = { - offset: Infinity, - time: Infinity - }; - if (!this.moov) { - throw "Cannot seek: moov not received!"; - } else { - for (i = 0; i < moov.traks.length; i++) { - trak = moov.traks[i]; - if (time > this.getTrackDuration(trak)) { - // skip tracks that already ended - continue; - } - trak_seek_info = this.seekTrack(time, useRap, trak); - if (trak_seek_info.offset < seek_info.offset) { - seek_info.offset = trak_seek_info.offset; - } - if (trak_seek_info.time < seek_info.time) { - seek_info.time = trak_seek_info.time; - } - } - Log.info("ISOFile", "Seeking at time " + Log.getDurationString(seek_info.time, 1) + " needs a buffer with a fileStart position of " + seek_info.offset); - if (seek_info.offset === Infinity) { - /* No sample info, in all tracks, cannot seek */ - seek_info = { - offset: this.nextParsePosition, - time: 0 - }; - } else { - /* check if the seek position is already in some buffer and - in that case return the end of that buffer (or of the last contiguous buffer) */ - /* TODO: Should wait until append operations are done */ - seek_info.offset = this.stream.getEndFilePositionAfter(seek_info.offset); - } - Log.info("ISOFile", "Adjusted seek position (after checking data already in buffer): " + seek_info.offset); - return seek_info; - } - }; - ISOFile.prototype.equal = function (b) { - var box_index = 0; - while (box_index < this.boxes.length && box_index < b.boxes.length) { - var a_box = this.boxes[box_index]; - var b_box = b.boxes[box_index]; - if (!BoxParser.boxEqual(a_box, b_box)) { - return false; - } - box_index++; - } - return true; - }; - { - exports.ISOFile = ISOFile; - } - // file:src/isofile-advanced-parsing.js - /* position in the current buffer of the beginning of the last box parsed */ - ISOFile.prototype.lastBoxStartPosition = 0; - /* indicator if the parsing is stuck in the middle of an mdat box */ - ISOFile.prototype.parsingMdat = null; - /* next file position that the parser needs: - - 0 until the first buffer (i.e. fileStart ===0) has been received - - otherwise, the next box start until the moov box has been parsed - - otherwise, the position of the next sample to fetch - */ - ISOFile.prototype.nextParsePosition = 0; - /* keep mdat data */ - ISOFile.prototype.discardMdatData = false; - ISOFile.prototype.processIncompleteBox = function (ret) { - var box; - var merged; - var found; - - /* we did not have enough bytes in the current buffer to parse the entire box */ - if (ret.type === "mdat") { - /* we had enough bytes to get its type and size and it's an 'mdat' */ - - /* special handling for mdat boxes, since we don't actually need to parse it linearly - we create the box */ - box = new BoxParser[ret.type + "Box"](ret.size); - this.parsingMdat = box; - this.boxes.push(box); - this.mdats.push(box); - box.start = ret.start; - box.hdr_size = ret.hdr_size; - this.stream.addUsedBytes(box.hdr_size); - - /* indicate that the parsing should start from the end of the box */ - this.lastBoxStartPosition = box.start + box.size; - /* let's see if we have the end of the box in the other buffers */ - found = this.stream.seek(box.start + box.size, false, this.discardMdatData); - if (found) { - /* found the end of the box */ - this.parsingMdat = null; - /* let's see if we can parse more in this buffer */ - return true; - } else { - /* 'mdat' end not found in the existing buffers */ - /* determine the next position in the file to start parsing from */ - if (!this.moovStartFound) { - /* moov not find yet, - the file probably has 'mdat' at the beginning, and 'moov' at the end, - indicate that the downloader should not try to download those bytes now */ - this.nextParsePosition = box.start + box.size; - } else { - /* we have the start of the moov box, - the next bytes should try to complete the current 'mdat' */ - this.nextParsePosition = this.stream.findEndContiguousBuf(); - } - /* not much we can do, wait for more buffers to arrive */ - return false; - } - } else { - /* box is incomplete, we may not even know its type */ - if (ret.type === "moov") { - /* the incomplete box is a 'moov' box */ - this.moovStartFound = true; - if (this.mdats.length === 0) { - this.isProgressive = true; - } - } - /* either it's not an mdat box (and we need to parse it, we cannot skip it) - (TODO: we could skip 'free' boxes ...) - or we did not have enough data to parse the type and size of the box, - we try to concatenate the current buffer with the next buffer to restart parsing */ - merged = this.stream.mergeNextBuffer ? this.stream.mergeNextBuffer() : false; - if (merged) { - /* The next buffer was contiguous, the merging succeeded, - we can now continue parsing, - the next best position to parse is at the end of this new buffer */ - this.nextParsePosition = this.stream.getEndPosition(); - return true; - } else { - /* we cannot concatenate existing buffers because they are not contiguous or because there is no additional buffer */ - /* The next best position to parse is still at the end of this old buffer */ - if (!ret.type) { - /* There were not enough bytes in the buffer to parse the box type and length, - the next fetch should retrieve those missing bytes, i.e. the next bytes after this buffer */ - this.nextParsePosition = this.stream.getEndPosition(); - } else { - /* we had enough bytes to parse size and type of the incomplete box - if we haven't found yet the moov box, skip this one and try the next one - if we have found the moov box, let's continue linear parsing */ - if (this.moovStartFound) { - this.nextParsePosition = this.stream.getEndPosition(); - } else { - this.nextParsePosition = this.stream.getPosition() + ret.size; - } - } - return false; - } - } - }; - ISOFile.prototype.hasIncompleteMdat = function () { - return this.parsingMdat !== null; - }; - ISOFile.prototype.processIncompleteMdat = function () { - var box; - var found; - - /* we are in the parsing of an incomplete mdat box */ - box = this.parsingMdat; - found = this.stream.seek(box.start + box.size, false, this.discardMdatData); - if (found) { - Log.debug("ISOFile", "Found 'mdat' end in buffered data"); - /* the end of the mdat has been found */ - this.parsingMdat = null; - /* we can parse more in this buffer */ - return true; - } else { - /* we don't have the end of this mdat yet, - indicate that the next byte to fetch is the end of the buffers we have so far, - return and wait for more buffer to come */ - this.nextParsePosition = this.stream.findEndContiguousBuf(); - return false; - } - }; - ISOFile.prototype.restoreParsePosition = function () { - /* Reposition at the start position of the previous box not entirely parsed */ - return this.stream.seek(this.lastBoxStartPosition, true, this.discardMdatData); - }; - ISOFile.prototype.saveParsePosition = function () { - /* remember the position of the box start in case we need to roll back (if the box is incomplete) */ - this.lastBoxStartPosition = this.stream.getPosition(); - }; - ISOFile.prototype.updateUsedBytes = function (box, ret) { - if (this.stream.addUsedBytes) { - if (box.type === "mdat") { - /* for an mdat box, only its header is considered used, other bytes will be used when sample data is requested */ - this.stream.addUsedBytes(box.hdr_size); - if (this.discardMdatData) { - this.stream.addUsedBytes(box.size - box.hdr_size); - } - } else { - /* for all other boxes, the entire box data is considered used */ - this.stream.addUsedBytes(box.size); - } - } - }; - // file:src/isofile-advanced-creation.js - ISOFile.prototype.add = BoxParser.Box.prototype.add; - ISOFile.prototype.addBox = BoxParser.Box.prototype.addBox; - ISOFile.prototype.init = function (_options) { - var options = _options || {}; - this.add("ftyp").set("major_brand", options.brands && options.brands[0] || "iso4").set("minor_version", 0).set("compatible_brands", options.brands || ["iso4"]); - var moov = this.add("moov"); - moov.add("mvhd").set("timescale", options.timescale || 600).set("rate", options.rate || 1 << 16).set("creation_time", 0).set("modification_time", 0).set("duration", options.duration || 0).set("volume", options.width ? 0 : 0x0100).set("matrix", [1 << 16, 0, 0, 0, 1 << 16, 0, 0, 0, 0x40000000]).set("next_track_id", 1); - moov.add("mvex"); - return this; - }; - ISOFile.prototype.addTrack = function (_options) { - if (!this.moov) { - this.init(_options); - } - var options = _options || {}; - options.width = options.width || 320; - options.height = options.height || 320; - options.id = options.id || this.moov.mvhd.next_track_id; - options.type = options.type || "avc1"; - var trak = this.moov.add("trak"); - this.moov.mvhd.next_track_id = options.id + 1; - trak.add("tkhd").set("flags", BoxParser.TKHD_FLAG_ENABLED | BoxParser.TKHD_FLAG_IN_MOVIE | BoxParser.TKHD_FLAG_IN_PREVIEW).set("creation_time", 0).set("modification_time", 0).set("track_id", options.id).set("duration", options.duration || 0).set("layer", options.layer || 0).set("alternate_group", 0).set("volume", 1).set("matrix", [0, 0, 0, 0, 0, 0, 0, 0, 0]).set("width", options.width << 16).set("height", options.height << 16); - var mdia = trak.add("mdia"); - mdia.add("mdhd").set("creation_time", 0).set("modification_time", 0).set("timescale", options.timescale || 1).set("duration", options.media_duration || 0).set("language", options.language || "und"); - mdia.add("hdlr").set("handler", options.hdlr || "vide").set("name", options.name || "Track created with MP4Box.js"); - mdia.add("elng").set("extended_language", options.language || "fr-FR"); - var minf = mdia.add("minf"); - if (BoxParser[options.type + "SampleEntry"] === undefined) return; - var sample_description_entry = new BoxParser[options.type + "SampleEntry"](); - sample_description_entry.data_reference_index = 1; - var media_type = ""; - for (var mediaType in BoxParser.sampleEntryCodes) { - var codes = BoxParser.sampleEntryCodes[mediaType]; - for (var i = 0; i < codes.length; i++) { - if (codes.indexOf(options.type) > -1) { - media_type = mediaType; - break; - } - } - } - switch (media_type) { - case "Visual": - minf.add("vmhd").set("graphicsmode", 0).set("opcolor", [0, 0, 0]); - sample_description_entry.set("width", options.width).set("height", options.height).set("horizresolution", 0x48 << 16).set("vertresolution", 0x48 << 16).set("frame_count", 1).set("compressorname", options.type + " Compressor").set("depth", 0x18); - if (options.avcDecoderConfigRecord) { - var avcC = new BoxParser.avcCBox(); - avcC.parse(new MP4BoxStream(options.avcDecoderConfigRecord)); - sample_description_entry.addBox(avcC); - } else if (options.hevcDecoderConfigRecord) { - var hvcC = new BoxParser.hvcCBox(); - hvcC.parse(new MP4BoxStream(options.hevcDecoderConfigRecord)); - sample_description_entry.addBox(hvcC); - } - break; - case "Audio": - minf.add("smhd").set("balance", options.balance || 0); - sample_description_entry.set("channel_count", options.channel_count || 2).set("samplesize", options.samplesize || 16).set("samplerate", options.samplerate || 1 << 16); - break; - case "Hint": - minf.add("hmhd"); // TODO: add properties - break; - case "Subtitle": - minf.add("sthd"); - switch (options.type) { - case "stpp": - sample_description_entry.set("namespace", options.namespace || "nonamespace").set("schema_location", options.schema_location || "").set("auxiliary_mime_types", options.auxiliary_mime_types || ""); - break; - } - break; - case "Metadata": - minf.add("nmhd"); - break; - case "System": - minf.add("nmhd"); - break; - default: - minf.add("nmhd"); - break; - } - if (options.description) { - sample_description_entry.addBox(options.description); - } - if (options.description_boxes) { - options.description_boxes.forEach(function (b) { - sample_description_entry.addBox(b); - }); - } - minf.add("dinf").add("dref").addEntry(new BoxParser["url Box"]().set("flags", 0x1)); - var stbl = minf.add("stbl"); - stbl.add("stsd").addEntry(sample_description_entry); - stbl.add("stts").set("sample_counts", []).set("sample_deltas", []); - stbl.add("stsc").set("first_chunk", []).set("samples_per_chunk", []).set("sample_description_index", []); - stbl.add("stco").set("chunk_offsets", []); - stbl.add("stsz").set("sample_sizes", []); - this.moov.mvex.add("trex").set("track_id", options.id).set("default_sample_description_index", options.default_sample_description_index || 1).set("default_sample_duration", options.default_sample_duration || 0).set("default_sample_size", options.default_sample_size || 0).set("default_sample_flags", options.default_sample_flags || 0); - this.buildTrakSampleLists(trak); - return options.id; - }; - BoxParser.Box.prototype.computeSize = function (stream_) { - var stream = stream_ || new DataStream(); - stream.endianness = DataStream.BIG_ENDIAN; - this.write(stream); - }; - ISOFile.prototype.addSample = function (track_id, data, _options) { - var options = _options || {}; - var sample = {}; - var trak = this.getTrackById(track_id); - if (trak === null) return; - sample.number = trak.samples.length; - sample.track_id = trak.tkhd.track_id; - sample.timescale = trak.mdia.mdhd.timescale; - sample.description_index = options.sample_description_index ? options.sample_description_index - 1 : 0; - sample.description = trak.mdia.minf.stbl.stsd.entries[sample.description_index]; - sample.data = data; - sample.size = data.byteLength; - sample.alreadyRead = sample.size; - sample.duration = options.duration || 1; - sample.cts = options.cts || 0; - sample.dts = options.dts || 0; - sample.is_sync = options.is_sync || false; - sample.is_leading = options.is_leading || 0; - sample.depends_on = options.depends_on || 0; - sample.is_depended_on = options.is_depended_on || 0; - sample.has_redundancy = options.has_redundancy || 0; - sample.degradation_priority = options.degradation_priority || 0; - sample.offset = 0; - sample.subsamples = options.subsamples; - trak.samples.push(sample); - trak.samples_size += sample.size; - trak.samples_duration += sample.duration; - if (trak.first_dts === undefined) { - trak.first_dts = options.dts; - } - this.processSamples(); - var moof = this.createSingleSampleMoof(sample); - this.addBox(moof); - moof.computeSize(); - /* adjusting the data_offset now that the moof size is known*/ - moof.trafs[0].truns[0].data_offset = moof.size + 8; //8 is mdat header - this.add("mdat").data = new Uint8Array(data); - return sample; - }; - ISOFile.prototype.createSingleSampleMoof = function (sample) { - var sample_flags = 0; - if (sample.is_sync) sample_flags = 1 << 25; // sample_depends_on_none (I picture) - else sample_flags = 1 << 16; // non-sync - - var moof = new BoxParser.moofBox(); - moof.add("mfhd").set("sequence_number", this.nextMoofNumber); - this.nextMoofNumber++; - var traf = moof.add("traf"); - var trak = this.getTrackById(sample.track_id); - traf.add("tfhd").set("track_id", sample.track_id).set("flags", BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF); - traf.add("tfdt").set("baseMediaDecodeTime", sample.dts - (trak.first_dts || 0)); - traf.add("trun").set("flags", BoxParser.TRUN_FLAGS_DATA_OFFSET | BoxParser.TRUN_FLAGS_DURATION | BoxParser.TRUN_FLAGS_SIZE | BoxParser.TRUN_FLAGS_FLAGS | BoxParser.TRUN_FLAGS_CTS_OFFSET).set("data_offset", 0).set("first_sample_flags", 0).set("sample_count", 1).set("sample_duration", [sample.duration]).set("sample_size", [sample.size]).set("sample_flags", [sample_flags]).set("sample_composition_time_offset", [sample.cts - sample.dts]); - return moof; - }; - - // file:src/isofile-sample-processing.js - /* Index of the last moof box received */ - ISOFile.prototype.lastMoofIndex = 0; - - /* size of the buffers allocated for samples */ - ISOFile.prototype.samplesDataSize = 0; - - /* Resets all sample tables */ - ISOFile.prototype.resetTables = function () { - var i; - var trak, stco, stsc, stsz, stts, ctts, stss; - this.initial_duration = this.moov.mvhd.duration; - this.moov.mvhd.duration = 0; - for (i = 0; i < this.moov.traks.length; i++) { - trak = this.moov.traks[i]; - trak.tkhd.duration = 0; - trak.mdia.mdhd.duration = 0; - stco = trak.mdia.minf.stbl.stco || trak.mdia.minf.stbl.co64; - stco.chunk_offsets = []; - stsc = trak.mdia.minf.stbl.stsc; - stsc.first_chunk = []; - stsc.samples_per_chunk = []; - stsc.sample_description_index = []; - stsz = trak.mdia.minf.stbl.stsz || trak.mdia.minf.stbl.stz2; - stsz.sample_sizes = []; - stts = trak.mdia.minf.stbl.stts; - stts.sample_counts = []; - stts.sample_deltas = []; - ctts = trak.mdia.minf.stbl.ctts; - if (ctts) { - ctts.sample_counts = []; - ctts.sample_offsets = []; - } - stss = trak.mdia.minf.stbl.stss; - var k = trak.mdia.minf.stbl.boxes.indexOf(stss); - if (k != -1) trak.mdia.minf.stbl.boxes[k] = null; - } - }; - ISOFile.initSampleGroups = function (trak, traf, sbgps, trak_sgpds, traf_sgpds) { - var l; - var k; - var sample_group_info; - var sample_group_key; - function SampleGroupInfo(_type, _parameter, _sbgp) { - this.grouping_type = _type; - this.grouping_type_parameter = _parameter; - this.sbgp = _sbgp; - this.last_sample_in_run = -1; - this.entry_index = -1; - } - if (traf) { - traf.sample_groups_info = []; - } - if (!trak.sample_groups_info) { - trak.sample_groups_info = []; - } - for (k = 0; k < sbgps.length; k++) { - sample_group_key = sbgps[k].grouping_type + "/" + sbgps[k].grouping_type_parameter; - sample_group_info = new SampleGroupInfo(sbgps[k].grouping_type, sbgps[k].grouping_type_parameter, sbgps[k]); - if (traf) { - traf.sample_groups_info[sample_group_key] = sample_group_info; - } - if (!trak.sample_groups_info[sample_group_key]) { - trak.sample_groups_info[sample_group_key] = sample_group_info; - } - for (l = 0; l < trak_sgpds.length; l++) { - if (trak_sgpds[l].grouping_type === sbgps[k].grouping_type) { - sample_group_info.description = trak_sgpds[l]; - sample_group_info.description.used = true; - } - } - if (traf_sgpds) { - for (l = 0; l < traf_sgpds.length; l++) { - if (traf_sgpds[l].grouping_type === sbgps[k].grouping_type) { - sample_group_info.fragment_description = traf_sgpds[l]; - sample_group_info.fragment_description.used = true; - sample_group_info.is_fragment = true; - } - } - } - } - if (!traf) { - for (k = 0; k < trak_sgpds.length; k++) { - if (!trak_sgpds[k].used && trak_sgpds[k].version >= 2) { - sample_group_key = trak_sgpds[k].grouping_type + "/0"; - sample_group_info = new SampleGroupInfo(trak_sgpds[k].grouping_type, 0); - if (!trak.sample_groups_info[sample_group_key]) { - trak.sample_groups_info[sample_group_key] = sample_group_info; - } - } - } - } else { - if (traf_sgpds) { - for (k = 0; k < traf_sgpds.length; k++) { - if (!traf_sgpds[k].used && traf_sgpds[k].version >= 2) { - sample_group_key = traf_sgpds[k].grouping_type + "/0"; - sample_group_info = new SampleGroupInfo(traf_sgpds[k].grouping_type, 0); - sample_group_info.is_fragment = true; - if (!traf.sample_groups_info[sample_group_key]) { - traf.sample_groups_info[sample_group_key] = sample_group_info; - } - } - } - } - } - }; - ISOFile.setSampleGroupProperties = function (trak, sample, sample_number, sample_groups_info) { - var k; - var index; - sample.sample_groups = []; - for (k in sample_groups_info) { - sample.sample_groups[k] = {}; - sample.sample_groups[k].grouping_type = sample_groups_info[k].grouping_type; - sample.sample_groups[k].grouping_type_parameter = sample_groups_info[k].grouping_type_parameter; - if (sample_number >= sample_groups_info[k].last_sample_in_run) { - if (sample_groups_info[k].last_sample_in_run < 0) { - sample_groups_info[k].last_sample_in_run = 0; - } - sample_groups_info[k].entry_index++; - if (sample_groups_info[k].entry_index <= sample_groups_info[k].sbgp.entries.length - 1) { - sample_groups_info[k].last_sample_in_run += sample_groups_info[k].sbgp.entries[sample_groups_info[k].entry_index].sample_count; - } - } - if (sample_groups_info[k].entry_index <= sample_groups_info[k].sbgp.entries.length - 1) { - sample.sample_groups[k].group_description_index = sample_groups_info[k].sbgp.entries[sample_groups_info[k].entry_index].group_description_index; - } else { - sample.sample_groups[k].group_description_index = -1; // special value for not defined - } - if (sample.sample_groups[k].group_description_index !== 0) { - var description; - if (sample_groups_info[k].fragment_description) { - description = sample_groups_info[k].fragment_description; - } else { - description = sample_groups_info[k].description; - } - if (sample.sample_groups[k].group_description_index > 0) { - if (sample.sample_groups[k].group_description_index > 65535) { - index = (sample.sample_groups[k].group_description_index >> 16) - 1; - } else { - index = sample.sample_groups[k].group_description_index - 1; - } - if (description && index >= 0) { - sample.sample_groups[k].description = description.entries[index]; - } - } else { - if (description && description.version >= 2) { - if (description.default_group_description_index > 0) { - sample.sample_groups[k].description = description.entries[description.default_group_description_index - 1]; - } - } - } - } - } - }; - ISOFile.process_sdtp = function (sdtp, sample, number) { - if (!sample) { - return; - } - if (sdtp) { - sample.is_leading = sdtp.is_leading[number]; - sample.depends_on = sdtp.sample_depends_on[number]; - sample.is_depended_on = sdtp.sample_is_depended_on[number]; - sample.has_redundancy = sdtp.sample_has_redundancy[number]; - } else { - sample.is_leading = 0; - sample.depends_on = 0; - sample.is_depended_on = 0; - sample.has_redundancy = 0; - } - }; - - /* Build initial sample list from sample tables */ - ISOFile.prototype.buildSampleLists = function () { - var i; - var trak; - for (i = 0; i < this.moov.traks.length; i++) { - trak = this.moov.traks[i]; - this.buildTrakSampleLists(trak); - } - }; - ISOFile.prototype.buildTrakSampleLists = function (trak) { - var j; - var stco, stsc, stsz, stts, ctts, stss, stsd, subs, sbgps, sgpds, stdp; - var chunk_run_index, chunk_index, last_chunk_in_run, offset_in_chunk, last_sample_in_chunk; - var last_sample_in_stts_run, stts_run_index, last_sample_in_ctts_run, ctts_run_index, last_stss_index, subs_entry_index, last_subs_sample_index; - trak.samples = []; - trak.samples_duration = 0; - trak.samples_size = 0; - stco = trak.mdia.minf.stbl.stco || trak.mdia.minf.stbl.co64; - stsc = trak.mdia.minf.stbl.stsc; - stsz = trak.mdia.minf.stbl.stsz || trak.mdia.minf.stbl.stz2; - stts = trak.mdia.minf.stbl.stts; - ctts = trak.mdia.minf.stbl.ctts; - stss = trak.mdia.minf.stbl.stss; - stsd = trak.mdia.minf.stbl.stsd; - subs = trak.mdia.minf.stbl.subs; - stdp = trak.mdia.minf.stbl.stdp; - sbgps = trak.mdia.minf.stbl.sbgps; - sgpds = trak.mdia.minf.stbl.sgpds; - last_sample_in_stts_run = -1; - stts_run_index = -1; - last_sample_in_ctts_run = -1; - ctts_run_index = -1; - last_stss_index = 0; - subs_entry_index = 0; - last_subs_sample_index = 0; - ISOFile.initSampleGroups(trak, null, sbgps, sgpds); - if (typeof stsz === "undefined") { - return; - } - - /* we build the samples one by one and compute their properties */ - for (j = 0; j < stsz.sample_sizes.length; j++) { - var sample = {}; - sample.number = j; - sample.track_id = trak.tkhd.track_id; - sample.timescale = trak.mdia.mdhd.timescale; - sample.alreadyRead = 0; - trak.samples[j] = sample; - /* size can be known directly */ - sample.size = stsz.sample_sizes[j]; - trak.samples_size += sample.size; - /* computing chunk-based properties (offset, sample description index)*/ - if (j === 0) { - chunk_index = 1; /* the first sample is in the first chunk (chunk indexes are 1-based) */ - chunk_run_index = 0; /* the first chunk is the first entry in the first_chunk table */ - sample.chunk_index = chunk_index; - sample.chunk_run_index = chunk_run_index; - last_sample_in_chunk = stsc.samples_per_chunk[chunk_run_index]; - offset_in_chunk = 0; - - /* Is there another entry in the first_chunk table ? */ - if (chunk_run_index + 1 < stsc.first_chunk.length) { - /* The last chunk in the run is the chunk before the next first chunk */ - last_chunk_in_run = stsc.first_chunk[chunk_run_index + 1] - 1; - } else { - /* There is only one entry in the table, it is valid for all future chunks*/ - last_chunk_in_run = Infinity; - } - } else { - if (j < last_sample_in_chunk) { - /* the sample is still in the current chunk */ - sample.chunk_index = chunk_index; - sample.chunk_run_index = chunk_run_index; - } else { - /* the sample is in the next chunk */ - chunk_index++; - sample.chunk_index = chunk_index; - /* reset the accumulated offset in the chunk */ - offset_in_chunk = 0; - if (chunk_index <= last_chunk_in_run) ; else { - chunk_run_index++; - /* Is there another entry in the first_chunk table ? */ - if (chunk_run_index + 1 < stsc.first_chunk.length) { - /* The last chunk in the run is the chunk before the next first chunk */ - last_chunk_in_run = stsc.first_chunk[chunk_run_index + 1] - 1; - } else { - /* There is only one entry in the table, it is valid for all future chunks*/ - last_chunk_in_run = Infinity; - } - } - sample.chunk_run_index = chunk_run_index; - last_sample_in_chunk += stsc.samples_per_chunk[chunk_run_index]; - } - } - sample.description_index = stsc.sample_description_index[sample.chunk_run_index] - 1; - sample.description = stsd.entries[sample.description_index]; - sample.offset = stco.chunk_offsets[sample.chunk_index - 1] + offset_in_chunk; /* chunk indexes are 1-based */ - offset_in_chunk += sample.size; - - /* setting dts, cts, duration and rap flags */ - if (j > last_sample_in_stts_run) { - stts_run_index++; - if (last_sample_in_stts_run < 0) { - last_sample_in_stts_run = 0; - } - last_sample_in_stts_run += stts.sample_counts[stts_run_index]; - } - if (j > 0) { - trak.samples[j - 1].duration = stts.sample_deltas[stts_run_index]; - trak.samples_duration += trak.samples[j - 1].duration; - sample.dts = trak.samples[j - 1].dts + trak.samples[j - 1].duration; - } else { - sample.dts = 0; - } - if (ctts) { - if (j >= last_sample_in_ctts_run) { - ctts_run_index++; - if (last_sample_in_ctts_run < 0) { - last_sample_in_ctts_run = 0; - } - last_sample_in_ctts_run += ctts.sample_counts[ctts_run_index]; - } - sample.cts = trak.samples[j].dts + ctts.sample_offsets[ctts_run_index]; - } else { - sample.cts = sample.dts; - } - if (stss) { - if (j == stss.sample_numbers[last_stss_index] - 1) { - // sample numbers are 1-based - sample.is_sync = true; - last_stss_index++; - } else { - sample.is_sync = false; - sample.degradation_priority = 0; - } - if (subs) { - if (subs.entries[subs_entry_index].sample_delta + last_subs_sample_index == j + 1) { - sample.subsamples = subs.entries[subs_entry_index].subsamples; - last_subs_sample_index += subs.entries[subs_entry_index].sample_delta; - subs_entry_index++; - } - } - } else { - sample.is_sync = true; - } - ISOFile.process_sdtp(trak.mdia.minf.stbl.sdtp, sample, sample.number); - if (stdp) { - sample.degradation_priority = stdp.priority[j]; - } else { - sample.degradation_priority = 0; - } - if (subs) { - if (subs.entries[subs_entry_index].sample_delta + last_subs_sample_index == j) { - sample.subsamples = subs.entries[subs_entry_index].subsamples; - last_subs_sample_index += subs.entries[subs_entry_index].sample_delta; - } - } - if (sbgps.length > 0 || sgpds.length > 0) { - ISOFile.setSampleGroupProperties(trak, sample, j, trak.sample_groups_info); - } - } - if (j > 0) { - trak.samples[j - 1].duration = Math.max(trak.mdia.mdhd.duration - trak.samples[j - 1].dts, 0); - trak.samples_duration += trak.samples[j - 1].duration; - } - }; - - /* Update sample list when new 'moof' boxes are received */ - ISOFile.prototype.updateSampleLists = function () { - var i, j, k; - var default_sample_description_index, default_sample_duration, default_sample_size, default_sample_flags; - var last_run_position; - var box, moof, traf, trak, trex; - var sample; - var sample_flags; - if (this.moov === undefined) { - return; - } - /* if the input file is fragmented and fetched in multiple downloads, we need to update the list of samples */ - while (this.lastMoofIndex < this.moofs.length) { - box = this.moofs[this.lastMoofIndex]; - this.lastMoofIndex++; - if (box.type == "moof") { - moof = box; - for (i = 0; i < moof.trafs.length; i++) { - traf = moof.trafs[i]; - trak = this.getTrackById(traf.tfhd.track_id); - trex = this.getTrexById(traf.tfhd.track_id); - if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_DESC) { - default_sample_description_index = traf.tfhd.default_sample_description_index; - } else { - default_sample_description_index = trex ? trex.default_sample_description_index : 1; - } - if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_DUR) { - default_sample_duration = traf.tfhd.default_sample_duration; - } else { - default_sample_duration = trex ? trex.default_sample_duration : 0; - } - if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_SIZE) { - default_sample_size = traf.tfhd.default_sample_size; - } else { - default_sample_size = trex ? trex.default_sample_size : 0; - } - if (traf.tfhd.flags & BoxParser.TFHD_FLAG_SAMPLE_FLAGS) { - default_sample_flags = traf.tfhd.default_sample_flags; - } else { - default_sample_flags = trex ? trex.default_sample_flags : 0; - } - traf.sample_number = 0; - /* process sample groups */ - if (traf.sbgps.length > 0) { - ISOFile.initSampleGroups(trak, traf, traf.sbgps, trak.mdia.minf.stbl.sgpds, traf.sgpds); - } - for (j = 0; j < traf.truns.length; j++) { - var trun = traf.truns[j]; - for (k = 0; k < trun.sample_count; k++) { - sample = {}; - sample.moof_number = this.lastMoofIndex; - sample.number_in_traf = traf.sample_number; - traf.sample_number++; - sample.number = trak.samples.length; - traf.first_sample_index = trak.samples.length; - trak.samples.push(sample); - sample.track_id = trak.tkhd.track_id; - sample.timescale = trak.mdia.mdhd.timescale; - sample.description_index = default_sample_description_index - 1; - sample.description = trak.mdia.minf.stbl.stsd.entries[sample.description_index]; - sample.size = default_sample_size; - if (trun.flags & BoxParser.TRUN_FLAGS_SIZE) { - sample.size = trun.sample_size[k]; - } - trak.samples_size += sample.size; - sample.duration = default_sample_duration; - if (trun.flags & BoxParser.TRUN_FLAGS_DURATION) { - sample.duration = trun.sample_duration[k]; - } - trak.samples_duration += sample.duration; - if (trak.first_traf_merged || k > 0) { - sample.dts = trak.samples[trak.samples.length - 2].dts + trak.samples[trak.samples.length - 2].duration; - } else { - if (traf.tfdt) { - sample.dts = traf.tfdt.baseMediaDecodeTime; - } else { - sample.dts = 0; - } - trak.first_traf_merged = true; - } - sample.cts = sample.dts; - if (trun.flags & BoxParser.TRUN_FLAGS_CTS_OFFSET) { - sample.cts = sample.dts + trun.sample_composition_time_offset[k]; - } - sample_flags = default_sample_flags; - if (trun.flags & BoxParser.TRUN_FLAGS_FLAGS) { - sample_flags = trun.sample_flags[k]; - } else if (k === 0 && trun.flags & BoxParser.TRUN_FLAGS_FIRST_FLAG) { - sample_flags = trun.first_sample_flags; - } - sample.is_sync = sample_flags >> 16 & 0x1 ? false : true; - sample.is_leading = sample_flags >> 26 & 0x3; - sample.depends_on = sample_flags >> 24 & 0x3; - sample.is_depended_on = sample_flags >> 22 & 0x3; - sample.has_redundancy = sample_flags >> 20 & 0x3; - sample.degradation_priority = sample_flags & 0xFFFF; - //ISOFile.process_sdtp(traf.sdtp, sample, sample.number_in_traf); - var bdop = traf.tfhd.flags & BoxParser.TFHD_FLAG_BASE_DATA_OFFSET ? true : false; - var dbim = traf.tfhd.flags & BoxParser.TFHD_FLAG_DEFAULT_BASE_IS_MOOF ? true : false; - var dop = trun.flags & BoxParser.TRUN_FLAGS_DATA_OFFSET ? true : false; - var bdo = 0; - if (!bdop) { - if (!dbim) { - if (j === 0) { - // the first track in the movie fragment - bdo = moof.start; // the position of the first byte of the enclosing Movie Fragment Box - } else { - bdo = last_run_position; // end of the data defined by the preceding *track* (irrespective of the track id) fragment in the moof - } - } else { - bdo = moof.start; - } - } else { - bdo = traf.tfhd.base_data_offset; - } - if (j === 0 && k === 0) { - if (dop) { - sample.offset = bdo + trun.data_offset; // If the data-offset is present, it is relative to the base-data-offset established in the track fragment header - } else { - sample.offset = bdo; // the data for this run starts the base-data-offset defined by the track fragment header - } - } else { - sample.offset = last_run_position; // this run starts immediately after the data of the previous run - } - last_run_position = sample.offset + sample.size; - if (traf.sbgps.length > 0 || traf.sgpds.length > 0 || trak.mdia.minf.stbl.sbgps.length > 0 || trak.mdia.minf.stbl.sgpds.length > 0) { - ISOFile.setSampleGroupProperties(trak, sample, sample.number_in_traf, traf.sample_groups_info); - } - } - } - if (traf.subs) { - trak.has_fragment_subsamples = true; - var sample_index = traf.first_sample_index; - for (j = 0; j < traf.subs.entries.length; j++) { - sample_index += traf.subs.entries[j].sample_delta; - sample = trak.samples[sample_index - 1]; - sample.subsamples = traf.subs.entries[j].subsamples; - } - } - } - } - } - }; - - /* Try to get sample data for a given sample: - returns null if not found - returns the same sample if already requested - */ - ISOFile.prototype.getSample = function (trak, sampleNum) { - var buffer; - var sample = trak.samples[sampleNum]; - if (!this.moov) { - return null; - } - if (!sample.data) { - /* Not yet fetched */ - sample.data = new Uint8Array(sample.size); - sample.alreadyRead = 0; - this.samplesDataSize += sample.size; - Log.debug("ISOFile", "Allocating sample #" + sampleNum + " on track #" + trak.tkhd.track_id + " of size " + sample.size + " (total: " + this.samplesDataSize + ")"); - } else if (sample.alreadyRead == sample.size) { - /* Already fetched entirely */ - return sample; - } - - /* The sample has only been partially fetched, we need to check in all buffers */ - while (true) { - var index = this.stream.findPosition(true, sample.offset + sample.alreadyRead, false); - if (index > -1) { - buffer = this.stream.buffers[index]; - var lengthAfterStart = buffer.byteLength - (sample.offset + sample.alreadyRead - buffer.fileStart); - if (sample.size - sample.alreadyRead <= lengthAfterStart) { - /* the (rest of the) sample is entirely contained in this buffer */ - - Log.debug("ISOFile", "Getting sample #" + sampleNum + " data (alreadyRead: " + sample.alreadyRead + " offset: " + (sample.offset + sample.alreadyRead - buffer.fileStart) + " read size: " + (sample.size - sample.alreadyRead) + " full size: " + sample.size + ")"); - DataStream.memcpy(sample.data.buffer, sample.alreadyRead, buffer, sample.offset + sample.alreadyRead - buffer.fileStart, sample.size - sample.alreadyRead); - - /* update the number of bytes used in this buffer and check if it needs to be removed */ - buffer.usedBytes += sample.size - sample.alreadyRead; - this.stream.logBufferLevel(); - sample.alreadyRead = sample.size; - return sample; - } else { - /* the sample does not end in this buffer */ - - if (lengthAfterStart === 0) return null; - Log.debug("ISOFile", "Getting sample #" + sampleNum + " partial data (alreadyRead: " + sample.alreadyRead + " offset: " + (sample.offset + sample.alreadyRead - buffer.fileStart) + " read size: " + lengthAfterStart + " full size: " + sample.size + ")"); - DataStream.memcpy(sample.data.buffer, sample.alreadyRead, buffer, sample.offset + sample.alreadyRead - buffer.fileStart, lengthAfterStart); - sample.alreadyRead += lengthAfterStart; - - /* update the number of bytes used in this buffer and check if it needs to be removed */ - buffer.usedBytes += lengthAfterStart; - this.stream.logBufferLevel(); - - /* keep looking in the next buffer */ - } - } else { - return null; - } - } - }; - - /* Release the memory used to store the data of the sample */ - ISOFile.prototype.releaseSample = function (trak, sampleNum) { - var sample = trak.samples[sampleNum]; - if (sample.data) { - this.samplesDataSize -= sample.size; - sample.data = null; - sample.alreadyRead = 0; - return sample.size; - } else { - return 0; - } - }; - ISOFile.prototype.getAllocatedSampleDataSize = function () { - return this.samplesDataSize; - }; - - /* Builds the MIME Type 'codecs' sub-parameters for the whole file */ - ISOFile.prototype.getCodecs = function () { - var i; - var codecs = ""; - for (i = 0; i < this.moov.traks.length; i++) { - var trak = this.moov.traks[i]; - if (i > 0) { - codecs += ","; - } - codecs += trak.mdia.minf.stbl.stsd.entries[0].getCodec(); - } - return codecs; - }; - - /* Helper function */ - ISOFile.prototype.getTrexById = function (id) { - var i; - if (!this.moov || !this.moov.mvex) return null; - for (i = 0; i < this.moov.mvex.trexs.length; i++) { - var trex = this.moov.mvex.trexs[i]; - if (trex.track_id == id) return trex; - } - return null; - }; - - /* Helper function */ - ISOFile.prototype.getTrackById = function (id) { - if (this.moov === undefined) { - return null; - } - for (var j = 0; j < this.moov.traks.length; j++) { - var trak = this.moov.traks[j]; - if (trak.tkhd.track_id == id) return trak; - } - return null; - }; - // file:src/isofile-item-processing.js - /* size of the buffers allocated for samples */ - ISOFile.prototype.itemsDataSize = 0; - ISOFile.prototype.flattenItemInfo = function () { - var items = this.items; - var entity_groups = this.entity_groups; - var i, j; - var item; - var meta = this.meta; - if (meta === null || meta === undefined) return; - if (meta.hdlr === undefined) return; - if (meta.iinf === undefined) return; - for (i = 0; i < meta.iinf.item_infos.length; i++) { - item = {}; - item.id = meta.iinf.item_infos[i].item_ID; - items[item.id] = item; - item.ref_to = []; - item.name = meta.iinf.item_infos[i].item_name; - if (meta.iinf.item_infos[i].protection_index > 0) { - item.protection = meta.ipro.protections[meta.iinf.item_infos[i].protection_index - 1]; - } - if (meta.iinf.item_infos[i].item_type) { - item.type = meta.iinf.item_infos[i].item_type; - } else { - item.type = "mime"; - } - item.content_type = meta.iinf.item_infos[i].content_type; - item.content_encoding = meta.iinf.item_infos[i].content_encoding; - } - if (meta.grpl) { - for (i = 0; i < meta.grpl.boxes.length; i++) { - entity_group = {}; - entity_group.id = meta.grpl.boxes[i].group_id; - entity_group.entity_ids = meta.grpl.boxes[i].entity_ids; - entity_group.type = meta.grpl.boxes[i].type; - entity_groups[entity_group.id] = entity_group; - } - } - if (meta.iloc) { - for (i = 0; i < meta.iloc.items.length; i++) { - var itemloc = meta.iloc.items[i]; - item = items[itemloc.item_ID]; - if (itemloc.data_reference_index !== 0) { - Log.warn("Item storage with reference to other files: not supported"); - item.source = meta.dinf.boxes[itemloc.data_reference_index - 1]; - } - switch (itemloc.construction_method) { - case 0: - // offset into the file referenced by the data reference index - break; - case 1: - // offset into the idat box of this meta box - break; - case 2: - // offset into another item - Log.warn("Item storage with construction_method : not supported"); - break; - } - item.extents = []; - item.size = 0; - for (j = 0; j < itemloc.extents.length; j++) { - item.extents[j] = {}; - item.extents[j].offset = itemloc.extents[j].extent_offset + itemloc.base_offset; - if (itemloc.construction_method == 1) { - item.extents[j].offset += meta.idat.start + meta.idat.hdr_size; - } - item.extents[j].length = itemloc.extents[j].extent_length; - item.extents[j].alreadyRead = 0; - item.size += item.extents[j].length; - } - } - } - if (meta.pitm) { - items[meta.pitm.item_id].primary = true; - } - if (meta.iref) { - for (i = 0; i < meta.iref.references.length; i++) { - var ref = meta.iref.references[i]; - for (j = 0; j < ref.references.length; j++) { - items[ref.from_item_ID].ref_to.push({ - type: ref.type, - id: ref.references[j] - }); - } - } - } - if (meta.iprp) { - for (var k = 0; k < meta.iprp.ipmas.length; k++) { - var ipma = meta.iprp.ipmas[k]; - for (i = 0; i < ipma.associations.length; i++) { - var association = ipma.associations[i]; - item = items[association.id]; - if (!item) { - item = entity_groups[association.id]; - } - if (item) { - if (item.properties === undefined) { - item.properties = {}; - item.properties.boxes = []; - } - for (j = 0; j < association.props.length; j++) { - var propEntry = association.props[j]; - if (propEntry.property_index > 0 && propEntry.property_index - 1 < meta.iprp.ipco.boxes.length) { - var propbox = meta.iprp.ipco.boxes[propEntry.property_index - 1]; - item.properties[propbox.type] = propbox; - item.properties.boxes.push(propbox); - } - } - } - } - } - } - }; - ISOFile.prototype.getItem = function (item_id) { - var buffer; - var item; - if (!this.meta) { - return null; - } - item = this.items[item_id]; - if (!item.data && item.size) { - /* Not yet fetched */ - item.data = new Uint8Array(item.size); - item.alreadyRead = 0; - this.itemsDataSize += item.size; - Log.debug("ISOFile", "Allocating item #" + item_id + " of size " + item.size + " (total: " + this.itemsDataSize + ")"); - } else if (item.alreadyRead === item.size) { - /* Already fetched entirely */ - return item; - } - - /* The item has only been partially fetched, we need to check in all buffers to find the remaining extents*/ - - for (var i = 0; i < item.extents.length; i++) { - var extent = item.extents[i]; - if (extent.alreadyRead === extent.length) { - continue; - } else { - var index = this.stream.findPosition(true, extent.offset + extent.alreadyRead, false); - if (index > -1) { - buffer = this.stream.buffers[index]; - var lengthAfterStart = buffer.byteLength - (extent.offset + extent.alreadyRead - buffer.fileStart); - if (extent.length - extent.alreadyRead <= lengthAfterStart) { - /* the (rest of the) extent is entirely contained in this buffer */ - - Log.debug("ISOFile", "Getting item #" + item_id + " extent #" + i + " data (alreadyRead: " + extent.alreadyRead + " offset: " + (extent.offset + extent.alreadyRead - buffer.fileStart) + " read size: " + (extent.length - extent.alreadyRead) + " full extent size: " + extent.length + " full item size: " + item.size + ")"); - DataStream.memcpy(item.data.buffer, item.alreadyRead, buffer, extent.offset + extent.alreadyRead - buffer.fileStart, extent.length - extent.alreadyRead); - - /* update the number of bytes used in this buffer and check if it needs to be removed */ - buffer.usedBytes += extent.length - extent.alreadyRead; - this.stream.logBufferLevel(); - item.alreadyRead += extent.length - extent.alreadyRead; - extent.alreadyRead = extent.length; - } else { - /* the sample does not end in this buffer */ - - Log.debug("ISOFile", "Getting item #" + item_id + " extent #" + i + " partial data (alreadyRead: " + extent.alreadyRead + " offset: " + (extent.offset + extent.alreadyRead - buffer.fileStart) + " read size: " + lengthAfterStart + " full extent size: " + extent.length + " full item size: " + item.size + ")"); - DataStream.memcpy(item.data.buffer, item.alreadyRead, buffer, extent.offset + extent.alreadyRead - buffer.fileStart, lengthAfterStart); - extent.alreadyRead += lengthAfterStart; - item.alreadyRead += lengthAfterStart; - - /* update the number of bytes used in this buffer and check if it needs to be removed */ - buffer.usedBytes += lengthAfterStart; - this.stream.logBufferLevel(); - return null; - } - } else { - return null; - } - } - } - if (item.alreadyRead === item.size) { - /* fetched entirely */ - return item; - } else { - return null; - } - }; - - /* Release the memory used to store the data of the item */ - ISOFile.prototype.releaseItem = function (item_id) { - var item = this.items[item_id]; - if (item.data) { - this.itemsDataSize -= item.size; - item.data = null; - item.alreadyRead = 0; - for (var i = 0; i < item.extents.length; i++) { - var extent = item.extents[i]; - extent.alreadyRead = 0; - } - return item.size; - } else { - return 0; - } - }; - ISOFile.prototype.processItems = function (callback) { - for (var i in this.items) { - var item = this.items[i]; - this.getItem(item.id); - if (callback && !item.sent) { - callback(item); - item.sent = true; - item.data = null; - } - } - }; - ISOFile.prototype.hasItem = function (name) { - for (var i in this.items) { - var item = this.items[i]; - if (item.name === name) { - return item.id; - } - } - return -1; - }; - ISOFile.prototype.getMetaHandler = function () { - if (!this.meta) { - return null; - } else { - return this.meta.hdlr.handler; - } - }; - ISOFile.prototype.getPrimaryItem = function () { - if (!this.meta || !this.meta.pitm) { - return null; - } else { - return this.getItem(this.meta.pitm.item_id); - } - }; - ISOFile.prototype.itemToFragmentedTrackFile = function (_options) { - var options = _options || {}; - var item = null; - if (options.itemId) { - item = this.getItem(options.itemId); - } else { - item = this.getPrimaryItem(); - } - if (item == null) return null; - var file = new ISOFile(); - file.discardMdatData = false; - // assuming the track type is the same as the item type - var trackOptions = { - type: item.type, - description_boxes: item.properties.boxes - }; - if (item.properties.ispe) { - trackOptions.width = item.properties.ispe.image_width; - trackOptions.height = item.properties.ispe.image_height; - } - var trackId = file.addTrack(trackOptions); - if (trackId) { - file.addSample(trackId, item.data); - return file; - } else { - return null; - } - }; - - // file:src/isofile-write.js - /* Rewrite the entire file */ - ISOFile.prototype.write = function (outstream) { - for (var i = 0; i < this.boxes.length; i++) { - this.boxes[i].write(outstream); - } - }; - ISOFile.prototype.createFragment = function (track_id, sampleNumber, stream_) { - var trak = this.getTrackById(track_id); - var sample = this.getSample(trak, sampleNumber); - if (sample == null) { - this.setNextSeekPositionFromSample(trak.samples[sampleNumber]); - return null; - } - var stream = stream_ || new DataStream(); - stream.endianness = DataStream.BIG_ENDIAN; - var moof = this.createSingleSampleMoof(sample); - moof.write(stream); - - /* adjusting the data_offset now that the moof size is known*/ - moof.trafs[0].truns[0].data_offset = moof.size + 8; //8 is mdat header - Log.debug("MP4Box", "Adjusting data_offset with new value " + moof.trafs[0].truns[0].data_offset); - stream.adjustUint32(moof.trafs[0].truns[0].data_offset_position, moof.trafs[0].truns[0].data_offset); - var mdat = new BoxParser.mdatBox(); - mdat.data = sample.data; - mdat.write(stream); - return stream; - }; - - /* Modify the file and create the initialization segment */ - ISOFile.writeInitializationSegment = function (ftyp, moov, total_duration, sample_duration) { - var i; - Log.debug("ISOFile", "Generating initialization segment"); - var stream = new DataStream(); - stream.endianness = DataStream.BIG_ENDIAN; - ftyp.write(stream); - - /* we can now create the new mvex box */ - var mvex = moov.add("mvex"); - if (total_duration) { - mvex.add("mehd").set("fragment_duration", total_duration); - } - for (i = 0; i < moov.traks.length; i++) { - mvex.add("trex").set("track_id", moov.traks[i].tkhd.track_id).set("default_sample_description_index", 1).set("default_sample_duration", sample_duration).set("default_sample_size", 0).set("default_sample_flags", 1 << 16); - } - moov.write(stream); - return stream.buffer; - }; - ISOFile.prototype.save = function (name) { - var stream = new DataStream(); - stream.endianness = DataStream.BIG_ENDIAN; - this.write(stream); - stream.save(name); - }; - ISOFile.prototype.getBuffer = function () { - var stream = new DataStream(); - stream.endianness = DataStream.BIG_ENDIAN; - this.write(stream); - return stream.buffer; - }; - ISOFile.prototype.initializeSegmentation = function () { - var i; - var initSegs; - var trak; - var seg; - if (this.onSegment === null) { - Log.warn("MP4Box", "No segmentation callback set!"); - } - if (!this.isFragmentationInitialized) { - this.isFragmentationInitialized = true; - this.nextMoofNumber = 0; - this.resetTables(); - } - initSegs = []; - for (i = 0; i < this.fragmentedTracks.length; i++) { - var moov = new BoxParser.moovBox(); - moov.mvhd = this.moov.mvhd; - moov.boxes.push(moov.mvhd); - trak = this.getTrackById(this.fragmentedTracks[i].id); - moov.boxes.push(trak); - moov.traks.push(trak); - seg = {}; - seg.id = trak.tkhd.track_id; - seg.user = this.fragmentedTracks[i].user; - seg.buffer = ISOFile.writeInitializationSegment(this.ftyp, moov, this.moov.mvex && this.moov.mvex.mehd ? this.moov.mvex.mehd.fragment_duration : undefined, this.moov.traks[i].samples.length > 0 ? this.moov.traks[i].samples[0].duration : 0); - initSegs.push(seg); - } - return initSegs; - }; - - // file:src/box-print.js - /* - * Copyright (c) Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - BoxParser.Box.prototype.printHeader = function (output) { - this.size += 8; - if (this.size > MAX_SIZE) { - this.size += 8; - } - if (this.type === "uuid") { - this.size += 16; - } - output.log(output.indent + "size:" + this.size); - output.log(output.indent + "type:" + this.type); - }; - BoxParser.FullBox.prototype.printHeader = function (output) { - this.size += 4; - BoxParser.Box.prototype.printHeader.call(this, output); - output.log(output.indent + "version:" + this.version); - output.log(output.indent + "flags:" + this.flags); - }; - BoxParser.Box.prototype.print = function (output) { - this.printHeader(output); - }; - BoxParser.ContainerBox.prototype.print = function (output) { - this.printHeader(output); - for (var i = 0; i < this.boxes.length; i++) { - if (this.boxes[i]) { - var prev_indent = output.indent; - output.indent += " "; - this.boxes[i].print(output); - output.indent = prev_indent; - } - } - }; - ISOFile.prototype.print = function (output) { - output.indent = ""; - for (var i = 0; i < this.boxes.length; i++) { - if (this.boxes[i]) { - this.boxes[i].print(output); - } - } - }; - BoxParser.mvhdBox.prototype.print = function (output) { - BoxParser.FullBox.prototype.printHeader.call(this, output); - output.log(output.indent + "creation_time: " + this.creation_time); - output.log(output.indent + "modification_time: " + this.modification_time); - output.log(output.indent + "timescale: " + this.timescale); - output.log(output.indent + "duration: " + this.duration); - output.log(output.indent + "rate: " + this.rate); - output.log(output.indent + "volume: " + (this.volume >> 8)); - output.log(output.indent + "matrix: " + this.matrix.join(", ")); - output.log(output.indent + "next_track_id: " + this.next_track_id); - }; - BoxParser.tkhdBox.prototype.print = function (output) { - BoxParser.FullBox.prototype.printHeader.call(this, output); - output.log(output.indent + "creation_time: " + this.creation_time); - output.log(output.indent + "modification_time: " + this.modification_time); - output.log(output.indent + "track_id: " + this.track_id); - output.log(output.indent + "duration: " + this.duration); - output.log(output.indent + "volume: " + (this.volume >> 8)); - output.log(output.indent + "matrix: " + this.matrix.join(", ")); - output.log(output.indent + "layer: " + this.layer); - output.log(output.indent + "alternate_group: " + this.alternate_group); - output.log(output.indent + "width: " + this.width); - output.log(output.indent + "height: " + this.height); - }; // file:src/mp4box.js - /* - * Copyright (c) 2012-2013. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato - * License: BSD-3-Clause (see LICENSE file) - */ - var MP4Box = {}; - MP4Box.createFile = function (_keepMdatData, _stream) { - /* Boolean indicating if bytes containing media data should be kept in memory */ - var keepMdatData = _keepMdatData !== undefined ? _keepMdatData : true; - var file = new ISOFile(_stream); - file.discardMdatData = keepMdatData ? false : true; - return file; - }; - { - exports.createFile = MP4Box.createFile; - } - })(mp4box_all); - return mp4box_all; - } - - var mp4box_allExports = requireMp4box_all(); - - // Decode a MP4 container into individual samples. - class Parser { - info; - #mp4 = mp4box_allExports.createFile(); - #offset = 0; - #samples = []; - constructor(init) { - this.#mp4.onError = (err) => { - console.error("MP4 error", err); - }; - this.#mp4.onReady = (info) => { - this.info = info; - // Extract all of the tracks, because we don't know if it's audio or video. - for (const track of info.tracks) { - this.#mp4.setExtractionOptions(track.id, track, { nbSamples: 1 }); - } - }; - this.#mp4.onSamples = (_track_id, track, samples) => { - for (const sample of samples) { - this.#samples.push({ track, sample }); - } - }; - this.#mp4.start(); - // For some reason we need to modify the underlying ArrayBuffer with offset - const copy = new Uint8Array(init); - const buffer = copy.buffer; - buffer.fileStart = this.#offset; - this.#mp4.appendBuffer(buffer); - this.#offset += buffer.byteLength; - this.#mp4.flush(); - if (!this.info) { - throw new Error("could not parse MP4 info"); - } - } - decode(chunk) { - const copy = new Uint8Array(chunk); - // For some reason we need to modify the underlying ArrayBuffer with offset - const buffer = copy.buffer; - buffer.fileStart = this.#offset; - // Parse the data - this.#mp4.appendBuffer(buffer); - this.#mp4.flush(); - this.#offset += buffer.byteLength; - const samples = [...this.#samples]; - this.#samples.length = 0; - return samples; - } - } - - // Rename some stuff so it's on brand. - // We need a separate file so this file can use the rename too. - function isAudioTrack(track) { - // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition - return track.audio !== undefined; - } - function isVideoTrack(track) { - // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition - return track.video !== undefined; - } - // TODO contribute to mp4box - mp4box_allExports.BoxParser.dOpsBox.prototype.write = function (stream) { - this.size = this.ChannelMappingFamily === 0 ? 11 : 13 + this.ChannelMapping.length; - this.writeHeader(stream); - stream.writeUint8(this.Version); - stream.writeUint8(this.OutputChannelCount); - stream.writeUint16(this.PreSkip); - stream.writeUint32(this.InputSampleRate); - stream.writeInt16(this.OutputGain); - stream.writeUint8(this.ChannelMappingFamily); - if (this.ChannelMappingFamily !== 0) { - stream.writeUint8(this.StreamCount); - stream.writeUint8(this.CoupledCount); - for (const mapping of this.ChannelMapping) { - stream.writeUint8(mapping); - } - } - }; - - // This is run in a worker. - let Renderer$1 = class Renderer { - #ring; - #timeline; - #decoder; - #stream; - constructor(config, timeline) { - this.#timeline = timeline; - this.#ring = new Ring(config.ring); - this.#stream = new TransformStream({ - start: this.#start.bind(this), - transform: this.#transform.bind(this), - }); - this.#run().catch(console.error); - } - #start(controller) { - this.#decoder = new AudioDecoder({ - output: (frame) => { - controller.enqueue(frame); - }, - error: console.warn, - }); - } - #transform(frame) { - if (this.#decoder.state !== "configured") { - const track = frame.track; - if (!isAudioTrack(track)) - throw new Error("expected audio track"); - // We only support OPUS right now which doesn't need a description. - this.#decoder.configure({ - codec: track.codec, - sampleRate: track.audio.sample_rate, - numberOfChannels: track.audio.channel_count, - }); - } - const chunk = new EncodedAudioChunk({ - type: frame.sample.is_sync ? "key" : "delta", - timestamp: frame.sample.dts / frame.track.timescale, - duration: frame.sample.duration, - data: frame.sample.data, - }); - this.#decoder.decode(chunk); - } - async #run() { - const reader = this.#timeline.frames.pipeThrough(this.#stream).getReader(); - for (;;) { - const { value: frame, done } = await reader.read(); - if (done) - break; - // Write audio samples to the ring buffer, dropping when there's no space. - const written = this.#ring.write(frame); - if (written < frame.numberOfFrames) { - console.warn(`droppped ${frame.numberOfFrames - written} audio samples`); - } - } - } - }; - - class Renderer { - #canvas; - #timeline; - #decoder; - #queue; - #decoderConfig; - #waitingForKeyframe = true; - constructor(config, timeline) { - this.#canvas = config.canvas; - this.#timeline = timeline; - this.#queue = new TransformStream({ - start: this.#start.bind(this), - transform: this.#transform.bind(this), - }); - this.#run().catch(console.error); - } - pause() { - console.log("pause"); - this.#waitingForKeyframe = true; - } - async #run() { - const reader = this.#timeline.frames.pipeThrough(this.#queue).getReader(); - for (;;) { - const { value: frame, done } = await reader.read(); - if (done) - break; - self.requestAnimationFrame(() => { - this.#canvas.width = frame.displayWidth; - this.#canvas.height = frame.displayHeight; - const ctx = this.#canvas.getContext("2d"); - if (!ctx) - throw new Error("failed to get canvas context"); - ctx.drawImage(frame, 0, 0, frame.displayWidth, frame.displayHeight); // TODO respect aspect ratio - frame.close(); - }); - } - } - #start(controller) { - this.#decoder = new VideoDecoder({ - output: (frame) => { - controller.enqueue(frame); - }, - error: console.error, - }); - } - #transform(frame) { - if (this.#decoder.state === "closed") { - console.warn("Decoder is closed. Skipping frame."); - return; - } - const { sample, track } = frame; - // Reset the decoder on video track change - if (this.#decoderConfig && this.#decoder.state == "configured") { - if (isVideoTrack(track)) { - const configMismatch = this.#decoderConfig.codec !== track.codec || - this.#decoderConfig.codedWidth !== track.video.width || - this.#decoderConfig.codedHeight !== track.video.height; - if (configMismatch) { - this.#decoder.reset(); - this.#decoderConfig = undefined; - } - } - } - // Configure the decoder with the first frame - if (this.#decoder.state !== "configured") { - const desc = sample.description; - const box = desc.avcC ?? desc.hvcC ?? desc.vpcC ?? desc.av1C; - if (!box) - throw new Error(`unsupported codec: ${track.codec}`); - const buffer = new mp4box_allExports.DataStream(undefined, 0, mp4box_allExports.DataStream.BIG_ENDIAN); - box.write(buffer); - const description = new Uint8Array(buffer.buffer, 8); // Remove the box header. - if (!isVideoTrack(track)) - throw new Error("expected video track"); - this.#decoderConfig = { - codec: track.codec, - codedHeight: track.video.height, - codedWidth: track.video.width, - description, - // optimizeForLatency: true - }; - this.#decoder.configure(this.#decoderConfig); - if (!frame.sample.is_sync) { - this.#waitingForKeyframe = true; - } - else { - this.#waitingForKeyframe = false; - } - } - //At the start of decode , VideoDecoder seems to expect a key frame after configure() or flush() - if (this.#decoder.state == "configured") { - if (this.#waitingForKeyframe && !frame.sample.is_sync) { - console.warn("Skipping non-keyframe until a keyframe is found."); - return; - } - // On arrival of a keyframe, allow decoding and stop waiting for a keyframe. - if (frame.sample.is_sync) { - this.#waitingForKeyframe = false; - } - const chunk = new EncodedVideoChunk({ - type: frame.sample.is_sync ? "key" : "delta", - data: frame.sample.data, - timestamp: frame.sample.dts / frame.track.timescale, - }); - this.#decoder.decode(chunk); - } - } - } - - // I hate javascript - function asError(e) { - if (e instanceof Error) { - return e; - } - else if (typeof e === "string") { - return new Error(e); - } - else { - return new Error(String(e)); - } - } - - class Deferred { - promise; - resolve; - reject; - pending = true; - constructor() { - this.promise = new Promise((resolve, reject) => { - this.resolve = (value) => { - this.pending = false; - resolve(value); - }; - this.reject = (reason) => { - this.pending = false; - reject(reason); - }; - }); - } - } - - const MAX_U53 = Number.MAX_SAFE_INTEGER; - // Reader wraps a stream and provides convience methods for reading pieces from a stream - // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet. - class Reader { - #buffer; - #stream; - #reader; - constructor(buffer, stream) { - this.#buffer = buffer; - this.#stream = stream; - this.#reader = this.#stream.getReader(); - } - // Adds more data to the buffer, returning true if more data was added. - async #fill() { - const result = await this.#reader.read(); - if (result.done) { - return false; - } - const buffer = new Uint8Array(result.value); - if (this.#buffer.byteLength == 0) { - this.#buffer = buffer; - } - else { - const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength); - temp.set(this.#buffer); - temp.set(buffer, this.#buffer.byteLength); - this.#buffer = temp; - } - return true; - } - // Add more data to the buffer until it's at least size bytes. - async #fillTo(size) { - while (this.#buffer.byteLength < size) { - if (!(await this.#fill())) { - throw new Error("unexpected end of stream"); - } - } - } - // Consumes the first size bytes of the buffer. - #slice(size) { - const result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size); - this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size); - return result; - } - async read(size) { - if (size == 0) - return new Uint8Array(); - await this.#fillTo(size); - return this.#slice(size); - } - async readAll() { - // eslint-disable-next-line no-empty - while (await this.#fill()) { } - return this.#slice(this.#buffer.byteLength); - } - async string(maxLength) { - const length = await this.u53(); - if (maxLength !== undefined && length > maxLength) { - throw new Error(`string length ${length} exceeds max length ${maxLength}`); - } - const buffer = await this.read(length); - return new TextDecoder().decode(buffer); - } - async u8() { - await this.#fillTo(1); - return this.#slice(1)[0]; - } - // Returns a Number using 53-bits, the max Javascript can use for integer math - async u53() { - const v = await this.u62(); - if (v > MAX_U53) { - throw new Error("value larger than 53-bits; use v62 instead"); - } - return Number(v); - } - // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits - async u62() { - await this.#fillTo(1); - const size = (this.#buffer[0] & 0xc0) >> 6; - if (size == 0) { - const first = this.#slice(1)[0]; - return BigInt(first) & 0x3fn; - } - else if (size == 1) { - await this.#fillTo(2); - const slice = this.#slice(2); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return BigInt(view.getInt16(0)) & 0x3fffn; - } - else if (size == 2) { - await this.#fillTo(4); - const slice = this.#slice(4); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return BigInt(view.getUint32(0)) & 0x3fffffffn; - } - else if (size == 3) { - await this.#fillTo(8); - const slice = this.#slice(8); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return view.getBigUint64(0) & 0x3fffffffffffffffn; - } - else { - throw new Error("impossible"); - } - } - async done() { - if (this.#buffer.byteLength > 0) - return false; - return !(await this.#fill()); - } - async close() { - this.#reader.releaseLock(); - await this.#stream.cancel(); - } - release() { - this.#reader.releaseLock(); - return [this.#buffer, this.#stream]; - } - } - - var StreamType; - (function (StreamType) { - StreamType[StreamType["Object"] = 0] = "Object"; - StreamType[StreamType["Track"] = 80] = "Track"; - StreamType[StreamType["Group"] = 81] = "Group"; - })(StreamType || (StreamType = {})); - var Status; - (function (Status) { - Status[Status["OBJECT_NULL"] = 1] = "OBJECT_NULL"; - Status[Status["GROUP_NULL"] = 2] = "GROUP_NULL"; - Status[Status["GROUP_END"] = 3] = "GROUP_END"; - Status[Status["TRACK_END"] = 4] = "TRACK_END"; - })(Status || (Status = {})); - class GroupReader { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async read() { - if (await this.stream.done()) { - return; - } - const object = await this.stream.u53(); - const size = await this.stream.u53(); - let payload; - if (size == 0) { - payload = (await this.stream.u53()); - } - else { - payload = await this.stream.read(size); - } - return { - object, - payload, - }; - } - async close() { - await this.stream.close(); - } - } - - class Worker { - // Timeline receives samples, buffering them and choosing the timestamp to render. - #timeline = new Timeline(); - // A map of init tracks. - #inits = new Map(); - // Renderer requests samples, rendering video frames and emitting audio frames. - #audio; - #video; - on(e) { - const msg = e.data; - if (msg.config) { - this.#onConfig(msg.config); - } - else if (msg.init) { - // TODO buffer the init segmnet so we don't hold the stream open. - this.#onInit(msg.init); - } - else if (msg.segment) { - this.#onSegment(msg.segment).catch(console.warn); - } - else if (msg.pause) { - this.#onPause(msg.pause); - } - else { - throw new Error(`unknown message: + ${JSON.stringify(msg)}`); - } - } - #onConfig(msg) { - if (msg.audio) { - this.#audio = new Renderer$1(msg.audio, this.#timeline.audio); - } - if (msg.video) { - this.#video = new Renderer(msg.video, this.#timeline.video); - } - } - #onInit(msg) { - let init = this.#inits.get(msg.name); - if (!init) { - init = new Deferred(); - this.#inits.set(msg.name, init); - } - init.resolve(msg.data); - } - async #onSegment(msg) { - let init = this.#inits.get(msg.init); - if (!init) { - init = new Deferred(); - this.#inits.set(msg.init, init); - } - // Create a new stream that we will use to decode. - const container = new Parser(await init.promise); - const timeline = msg.kind === "audio" ? this.#timeline.audio : this.#timeline.video; - const reader = new GroupReader(msg.header, new Reader(msg.buffer, msg.stream)); - // Create a queue that will contain each MP4 frame. - const queue = new TransformStream({}); - const segment = queue.writable.getWriter(); - // Add the segment to the timeline - const segments = timeline.segments.getWriter(); - await segments.write({ - sequence: msg.header.group, - frames: queue.readable, - }); - segments.releaseLock(); - // Read each chunk, decoding the MP4 frames and adding them to the queue. - for (;;) { - const chunk = await reader.read(); - if (!chunk) { - break; - } - if (!(chunk.payload instanceof Uint8Array)) { - throw new Error(`invalid payload: ${chunk.payload}`); - } - const frames = container.decode(chunk.payload); - for (const frame of frames) { - await segment.write(frame); - } - } - // We done. - await segment.close(); - } - #onPause(pause) { - if (this.#video && pause) { - this.#video.pause(); - } - } - } - // Pass all events to the worker - const worker = new Worker(); - self.addEventListener("message", (msg) => { - try { - worker.on(msg); - } - catch (e) { - const err = asError(e); - console.warn("worker error:", err); - } - }); - - })(); - - }); - /* eslint-enable */ - - // Ring buffer with audio samples. - var STATE; - (function (STATE) { - STATE[STATE["READ_POS"] = 0] = "READ_POS"; - STATE[STATE["WRITE_POS"] = 1] = "WRITE_POS"; - STATE[STATE["LENGTH"] = 2] = "LENGTH"; - })(STATE || (STATE = {})); - // No prototype to make this easier to send via postMessage - class RingShared { - state; - channels; - capacity; - constructor(channels, capacity) { - // Store the current state in a separate ring buffer. - this.state = new SharedArrayBuffer(STATE.LENGTH * Int32Array.BYTES_PER_ELEMENT); - // Create a buffer for each audio channel - this.channels = []; - for (let i = 0; i < channels; i += 1) { - const buffer = new SharedArrayBuffer(capacity * Float32Array.BYTES_PER_ELEMENT); - this.channels.push(buffer); - } - this.capacity = capacity; - } - } - - // This is a non-standard way of importing worklet/workers. - // Unfortunately, it's the only option because of a Vite bug: https://github.com/vitejs/vite/issues/11823 - // Responsible for sending messages to the worker and worklet. - class Backend { - // General worker - #worker; - // The audio context, which must be created on the main thread. - #audio; - constructor(config) { - // TODO does this block the main thread? If so, make this async - this.#worker = new WorkerFactory(); - this.#worker.addEventListener("message", this.on.bind(this)); - let sampleRate; - let channels; - for (const track of config.catalog.tracks) { - if (isAudioTrack(track)) { - if (sampleRate && track.selectionParams.samplerate !== sampleRate) { - throw new Error(`TODO multiple audio tracks with different sample rates`); - } - sampleRate = track.selectionParams.samplerate; - // TODO properly handle weird channel configs - channels = Math.max(+track.selectionParams.channelConfig, channels ?? 0); - } - } - const msg = {}; - // Only configure audio is we have an audio track - if (sampleRate && channels) { - msg.audio = { - channels: channels, - sampleRate: sampleRate, - ring: new RingShared(2, sampleRate / 10), // 100ms - }; - this.#audio = new Audio(msg.audio); - } - // TODO only send the canvas if we have a video track - msg.video = { - canvas: config.canvas, - }; - this.send({ config: msg }, msg.video.canvas); - } - pause() { - this.send({ pause: true }); - } - async mute() { - await this.#audio?.context.suspend(); - } - async unmute() { - await this.#audio?.context.resume(); - } - init(init) { - this.send({ init }); - } - segment(segment) { - this.send({ segment }, segment.stream); - } - async close() { - this.#worker.terminate(); - await this.#audio?.context.close(); - } - // Enforce we're sending valid types to the worker - send(msg, ...transfer) { - //console.log("sent message from main to worker", msg) - this.#worker.postMessage(msg, transfer); - } - on(e) { - const msg = e.data; - // Don't print the verbose timeline message. - if (!msg.timeline) ; - } - } - - const MAX_U6 = Math.pow(2, 6) - 1; - const MAX_U14 = Math.pow(2, 14) - 1; - const MAX_U30 = Math.pow(2, 30) - 1; - const MAX_U31 = Math.pow(2, 31) - 1; - const MAX_U53 = Number.MAX_SAFE_INTEGER; - const MAX_U62 = 2n ** 62n - 1n; - // Reader wraps a stream and provides convience methods for reading pieces from a stream - // Unfortunately we can't use a BYOB reader because it's not supported with WebTransport+WebWorkers yet. - class Reader { - #buffer; - #stream; - #reader; - constructor(buffer, stream) { - this.#buffer = buffer; - this.#stream = stream; - this.#reader = this.#stream.getReader(); - } - // Adds more data to the buffer, returning true if more data was added. - async #fill() { - const result = await this.#reader.read(); - if (result.done) { - return false; - } - const buffer = new Uint8Array(result.value); - if (this.#buffer.byteLength == 0) { - this.#buffer = buffer; - } - else { - const temp = new Uint8Array(this.#buffer.byteLength + buffer.byteLength); - temp.set(this.#buffer); - temp.set(buffer, this.#buffer.byteLength); - this.#buffer = temp; - } - return true; - } - // Add more data to the buffer until it's at least size bytes. - async #fillTo(size) { - while (this.#buffer.byteLength < size) { - if (!(await this.#fill())) { - throw new Error("unexpected end of stream"); - } - } - } - // Consumes the first size bytes of the buffer. - #slice(size) { - const result = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset, size); - this.#buffer = new Uint8Array(this.#buffer.buffer, this.#buffer.byteOffset + size); - return result; - } - async read(size) { - if (size == 0) - return new Uint8Array(); - await this.#fillTo(size); - return this.#slice(size); - } - async readAll() { - // eslint-disable-next-line no-empty - while (await this.#fill()) { } - return this.#slice(this.#buffer.byteLength); - } - async string(maxLength) { - const length = await this.u53(); - if (maxLength !== undefined && length > maxLength) { - throw new Error(`string length ${length} exceeds max length ${maxLength}`); - } - const buffer = await this.read(length); - return new TextDecoder().decode(buffer); - } - async u8() { - await this.#fillTo(1); - return this.#slice(1)[0]; - } - // Returns a Number using 53-bits, the max Javascript can use for integer math - async u53() { - const v = await this.u62(); - if (v > MAX_U53) { - throw new Error("value larger than 53-bits; use v62 instead"); - } - return Number(v); - } - // NOTE: Returns a bigint instead of a number since it may be larger than 53-bits - async u62() { - await this.#fillTo(1); - const size = (this.#buffer[0] & 0xc0) >> 6; - if (size == 0) { - const first = this.#slice(1)[0]; - return BigInt(first) & 0x3fn; - } - else if (size == 1) { - await this.#fillTo(2); - const slice = this.#slice(2); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return BigInt(view.getInt16(0)) & 0x3fffn; - } - else if (size == 2) { - await this.#fillTo(4); - const slice = this.#slice(4); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return BigInt(view.getUint32(0)) & 0x3fffffffn; - } - else if (size == 3) { - await this.#fillTo(8); - const slice = this.#slice(8); - const view = new DataView(slice.buffer, slice.byteOffset, slice.byteLength); - return view.getBigUint64(0) & 0x3fffffffffffffffn; - } - else { - throw new Error("impossible"); - } - } - async done() { - if (this.#buffer.byteLength > 0) - return false; - return !(await this.#fill()); - } - async close() { - this.#reader.releaseLock(); - await this.#stream.cancel(); - } - release() { - this.#reader.releaseLock(); - return [this.#buffer, this.#stream]; - } - } - // Writer wraps a stream and writes chunks of data - class Writer { - #scratch; - #writer; - #stream; - constructor(stream) { - this.#stream = stream; - this.#scratch = new Uint8Array(8); - this.#writer = this.#stream.getWriter(); - } - async u8(v) { - await this.write(setUint8(this.#scratch, v)); - } - async i32(v) { - if (Math.abs(v) > MAX_U31) { - throw new Error(`overflow, value larger than 32-bits: ${v}`); - } - // We don't use a VarInt, so it always takes 4 bytes. - // This could be improved but nothing is standardized yet. - await this.write(setInt32(this.#scratch, v)); - } - async u53(v) { - if (v < 0) { - throw new Error(`underflow, value is negative: ${v}`); - } - else if (v > MAX_U53) { - throw new Error(`overflow, value larger than 53-bits: ${v}`); - } - await this.write(setVint53(this.#scratch, v)); - } - async u62(v) { - if (v < 0) { - throw new Error(`underflow, value is negative: ${v}`); - } - else if (v >= MAX_U62) { - throw new Error(`overflow, value larger than 62-bits: ${v}`); - } - await this.write(setVint62(this.#scratch, v)); - } - async write(v) { - await this.#writer.write(v); - } - async string(str) { - const data = new TextEncoder().encode(str); - await this.u53(data.byteLength); - await this.write(data); - } - async close() { - this.#writer.releaseLock(); - await this.#stream.close(); - } - release() { - this.#writer.releaseLock(); - return this.#stream; - } - } - function setUint8(dst, v) { - dst[0] = v; - return dst.slice(0, 1); - } - function setUint16(dst, v) { - const view = new DataView(dst.buffer, dst.byteOffset, 2); - view.setUint16(0, v); - return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); - } - function setInt32(dst, v) { - const view = new DataView(dst.buffer, dst.byteOffset, 4); - view.setInt32(0, v); - return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); - } - function setUint32(dst, v) { - const view = new DataView(dst.buffer, dst.byteOffset, 4); - view.setUint32(0, v); - return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); - } - function setVint53(dst, v) { - if (v <= MAX_U6) { - return setUint8(dst, v); - } - else if (v <= MAX_U14) { - return setUint16(dst, v | 0x4000); - } - else if (v <= MAX_U30) { - return setUint32(dst, v | 0x80000000); - } - else if (v <= MAX_U53) { - return setUint64(dst, BigInt(v) | 0xc000000000000000n); - } - else { - throw new Error(`overflow, value larger than 53-bits: ${v}`); - } - } - function setVint62(dst, v) { - if (v < MAX_U6) { - return setUint8(dst, Number(v)); - } - else if (v < MAX_U14) { - return setUint16(dst, Number(v) | 0x4000); - } - else if (v <= MAX_U30) { - return setUint32(dst, Number(v) | 0x80000000); - } - else if (v <= MAX_U62) { - return setUint64(dst, BigInt(v) | 0xc000000000000000n); - } - else { - throw new Error(`overflow, value larger than 62-bits: ${v}`); - } - } - function setUint64(dst, v) { - const view = new DataView(dst.buffer, dst.byteOffset, 8); - view.setBigUint64(0, v); - return new Uint8Array(view.buffer, view.byteOffset, view.byteLength); - } - - var Version; - (function (Version) { - Version[Version["DRAFT_00"] = 4278190080] = "DRAFT_00"; - Version[Version["DRAFT_01"] = 4278190081] = "DRAFT_01"; - Version[Version["DRAFT_02"] = 4278190082] = "DRAFT_02"; - Version[Version["DRAFT_03"] = 4278190083] = "DRAFT_03"; - Version[Version["DRAFT_04"] = 4278190084] = "DRAFT_04"; - Version[Version["DRAFT_05"] = 4278190085] = "DRAFT_05"; - Version[Version["KIXEL_00"] = 765184] = "KIXEL_00"; - Version[Version["KIXEL_01"] = 765185] = "KIXEL_01"; - })(Version || (Version = {})); - let Stream$1 = class Stream { - recv; - send; - constructor(r, w) { - this.recv = new Decoder$1(r); - this.send = new Encoder$1(w); - } - }; - let Decoder$1 = class Decoder { - r; - constructor(r) { - this.r = r; - } - async client() { - const type = await this.r.u53(); - if (type !== 0x40) - throw new Error(`client SETUP type must be 0x40, got ${type}`); - const count = await this.r.u53(); - const versions = []; - for (let i = 0; i < count; i++) { - const version = await this.r.u53(); - versions.push(version); - } - const params = await this.parameters(); - const role = this.role(params?.get(0n)); - return { - versions, - role, - params, - }; - } - async server() { - const type = await this.r.u53(); - if (type !== 0x41) - throw new Error(`server SETUP type must be 0x41, got ${type}`); - const version = await this.r.u53(); - const params = await this.parameters(); - return { - version, - params, - }; - } - async parameters() { - const count = await this.r.u53(); - if (count == 0) - return undefined; - const params = new Map(); - for (let i = 0; i < count; i++) { - const id = await this.r.u62(); - const size = await this.r.u53(); - const value = await this.r.read(size); - if (params.has(id)) { - throw new Error(`duplicate parameter id: ${id}`); - } - params.set(id, value); - } - return params; - } - role(raw) { - if (!raw) - throw new Error("missing role parameter"); - if (raw.length != 1) - throw new Error("multi-byte varint not supported"); - switch (raw[0]) { - case 1: - return "publisher"; - case 2: - return "subscriber"; - case 3: - return "both"; - default: - throw new Error(`invalid role: ${raw[0]}`); - } - } - }; - let Encoder$1 = class Encoder { - w; - constructor(w) { - this.w = w; - } - async client(c) { - await this.w.u53(0x40); - await this.w.u53(c.versions.length); - for (const v of c.versions) { - await this.w.u53(v); - } - // I hate it - const params = c.params ?? new Map(); - params.set(0n, new Uint8Array([c.role == "publisher" ? 1 : c.role == "subscriber" ? 2 : 3])); - await this.parameters(params); - } - async server(s) { - await this.w.u53(0x41); - await this.w.u53(s.version); - await this.parameters(s.params); - } - async parameters(p) { - if (!p) { - await this.w.u8(0); - return; - } - await this.w.u53(p.size); - for (const [id, value] of p) { - await this.w.u62(id); - await this.w.u53(value.length); - await this.w.write(value); - } - } - }; - - function isPublisher(m) { - return (m.kind == Msg.SubscribeOk || - m.kind == Msg.SubscribeError || - m.kind == Msg.SubscribeDone || - m.kind == Msg.Announce || - m.kind == Msg.Unannounce); - } - // I wish we didn't have to split Msg and Id into separate enums. - // However using the string in the message makes it easier to debug. - // We'll take the tiny performance hit until I'm better at Typescript. - var Msg; - (function (Msg) { - // NOTE: object and setup are in other modules - Msg["Subscribe"] = "subscribe"; - Msg["SubscribeOk"] = "subscribe_ok"; - Msg["SubscribeError"] = "subscribe_error"; - Msg["SubscribeDone"] = "subscribe_done"; - Msg["Unsubscribe"] = "unsubscribe"; - Msg["Announce"] = "announce"; - Msg["AnnounceOk"] = "announce_ok"; - Msg["AnnounceError"] = "announce_error"; - Msg["Unannounce"] = "unannounce"; - Msg["GoAway"] = "go_away"; - })(Msg || (Msg = {})); - var Id; - (function (Id) { - // NOTE: object and setup are in other modules - // Object = 0, - // Setup = 1, - Id[Id["Subscribe"] = 3] = "Subscribe"; - Id[Id["SubscribeOk"] = 4] = "SubscribeOk"; - Id[Id["SubscribeError"] = 5] = "SubscribeError"; - Id[Id["SubscribeDone"] = 11] = "SubscribeDone"; - Id[Id["Unsubscribe"] = 10] = "Unsubscribe"; - Id[Id["Announce"] = 6] = "Announce"; - Id[Id["AnnounceOk"] = 7] = "AnnounceOk"; - Id[Id["AnnounceError"] = 8] = "AnnounceError"; - Id[Id["Unannounce"] = 9] = "Unannounce"; - Id[Id["GoAway"] = 16] = "GoAway"; - })(Id || (Id = {})); - var GroupOrder; - (function (GroupOrder) { - GroupOrder[GroupOrder["Publisher"] = 0] = "Publisher"; - GroupOrder[GroupOrder["Ascending"] = 1] = "Ascending"; - GroupOrder[GroupOrder["Descending"] = 2] = "Descending"; - })(GroupOrder || (GroupOrder = {})); - class Stream { - decoder; - encoder; - #mutex = Promise.resolve(); - constructor(r, w) { - this.decoder = new Decoder(r); - this.encoder = new Encoder(w); - } - // Will error if two messages are read at once. - async recv() { - const msg = await this.decoder.message(); - console.log("received message", msg); - return msg; - } - async send(msg) { - const unlock = await this.#lock(); - try { - console.log("sending message", msg); - await this.encoder.message(msg); - } - finally { - unlock(); - } - } - async #lock() { - // Make a new promise that we can resolve later. - let done; - const p = new Promise((resolve) => { - done = () => resolve(); - }); - // Wait until the previous lock is done, then resolve our our lock. - const lock = this.#mutex.then(() => done); - // Save our lock as the next lock. - this.#mutex = p; - // Return the lock. - return lock; - } - } - class Decoder { - r; - constructor(r) { - this.r = r; - } - async msg() { - const t = await this.r.u53(); - switch (t) { - case Id.Subscribe: - return Msg.Subscribe; - case Id.SubscribeOk: - return Msg.SubscribeOk; - case Id.SubscribeDone: - return Msg.SubscribeDone; - case Id.SubscribeError: - return Msg.SubscribeError; - case Id.Unsubscribe: - return Msg.Unsubscribe; - case Id.Announce: - return Msg.Announce; - case Id.AnnounceOk: - return Msg.AnnounceOk; - case Id.AnnounceError: - return Msg.AnnounceError; - case Id.Unannounce: - return Msg.Unannounce; - case Id.GoAway: - return Msg.GoAway; - } - throw new Error(`unknown control message type: ${t}`); - } - async message() { - const t = await this.msg(); - switch (t) { - case Msg.Subscribe: - return this.subscribe(); - case Msg.SubscribeOk: - return this.subscribe_ok(); - case Msg.SubscribeError: - return this.subscribe_error(); - case Msg.SubscribeDone: - return this.subscribe_done(); - case Msg.Unsubscribe: - return this.unsubscribe(); - case Msg.Announce: - return this.announce(); - case Msg.AnnounceOk: - return this.announce_ok(); - case Msg.Unannounce: - return this.unannounce(); - case Msg.AnnounceError: - return this.announce_error(); - case Msg.GoAway: - throw new Error("TODO: implement go away"); - } - } - async subscribe() { - return { - kind: Msg.Subscribe, - id: await this.r.u62(), - trackId: await this.r.u62(), - namespace: await this.r.string(), - name: await this.r.string(), - subscriber_priority: await this.r.u8(), - group_order: await this.decodeGroupOrder(), - location: await this.location(), - params: await this.parameters(), - }; - } - async decodeGroupOrder() { - const orderCode = await this.r.u8(); - switch (orderCode) { - case 0: - return GroupOrder.Publisher; - case 1: - return GroupOrder.Ascending; - case 2: - return GroupOrder.Descending; - default: - throw new Error(`Invalid GroupOrder value: ${orderCode}`); - } - } - async location() { - const mode = await this.r.u62(); - if (mode == 1n) { - return { - mode: "latest_group", - }; - } - else if (mode == 2n) { - return { - mode: "latest_object", - }; - } - else if (mode == 3n) { - return { - mode: "absolute_start", - start_group: await this.r.u53(), - start_object: await this.r.u53(), - }; - } - else if (mode == 4n) { - return { - mode: "absolute_range", - start_group: await this.r.u53(), - start_object: await this.r.u53(), - end_group: await this.r.u53(), - end_object: await this.r.u53(), - }; - } - else { - throw new Error(`invalid filter type: ${mode}`); - } - } - async parameters() { - const count = await this.r.u53(); - if (count == 0) - return undefined; - const params = new Map(); - for (let i = 0; i < count; i++) { - const id = await this.r.u62(); - const size = await this.r.u53(); - const value = await this.r.read(size); - if (params.has(id)) { - throw new Error(`duplicate parameter id: ${id}`); - } - params.set(id, value); - } - return params; - } - async subscribe_ok() { - const id = await this.r.u62(); - const expires = await this.r.u62(); - const group_order = await this.decodeGroupOrder(); - let latest; - const flag = await this.r.u8(); - if (flag === 1) { - latest = [await this.r.u53(), await this.r.u53()]; - } - else if (flag !== 0) { - throw new Error(`invalid final flag: ${flag}`); - } - return { - kind: Msg.SubscribeOk, - id, - expires, - group_order, - latest, - }; - } - async subscribe_done() { - const id = await this.r.u62(); - const code = await this.r.u62(); - const reason = await this.r.string(); - let final; - const flag = await this.r.u8(); - if (flag === 1) { - final = [await this.r.u53(), await this.r.u53()]; - } - else if (flag !== 0) { - throw new Error(`invalid final flag: ${flag}`); - } - return { - kind: Msg.SubscribeDone, - id, - code, - reason, - final, - }; - } - async subscribe_error() { - return { - kind: Msg.SubscribeError, - id: await this.r.u62(), - code: await this.r.u62(), - reason: await this.r.string(), - }; - } - async unsubscribe() { - return { - kind: Msg.Unsubscribe, - id: await this.r.u62(), - }; - } - async announce() { - const namespace = await this.r.string(); - return { - kind: Msg.Announce, - namespace, - params: await this.parameters(), - }; - } - async announce_ok() { - return { - kind: Msg.AnnounceOk, - namespace: await this.r.string(), - }; - } - async announce_error() { - return { - kind: Msg.AnnounceError, - namespace: await this.r.string(), - code: await this.r.u62(), - reason: await this.r.string(), - }; - } - async unannounce() { - return { - kind: Msg.Unannounce, - namespace: await this.r.string(), - }; - } - } - class Encoder { - w; - constructor(w) { - this.w = w; - } - async message(m) { - switch (m.kind) { - case Msg.Subscribe: - return this.subscribe(m); - case Msg.SubscribeOk: - return this.subscribe_ok(m); - case Msg.SubscribeError: - return this.subscribe_error(m); - case Msg.SubscribeDone: - return this.subscribe_done(m); - case Msg.Unsubscribe: - return this.unsubscribe(m); - case Msg.Announce: - return this.announce(m); - case Msg.AnnounceOk: - return this.announce_ok(m); - case Msg.AnnounceError: - return this.announce_error(m); - case Msg.Unannounce: - return this.unannounce(m); - } - } - async subscribe(s) { - await this.w.u53(Id.Subscribe); - await this.w.u62(s.id); - await this.w.u62(s.trackId); - await this.w.string(s.namespace); - await this.w.string(s.name); - await this.w.u8(s.subscriber_priority ?? 127); - await this.encodeGroupOrder(s.group_order ?? GroupOrder.Publisher); - await this.location(s.location); - await this.parameters(s.params); - } - async encodeGroupOrder(order) { - switch (order) { - case GroupOrder.Publisher: - await this.w.u8(GroupOrder.Publisher); - break; - case GroupOrder.Ascending: - await this.w.u8(GroupOrder.Ascending); - break; - case GroupOrder.Descending: - await this.w.u8(GroupOrder.Descending); - break; - default: - throw new Error("Invalid GroupOrder value"); - } - } - async location(l) { - switch (l.mode) { - case "latest_group": - await this.w.u62(1n); - break; - case "latest_object": - await this.w.u62(2n); - break; - case "absolute_start": - await this.w.u62(3n); - await this.w.u53(l.start_group); - await this.w.u53(l.start_object); - break; - case "absolute_range": - await this.w.u62(3n); - await this.w.u53(l.start_group); - await this.w.u53(l.start_object); - await this.w.u53(l.end_group); - await this.w.u53(l.end_object); - } - } - async parameters(p) { - if (!p) { - await this.w.u8(0); - return; - } - await this.w.u53(p.size); - for (const [id, value] of p) { - await this.w.u62(id); - await this.w.u53(value.length); - await this.w.write(value); - } - } - async subscribe_ok(s) { - await this.w.u53(Id.SubscribeOk); - await this.w.u62(s.id); - await this.w.u62(s.expires); - await this.encodeGroupOrder(s.group_order); - if (s.latest !== undefined) { - await this.w.u8(1); - await this.w.u53(s.latest[0]); - await this.w.u53(s.latest[1]); - } - else { - await this.w.u8(0); - } - } - async subscribe_done(s) { - await this.w.u53(Id.SubscribeDone); - await this.w.u62(s.id); - await this.w.u62(s.code); - await this.w.string(s.reason); - if (s.final !== undefined) { - await this.w.u8(1); - await this.w.u53(s.final[0]); - await this.w.u53(s.final[1]); - } - else { - await this.w.u8(0); - } - } - async subscribe_error(s) { - await this.w.u53(Id.SubscribeError); - await this.w.u62(s.id); - } - async unsubscribe(s) { - await this.w.u53(Id.Unsubscribe); - await this.w.u62(s.id); - } - async announce(a) { - await this.w.u53(Id.Announce); - await this.w.string(a.namespace); - await this.w.u53(0); // parameters - } - async announce_ok(a) { - await this.w.u53(Id.AnnounceOk); - await this.w.string(a.namespace); - } - async announce_error(a) { - await this.w.u53(Id.AnnounceError); - await this.w.string(a.namespace); - await this.w.u62(a.code); - await this.w.string(a.reason); - } - async unannounce(a) { - await this.w.u53(Id.Unannounce); - await this.w.string(a.namespace); - } - } - - var StreamType; - (function (StreamType) { - StreamType[StreamType["Object"] = 0] = "Object"; - StreamType[StreamType["Track"] = 80] = "Track"; - StreamType[StreamType["Group"] = 81] = "Group"; - })(StreamType || (StreamType = {})); - var Status; - (function (Status) { - Status[Status["OBJECT_NULL"] = 1] = "OBJECT_NULL"; - Status[Status["GROUP_NULL"] = 2] = "GROUP_NULL"; - Status[Status["GROUP_END"] = 3] = "GROUP_END"; - Status[Status["TRACK_END"] = 4] = "TRACK_END"; - })(Status || (Status = {})); - class Objects { - quic; - constructor(quic) { - this.quic = quic; - } - async send(h) { - const stream = await this.quic.createUnidirectionalStream(); - const w = new Writer(stream); - await w.u53(h.type); - await w.u62(h.sub); - await w.u62(h.track); - let res; - if (h.type == StreamType.Object) { - await w.u53(h.group); - await w.u53(h.object); - await w.u8(h.publisher_priority); - await w.u53(h.status); - res = new ObjectWriter(h, w); - } - else if (h.type === StreamType.Group) { - await w.u53(h.group); - await w.u8(h.publisher_priority); - res = new GroupWriter(h, w); - } - else if (h.type === StreamType.Track) { - await w.u8(h.publisher_priority); - res = new TrackWriter(h, w); - } - else { - throw new Error("unknown header type"); - } - // console.trace("send object", res.header) - return res; - } - async recv() { - const streams = this.quic.incomingUnidirectionalStreams.getReader(); - const { value, done } = await streams.read(); - streams.releaseLock(); - if (done) - return; - const r = new Reader(new Uint8Array(), value); - const type = (await r.u53()); - let res; - if (type == StreamType.Track) { - const h = { - type, - sub: await r.u62(), - track: await r.u62(), - publisher_priority: await r.u8(), - }; - res = new TrackReader(h, r); - } - else if (type == StreamType.Group) { - const h = { - type, - sub: await r.u62(), - track: await r.u62(), - group: await r.u53(), - publisher_priority: await r.u8(), - }; - res = new GroupReader(h, r); - } - else if (type == StreamType.Object) { - const h = { - type, - sub: await r.u62(), - track: await r.u62(), - group: await r.u53(), - object: await r.u53(), - status: await r.u53(), - publisher_priority: await r.u8(), - }; - res = new ObjectReader(h, r); - } - else { - throw new Error("unknown stream type"); - } - // console.trace("receive object", res.header) - return res; - } - } - class TrackWriter { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async write(c) { - await this.stream.u53(c.group); - await this.stream.u53(c.object); - if (c.payload instanceof Uint8Array) { - await this.stream.u53(c.payload.byteLength); - await this.stream.write(c.payload); - } - else { - // empty payload with status - await this.stream.u53(0); - await this.stream.u53(c.payload); - } - } - async close() { - await this.stream.close(); - } - } - class GroupWriter { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async write(c) { - await this.stream.u53(c.object); - if (c.payload instanceof Uint8Array) { - await this.stream.u53(c.payload.byteLength); - await this.stream.write(c.payload); - } - else { - await this.stream.u53(0); - await this.stream.u53(c.payload); - } - } - async close() { - await this.stream.close(); - } - } - class ObjectWriter { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async write(c) { - await this.stream.write(c.payload); - } - async close() { - await this.stream.close(); - } - } - class TrackReader { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async read() { - if (await this.stream.done()) { - return; - } - const group = await this.stream.u53(); - const object = await this.stream.u53(); - const size = await this.stream.u53(); - let payload; - if (size == 0) { - payload = (await this.stream.u53()); - } - else { - payload = await this.stream.read(size); - } - return { - group, - object, - payload, - }; - } - async close() { - await this.stream.close(); - } - } - class GroupReader { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - async read() { - if (await this.stream.done()) { - return; - } - const object = await this.stream.u53(); - const size = await this.stream.u53(); - let payload; - if (size == 0) { - payload = (await this.stream.u53()); - } - else { - payload = await this.stream.read(size); - } - return { - object, - payload, - }; - } - async close() { - await this.stream.close(); - } - } - class ObjectReader { - header; - stream; - constructor(header, stream) { - this.header = header; - this.stream = stream; - } - // NOTE: Can only be called once. - async read() { - if (await this.stream.done()) { - return; - } - return { - payload: await this.stream.readAll(), - }; - } - async close() { - await this.stream.close(); - } - } - - class Deferred { - promise; - resolve; - reject; - pending = true; - constructor() { - this.promise = new Promise((resolve, reject) => { - this.resolve = (value) => { - this.pending = false; - resolve(value); - }; - this.reject = (reason) => { - this.pending = false; - reject(reason); - }; - }); - } - } - class Watch { - #current; - #next = new Deferred(); - constructor(init) { - this.#next = new Deferred(); - this.#current = [init, this.#next.promise]; - } - value() { - return this.#current; - } - update(v) { - if (!this.#next.pending) { - throw new Error("already closed"); - } - // If we're given a function, call it with the current value - if (v instanceof Function) { - v = v(this.#current[0]); - } - const next = new Deferred(); - this.#current = [v, next.promise]; - this.#next.resolve(this.#current); - this.#next = next; - } - close() { - this.#current[1] = undefined; - this.#next.resolve(this.#current); - } - } - // Allows queuing N values, like a Channel. - class Queue { - #stream; - #closed = false; - constructor(capacity = 1) { - const queue = new CountQueuingStrategy({ highWaterMark: capacity }); - this.#stream = new TransformStream({}, undefined, queue); - } - async push(v) { - const w = this.#stream.writable.getWriter(); - await w.write(v); - w.releaseLock(); - } - async next() { - const r = this.#stream.readable.getReader(); - const { value, done } = await r.read(); - r.releaseLock(); - if (done) - return; - return value; - } - async abort(err) { - if (this.#closed) - return; - await this.#stream.writable.abort(err); - this.#closed = true; - } - async close() { - if (this.#closed) - return; - await this.#stream.writable.close(); - this.#closed = true; - } - closed() { - return this.#closed; - } - } - - class Publisher { - // Used to send control messages - #control; - // Use to send objects. - #objects; - // Our announced tracks. - #announce = new Map(); - // Their subscribed tracks. - #subscribe = new Map(); - #subscribeQueue = new Queue(Number.MAX_SAFE_INTEGER); // Unbounded queue in case there's no receiver - constructor(control, objects) { - this.#control = control; - this.#objects = objects; - } - // Announce a track namespace. - async announce(namespace) { - if (this.#announce.has(namespace)) { - throw new Error(`already announce: ${namespace}`); - } - const announce = new AnnounceSend(this.#control, namespace); - this.#announce.set(namespace, announce); - await this.#control.send({ - kind: Msg.Announce, - namespace, - }); - return announce; - } - // Receive the next new subscription - async subscribed() { - return await this.#subscribeQueue.next(); - } - async recv(msg) { - if (msg.kind == Msg.Subscribe) { - await this.recvSubscribe(msg); - } - else if (msg.kind == Msg.Unsubscribe) { - this.recvUnsubscribe(msg); - } - else if (msg.kind == Msg.AnnounceOk) { - this.recvAnnounceOk(msg); - } - else if (msg.kind == Msg.AnnounceError) { - this.recvAnnounceError(msg); - } - else { - throw new Error(`unknown control message`); // impossible - } - } - recvAnnounceOk(msg) { - const announce = this.#announce.get(msg.namespace); - if (!announce) { - throw new Error(`announce OK for unknown announce: ${msg.namespace}`); - } - announce.onOk(); - } - recvAnnounceError(msg) { - const announce = this.#announce.get(msg.namespace); - if (!announce) { - // TODO debug this - console.warn(`announce error for unknown announce: ${msg.namespace}`); - return; - } - announce.onError(msg.code, msg.reason); - } - async recvSubscribe(msg) { - if (this.#subscribe.has(msg.id)) { - throw new Error(`duplicate subscribe for id: ${msg.id}`); - } - const subscribe = new SubscribeRecv(this.#control, this.#objects, msg); - this.#subscribe.set(msg.id, subscribe); - await this.#subscribeQueue.push(subscribe); - await this.#control.send({ - kind: Msg.SubscribeOk, - id: msg.id, - expires: 0n, - group_order: msg.group_order, - }); - } - recvUnsubscribe(_msg) { - throw new Error("TODO unsubscribe"); - } - } - class AnnounceSend { - #control; - namespace; - // The current state, updated by control messages. - #state = new Watch("init"); - constructor(control, namespace) { - this.#control = control; - this.namespace = namespace; - } - async ok() { - for (;;) { - const [state, next] = this.#state.value(); - if (state === "ack") - return; - if (state instanceof Error) - throw state; - if (!next) - throw new Error("closed"); - await next; - } - } - async active() { - for (;;) { - const [state, next] = this.#state.value(); - if (state instanceof Error) - throw state; - if (!next) - return; - await next; - } - } - async close() { - // TODO implement unsubscribe - // await this.#inner.sendUnsubscribe() - } - closed() { - const [state, next] = this.#state.value(); - return state instanceof Error || next == undefined; - } - onOk() { - if (this.closed()) - return; - this.#state.update("ack"); - } - onError(code, reason) { - if (this.closed()) - return; - const err = new Error(`ANNOUNCE_ERROR (${code})` + reason ? `: ${reason}` : ""); - this.#state.update(err); - } - } - class SubscribeRecv { - #control; - #objects; - #id; - #trackId; - #subscriberPriority; - groupOrder; - namespace; - track; - // The current state of the subscription. - #state = "init"; - constructor(control, objects, msg) { - this.#control = control; // so we can send messages - this.#objects = objects; // so we can send objects - this.#id = msg.id; - this.#trackId = msg.trackId; - this.namespace = msg.namespace; - this.track = msg.name; - this.#subscriberPriority = msg.subscriber_priority; - this.groupOrder = msg.group_order; - } - // Acknowledge the subscription as valid. - async ack() { - if (this.#state !== "init") - return; - this.#state = "ack"; - // Send the control message. - return this.#control.send({ - kind: Msg.SubscribeOk, - id: this.#id, - expires: 0n, - group_order: this.groupOrder, - }); - } - // Close the subscription with an error. - async close(code = 0n, reason = "") { - if (this.#state === "closed") - return; - this.#state = "closed"; - return this.#control.send({ - kind: Msg.SubscribeDone, - id: this.#id, - code, - reason, - }); - } - // Create a writable data stream for the entire track - async serve(props) { - return this.#objects.send({ - type: StreamType.Track, - sub: this.#id, - track: this.#trackId, - publisher_priority: props?.priority ?? 127, - }); - } - // Create a writable data stream for a group within the track - async group(props) { - return this.#objects.send({ - type: StreamType.Group, - sub: this.#id, - track: this.#trackId, - group: props.group, - publisher_priority: props.priority ?? 127, - }); - } - // Create a writable data stream for a single object within the track - async object(props) { - return this.#objects.send({ - type: StreamType.Object, - sub: this.#id, - track: this.#trackId, - group: props.group, - object: props.object, - publisher_priority: props.priority ?? 127, - status: 0, - }); - } - } - - class Subscriber { - // Use to send control messages. - #control; - // Use to send objects. - #objects; - // Announced broadcasts. - #announce = new Map(); - #announceQueue = new Watch([]); - // Our subscribed tracks. - #subscribe = new Map(); - #subscribeNext = 0n; - #trackToIDMap = new Map(); - constructor(control, objects) { - this.#control = control; - this.#objects = objects; - } - announced() { - return this.#announceQueue; - } - async recv(msg) { - if (msg.kind == Msg.Announce) { - await this.recvAnnounce(msg); - } - else if (msg.kind == Msg.Unannounce) { - this.recvUnannounce(msg); - } - else if (msg.kind == Msg.SubscribeOk) { - this.recvSubscribeOk(msg); - } - else if (msg.kind == Msg.SubscribeError) { - await this.recvSubscribeError(msg); - } - else if (msg.kind == Msg.SubscribeDone) { - await this.recvSubscribeDone(msg); - } - else { - throw new Error(`unknown control message`); // impossible - } - } - async recvAnnounce(msg) { - if (this.#announce.has(msg.namespace)) { - throw new Error(`duplicate announce for namespace: ${msg.namespace}`); - } - await this.#control.send({ kind: Msg.AnnounceOk, namespace: msg.namespace }); - const announce = new AnnounceRecv(this.#control, msg.namespace); - this.#announce.set(msg.namespace, announce); - this.#announceQueue.update((queue) => [...queue, announce]); - } - recvUnannounce(_msg) { - throw new Error(`TODO Unannounce`); - } - async subscribe(namespace, track) { - const id = this.#subscribeNext++; - const subscribe = new SubscribeSend(this.#control, id, namespace, track); - this.#subscribe.set(id, subscribe); - this.#trackToIDMap.set(track, id); - await this.#control.send({ - kind: Msg.Subscribe, - id, - trackId: id, - namespace, - name: track, - subscriber_priority: 127, // default to mid value, see: https://github.com/moq-wg/moq-transport/issues/504 - group_order: GroupOrder.Publisher, - location: { - mode: "latest_group", - }, - }); - return subscribe; - } - async unsubscribe(track) { - if (this.#trackToIDMap.has(track)) { - const trackID = this.#trackToIDMap.get(track); - if (trackID === undefined) { - console.warn(`Exception track ${track} not found in trackToIDMap.`); - return; - } - try { - await this.#control.send({ kind: Msg.Unsubscribe, id: trackID }); - this.#trackToIDMap.delete(track); - } - catch (error) { - console.error(`Failed to unsubscribe from track ${track}:`, error); - } - } - else { - console.warn(`During unsubscribe request initiation attempt track ${track} not found in trackToIDMap.`); - } - } - recvSubscribeOk(msg) { - const subscribe = this.#subscribe.get(msg.id); - if (!subscribe) { - throw new Error(`subscribe ok for unknown id: ${msg.id}`); - } - subscribe.onOk(); - } - async recvSubscribeError(msg) { - const subscribe = this.#subscribe.get(msg.id); - if (!subscribe) { - throw new Error(`subscribe error for unknown id: ${msg.id}`); - } - await subscribe.onError(msg.code, msg.reason); - } - async recvSubscribeDone(msg) { - const subscribe = this.#subscribe.get(msg.id); - if (!subscribe) { - throw new Error(`subscribe error for unknown id: ${msg.id}`); - } - await subscribe.onError(msg.code, msg.reason); - } - async recvObject(reader) { - const subscribe = this.#subscribe.get(reader.header.track); - if (!subscribe) { - throw new Error(`data for for unknown track: ${reader.header.track}`); - } - await subscribe.onData(reader); - } - } - class AnnounceRecv { - #control; - namespace; - // The current state of the announce - #state = "init"; - constructor(control, namespace) { - this.#control = control; // so we can send messages - this.namespace = namespace; - } - // Acknowledge the subscription as valid. - async ok() { - if (this.#state !== "init") - return; - this.#state = "ack"; - // Send the control message. - return this.#control.send({ kind: Msg.AnnounceOk, namespace: this.namespace }); - } - async close(code = 0n, reason = "") { - if (this.#state === "closed") - return; - this.#state = "closed"; - return this.#control.send({ kind: Msg.AnnounceError, namespace: this.namespace, code, reason }); - } - } - class SubscribeSend { - #control; - #id; - namespace; - track; - // A queue of received streams for this subscription. - #data = new Queue(); - constructor(control, id, namespace, track) { - this.#control = control; // so we can send messages - this.#id = id; - this.namespace = namespace; - this.track = track; - } - async close(_code = 0n, _reason = "") { - // TODO implement unsubscribe - // await this.#inner.sendReset(code, reason) - } - onOk() { - // noop - } - async onError(code, reason) { - if (code == 0n) { - return await this.#data.close(); - } - if (reason !== "") { - reason = `: ${reason}`; - } - const err = new Error(`SUBSCRIBE_ERROR (${code})${reason}`); - return await this.#data.abort(err); - } - async onData(reader) { - if (!this.#data.closed()) - await this.#data.push(reader); - } - // Receive the next a readable data stream - async data() { - return await this.#data.next(); - } - } - - class Connection { - // The established WebTransport session. - #quic; - // Use to receive/send control messages. - #control; - // Use to receive/send objects. - #objects; - // Module for contributing tracks. - #publisher; - // Module for distributing tracks. - #subscriber; - // Async work running in the background - #running; - constructor(quic, control, objects) { - this.#quic = quic; - this.#control = control; - this.#objects = objects; - this.#publisher = new Publisher(this.#control, this.#objects); - this.#subscriber = new Subscriber(this.#control, this.#objects); - this.#running = this.#run(); - } - close(code = 0, reason = "") { - this.#quic.close({ closeCode: code, reason }); - } - async #run() { - await Promise.all([this.#runControl(), this.#runObjects()]); - } - announce(namespace) { - return this.#publisher.announce(namespace); - } - announced() { - return this.#subscriber.announced(); - } - subscribe(namespace, track) { - return this.#subscriber.subscribe(namespace, track); - } - unsubscribe(track) { - return this.#subscriber.unsubscribe(track); - } - subscribed() { - return this.#publisher.subscribed(); - } - async #runControl() { - // Receive messages until the connection is closed. - for (;;) { - const msg = await this.#control.recv(); - await this.#recv(msg); - } - } - async #runObjects() { - for (;;) { - const obj = await this.#objects.recv(); - if (!obj) - break; - await this.#subscriber.recvObject(obj); - } - } - async #recv(msg) { - if (isPublisher(msg)) { - await this.#subscriber.recv(msg); - } - else { - await this.#publisher.recv(msg); - } - } - async closed() { - try { - await this.#running; - return new Error("closed"); - } - catch (e) { - return asError(e); - } - } - } - - class Client { - #fingerprint; - config; - constructor(config) { - this.config = config; - this.#fingerprint = this.#fetchFingerprint(config.fingerprint).catch((e) => { - console.warn("failed to fetch fingerprint: ", e); - return undefined; - }); - } - async connect() { - // Helper function to make creating a promise easier - const options = {}; - const fingerprint = await this.#fingerprint; - if (fingerprint) - options.serverCertificateHashes = [fingerprint]; - const quic = new WebTransport(this.config.url, options); - await quic.ready; - const stream = await quic.createBidirectionalStream(); - const writer = new Writer(stream.writable); - const reader = new Reader(new Uint8Array(), stream.readable); - const setup = new Stream$1(reader, writer); - // Send the setup message. - await setup.send.client({ versions: [Version.DRAFT_05], role: this.config.role }); - // Receive the setup message. - // TODO verify the SETUP response. - const server = await setup.recv.server(); - if (server.version != Version.DRAFT_05) { - throw new Error(`unsupported server version: ${server.version}`); - } - const control = new Stream(reader, writer); - const objects = new Objects(quic); - return new Connection(quic, control, objects); - } - async #fetchFingerprint(url) { - if (!url) - return; - // TODO remove this fingerprint when Chrome WebTransport accepts the system CA - const response = await fetch(url); - const hexString = await response.text(); - const hexBytes = new Uint8Array(hexString.length / 2); - for (let i = 0; i < hexBytes.length; i += 1) { - hexBytes[i] = parseInt(hexString.slice(2 * i, 2 * i + 2), 16); - } - return { - algorithm: "sha-256", - value: hexBytes, - }; - } - } - - // This class must be created on the main thread due to AudioContext. - class Player { - #backend; - // A periodically updated timeline - //#timeline = new Watch(undefined) - #connection; - #catalog; - #tracksByName; - #tracknum; - #audioTrackName; - #videoTrackName; - #muted; - #paused; - // Running is a promise that resolves when the player is closed. - // #close is called with no error, while #abort is called with an error. - #running; - #close; - #abort; - #trackTasks = new Map(); - constructor(connection, catalog, backend, tracknum) { - this.#connection = connection; - this.#catalog = catalog; - this.#tracksByName = new Map(catalog.tracks.map((track) => [track.name, track])); - this.#backend = backend; - this.#tracknum = tracknum; - this.#audioTrackName = ""; - this.#videoTrackName = ""; - this.#muted = false; - this.#paused = false; - const abort = new Promise((resolve, reject) => { - this.#close = resolve; - this.#abort = reject; - }); - // Async work - this.#running = abort.catch(this.#close); - this.#run().catch((err) => { - console.error("Error in #run():", err); - this.#abort(err); - }); - } - static async create(config, tracknum) { - const client = new Client({ url: config.url, fingerprint: config.fingerprint, role: "subscriber" }); - const connection = await client.connect(); - const catalog = await fetch$1(connection, config.namespace); - console.log("catalog", catalog); - const canvas = config.canvas.transferControlToOffscreen(); - const backend = new Backend({ canvas, catalog }); - return new Player(connection, catalog, backend, tracknum); - } - async #run() { - const inits = new Set(); - const tracks = new Array(); - this.#catalog.tracks.forEach((track, index) => { - if (index == this.#tracknum || isAudioTrack(track)) { - if (!track.namespace) - throw new Error("track has no namespace"); - if (track.initTrack) - inits.add([track.namespace, track.initTrack]); - tracks.push(track); - } - }); - // Call #runInit on each unique init track - // TODO do this in parallel with #runTrack to remove a round trip - await Promise.all(Array.from(inits).map((init) => this.#runInit(...init))); - // Call #runTrack on each track - tracks.forEach((track) => { - this.#runTrack(track); - }); - } - async #runInit(namespace, name) { - const sub = await this.#connection.subscribe(namespace, name); - try { - const init = await Promise.race([sub.data(), this.#running]); - if (!init) - throw new Error("no init data"); - // We don't care what type of reader we get, we just want the payload. - const chunk = await init.read(); - if (!chunk) - throw new Error("no init chunk"); - if (!(chunk.payload instanceof Uint8Array)) - throw new Error("invalid init chunk"); - this.#backend.init({ data: chunk.payload, name }); - } - finally { - await sub.close(); - } - } - async #trackTask(track) { - if (!track.namespace) - throw new Error("track has no namespace"); - if (this.#paused) - return; - const kind = isVideoTrack(track) ? "video" : isAudioTrack(track) ? "audio" : "unknown"; - if (kind == "audio" && this.#muted) - return; - const sub = await this.#connection.subscribe(track.namespace, track.name); - if (kind == "audio") { - // Save ref to last audio track we subscribed to for unmuting - this.#audioTrackName = track.name; - } - if (kind == "video") { - this.#videoTrackName = track.name; - } - try { - for (;;) { - const segment = await Promise.race([sub.data(), this.#running]); - if (!segment) - continue; - if (!(segment instanceof GroupReader)) { - throw new Error(`expected group reader for segment: ${track.name}`); - } - if (kind == "unknown") { - throw new Error(`unknown track kind: ${track.name}`); - } - if (!track.initTrack) { - throw new Error(`no init track for segment: ${track.name}`); - } - const [buffer, stream] = segment.stream.release(); - this.#backend.segment({ - init: track.initTrack, - kind, - header: segment.header, - buffer, - stream, - }); - } - } - catch (error) { - console.error("Error in #runTrack:", error); - } - finally { - await sub.close(); - } - } - #runTrack(track) { - if (this.#trackTasks.has(track.name)) { - console.warn(`Already exist a runTrack task for the track: ${track.name}`); - return; - } - const task = (async () => this.#trackTask(track))(); - this.#trackTasks.set(track.name, task); - task.catch((err) => { - console.error(`Error to subscribe to track ${track.name}`, err); - }).finally(() => { - this.#trackTasks.delete(track.name); - }); - } - getCatalog() { - return this.#catalog; - } - getCurrentTrack() { - if (this.#tracknum >= 0 && this.#tracknum < this.#catalog.tracks.length) { - return this.#catalog.tracks[this.#tracknum]; - } - else { - console.warn("Invalid track number:", this.#tracknum); - return null; - } - } - getVideoTracks() { - return this.#catalog.tracks.filter(isVideoTrack).map((track) => track.name); - } - getAudioTracks() { - return this.#catalog.tracks.filter(isAudioTrack).map((track) => track.name); - } - async switchTrack(trackname) { - const currentTrack = this.getCurrentTrack(); - if (this.#paused) { - this.#videoTrackName = trackname; - return; - } - if (currentTrack) { - console.log(`Unsubscribing from track: ${currentTrack.name} and Subscribing to track: ${trackname}`); - await this.unsubscribeFromTrack(currentTrack.name); - } - else { - console.log(`Subscribing to track: ${trackname}`); - } - this.#tracknum = this.#catalog.tracks.findIndex((track) => track.name === trackname); - const tracksToStream = this.#catalog.tracks.filter((track) => track.name === trackname); - await Promise.all(tracksToStream.map((track) => this.#runTrack(track))); - } - async mute(isMuted) { - this.#muted = isMuted; - if (isMuted) { - console.log("Unsubscribing from audio track: ", this.#audioTrackName); - await this.unsubscribeFromTrack(this.#audioTrackName); - await this.#backend.mute(); - } - else { - console.log("Subscribing to audio track: ", this.#audioTrackName); - this.subscribeFromTrackName(this.#audioTrackName); - await this.#backend.unmute(); - } - } - async unsubscribeFromTrack(trackname) { - console.log(`Unsubscribing from track: ${trackname}`); - await this.#connection.unsubscribe(trackname); - const task = this.#trackTasks.get(trackname); - if (task) { - await task; - } - } - subscribeFromTrackName(trackname) { - console.log(`Subscribing to track: ${trackname}`); - const track = this.#tracksByName.get(trackname); - if (track) { - this.#runTrack(track); - } - else { - console.warn(`Track ${trackname} not in #tracksByName`); - } - } - #onMessage(msg) { - if (msg.timeline) ; - } - async close(err) { - if (err) - this.#abort(err); - else - this.#close(); - if (this.#connection) - this.#connection.close(); - if (this.#backend) - await this.#backend.close(); - } - async closed() { - try { - await this.#running; - } - catch (e) { - return asError(e); - } - } - /* - play() { - this.#backend.play({ minBuffer: 0.5 }) // TODO configurable - } - - seek(timestamp: number) { - this.#backend.seek({ timestamp }) - } - */ - async play() { - if (this.#paused) { - this.#paused = false; - this.subscribeFromTrackName(this.#videoTrackName); - if (!this.#muted) { - this.subscribeFromTrackName(this.#audioTrackName); - await this.#backend.unmute(); - } - } - else { - await this.unsubscribeFromTrack(this.#videoTrackName); - await this.unsubscribeFromTrack(this.#audioTrackName); - await this.#backend.mute(); - this.#backend.pause(); - this.#paused = true; - } - } - } - - return Player; - -})(); -//# sourceMappingURL=moq-player.iife.js.map diff --git a/simple-web/public/moq-player.iife.js.map b/simple-web/public/moq-player.iife.js.map deleted file mode 100644 index 575cf0c..0000000 --- a/simple-web/public/moq-player.iife.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"file":"moq-player.iife.js","sources":["../../../common/error.ts","../../../media/catalog/index.ts","../../../playback/audio.ts","../../../common/ring.ts","../../../playback/backend.ts","../../../transport/stream.ts","../../../transport/setup.ts","../../../transport/control.ts","../../../transport/objects.ts","../../../common/async.ts","../../../transport/publisher.ts","../../../transport/subscriber.ts","../../../transport/connection.ts","../../../transport/client.ts","../../../playback/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"names":["fetch","registerMyAudioWorklet","MediaWorker","Decoder","Encoder","Control.Msg","Control.GroupOrder","Control.isPublisher","Stream.Writer","Stream.Reader","Setup.Stream","Setup.Version","Control.Stream","Catalog.fetch","Catalog.isAudioTrack","Catalog.isVideoTrack"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file From b3c5483a01da30627e5e6989a28db5aeacc461ff Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Mon, 9 Dec 2024 16:37:15 -0300 Subject: [PATCH 05/14] feature: added volume control and UI element to test it --- lib/playback/audio.ts | 11 +++++-- lib/playback/backend.ts | 4 +++ lib/playback/index.ts | 9 +++++ web/src/components/volume.tsx | 62 +++++++++++++++++++++++++++-------- web/src/components/watch.tsx | 8 +++-- 5 files changed, 76 insertions(+), 18 deletions(-) diff --git a/lib/playback/audio.ts b/lib/playback/audio.ts index 687885a..a960bc5 100644 --- a/lib/playback/audio.ts +++ b/lib/playback/audio.ts @@ -10,12 +10,15 @@ import workletURL from "./worklet/index.ts?worker&url" export class Audio { context: AudioContext worklet: Promise + volumeNode: GainNode constructor(config: Message.ConfigAudio) { this.context = new AudioContext({ latencyHint: "interactive", sampleRate: config.sampleRate, }) + this.volumeNode = this.context.createGain() + this.volumeNode.gain.value = 1.0 this.worklet = this.load(config) } @@ -36,8 +39,8 @@ export class Audio { } // Connect the worklet to the volume node and then to the speakers - worklet.connect(volume) - volume.connect(this.context.destination) + worklet.connect(this.volumeNode) + this.volumeNode.connect(this.context.destination) worklet.port.postMessage({ config }) @@ -47,4 +50,8 @@ export class Audio { private on(_event: MessageEvent) { // TODO } + + public setVolume(newVolume: number) { + this.volumeNode.gain.setTargetAtTime(newVolume, this.context.currentTime, 0.01) + } } diff --git a/lib/playback/backend.ts b/lib/playback/backend.ts index 5505958..29393e5 100644 --- a/lib/playback/backend.ts +++ b/lib/playback/backend.ts @@ -87,6 +87,10 @@ export default class Backend { this.send({ segment }, segment.stream) } + setVolume(newVolume: number) { + this.#audio?.setVolume(newVolume) + } + async close() { this.#worker.terminate() await this.#audio?.context.close() diff --git a/lib/playback/index.ts b/lib/playback/index.ts index 79c98d3..caedb81 100644 --- a/lib/playback/index.ts +++ b/lib/playback/index.ts @@ -312,6 +312,15 @@ export class Player { } } + async setVolume(newVolume: number) { + this.#backend.setVolume(newVolume) + if (newVolume == 0 && !this.#muted) { + await this.mute(true) + } else if (newVolume > 0 && this.#muted) { + await this.mute(false) + } + } + /* async *timeline() { for (;;) { diff --git a/web/src/components/volume.tsx b/web/src/components/volume.tsx index 6e2b2e1..5415376 100644 --- a/web/src/components/volume.tsx +++ b/web/src/components/volume.tsx @@ -1,29 +1,63 @@ import { createSignal } from "solid-js" -type VolumeButtonProps = { +type VolumeControlProps = { mute: (isMuted: boolean) => void + setVolume: (newVolume: number) => void } -export const VolumeButton = (props: VolumeButtonProps) => { +export const VolumeControl = (props: VolumeControlProps) => { const [isMuted, setIsMuted] = createSignal(false) + const [currentVolume, setCurrentVolume] = createSignal(1) const toggleMute = () => { const newIsMuted = !isMuted() setIsMuted(newIsMuted) - props?.mute(newIsMuted) + props.mute(newIsMuted) + + if (newIsMuted) { + props.setVolume(0) + setCurrentVolume(0) + } else { + props.setVolume(1) + setCurrentVolume(1) + } + } + + const handleVolumeChange = (e: InputEvent & { currentTarget: HTMLInputElement }) => { + const volume = parseFloat(e.currentTarget.value) + if (volume == 0) { + setIsMuted(true) + } else { + setIsMuted(false) + } + setCurrentVolume(volume) + props.setVolume(volume) } return ( - +
+ + + +
) } diff --git a/web/src/components/watch.tsx b/web/src/components/watch.tsx index f054362..0cae9cc 100644 --- a/web/src/components/watch.tsx +++ b/web/src/components/watch.tsx @@ -2,7 +2,7 @@ import { Player } from "@kixelated/moq/playback" import Fail from "./fail" import { createEffect, createMemo, createSignal, onCleanup, Show } from "solid-js" -import { VolumeButton } from "./volume" +import { VolumeControl } from "./volume" import { PlayButton } from "./play-button" import { TrackSelect } from "./track-select" @@ -36,6 +36,10 @@ export default function Watch(props: { name: string }) { player()?.mute(state).catch(setError) } + const setVolume = (newVolume: number) => { + player()?.setVolume(newVolume).catch(setError) + } + const switchTrack = (track: string) => { void player()?.switchTrack(track) } @@ -108,7 +112,7 @@ export default function Watch(props: { name: string }) { >
- +
From 4c71184067d2fd3a5ff56e97939547f21ba7e568 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Mon, 9 Dec 2024 17:26:04 -0300 Subject: [PATCH 06/14] feat: no-op build script to express server --- simple-web/package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/simple-web/package.json b/simple-web/package.json index 516aa96..ac8a24e 100644 --- a/simple-web/package.json +++ b/simple-web/package.json @@ -2,6 +2,7 @@ "name": "simple-moq-web", "version": "1.0.0", "scripts": { + "build": "echo 'No build required'", "start": "node index.js", "dev": "nodemon index.js" }, From 924ce07f5c09fc6ac1c8eb25f6e566ecdf1cb381 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Tue, 10 Dec 2024 14:05:08 -0300 Subject: [PATCH 07/14] fix: restore previous volume level upon unmuting --- web/src/components/volume.tsx | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/web/src/components/volume.tsx b/web/src/components/volume.tsx index 5415376..69955d8 100644 --- a/web/src/components/volume.tsx +++ b/web/src/components/volume.tsx @@ -8,6 +8,7 @@ type VolumeControlProps = { export const VolumeControl = (props: VolumeControlProps) => { const [isMuted, setIsMuted] = createSignal(false) const [currentVolume, setCurrentVolume] = createSignal(1) + const [previousVolume, setPreviousVolume] = createSignal(1) const toggleMute = () => { const newIsMuted = !isMuted() @@ -15,11 +16,13 @@ export const VolumeControl = (props: VolumeControlProps) => { props.mute(newIsMuted) if (newIsMuted) { + setPreviousVolume(currentVolume()) props.setVolume(0) setCurrentVolume(0) } else { - props.setVolume(1) - setCurrentVolume(1) + const restoredVolume = previousVolume() + setCurrentVolume(restoredVolume) + props.setVolume(restoredVolume) } } From a977c50e421f2de2e0faa4415ae13b2a5ef53351 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Tue, 10 Dec 2024 15:25:59 -0300 Subject: [PATCH 08/14] fix: lint error fixed --- lib/.eslintrc.cjs | 2 ++ lib/rollup.config.js | 1 - simple-web/package.json | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/lib/.eslintrc.cjs b/lib/.eslintrc.cjs index 4984845..c771093 100644 --- a/lib/.eslintrc.cjs +++ b/lib/.eslintrc.cjs @@ -11,6 +11,7 @@ module.exports = { plugins: ["@typescript-eslint", "prettier", "solid"], root: true, env: { + commonjs: true, browser: true, es2022: true, worker: true, @@ -44,6 +45,7 @@ module.exports = { "@typescript-eslint/no-unsafe-member-access": "off", "@typescript-eslint/no-unsafe-assignment": "off", "@typescript-eslint/no-unsafe-return": "off", + "@typescript-eslint/no-var-requires": "off", // Make formatting errors into warnings "prettier/prettier": 1, diff --git a/lib/rollup.config.js b/lib/rollup.config.js index debbe20..de6403e 100644 --- a/lib/rollup.config.js +++ b/lib/rollup.config.js @@ -1,5 +1,4 @@ "use strict" -const path = require("path") const resolve = require("@rollup/plugin-node-resolve") const commonjs = require("@rollup/plugin-commonjs") const typescript = require("@rollup/plugin-typescript") diff --git a/simple-web/package.json b/simple-web/package.json index ac8a24e..72b18cf 100644 --- a/simple-web/package.json +++ b/simple-web/package.json @@ -3,6 +3,7 @@ "version": "1.0.0", "scripts": { "build": "echo 'No build required'", + "lint": "echo 'No lint configured'", "start": "node index.js", "dev": "nodemon index.js" }, From 0a4279079cdb3ed33f5412e00c096010cef8a027 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Tue, 10 Dec 2024 16:43:52 -0300 Subject: [PATCH 09/14] feat: minified build --- lib/package.json | 17 ++--- lib/rollup.config.js | 3 + package-lock.json | 122 ++++++++++++++++++++++++++++++++++- simple-web/public/index.html | 2 +- 4 files changed, 132 insertions(+), 12 deletions(-) diff --git a/lib/package.json b/lib/package.json index 695e47c..ce161b0 100644 --- a/lib/package.json +++ b/lib/package.json @@ -4,9 +4,9 @@ "description": "Media over QUIC library", "license": "(MIT OR Apache-2.0)", "entry": "playback/index.ts", - "main": "dist/next/moq-player.cjs.js", - "module": "dist/next/moq-player.esm.js", - "iife": "dist/iife/moq-player.iife.js", + "main": "dist/moq-player.cjs.js", + "module": "dist/moq-player.esm.js", + "iife": "dist/moq-player.iife.js", "types": "dist/types/moq-player.d.ts", "scripts": { "build": "rollup -c", @@ -18,15 +18,16 @@ "@babel/core": "^7.26.0", "@babel/preset-env": "^7.26.0", "@babel/preset-typescript": "^7.26.0", - "@typescript-eslint/eslint-plugin": "^6.4.0", - "@typescript-eslint/parser": "^6.4.0", "@rollup/plugin-babel": "^6.0.4", "@rollup/plugin-commonjs": "^28.0.1", "@rollup/plugin-node-resolve": "^15.3.0", + "@rollup/plugin-terser": "^0.4.4", "@rollup/plugin-typescript": "^12.1.1", "@types/audioworklet": "^0.0.50", "@types/dom-mediacapture-transform": "^0.1.6", "@types/dom-webcodecs": "^0.1.8", + "@typescript-eslint/eslint-plugin": "^6.4.0", + "@typescript-eslint/parser": "^6.4.0", "@typescript/lib-dom": "npm:@types/web@^0.0.115", "cross-env": "^7.0.2", "eslint": "^8.47.0", @@ -34,11 +35,11 @@ "eslint-plugin-prettier": "^5.0.0", "npm-run-all": "^4.1.5", "prettier": "^3.0.1", - "tslib": "^2.8.1", - "typescript": "^5.7.2", "rollup": "^4.28.0", "rollup-plugin-sourcemaps": "^0.6.2", - "rollup-plugin-web-worker-loader": "github:htoooth/rollup-plugin-web-worker-loader" + "rollup-plugin-web-worker-loader": "github:montevideo-tech/rollup-plugin-web-worker-loader", + "tslib": "^2.8.1", + "typescript": "^5.7.2" }, "dependencies": { "mp4box": "^0.5.2" diff --git a/lib/rollup.config.js b/lib/rollup.config.js index de6403e..c077621 100644 --- a/lib/rollup.config.js +++ b/lib/rollup.config.js @@ -4,6 +4,7 @@ const commonjs = require("@rollup/plugin-commonjs") const typescript = require("@rollup/plugin-typescript") const workerLoader = require("rollup-plugin-web-worker-loader") const babel = require("@rollup/plugin-babel") +const terser = require("@rollup/plugin-terser") const sourceMaps = require("rollup-plugin-sourcemaps") const pkg = require("./package.json") @@ -33,6 +34,7 @@ config.push({ presets: ["@babel/preset-env", "@babel/preset-typescript"], exclude: "./node_modules/*", }), + terser(), ], }) @@ -57,6 +59,7 @@ config.push({ presets: ["@babel/preset-env", "@babel/preset-typescript"], exclude: "./node_modules/*", }), + terser(), ], }) diff --git a/package-lock.json b/package-lock.json index 55de99d..c87ace8 100644 --- a/package-lock.json +++ b/package-lock.json @@ -28,6 +28,7 @@ "@rollup/plugin-babel": "^6.0.4", "@rollup/plugin-commonjs": "^28.0.1", "@rollup/plugin-node-resolve": "^15.3.0", + "@rollup/plugin-terser": "^0.4.4", "@rollup/plugin-typescript": "^12.1.1", "@types/audioworklet": "^0.0.50", "@types/dom-mediacapture-transform": "^0.1.6", @@ -43,7 +44,7 @@ "prettier": "^3.0.1", "rollup": "^4.28.0", "rollup-plugin-sourcemaps": "^0.6.2", - "rollup-plugin-web-worker-loader": "github:htoooth/rollup-plugin-web-worker-loader", + "rollup-plugin-web-worker-loader": "github:montevideo-tech/rollup-plugin-web-worker-loader", "tslib": "^2.8.1", "typescript": "^5.7.2" } @@ -2014,6 +2015,17 @@ "node": ">=6.0.0" } }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz", + "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, "node_modules/@jridgewell/sourcemap-codec": { "version": "1.4.15", "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", @@ -2389,6 +2401,29 @@ } } }, + "node_modules/@rollup/plugin-terser": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-0.4.4.tgz", + "integrity": "sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "serialize-javascript": "^6.0.1", + "smob": "^1.0.0", + "terser": "^5.17.4" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, "node_modules/@rollup/plugin-typescript": { "version": "12.1.1", "resolved": "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-12.1.1.tgz", @@ -3771,6 +3806,13 @@ "ieee754": "^1.2.1" } }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "devOptional": true, + "license": "MIT" + }, "node_modules/bundle-name": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-3.0.0.tgz", @@ -10219,6 +10261,16 @@ "integrity": "sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==", "optional": true }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, "node_modules/range-parser": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", @@ -10825,8 +10877,8 @@ "license": "MIT" }, "node_modules/rollup-plugin-web-worker-loader": { - "version": "1.6.1", - "resolved": "git+ssh://git@github.com/htoooth/rollup-plugin-web-worker-loader.git#f9c35e0cfd07bfedc38400e9163013a9e9265cbf", + "version": "1.6.2", + "resolved": "git+ssh://git@github.com/montevideo-tech/rollup-plugin-web-worker-loader.git#b07d05278c65c79fff58e93b4137cd2d57a3f646", "dev": true, "license": "MIT", "peerDependencies": { @@ -11163,6 +11215,16 @@ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" }, + "node_modules/serialize-javascript": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz", + "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "randombytes": "^2.1.0" + } + }, "node_modules/seroval": { "version": "0.5.1", "resolved": "https://registry.npmjs.org/seroval/-/seroval-0.5.1.tgz", @@ -11856,6 +11918,13 @@ "node": ">=8" } }, + "node_modules/smob": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/smob/-/smob-1.5.0.tgz", + "integrity": "sha512-g6T+p7QO8npa+/hNx9ohv1E5pVCmWrVCUzUXJyLdMmftX6ER0oiWY/w9knEonLpnOp6b6FenKnMfR8gqwWdwig==", + "dev": true, + "license": "MIT" + }, "node_modules/solid-js": { "version": "1.7.12", "resolved": "https://registry.npmjs.org/solid-js/-/solid-js-1.7.12.tgz", @@ -11906,6 +11975,27 @@ "decode-uri-component": "^0.2.0" } }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/source-map-support/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "devOptional": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/space-separated-tokens": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", @@ -12354,6 +12444,32 @@ "streamx": "^2.15.0" } }, + "node_modules/terser": { + "version": "5.37.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.37.0.tgz", + "integrity": "sha512-B8wRRkmre4ERucLM/uXx4MOV5cbnOlVAqUst+1+iLKPI0dOgFO28f84ptoQt9HEI537PMzfYa/d+GEPKTRXmYA==", + "devOptional": true, + "license": "BSD-2-Clause", + "dependencies": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/terser/node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "devOptional": true, + "license": "MIT" + }, "node_modules/text-table": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", diff --git a/simple-web/public/index.html b/simple-web/public/index.html index 1c0f36e..5c488cd 100644 --- a/simple-web/public/index.html +++ b/simple-web/public/index.html @@ -1,5 +1,5 @@ - + From 35d75d3d8b3916cd1c26fe4e15a567fc8f0e2446 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Wed, 11 Dec 2024 11:28:50 -0300 Subject: [PATCH 10/14] feat: improved play/pause --- lib/playback/backend.ts | 6 +++++- lib/playback/index.ts | 5 +++-- lib/playback/worker/index.ts | 17 +++++++++++++---- lib/playback/worker/message.ts | 2 +- lib/playback/worker/video.ts | 15 ++++++++++++--- 5 files changed, 34 insertions(+), 11 deletions(-) diff --git a/lib/playback/backend.ts b/lib/playback/backend.ts index 5505958..29cbf5d 100644 --- a/lib/playback/backend.ts +++ b/lib/playback/backend.ts @@ -68,7 +68,11 @@ export default class Backend { } pause() { - this.send({ pause: true }) + this.send({ play: false }) + } + + play() { + this.send({ play: true }) } async mute() { diff --git a/lib/playback/index.ts b/lib/playback/index.ts index 79c98d3..36aac6c 100644 --- a/lib/playback/index.ts +++ b/lib/playback/index.ts @@ -303,12 +303,13 @@ export class Player { this.subscribeFromTrackName(this.#audioTrackName) await this.#backend.unmute() } + this.#backend.play() } else { + this.#paused = true + this.#backend.pause() await this.unsubscribeFromTrack(this.#videoTrackName) await this.unsubscribeFromTrack(this.#audioTrackName) await this.#backend.mute() - this.#backend.pause() - this.#paused = true } } diff --git a/lib/playback/worker/index.ts b/lib/playback/worker/index.ts index a1a7ff9..11d9c10 100644 --- a/lib/playback/worker/index.ts +++ b/lib/playback/worker/index.ts @@ -22,6 +22,7 @@ class Worker { on(e: MessageEvent) { const msg = e.data as Message.ToWorker + console.log("message: ", msg) if (msg.config) { this.#onConfig(msg.config) @@ -30,8 +31,10 @@ class Worker { this.#onInit(msg.init) } else if (msg.segment) { this.#onSegment(msg.segment).catch(console.warn) - } else if (msg.pause) { - this.#onPause(msg.pause) + } else if (msg.play === false) { + this.#onPause(msg.play) + } else if (msg.play === true) { + this.#onPlay(msg.play) } else { throw new Error(`unknown message: + ${JSON.stringify(msg)}`) } @@ -103,11 +106,17 @@ class Worker { await segment.close() } - #onPause(pause: boolean) { - if (this.#video && pause) { + #onPause(play: boolean) { + if (this.#video && !play) { this.#video.pause() } } + + #onPlay(play: boolean) { + if (this.#video && play) { + this.#video.play() + } + } } // Pass all events to the worker diff --git a/lib/playback/worker/message.ts b/lib/playback/worker/message.ts index f0bba26..1d822d4 100644 --- a/lib/playback/worker/message.ts +++ b/lib/playback/worker/message.ts @@ -76,7 +76,7 @@ export interface ToWorker { // Sent on each init/data stream init?: Init segment?: Segment - pause?: boolean + play?: boolean /* // Sent to control playback diff --git a/lib/playback/worker/video.ts b/lib/playback/worker/video.ts index 682b512..5bb015a 100644 --- a/lib/playback/worker/video.ts +++ b/lib/playback/worker/video.ts @@ -27,10 +27,12 @@ export class Renderer { #decoderConfig?: DecoderConfig #waitingForKeyframe: boolean = true + #paused: boolean constructor(config: Message.ConfigVideo, timeline: Component) { this.#canvas = config.canvas this.#timeline = timeline + this.#paused = false this.#queue = new TransformStream({ start: this.#start.bind(this), @@ -41,10 +43,17 @@ export class Renderer { } pause() { - console.log("pause") + this.#paused = true + this.#decoder.flush().catch((err) => { + console.error(err) + }) this.#waitingForKeyframe = true } + play() { + this.#paused = false + } + async #run() { const reader = this.#timeline.frames.pipeThrough(this.#queue).getReader() for (;;) { @@ -74,8 +83,8 @@ export class Renderer { } #transform(frame: Frame) { - if (this.#decoder.state === "closed") { - console.warn("Decoder is closed. Skipping frame.") + if (this.#decoder.state === "closed" || this.#paused) { + console.warn("Decoder is closed or paused. Skipping frame.") return } From 8e04aaf4ec0f8a9e6531dc8e8abca955da4f5572 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Tue, 17 Dec 2024 15:07:09 -0300 Subject: [PATCH 11/14] feat: optimistic play button --- lib/playback/index.ts | 7 ++++--- lib/playback/worker/index.ts | 2 +- lib/playback/worker/video.ts | 1 + web/src/components/watch.tsx | 21 ++++++++++----------- 4 files changed, 16 insertions(+), 15 deletions(-) diff --git a/lib/playback/index.ts b/lib/playback/index.ts index 36aac6c..8a16b96 100644 --- a/lib/playback/index.ts +++ b/lib/playback/index.ts @@ -307,9 +307,10 @@ export class Player { } else { this.#paused = true this.#backend.pause() - await this.unsubscribeFromTrack(this.#videoTrackName) - await this.unsubscribeFromTrack(this.#audioTrackName) - await this.#backend.mute() + const mutePromise = this.#backend.mute() + const audioPromise = this.unsubscribeFromTrack(this.#audioTrackName) + const videoPromise = this.unsubscribeFromTrack(this.#videoTrackName) + await Promise.all([mutePromise, audioPromise, videoPromise]) } } diff --git a/lib/playback/worker/index.ts b/lib/playback/worker/index.ts index 11d9c10..07dd7fe 100644 --- a/lib/playback/worker/index.ts +++ b/lib/playback/worker/index.ts @@ -22,7 +22,7 @@ class Worker { on(e: MessageEvent) { const msg = e.data as Message.ToWorker - console.log("message: ", msg) + // console.log("message: ", msg) if (msg.config) { this.#onConfig(msg.config) diff --git a/lib/playback/worker/video.ts b/lib/playback/worker/video.ts index 5bb015a..b0c3061 100644 --- a/lib/playback/worker/video.ts +++ b/lib/playback/worker/video.ts @@ -58,6 +58,7 @@ export class Renderer { const reader = this.#timeline.frames.pipeThrough(this.#queue).getReader() for (;;) { const { value: frame, done } = await reader.read() + if (this.#paused) continue if (done) break self.requestAnimationFrame(() => { diff --git a/web/src/components/watch.tsx b/web/src/components/watch.tsx index f054362..000aa2f 100644 --- a/web/src/components/watch.tsx +++ b/web/src/components/watch.tsx @@ -5,6 +5,7 @@ import { createEffect, createMemo, createSignal, onCleanup, Show } from "solid-j import { VolumeButton } from "./volume" import { PlayButton } from "./play-button" import { TrackSelect } from "./track-select" +import { promise } from "astro/zod" export default function Watch(props: { name: string }) { // Use query params to allow overriding environment variables. @@ -47,17 +48,15 @@ export default function Watch(props: { name: string }) { const handlePlayPause = () => { const playerInstance = player() if (!playerInstance) return - - if (playerInstance.isPaused()) { - playerInstance - .play() - .then(() => setIsPlaying(true)) - .catch(setError) - } else { - playerInstance - .play() - .then(() => setIsPlaying(false)) - .catch(setError) + try { + void playerInstance.play() + if (playerInstance.isPaused()) { + setIsPlaying(false) + } else { + setIsPlaying(true) + } + } catch (err) { + setError(err instanceof Error ? err : new Error(String(err))) } } From 7665464d118c3a52b653f456710ec2f6adac810d Mon Sep 17 00:00:00 2001 From: Mike English Date: Thu, 19 Dec 2024 13:32:41 -0500 Subject: [PATCH 12/14] Add package-lock as resolved on my Mac --- package-lock.json | 7059 +++++++++++++++++++++++++++++---------------- 1 file changed, 4506 insertions(+), 2553 deletions(-) diff --git a/package-lock.json b/package-lock.json index c87ace8..001e2b7 100644 --- a/package-lock.json +++ b/package-lock.json @@ -49,58 +49,11 @@ "typescript": "^5.7.2" } }, - "lib/node_modules/rollup": { - "version": "4.28.1", - "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.28.1.tgz", - "integrity": "sha512-61fXYl/qNVinKmGSTHAZ6Yy8I3YIJC/r2m9feHo6SwVAVcLT5MPwOUFe7EuURA/4m0NR8lXG4BBXuo/IZEsjMg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@types/estree": "1.0.6" - }, - "bin": { - "rollup": "dist/bin/rollup" - }, - "engines": { - "node": ">=18.0.0", - "npm": ">=8.0.0" - }, - "optionalDependencies": { - "@rollup/rollup-android-arm-eabi": "4.28.1", - "@rollup/rollup-android-arm64": "4.28.1", - "@rollup/rollup-darwin-arm64": "4.28.1", - "@rollup/rollup-darwin-x64": "4.28.1", - "@rollup/rollup-freebsd-arm64": "4.28.1", - "@rollup/rollup-freebsd-x64": "4.28.1", - "@rollup/rollup-linux-arm-gnueabihf": "4.28.1", - "@rollup/rollup-linux-arm-musleabihf": "4.28.1", - "@rollup/rollup-linux-arm64-gnu": "4.28.1", - "@rollup/rollup-linux-arm64-musl": "4.28.1", - "@rollup/rollup-linux-loongarch64-gnu": "4.28.1", - "@rollup/rollup-linux-powerpc64le-gnu": "4.28.1", - "@rollup/rollup-linux-riscv64-gnu": "4.28.1", - "@rollup/rollup-linux-s390x-gnu": "4.28.1", - "@rollup/rollup-linux-x64-gnu": "4.28.1", - "@rollup/rollup-linux-x64-musl": "4.28.1", - "@rollup/rollup-win32-arm64-msvc": "4.28.1", - "@rollup/rollup-win32-ia32-msvc": "4.28.1", - "@rollup/rollup-win32-x64-msvc": "4.28.1", - "fsevents": "~2.3.2" - } - }, - "node_modules/@aashutoshrathi/word-wrap": { - "version": "1.2.6", - "resolved": "https://registry.npmjs.org/@aashutoshrathi/word-wrap/-/word-wrap-1.2.6.tgz", - "integrity": "sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/@alloc/quick-lru": { "version": "5.2.0", "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==", + "license": "MIT", "engines": { "node": ">=10" }, @@ -109,31 +62,35 @@ } }, "node_modules/@ampproject/remapping": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.1.tgz", - "integrity": "sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz", + "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==", + "license": "Apache-2.0", "dependencies": { - "@jridgewell/gen-mapping": "^0.3.0", - "@jridgewell/trace-mapping": "^0.3.9" + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" }, "engines": { "node": ">=6.0.0" } }, "node_modules/@astrojs/compiler": { - "version": "2.8.1", - "resolved": "https://registry.npmjs.org/@astrojs/compiler/-/compiler-2.8.1.tgz", - "integrity": "sha512-NGfPAgU/9rvDEwsXu82RI1AxiivaxtEYBK9saW1f+2fTHUUqCJQ27HYtb2akG2QxCmFikgZ9zk26BEWgiHho1Q==" + "version": "2.10.3", + "resolved": "https://registry.npmjs.org/@astrojs/compiler/-/compiler-2.10.3.tgz", + "integrity": "sha512-bL/O7YBxsFt55YHU021oL+xz+B/9HvGNId3F9xURN16aeqDK9juHGktdkCSXz+U4nqFACq6ZFvWomOzhV+zfPw==", + "license": "MIT" }, "node_modules/@astrojs/internal-helpers": { "version": "0.2.1", "resolved": "https://registry.npmjs.org/@astrojs/internal-helpers/-/internal-helpers-0.2.1.tgz", - "integrity": "sha512-06DD2ZnItMwUnH81LBLco3tWjcZ1lGU9rLCCBaeUCGYe9cI0wKyY2W3kDyoW1I6GmcWgt1fu+D1CTvz+FIKf8A==" + "integrity": "sha512-06DD2ZnItMwUnH81LBLco3tWjcZ1lGU9rLCCBaeUCGYe9cI0wKyY2W3kDyoW1I6GmcWgt1fu+D1CTvz+FIKf8A==", + "license": "MIT" }, "node_modules/@astrojs/markdown-remark": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/@astrojs/markdown-remark/-/markdown-remark-3.2.0.tgz", - "integrity": "sha512-jigyLfefUZPKgVmmraCkVpdUuFH1R3SrpgQO13axsgwLDBgkggaQpNR5Ag4O9PDualeBtbdt30aYSfvnBKx9Hg==", + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/@astrojs/markdown-remark/-/markdown-remark-3.5.0.tgz", + "integrity": "sha512-q7vdIqzYhxpsfghg2YmkmSXCfp4w7lBTYP+SSHw89wVhC5Riltr3u8w2otBRxNLSByNi+ht/gGkFC23Shetytw==", + "license": "MIT", "dependencies": { "@astrojs/prism": "^3.0.0", "github-slugger": "^2.0.0", @@ -145,21 +102,22 @@ "remark-parse": "^10.0.2", "remark-rehype": "^10.1.0", "remark-smartypants": "^2.0.0", - "shiki": "^0.14.3", + "shikiji": "^0.6.8", "unified": "^10.1.2", "unist-util-visit": "^4.1.2", "vfile": "^5.3.7" }, "peerDependencies": { - "astro": "^3.1.0" + "astro": "^3.0.0" } }, "node_modules/@astrojs/mdx": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/@astrojs/mdx/-/mdx-1.1.0.tgz", - "integrity": "sha512-rmLZBw3CUCkp+5blBJloV2EqJGRaJTraJygWMfCvrLcCA3vzhwzACnVQKdUDlts8EEr6V6+HXYVqi46AVEfobg==", + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@astrojs/mdx/-/mdx-1.1.5.tgz", + "integrity": "sha512-4bveyB1Lb1vWo2kdHJjQYoCytWlrIjAxHATHUTuYnBPmdPjsfy9wuCnb9rozwyyarDABx87CzG5gotBNYd+dVA==", + "license": "MIT", "dependencies": { - "@astrojs/markdown-remark": "3.2.0", + "@astrojs/markdown-remark": "3.5.0", "@mdx-js/mdx": "^2.3.0", "acorn": "^8.10.0", "es-module-lexer": "^1.3.0", @@ -179,36 +137,39 @@ "node": ">=18.14.1" }, "peerDependencies": { - "astro": "^3.1.0" + "astro": "^3.0.0" } }, "node_modules/@astrojs/node": { - "version": "6.0.2", - "resolved": "https://registry.npmjs.org/@astrojs/node/-/node-6.0.2.tgz", - "integrity": "sha512-iOUpBP9Wi8noJv4ka/MAHwUB/fUaYuDD4m6mOn7YCr0Rd7pbyyKtpg4yJAQUAKQues3HUOWZIVP58SaeTPbLMQ==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/@astrojs/node/-/node-6.1.0.tgz", + "integrity": "sha512-rqhZuVDUHVynkBaI/a8Y/WjVeFvKaH4qyrTkC8ZFwYUVff2DPQHS5/wLlTtS3s1GglApYsvPB9DdTL7sqUe9Kg==", + "license": "MIT", "dependencies": { "send": "^0.18.0", "server-destroy": "^1.0.1" }, "peerDependencies": { - "astro": "^3.2.1" + "astro": "^3.0.0" } }, "node_modules/@astrojs/prism": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/@astrojs/prism/-/prism-3.0.0.tgz", - "integrity": "sha512-g61lZupWq1bYbcBnYZqdjndShr/J3l/oFobBKPA3+qMat146zce3nz2kdO4giGbhYDt4gYdhmoBz0vZJ4sIurQ==", + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@astrojs/prism/-/prism-3.2.0.tgz", + "integrity": "sha512-GilTHKGCW6HMq7y3BUv9Ac7GMe/MO9gi9GW62GzKtth0SwukCu/qp2wLiGpEujhY+VVhaG9v7kv/5vFzvf4NYw==", + "license": "MIT", "dependencies": { "prismjs": "^1.29.0" }, "engines": { - "node": ">=18.14.1" + "node": "^18.17.1 || ^20.3.0 || >=22.0.0" } }, "node_modules/@astrojs/solid-js": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/@astrojs/solid-js/-/solid-js-3.0.1.tgz", - "integrity": "sha512-2powD8dA9WIH6E63ZWU+QRpI+9QmVsfmKk1VsQGvja0sxMcaGz/DJFpEFhHafK3sU4Htne7l5aAUnKVlA19iyw==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@astrojs/solid-js/-/solid-js-3.0.3.tgz", + "integrity": "sha512-MS/SoKUNByBjclhXn004DEsfi4rDNrg0LVbjgSnVfGHrdjP1dQd5bnm0wah04QuhqJCfsIF0ba9c02qJhaj/2w==", + "license": "MIT", "dependencies": { "vite-plugin-solid": "^2.7.0" }, @@ -220,16 +181,17 @@ } }, "node_modules/@astrojs/tailwind": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/@astrojs/tailwind/-/tailwind-5.0.0.tgz", - "integrity": "sha512-bMZZNNm/SW+ijUKMQDhdiuNWDdR3CubEKUHb2Ran4Arx1ikWn/kKIkFDXUV+MUnsLa7s19x9VMRlARRyKbqMkQ==", + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/@astrojs/tailwind/-/tailwind-5.1.3.tgz", + "integrity": "sha512-XF7WhXRhqEHGvADqc0kDtF7Yv/g4wAWTaj91jBBTBaYnc4+MQLH94duFfFa4NlTkRG40VQd012eF3MhO3Kk+bg==", + "license": "MIT", "dependencies": { - "autoprefixer": "^10.4.15", - "postcss": "^8.4.28", - "postcss-load-config": "^4.0.1" + "autoprefixer": "^10.4.20", + "postcss": "^8.4.49", + "postcss-load-config": "^4.0.2" }, "peerDependencies": { - "astro": "^3.0.0", + "astro": "^3.0.0 || ^4.0.0 || ^5.0.0", "tailwindcss": "^3.0.24" } }, @@ -237,6 +199,7 @@ "version": "3.0.4", "resolved": "https://registry.npmjs.org/@astrojs/telemetry/-/telemetry-3.0.4.tgz", "integrity": "sha512-A+0c7k/Xy293xx6odsYZuXiaHO0PL+bnDoXOc47sGDF5ffIKdKQGRPFl2NMlCF4L0NqN4Ynbgnaip+pPF0s7pQ==", + "license": "MIT", "dependencies": { "ci-info": "^3.8.0", "debug": "^4.3.4", @@ -307,6 +270,7 @@ "version": "6.3.1", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", "bin": { "semver": "bin/semver.js" } @@ -368,6 +332,7 @@ "version": "7.25.9", "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.25.9.tgz", "integrity": "sha512-UTZQMvt0d/rSz6KI+qdu7GQze5TIajwTS++GUozlw8VBJDEOAqSXwm1WvmYEZwqdqSGQshRocPDqrt4HBZB3fQ==", + "dev": true, "license": "MIT", "dependencies": { "@babel/helper-annotate-as-pure": "^7.25.9", @@ -389,6 +354,7 @@ "version": "6.3.1", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, "license": "ISC", "bin": { "semver": "bin/semver.js" @@ -443,6 +409,7 @@ "version": "7.25.9", "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.25.9.tgz", "integrity": "sha512-wbfdZ9w5vk0C0oyHqAJbc62+vet5prjj01jjJ8sKn3j9h3MQQlflEdXYvuqRWjHnM12coDEqiC1IRCi0U/EKwQ==", + "dev": true, "license": "MIT", "dependencies": { "@babel/traverse": "^7.25.9", @@ -486,6 +453,7 @@ "version": "7.25.9", "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.25.9.tgz", "integrity": "sha512-FIpuNaz5ow8VyrYcnXQTDRGvV6tTjkNtCK/RYNDXGSLlUD6cBuQTSw43CShGxjvfBTfcUA/r6UhUCbtYqkhcuQ==", + "dev": true, "license": "MIT", "dependencies": { "@babel/types": "^7.25.9" @@ -525,6 +493,7 @@ "version": "7.25.9", "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.25.9.tgz", "integrity": "sha512-IiDqTOTBQy0sWyeXyGSC5TBJpGFXBkRynjBeXsvbhQFKj2viwJC76Epz35YLU1fpe/Am6Vppb7W7zM4fPQzLsQ==", + "dev": true, "license": "MIT", "dependencies": { "@babel/helper-member-expression-to-functions": "^7.25.9", @@ -542,6 +511,7 @@ "version": "7.25.9", "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.25.9.tgz", "integrity": "sha512-K4Du3BFa3gvyhzgPcntrkDgZzQaq6uozzcpGbOO1OEJaI+EJdqWIMTLgFgQf6lrfiDFo5FU+BxKepI9RmZqahA==", + "dev": true, "license": "MIT", "dependencies": { "@babel/traverse": "^7.25.9", @@ -769,6 +739,7 @@ "version": "7.25.9", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.25.9.tgz", "integrity": "sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ==", + "dev": true, "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.25.9" @@ -1187,6 +1158,7 @@ "version": "7.26.3", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.26.3.tgz", "integrity": "sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ==", + "dev": true, "license": "MIT", "dependencies": { "@babel/helper-module-transforms": "^7.26.0", @@ -1436,15 +1408,16 @@ } }, "node_modules/@babel/plugin-transform-react-jsx": { - "version": "7.22.15", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.22.15.tgz", - "integrity": "sha512-oKckg2eZFa8771O/5vi7XeTvmM6+O9cxZu+kanTU7tD4sin5nO/G8jGJhq8Hvt2Z0kUoEDRayuZLaUlYl8QuGA==", + "version": "7.25.9", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.25.9.tgz", + "integrity": "sha512-s5XwpQYCqGerXl+Pu6VDL3x0j2d82eiV77UJ8a2mDHAW7j9SWRqQ2y1fNo1Z74CdcYipl5Z41zvjj4Nfzq36rw==", + "license": "MIT", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.22.5", - "@babel/helper-module-imports": "^7.22.15", - "@babel/helper-plugin-utils": "^7.22.5", - "@babel/plugin-syntax-jsx": "^7.22.5", - "@babel/types": "^7.22.15" + "@babel/helper-annotate-as-pure": "^7.25.9", + "@babel/helper-module-imports": "^7.25.9", + "@babel/helper-plugin-utils": "^7.25.9", + "@babel/plugin-syntax-jsx": "^7.25.9", + "@babel/types": "^7.25.9" }, "engines": { "node": ">=6.9.0" @@ -1588,6 +1561,7 @@ "version": "7.26.3", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.26.3.tgz", "integrity": "sha512-6+5hpdr6mETwSKjmJUdYw0EIkATiQhnELWlE3kJFBwSg/BGIVwVaVbX+gOXBCdc7Ln1RXZxyWGecIXhUfnl7oA==", + "dev": true, "license": "MIT", "dependencies": { "@babel/helper-annotate-as-pure": "^7.25.9", @@ -1783,6 +1757,7 @@ "version": "7.26.0", "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.26.0.tgz", "integrity": "sha512-NMk1IGZ5I/oHhoXEElcm+xUnL/szL6xflkFZmoEU9xj1qSJXpiS7rsspYo92B4DRCDvZn2erT5LdsCeXAKNCkg==", + "dev": true, "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.25.9", @@ -1799,10 +1774,11 @@ } }, "node_modules/@babel/runtime": { - "version": "7.23.1", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.23.1.tgz", - "integrity": "sha512-hC2v6p8ZSI/W0HUzh3V8C5g+NwSKzKPtJwSpTjwl0o297GP9+ZLQSkdvHz46CM3LqyoXxq+5G9komY+eSqSO0g==", + "version": "7.26.0", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.26.0.tgz", + "integrity": "sha512-FDSOghenHTiToteC/QRlv2q3DhPZ/oOXTBoirfWNx1Cx3TMVcGWQtMMmQcSvb/JjpNeGzx8Pq/b4fKEJuWm1sw==", "dev": true, + "license": "MIT", "dependencies": { "regenerator-runtime": "^0.14.0" }, @@ -1855,591 +1831,964 @@ "node": ">=6.9.0" } }, - "node_modules/@esbuild/linux-x64": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.4.tgz", - "integrity": "sha512-Mi4aNA3rz1BNFtB7aGadMD0MavmzuuXNTaYL6/uiYIs08U7YMPETpgNn5oue3ICr+inKwItOwSsJDYkrE9ekVg==", + "node_modules/@esbuild/aix-ppc64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.19.12.tgz", + "integrity": "sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==", "cpu": [ - "x64" + "ppc64" ], + "license": "MIT", "optional": true, "os": [ - "linux" + "aix" ], "engines": { "node": ">=12" } }, - "node_modules/@eslint-community/eslint-utils": { - "version": "4.4.0", - "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", - "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", - "dev": true, - "dependencies": { - "eslint-visitor-keys": "^3.3.0" - }, + "node_modules/@esbuild/android-arm": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.12.tgz", + "integrity": "sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" - }, - "peerDependencies": { - "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + "node": ">=12" } }, - "node_modules/@eslint-community/regexpp": { - "version": "4.9.1", - "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.9.1.tgz", - "integrity": "sha512-Y27x+MBLjXa+0JWDhykM3+JE+il3kHKAEqabfEWq3SDhZjLYb6/BHL/JKFnH3fe207JaXkyDo685Oc2Glt6ifA==", - "dev": true, + "node_modules/@esbuild/android-arm64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.12.tgz", + "integrity": "sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], "engines": { - "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + "node": ">=12" } }, - "node_modules/@eslint/eslintrc": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.2.tgz", - "integrity": "sha512-+wvgpDsrB1YqAMdEUCcnTlpfVBH7Vqn6A/NT3D8WVXFIaKMlErPIZT3oCIAVCOtarRpMtelZLqJeU3t7WY6X6g==", - "dev": true, - "dependencies": { - "ajv": "^6.12.4", - "debug": "^4.3.2", - "espree": "^9.6.0", - "globals": "^13.19.0", - "ignore": "^5.2.0", - "import-fresh": "^3.2.1", - "js-yaml": "^4.1.0", - "minimatch": "^3.1.2", - "strip-json-comments": "^3.1.1" - }, + "node_modules/@esbuild/android-x64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.12.tgz", + "integrity": "sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" - }, - "funding": { - "url": "https://opencollective.com/eslint" + "node": ">=12" } }, - "node_modules/@eslint/eslintrc/node_modules/globals": { - "version": "13.22.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.22.0.tgz", - "integrity": "sha512-H1Ddc/PbZHTDVJSnj8kWptIRSD6AM3pK+mKytuIVF4uoBV7rshFlhhvA58ceJ5wp3Er58w6zj7bykMpYXt3ETw==", - "dev": true, - "dependencies": { - "type-fest": "^0.20.2" - }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.12.tgz", + "integrity": "sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "node": ">=12" } }, - "node_modules/@eslint/eslintrc/node_modules/type-fest": { - "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", - "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", - "dev": true, + "node_modules/@esbuild/darwin-x64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.12.tgz", + "integrity": "sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "node": ">=12" } }, - "node_modules/@eslint/js": { - "version": "8.50.0", - "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.50.0.tgz", - "integrity": "sha512-NCC3zz2+nvYd+Ckfh87rA47zfu2QsQpvc6k1yzTk+b9KzRj0wkGa8LSoGOXN6Zv4lRf/EIoZ80biDh9HOI+RNQ==", - "dev": true, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.12.tgz", + "integrity": "sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], "engines": { - "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + "node": ">=12" } }, - "node_modules/@humanwhocodes/config-array": { - "version": "0.11.11", - "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.11.tgz", - "integrity": "sha512-N2brEuAadi0CcdeMXUkhbZB84eskAc8MEX1By6qEchoVywSgXPIjou4rYsl0V3Hj0ZnuGycGCjdNgockbzeWNA==", - "dev": true, - "dependencies": { - "@humanwhocodes/object-schema": "^1.2.1", - "debug": "^4.1.1", - "minimatch": "^3.0.5" - }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.12.tgz", + "integrity": "sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], "engines": { - "node": ">=10.10.0" + "node": ">=12" } }, - "node_modules/@humanwhocodes/module-importer": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", - "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", - "dev": true, + "node_modules/@esbuild/linux-arm": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.12.tgz", + "integrity": "sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">=12.22" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/nzakas" + "node": ">=12" } }, - "node_modules/@humanwhocodes/object-schema": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz", - "integrity": "sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==", - "dev": true - }, - "node_modules/@jridgewell/gen-mapping": { - "version": "0.3.5", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz", - "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==", - "dependencies": { - "@jridgewell/set-array": "^1.2.1", - "@jridgewell/sourcemap-codec": "^1.4.10", - "@jridgewell/trace-mapping": "^0.3.24" - }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.12.tgz", + "integrity": "sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">=6.0.0" + "node": ">=12" } }, - "node_modules/@jridgewell/resolve-uri": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", - "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", - "engines": { - "node": ">=6.0.0" + "node_modules/@esbuild/linux-ia32": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.12.tgz", + "integrity": "sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" } }, - "node_modules/@jridgewell/set-array": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", - "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", + "node_modules/@esbuild/linux-loong64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.12.tgz", + "integrity": "sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA==", + "cpu": [ + "loong64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">=6.0.0" + "node": ">=12" } }, - "node_modules/@jridgewell/source-map": { - "version": "0.3.6", - "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz", - "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==", - "devOptional": true, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.12.tgz", + "integrity": "sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w==", + "cpu": [ + "mips64el" + ], "license": "MIT", - "dependencies": { - "@jridgewell/gen-mapping": "^0.3.5", - "@jridgewell/trace-mapping": "^0.3.25" + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" } }, - "node_modules/@jridgewell/sourcemap-codec": { - "version": "1.4.15", - "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", - "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==" - }, - "node_modules/@jridgewell/trace-mapping": { - "version": "0.3.25", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", - "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", - "dependencies": { - "@jridgewell/resolve-uri": "^3.1.0", - "@jridgewell/sourcemap-codec": "^1.4.14" + "node_modules/@esbuild/linux-ppc64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.12.tgz", + "integrity": "sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" } }, - "node_modules/@mdx-js/mdx": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-2.3.0.tgz", - "integrity": "sha512-jLuwRlz8DQfQNiUCJR50Y09CGPq3fLtmtUQfVrj79E0JWu3dvsVcxVIcfhR5h0iXu+/z++zDrYeiJqifRynJkA==", - "dependencies": { - "@types/estree-jsx": "^1.0.0", - "@types/mdx": "^2.0.0", - "estree-util-build-jsx": "^2.0.0", - "estree-util-is-identifier-name": "^2.0.0", - "estree-util-to-js": "^1.1.0", - "estree-walker": "^3.0.0", - "hast-util-to-estree": "^2.0.0", - "markdown-extensions": "^1.0.0", - "periscopic": "^3.0.0", - "remark-mdx": "^2.0.0", - "remark-parse": "^10.0.0", - "remark-rehype": "^10.0.0", - "unified": "^10.0.0", - "unist-util-position-from-estree": "^1.0.0", - "unist-util-stringify-position": "^3.0.0", - "unist-util-visit": "^4.0.0", - "vfile": "^5.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "node_modules/@esbuild/linux-riscv64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.12.tgz", + "integrity": "sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg==", + "cpu": [ + "riscv64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" } }, - "node_modules/@nodelib/fs.scandir": { - "version": "2.1.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", - "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", - "dependencies": { - "@nodelib/fs.stat": "2.0.5", - "run-parallel": "^1.1.9" - }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.12.tgz", + "integrity": "sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg==", + "cpu": [ + "s390x" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">= 8" + "node": ">=12" } }, - "node_modules/@nodelib/fs.stat": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", - "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "node_modules/@esbuild/linux-x64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.12.tgz", + "integrity": "sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], "engines": { - "node": ">= 8" + "node": ">=12" } }, - "node_modules/@nodelib/fs.walk": { - "version": "1.2.8", - "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", - "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", - "dependencies": { - "@nodelib/fs.scandir": "2.1.5", - "fastq": "^1.6.0" - }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.12.tgz", + "integrity": "sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], "engines": { - "node": ">= 8" + "node": ">=12" } }, - "node_modules/@octokit/auth-token": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-3.0.4.tgz", - "integrity": "sha512-TWFX7cZF2LXoCvdmJWY7XVPi74aSY0+FfBZNSXEXFkMpjcqsQwDSYVv5FhRFaI0V1ECnwbz4j59T/G+rXNWaIQ==", + "node_modules/@esbuild/openbsd-x64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.12.tgz", + "integrity": "sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], "engines": { - "node": ">= 14" + "node": ">=12" } }, - "node_modules/@octokit/core": { - "version": "4.2.4", - "resolved": "https://registry.npmjs.org/@octokit/core/-/core-4.2.4.tgz", - "integrity": "sha512-rYKilwgzQ7/imScn3M9/pFfUf4I1AZEH3KhyJmtPdE2zfaXAn2mFfUy4FbKewzc2We5y/LlKLj36fWJLKC2SIQ==", - "dependencies": { - "@octokit/auth-token": "^3.0.0", - "@octokit/graphql": "^5.0.0", - "@octokit/request": "^6.0.0", - "@octokit/request-error": "^3.0.0", - "@octokit/types": "^9.0.0", - "before-after-hook": "^2.2.0", - "universal-user-agent": "^6.0.0" - }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.12.tgz", + "integrity": "sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], "engines": { - "node": ">= 14" + "node": ">=12" } }, - "node_modules/@octokit/endpoint": { - "version": "7.0.6", - "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-7.0.6.tgz", - "integrity": "sha512-5L4fseVRUsDFGR00tMWD/Trdeeihn999rTMGRMC1G/Ldi1uWlWJzI98H4Iak5DB/RVvQuyMYKqSK/R6mbSOQyg==", - "dependencies": { - "@octokit/types": "^9.0.0", - "is-plain-object": "^5.0.0", - "universal-user-agent": "^6.0.0" - }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.12.tgz", + "integrity": "sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], "engines": { - "node": ">= 14" + "node": ">=12" } }, - "node_modules/@octokit/graphql": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-5.0.6.tgz", - "integrity": "sha512-Fxyxdy/JH0MnIB5h+UQ3yCoh1FG4kWXfFKkpWqjZHw/p+Kc8Y44Hu/kCgNBT6nU1shNumEchmW/sUO1JuQnPcw==", - "dependencies": { - "@octokit/request": "^6.0.0", - "@octokit/types": "^9.0.0", - "universal-user-agent": "^6.0.0" - }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.12.tgz", + "integrity": "sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], "engines": { - "node": ">= 14" + "node": ">=12" } }, - "node_modules/@octokit/openapi-types": { - "version": "18.1.1", - "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-18.1.1.tgz", - "integrity": "sha512-VRaeH8nCDtF5aXWnjPuEMIYf1itK/s3JYyJcWFJT8X9pSNnBtriDf7wlEWsGuhPLl4QIH4xM8fqTXDwJ3Mu6sw==" + "node_modules/@esbuild/win32-x64": { + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.12.tgz", + "integrity": "sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } }, - "node_modules/@octokit/plugin-paginate-rest": { - "version": "6.1.2", - "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-6.1.2.tgz", - "integrity": "sha512-qhrmtQeHU/IivxucOV1bbI/xZyC/iOBhclokv7Sut5vnejAIAEXVcGQeRpQlU39E0WwK9lNvJHphHri/DB6lbQ==", + "node_modules/@eslint-community/eslint-utils": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.1.tgz", + "integrity": "sha512-s3O3waFUrMV8P/XaF/+ZTp1X9XBZW1a4B97ZnjQF2KYWaFD2A8KyFBsrsfSjEmjn3RGWAIuvlneuZm3CUK3jbA==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/tsconfig": "^1.0.2", - "@octokit/types": "^9.2.3" + "eslint-visitor-keys": "^3.4.3" }, "engines": { - "node": ">= 14" + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" }, "peerDependencies": { - "@octokit/core": ">=4" + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, - "node_modules/@octokit/plugin-request-log": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz", - "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA==", - "peerDependencies": { - "@octokit/core": ">=3" + "node_modules/@eslint-community/regexpp": { + "version": "4.12.1", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz", + "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" } }, - "node_modules/@octokit/plugin-rest-endpoint-methods": { - "version": "7.2.3", - "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-7.2.3.tgz", - "integrity": "sha512-I5Gml6kTAkzVlN7KCtjOM+Ruwe/rQppp0QU372K1GP7kNOYEKe8Xn5BW4sE62JAHdwpq95OQK/qGNyKQMUzVgA==", + "node_modules/@eslint/eslintrc": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/types": "^10.0.0" + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.6.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" }, "engines": { - "node": ">= 14" + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, - "peerDependencies": { - "@octokit/core": ">=3" + "funding": { + "url": "https://opencollective.com/eslint" } }, - "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/types": { - "version": "10.0.0", - "resolved": "https://registry.npmjs.org/@octokit/types/-/types-10.0.0.tgz", - "integrity": "sha512-Vm8IddVmhCgU1fxC1eyinpwqzXPEYu0NrYzD3YZjlGjyftdLBTeqNblRC0jmJmgxbJIsQlyogVeGnrNaaMVzIg==", + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "dev": true, + "license": "MIT", "dependencies": { - "@octokit/openapi-types": "^18.0.0" - } - }, - "node_modules/@octokit/request": { - "version": "6.2.8", - "resolved": "https://registry.npmjs.org/@octokit/request/-/request-6.2.8.tgz", - "integrity": "sha512-ow4+pkVQ+6XVVsekSYBzJC0VTVvh/FCTUUgTsboGq+DTeWdyIFV8WSCdo0RIxk6wSkBTHqIK1mYuY7nOBXOchw==", - "dependencies": { - "@octokit/endpoint": "^7.0.0", - "@octokit/request-error": "^3.0.0", - "@octokit/types": "^9.0.0", - "is-plain-object": "^5.0.0", - "node-fetch": "^2.6.7", - "universal-user-agent": "^6.0.0" + "type-fest": "^0.20.2" }, "engines": { - "node": ">= 14" + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/@octokit/request-error": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-3.0.3.tgz", - "integrity": "sha512-crqw3V5Iy2uOU5Np+8M/YexTlT8zxCfI+qu+LxUB7SZpje4Qmx3mub5DfEKSO8Ylyk0aogi6TYdf6kxzh2BguQ==", - "dependencies": { - "@octokit/types": "^9.0.0", - "deprecation": "^2.0.0", - "once": "^1.4.0" + "node_modules/@eslint/eslintrc/node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz", + "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==", + "dev": true, + "license": "MIT", "engines": { - "node": ">= 14" + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" } }, - "node_modules/@octokit/rest": { - "version": "19.0.13", - "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-19.0.13.tgz", - "integrity": "sha512-/EzVox5V9gYGdbAI+ovYj3nXQT1TtTHRT+0eZPcuC05UFSWO3mdO9UY1C0i2eLF9Un1ONJkAk+IEtYGAC+TahA==", + "node_modules/@humanwhocodes/config-array": { + "version": "0.13.0", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz", + "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==", + "deprecated": "Use @eslint/config-array instead", + "dev": true, + "license": "Apache-2.0", "dependencies": { - "@octokit/core": "^4.2.1", - "@octokit/plugin-paginate-rest": "^6.1.2", - "@octokit/plugin-request-log": "^1.0.4", - "@octokit/plugin-rest-endpoint-methods": "^7.1.2" + "@humanwhocodes/object-schema": "^2.0.3", + "debug": "^4.3.1", + "minimatch": "^3.0.5" }, "engines": { - "node": ">= 14" + "node": ">=10.10.0" } }, - "node_modules/@octokit/tsconfig": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@octokit/tsconfig/-/tsconfig-1.0.2.tgz", - "integrity": "sha512-I0vDR0rdtP8p2lGMzvsJzbhdOWy405HcGovrspJ8RRibHnyRgggUSNO5AIox5LmqiwmatHKYsvj6VGFHkqS7lA==" - }, - "node_modules/@octokit/types": { - "version": "9.3.2", - "resolved": "https://registry.npmjs.org/@octokit/types/-/types-9.3.2.tgz", - "integrity": "sha512-D4iHGTdAnEEVsB8fl95m1hiz7D5YiRdQ9b/OEb3BYRVwbLsGHcRVPz+u+BgRLNk0Q0/4iZCBqDN96j2XNxfXrA==", - "dependencies": { - "@octokit/openapi-types": "^18.0.0" + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" } }, - "node_modules/@pkgr/utils": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/@pkgr/utils/-/utils-2.4.2.tgz", - "integrity": "sha512-POgTXhjrTfbTV63DiFXav4lBHiICLKKwDeaKn9Nphwj7WH6m0hMMCaJkMyRWjgtPFyRKRVoMXXjczsTQRDEhYw==", + "node_modules/@humanwhocodes/object-schema": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz", + "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==", + "deprecated": "Use @eslint/object-schema instead", "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "license": "ISC", "dependencies": { - "cross-spawn": "^7.0.3", - "fast-glob": "^3.3.0", - "is-glob": "^4.0.3", - "open": "^9.1.0", - "picocolors": "^1.0.0", - "tslib": "^2.6.0" + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" }, "engines": { - "node": "^12.20.0 || ^14.18.0 || >=16.0.0" - }, - "funding": { - "url": "https://opencollective.com/unts" + "node": ">=12" } }, - "node_modules/@rollup/plugin-babel": { - "version": "6.0.4", - "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-6.0.4.tgz", - "integrity": "sha512-YF7Y52kFdFT/xVSuVdjkV5ZdX/3YtmX0QulG+x0taQOtJdHYzVU61aSSkAgVJ7NOv6qPkIYiJSgSWWN/DM5sGw==", - "dev": true, + "node_modules/@isaacs/cliui/node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", "license": "MIT", "dependencies": { - "@babel/helper-module-imports": "^7.18.6", - "@rollup/pluginutils": "^5.0.1" + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" }, "engines": { - "node": ">=14.0.0" - }, - "peerDependencies": { - "@babel/core": "^7.0.0", - "@types/babel__core": "^7.1.9", - "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + "node": ">=12" }, - "peerDependenciesMeta": { - "@types/babel__core": { - "optional": true - }, - "rollup": { - "optional": true - } + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/@rollup/plugin-commonjs": { - "version": "28.0.1", - "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-28.0.1.tgz", - "integrity": "sha512-+tNWdlWKbpB3WgBN7ijjYkq9X5uhjmcvyjEght4NmH5fAU++zfQzAJ6wumLS+dNcvwEZhKx2Z+skY8m7v0wGSA==", - "dev": true, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz", + "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==", "license": "MIT", "dependencies": { - "@rollup/pluginutils": "^5.0.1", - "commondir": "^1.0.1", - "estree-walker": "^2.0.2", - "fdir": "^6.2.0", - "is-reference": "1.2.1", - "magic-string": "^0.30.3", - "picomatch": "^4.0.2" + "@jridgewell/set-array": "^1.2.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.24" }, "engines": { - "node": ">=16.0.0 || 14 >= 14.17" - }, - "peerDependencies": { - "rollup": "^2.68.0||^3.0.0||^4.0.0" - }, - "peerDependenciesMeta": { - "rollup": { - "optional": true - } + "node": ">=6.0.0" } }, - "node_modules/@rollup/plugin-commonjs/node_modules/estree-walker": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", - "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", - "dev": true, - "license": "MIT" - }, - "node_modules/@rollup/plugin-commonjs/node_modules/fdir": { - "version": "6.4.2", - "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.2.tgz", - "integrity": "sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ==", - "dev": true, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", "license": "MIT", - "peerDependencies": { - "picomatch": "^3 || ^4" - }, - "peerDependenciesMeta": { - "picomatch": { - "optional": true - } + "engines": { + "node": ">=6.0.0" } }, - "node_modules/@rollup/plugin-commonjs/node_modules/is-reference": { + "node_modules/@jridgewell/set-array": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz", - "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==", - "dev": true, + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", + "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz", + "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==", + "devOptional": true, "license": "MIT", "dependencies": { - "@types/estree": "*" + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" } }, - "node_modules/@rollup/plugin-commonjs/node_modules/picomatch": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", - "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", - "dev": true, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz", + "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==", + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.25", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", + "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", "license": "MIT", - "engines": { - "node": ">=12" + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@mdx-js/mdx": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-2.3.0.tgz", + "integrity": "sha512-jLuwRlz8DQfQNiUCJR50Y09CGPq3fLtmtUQfVrj79E0JWu3dvsVcxVIcfhR5h0iXu+/z++zDrYeiJqifRynJkA==", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "@types/mdx": "^2.0.0", + "estree-util-build-jsx": "^2.0.0", + "estree-util-is-identifier-name": "^2.0.0", + "estree-util-to-js": "^1.1.0", + "estree-walker": "^3.0.0", + "hast-util-to-estree": "^2.0.0", + "markdown-extensions": "^1.0.0", + "periscopic": "^3.0.0", + "remark-mdx": "^2.0.0", + "remark-parse": "^10.0.0", + "remark-rehype": "^10.0.0", + "unified": "^10.0.0", + "unist-util-position-from-estree": "^1.0.0", + "unist-util-stringify-position": "^3.0.0", + "unist-util-visit": "^4.0.0", + "vfile": "^5.0.0" }, "funding": { - "url": "https://github.com/sponsors/jonschlinkert" + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/@rollup/plugin-node-resolve": { - "version": "15.3.0", - "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.3.0.tgz", - "integrity": "sha512-9eO5McEICxMzJpDW9OnMYSv4Sta3hmt7VtBFz5zR9273suNOydOyq/FrGeGy+KsTRFm8w0SLVhzig2ILFT63Ag==", - "dev": true, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", "license": "MIT", "dependencies": { - "@rollup/pluginutils": "^5.0.1", - "@types/resolve": "1.20.2", - "deepmerge": "^4.2.2", - "is-module": "^1.0.0", - "resolve": "^1.22.1" + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" }, "engines": { - "node": ">=14.0.0" - }, - "peerDependencies": { - "rollup": "^2.78.0||^3.0.0||^4.0.0" - }, - "peerDependenciesMeta": { - "rollup": { - "optional": true - } + "node": ">= 8" } }, - "node_modules/@rollup/plugin-terser": { - "version": "0.4.4", - "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-0.4.4.tgz", - "integrity": "sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==", - "dev": true, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", "license": "MIT", - "dependencies": { - "serialize-javascript": "^6.0.1", - "smob": "^1.0.0", - "terser": "^5.17.4" - }, "engines": { - "node": ">=14.0.0" - }, - "peerDependencies": { - "rollup": "^2.0.0||^3.0.0||^4.0.0" - }, - "peerDependenciesMeta": { - "rollup": { - "optional": true - } + "node": ">= 8" } }, - "node_modules/@rollup/plugin-typescript": { - "version": "12.1.1", - "resolved": "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-12.1.1.tgz", - "integrity": "sha512-t7O653DpfB5MbFrqPe/VcKFFkvRuFNp9qId3xq4Eth5xlyymzxNpye2z8Hrl0RIMuXTSr5GGcFpkdlMeacUiFQ==", - "dev": true, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", "license": "MIT", "dependencies": { - "@rollup/pluginutils": "^5.1.0", - "resolve": "^1.22.1" + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" }, "engines": { - "node": ">=14.0.0" - }, - "peerDependencies": { - "rollup": "^2.14.0||^3.0.0||^4.0.0", - "tslib": "*", + "node": ">= 8" + } + }, + "node_modules/@octokit/auth-token": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-4.0.0.tgz", + "integrity": "sha512-tY/msAuJo6ARbK6SPIxZrPBms3xPbfwBrulZe0Wtr/DIY9lje2HeV1uoebShn6mx7SjCHif6EjMvoREj+gZ+SA==", + "license": "MIT", + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/core": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@octokit/core/-/core-5.2.0.tgz", + "integrity": "sha512-1LFfa/qnMQvEOAdzlQymH0ulepxbxnCYAKJZfMci/5XJyIHWgEYnDmgnKakbTh7CH2tFQ5O60oYDvns4i9RAIg==", + "license": "MIT", + "dependencies": { + "@octokit/auth-token": "^4.0.0", + "@octokit/graphql": "^7.1.0", + "@octokit/request": "^8.3.1", + "@octokit/request-error": "^5.1.0", + "@octokit/types": "^13.0.0", + "before-after-hook": "^2.2.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/endpoint": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-9.0.5.tgz", + "integrity": "sha512-ekqR4/+PCLkEBF6qgj8WqJfvDq65RH85OAgrtnVp1mSxaXF03u2xW/hUdweGS5654IlC0wkNYC18Z50tSYTAFw==", + "license": "MIT", + "dependencies": { + "@octokit/types": "^13.1.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/graphql": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-7.1.0.tgz", + "integrity": "sha512-r+oZUH7aMFui1ypZnAvZmn0KSqAUgE1/tUXIWaqUCa1758ts/Jio84GZuzsvUkme98kv0WFY8//n0J1Z+vsIsQ==", + "license": "MIT", + "dependencies": { + "@octokit/request": "^8.3.0", + "@octokit/types": "^13.0.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/openapi-types": { + "version": "22.2.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-22.2.0.tgz", + "integrity": "sha512-QBhVjcUa9W7Wwhm6DBFu6ZZ+1/t/oYxqc2tp81Pi41YNuJinbFRx8B133qVOrAaBbF7D/m0Et6f9/pZt9Rc+tg==", + "license": "MIT" + }, + "node_modules/@octokit/plugin-paginate-rest": { + "version": "11.3.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-11.3.1.tgz", + "integrity": "sha512-ryqobs26cLtM1kQxqeZui4v8FeznirUsksiA+RYemMPJ7Micju0WSkv50dBksTuZks9O5cg4wp+t8fZ/cLY56g==", + "license": "MIT", + "dependencies": { + "@octokit/types": "^13.5.0" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "@octokit/core": "5" + } + }, + "node_modules/@octokit/plugin-request-log": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-4.0.1.tgz", + "integrity": "sha512-GihNqNpGHorUrO7Qa9JbAl0dbLnqJVrV8OXe2Zm5/Y4wFkZQDfTreBzVmiRfJVfE4mClXdihHnbpyyO9FSX4HA==", + "license": "MIT", + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "@octokit/core": "5" + } + }, + "node_modules/@octokit/plugin-rest-endpoint-methods": { + "version": "13.2.2", + "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-13.2.2.tgz", + "integrity": "sha512-EI7kXWidkt3Xlok5uN43suK99VWqc8OaIMktY9d9+RNKl69juoTyxmLoWPIZgJYzi41qj/9zU7G/ljnNOJ5AFA==", + "license": "MIT", + "dependencies": { + "@octokit/types": "^13.5.0" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "@octokit/core": "^5" + } + }, + "node_modules/@octokit/request": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/@octokit/request/-/request-8.4.0.tgz", + "integrity": "sha512-9Bb014e+m2TgBeEJGEbdplMVWwPmL1FPtggHQRkV+WVsMggPtEkLKPlcVYm/o8xKLkpJ7B+6N8WfQMtDLX2Dpw==", + "license": "MIT", + "dependencies": { + "@octokit/endpoint": "^9.0.1", + "@octokit/request-error": "^5.1.0", + "@octokit/types": "^13.1.0", + "universal-user-agent": "^6.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/request-error": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-5.1.0.tgz", + "integrity": "sha512-GETXfE05J0+7H2STzekpKObFe765O5dlAKUTLNGeH+x47z7JjXHfsHKo5z21D/o/IOZTUEI6nyWyR+bZVP/n5Q==", + "license": "MIT", + "dependencies": { + "@octokit/types": "^13.1.0", + "deprecation": "^2.0.0", + "once": "^1.4.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/rest": { + "version": "20.1.1", + "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-20.1.1.tgz", + "integrity": "sha512-MB4AYDsM5jhIHro/dq4ix1iWTLGToIGk6cWF5L6vanFaMble5jTX/UBQyiv05HsWnwUtY8JrfHy2LWfKwihqMw==", + "license": "MIT", + "dependencies": { + "@octokit/core": "^5.0.2", + "@octokit/plugin-paginate-rest": "11.3.1", + "@octokit/plugin-request-log": "^4.0.0", + "@octokit/plugin-rest-endpoint-methods": "13.2.2" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/@octokit/types": { + "version": "13.6.2", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-13.6.2.tgz", + "integrity": "sha512-WpbZfZUcZU77DrSW4wbsSgTPfKcp286q3ItaIgvSbBpZJlu6mnYXAkjZz6LVZPXkEvLIM8McanyZejKTYUHipA==", + "license": "MIT", + "dependencies": { + "@octokit/openapi-types": "^22.2.0" + } + }, + "node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=14" + } + }, + "node_modules/@pkgr/core": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.1.1.tgz", + "integrity": "sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/unts" + } + }, + "node_modules/@rollup/plugin-babel": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-6.0.4.tgz", + "integrity": "sha512-YF7Y52kFdFT/xVSuVdjkV5ZdX/3YtmX0QulG+x0taQOtJdHYzVU61aSSkAgVJ7NOv6qPkIYiJSgSWWN/DM5sGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.18.6", + "@rollup/pluginutils": "^5.0.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0", + "@types/babel__core": "^7.1.9", + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "@types/babel__core": { + "optional": true + }, + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-commonjs": { + "version": "28.0.2", + "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-28.0.2.tgz", + "integrity": "sha512-BEFI2EDqzl+vA1rl97IDRZ61AIwGH093d9nz8+dThxJNH8oSoB7MjWvPCX3dkaK1/RCJ/1v/R1XB15FuSs0fQw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "commondir": "^1.0.1", + "estree-walker": "^2.0.2", + "fdir": "^6.2.0", + "is-reference": "1.2.1", + "magic-string": "^0.30.3", + "picomatch": "^4.0.2" + }, + "engines": { + "node": ">=16.0.0 || 14 >= 14.17" + }, + "peerDependencies": { + "rollup": "^2.68.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-commonjs/node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/plugin-node-resolve": { + "version": "15.3.1", + "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.3.1.tgz", + "integrity": "sha512-tgg6b91pAybXHJQMAAwW9VuWBO6Thi+q7BCNARLwSqlmsHz0XYURtGvh/AuwSADXSI4h/2uHbs7s4FzlZDGSGA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "@types/resolve": "1.20.2", + "deepmerge": "^4.2.2", + "is-module": "^1.0.0", + "resolve": "^1.22.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.78.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-terser": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-0.4.4.tgz", + "integrity": "sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "serialize-javascript": "^6.0.1", + "smob": "^1.0.0", + "terser": "^5.17.4" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-typescript": { + "version": "12.1.2", + "resolved": "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-12.1.2.tgz", + "integrity": "sha512-cdtSp154H5sv637uMr1a8OTWB0L1SWDSm1rDGiyfcGcvQ6cuTs4MDk2BVEBGysUWago4OJN4EQZqOTl/QY3Jgg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.1.0", + "resolve": "^1.22.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.14.0||^3.0.0||^4.0.0", + "tslib": "*", "typescript": ">=3.7.0" }, "peerDependenciesMeta": { @@ -2452,9 +2801,9 @@ } }, "node_modules/@rollup/pluginutils": { - "version": "5.1.3", - "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.3.tgz", - "integrity": "sha512-Pnsb6f32CD2W3uCaLZIzDmeFyQ2b8UWMFI7xtwUezpcGBDVDW6y9XgAWIlARiGAo6eNF5FK5aQTr0LFyNyqq5A==", + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.4.tgz", + "integrity": "sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==", "dev": true, "license": "MIT", "dependencies": { @@ -2481,62 +2830,289 @@ "dev": true, "license": "MIT" }, - "node_modules/@rollup/pluginutils/node_modules/picomatch": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", - "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.28.1.tgz", + "integrity": "sha512-2aZp8AES04KI2dy3Ss6/MDjXbwBzj+i0GqKtWXgw2/Ma6E4jJvujryO6gJAghIRVz7Vwr9Gtl/8na3nDUKpraQ==", + "cpu": [ + "arm" + ], "dev": true, "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/jonschlinkert" - } + "optional": true, + "os": [ + "android" + ] }, - "node_modules/@rollup/rollup-linux-x64-gnu": { + "node_modules/@rollup/rollup-android-arm64": { "version": "4.28.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.28.1.tgz", - "integrity": "sha512-fzgeABz7rrAlKYB0y2kSEiURrI0691CSL0+KXwKwhxvj92VULEDQLpBYLHpF49MSiPG4sq5CK3qHMnb9tlCjBw==", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.28.1.tgz", + "integrity": "sha512-EbkK285O+1YMrg57xVA+Dp0tDBRB93/BZKph9XhMjezf6F4TpYjaUSuPt5J0fZXlSag0LmZAsTmdGGqPp4pQFA==", "cpu": [ - "x64" + "arm64" ], "dev": true, "license": "MIT", "optional": true, "os": [ - "linux" + "android" ] }, - "node_modules/@rollup/rollup-linux-x64-musl": { + "node_modules/@rollup/rollup-darwin-arm64": { "version": "4.28.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.28.1.tgz", - "integrity": "sha512-xQTDVzSGiMlSshpJCtudbWyRfLaNiVPXt1WgdWTwWz9n0U12cI2ZVtWe/Jgwyv/6wjL7b66uu61Vg0POWVfz4g==", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.28.1.tgz", + "integrity": "sha512-prduvrMKU6NzMq6nxzQw445zXgaDBbMQvmKSJaxpaZ5R1QDM8w+eGxo6Y/jhT/cLoCvnZI42oEqf9KQNYz1fqQ==", "cpu": [ - "x64" + "arm64" ], "dev": true, "license": "MIT", "optional": true, "os": [ - "linux" + "darwin" ] }, - "node_modules/@tailwindcss/forms": { - "version": "0.5.6", - "resolved": "https://registry.npmjs.org/@tailwindcss/forms/-/forms-0.5.6.tgz", - "integrity": "sha512-Fw+2BJ0tmAwK/w01tEFL5TiaJBX1NLT1/YbWgvm7ws3Qcn11kiXxzNTEQDMs5V3mQemhB56l3u0i9dwdzSQldA==", - "dependencies": { + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.28.1.tgz", + "integrity": "sha512-WsvbOunsUk0wccO/TV4o7IKgloJ942hVFK1CLatwv6TJspcCZb9umQkPdvB7FihmdxgaKR5JyxDjWpCOp4uZlQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.28.1.tgz", + "integrity": "sha512-HTDPdY1caUcU4qK23FeeGxCdJF64cKkqajU0iBnTVxS8F7H/7BewvYoG+va1KPSL63kQ1PGNyiwKOfReavzvNA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.28.1.tgz", + "integrity": "sha512-m/uYasxkUevcFTeRSM9TeLyPe2QDuqtjkeoTpP9SW0XxUWfcYrGDMkO/m2tTw+4NMAF9P2fU3Mw4ahNvo7QmsQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.28.1.tgz", + "integrity": "sha512-QAg11ZIt6mcmzpNE6JZBpKfJaKkqTm1A9+y9O+frdZJEuhQxiugM05gnCWiANHj4RmbgeVJpTdmKRmH/a+0QbA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.28.1.tgz", + "integrity": "sha512-dRP9PEBfolq1dmMcFqbEPSd9VlRuVWEGSmbxVEfiq2cs2jlZAl0YNxFzAQS2OrQmsLBLAATDMb3Z6MFv5vOcXg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.28.1.tgz", + "integrity": "sha512-uGr8khxO+CKT4XU8ZUH1TTEUtlktK6Kgtv0+6bIFSeiSlnGJHG1tSFSjm41uQ9sAO/5ULx9mWOz70jYLyv1QkA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.28.1.tgz", + "integrity": "sha512-QF54q8MYGAqMLrX2t7tNpi01nvq5RI59UBNx+3+37zoKX5KViPo/gk2QLhsuqok05sSCRluj0D00LzCwBikb0A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loongarch64-gnu": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.28.1.tgz", + "integrity": "sha512-vPul4uodvWvLhRco2w0GcyZcdyBfpfDRgNKU+p35AWEbJ/HPs1tOUrkSueVbBS0RQHAf/A+nNtDpvw95PeVKOA==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-powerpc64le-gnu": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.28.1.tgz", + "integrity": "sha512-pTnTdBuC2+pt1Rmm2SV7JWRqzhYpEILML4PKODqLz+C7Ou2apEV52h19CR7es+u04KlqplggmN9sqZlekg3R1A==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.28.1.tgz", + "integrity": "sha512-vWXy1Nfg7TPBSuAncfInmAI/WZDd5vOklyLJDdIRKABcZWojNDY0NJwruY2AcnCLnRJKSaBgf/GiJfauu8cQZA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.28.1.tgz", + "integrity": "sha512-/yqC2Y53oZjb0yz8PVuGOQQNOTwxcizudunl/tFs1aLvObTclTwZ0JhXF2XcPT/zuaymemCDSuuUPXJJyqeDOg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.28.1.tgz", + "integrity": "sha512-fzgeABz7rrAlKYB0y2kSEiURrI0691CSL0+KXwKwhxvj92VULEDQLpBYLHpF49MSiPG4sq5CK3qHMnb9tlCjBw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.28.1.tgz", + "integrity": "sha512-xQTDVzSGiMlSshpJCtudbWyRfLaNiVPXt1WgdWTwWz9n0U12cI2ZVtWe/Jgwyv/6wjL7b66uu61Vg0POWVfz4g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.28.1.tgz", + "integrity": "sha512-wSXmDRVupJstFP7elGMgv+2HqXelQhuNf+IS4V+nUpNVi/GUiBgDmfwD0UGN3pcAnWsgKG3I52wMOBnk1VHr/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.28.1.tgz", + "integrity": "sha512-ZkyTJ/9vkgrE/Rk9vhMXhf8l9D+eAhbAVbsGsXKy2ohmJaWg0LPQLnIxRdRp/bKyr8tXuPlXhIoGlEB5XpJnGA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.28.1.tgz", + "integrity": "sha512-ZvK2jBafvttJjoIdKm/Q/Bh7IJ1Ose9IBOwpOXcOvW3ikGTQGmKDgxTC6oCAzW6PynbkKP8+um1du81XJHZ0JA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@tailwindcss/forms": { + "version": "0.5.9", + "resolved": "https://registry.npmjs.org/@tailwindcss/forms/-/forms-0.5.9.tgz", + "integrity": "sha512-tM4XVr2+UVTxXJzey9Twx48c1gcxFStqn1pQz0tRsX8o3DvxhN5oY5pvyAbUx7VTaZxpej4Zzvc6h+1RJBzpIg==", + "license": "MIT", + "dependencies": { "mini-svg-data-uri": "^1.2.3" }, "peerDependencies": { - "tailwindcss": ">=3.0.0 || >= 3.0.0-alpha.1" + "tailwindcss": ">=3.0.0 || >= 3.0.0-alpha.1 || >= 4.0.0-alpha.20" } }, "node_modules/@tailwindcss/typography": { - "version": "0.5.10", - "resolved": "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.10.tgz", - "integrity": "sha512-Pe8BuPJQJd3FfRnm6H0ulKIGoMEQS+Vq01R6M5aCrFB/ccR/shT+0kXLjouGC1gFLm9hopTFN+DMP0pfwRWzPw==", + "version": "0.5.15", + "resolved": "https://registry.npmjs.org/@tailwindcss/typography/-/typography-0.5.15.tgz", + "integrity": "sha512-AqhlCXl+8grUz8uqExv5OTtgpjuVIwFTSXTrh8y9/pw6q2ek7fJ+Y8ZEVw7EB2DCcuCOtEjf9w3+J3rzts01uA==", + "license": "MIT", "dependencies": { "lodash.castarray": "^4.4.0", "lodash.isplainobject": "^4.0.6", @@ -2544,13 +3120,14 @@ "postcss-selector-parser": "6.0.10" }, "peerDependencies": { - "tailwindcss": ">=3.0.0 || insiders" + "tailwindcss": ">=3.0.0 || insiders || >=4.0.0-alpha.20" } }, "node_modules/@types/acorn": { "version": "4.0.6", "resolved": "https://registry.npmjs.org/@types/acorn/-/acorn-4.0.6.tgz", "integrity": "sha512-veQTnWP+1D/xbxVrPC3zHnCZRjSrKfhbMUlEA43iMZLu7EsnTtkJklIuwrCPbOi8YkvDQAiW05VQQFvvz9oieQ==", + "license": "MIT", "dependencies": { "@types/estree": "*" } @@ -2559,12 +3136,14 @@ "version": "0.0.50", "resolved": "https://registry.npmjs.org/@types/audioworklet/-/audioworklet-0.0.50.tgz", "integrity": "sha512-Wic6k+tczhJZz4yq2ianEowIF/xH10wI9ac8sBDh27Jvs+WIvXIeM+nWPPRITFwSKuLZKlvVjfLiNmUjfy4koA==", - "dev": true + "dev": true, + "license": "Apache-2.0" }, "node_modules/@types/babel__core": { - "version": "7.20.2", - "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.2.tgz", - "integrity": "sha512-pNpr1T1xLUc2l3xJKuPtsEky3ybxN3m4fJkknfIpTCTfIZCDW57oAg+EfCgIIp2rvCe0Wn++/FfodDS4YXxBwA==", + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "license": "MIT", "dependencies": { "@babel/parser": "^7.20.7", "@babel/types": "^7.20.7", @@ -2574,51 +3153,57 @@ } }, "node_modules/@types/babel__generator": { - "version": "7.6.5", - "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.5.tgz", - "integrity": "sha512-h9yIuWbJKdOPLJTbmSpPzkF67e659PbQDba7ifWm5BJ8xTv+sDmS7rFmywkWOvXedGTivCdeGSIIX8WLcRTz8w==", + "version": "7.6.8", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.8.tgz", + "integrity": "sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw==", + "license": "MIT", "dependencies": { "@babel/types": "^7.0.0" } }, "node_modules/@types/babel__template": { - "version": "7.4.2", - "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.2.tgz", - "integrity": "sha512-/AVzPICMhMOMYoSx9MoKpGDKdBRsIXMNByh1PXSZoa+v6ZoLa8xxtsT/uLQ/NJm0XVAWl/BvId4MlDeXJaeIZQ==", + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "license": "MIT", "dependencies": { "@babel/parser": "^7.1.0", "@babel/types": "^7.0.0" } }, "node_modules/@types/babel__traverse": { - "version": "7.20.2", - "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.2.tgz", - "integrity": "sha512-ojlGK1Hsfce93J0+kn3H5R73elidKUaZonirN33GSmgTUMpzI/MIFfSpF3haANe3G1bEBS9/9/QEqwTzwqFsKw==", + "version": "7.20.6", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.6.tgz", + "integrity": "sha512-r1bzfrm0tomOI8g1SzvCaQHo6Lcv6zu0EA+W2kHrt8dyrHQxGzBBL4kdkzIS+jBMV+EYcMAEAqXqYaLJq5rOZg==", + "license": "MIT", "dependencies": { "@babel/types": "^7.20.7" } }, "node_modules/@types/debug": { - "version": "4.1.9", - "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.9.tgz", - "integrity": "sha512-8Hz50m2eoS56ldRlepxSBa6PWEVCtzUo/92HgLc2qTMnotJNIm7xP+UZhyWoYsyOdd5dxZ+NZLb24rsKyFs2ow==", + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz", + "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==", + "license": "MIT", "dependencies": { "@types/ms": "*" } }, "node_modules/@types/dom-mediacapture-transform": { - "version": "0.1.7", - "resolved": "https://registry.npmjs.org/@types/dom-mediacapture-transform/-/dom-mediacapture-transform-0.1.7.tgz", - "integrity": "sha512-xrFtEIDCn+VeMEYm4JdjLEOeho3dsTxOxx4hDqCA0WRrENF4DMTF9JaTzTRUVc5rI58j9nRTxIZlU1Wqfr08PA==", + "version": "0.1.10", + "resolved": "https://registry.npmjs.org/@types/dom-mediacapture-transform/-/dom-mediacapture-transform-0.1.10.tgz", + "integrity": "sha512-zUxMN2iShu7p3Fz5sqfvLp93qW/3sLs+RwXWWOkMb969hsuoVqUUokqrENjXqTMNmEEcVXKoHuMMbIGcWyrVVA==", "dev": true, + "license": "MIT", "dependencies": { "@types/dom-webcodecs": "*" } }, "node_modules/@types/dom-webcodecs": { - "version": "0.1.8", - "resolved": "https://registry.npmjs.org/@types/dom-webcodecs/-/dom-webcodecs-0.1.8.tgz", - "integrity": "sha512-KThTPaGQJLITk8Q0XkEkz+GqFdoWDyQfbyeJmfEUagB15TZQdNx5AqP2b7GP6vkVM6X/6T1Z8EHxA8RgHfY9BA==" + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/@types/dom-webcodecs/-/dom-webcodecs-0.1.13.tgz", + "integrity": "sha512-O5hkiFIcjjszPIYyUSyvScyvrBoV3NOEEZx/pMlsu44TKzWNkLVBBxnxJz42in5n3QIolYOcBYFCPZZ0h8SkwQ==", + "license": "MIT" }, "node_modules/@types/estree": { "version": "1.0.6", @@ -2627,49 +3212,56 @@ "license": "MIT" }, "node_modules/@types/estree-jsx": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.1.tgz", - "integrity": "sha512-sHyakZlAezNFxmYRo0fopDZW+XvK6ipeZkkp5EAOLjdPfZp8VjZBJ67vSRI99RSCAoqXVmXOHS4fnWoxpuGQtQ==", + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz", + "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==", + "license": "MIT", "dependencies": { "@types/estree": "*" } }, "node_modules/@types/hast": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.6.tgz", - "integrity": "sha512-47rJE80oqPmFdVDCD7IheXBrVdwuBgsYwoczFvKmwfo2Mzsnt+V9OONsYauFmICb6lQPpCuXYJWejBNs4pDJRg==", + "version": "2.3.10", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.10.tgz", + "integrity": "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } }, "node_modules/@types/json-schema": { - "version": "7.0.13", - "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.13.tgz", - "integrity": "sha512-RbSSoHliUbnXj3ny0CNFOoxrIDV6SUGyStHsvDqosw6CkdPV8TtWGlfecuK4ToyMEAql6pzNxgCFKanovUzlgQ==", - "dev": true + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true, + "license": "MIT" }, "node_modules/@types/mdast": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.1.tgz", - "integrity": "sha512-IlKct1rUTJ1T81d8OHzyop15kGv9A/ff7Gz7IJgrk6jDb4Udw77pCJ+vq8oxZf4Ghpm+616+i1s/LNg/Vh7d+g==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz", + "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==", + "license": "MIT", "dependencies": { "@types/unist": "*" } }, "node_modules/@types/mdx": { - "version": "2.0.8", - "resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.8.tgz", - "integrity": "sha512-r7/zWe+f9x+zjXqGxf821qz++ld8tp6Z4jUS6qmPZUXH6tfh4riXOhAqb12tWGWAevCFtMt1goLWkQMqIJKpsA==" + "version": "2.0.13", + "resolved": "https://registry.npmjs.org/@types/mdx/-/mdx-2.0.13.tgz", + "integrity": "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==", + "license": "MIT" }, "node_modules/@types/ms": { - "version": "0.7.32", - "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.32.tgz", - "integrity": "sha512-xPSg0jm4mqgEkNhowKgZFBNtwoEwF6gJ4Dhww+GFpm3IgtNseHQZ5IqdNwnquZEoANxyDAKDRAdVo4Z72VvD/g==" + "version": "0.7.34", + "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.34.tgz", + "integrity": "sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==", + "license": "MIT" }, "node_modules/@types/nlcst": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@types/nlcst/-/nlcst-1.0.2.tgz", - "integrity": "sha512-ykxL/GDDUhqikjU0LIywZvEwb1NTYXTEWf+XgMSS2o6IXIakafPccxZmxgZcvJPZ3yFl2kdL1gJZz3U3iZF3QA==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@types/nlcst/-/nlcst-1.0.4.tgz", + "integrity": "sha512-ABoYdNQ/kBSsLvZAekMhIPMQ3YUZvavStpKYs7BjLLuKVmIMA0LUgZ7b54zzuWJRbHF80v1cNf4r90Vd6eMQDg==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -2677,7 +3269,8 @@ "node_modules/@types/parse5": { "version": "6.0.3", "resolved": "https://registry.npmjs.org/@types/parse5/-/parse5-6.0.3.tgz", - "integrity": "sha512-SuT16Q1K51EAVPz1K29DJ/sXjhSQ0zjvsypYJ6tlwVsRV9jwW5Adq2ch8Dq8kDBCkYnELS7N7VNCSB5nC56t/g==" + "integrity": "sha512-SuT16Q1K51EAVPz1K29DJ/sXjhSQ0zjvsypYJ6tlwVsRV9jwW5Adq2ch8Dq8kDBCkYnELS7N7VNCSB5nC56t/g==", + "license": "MIT" }, "node_modules/@types/resolve": { "version": "1.20.2", @@ -2687,27 +3280,30 @@ "license": "MIT" }, "node_modules/@types/semver": { - "version": "7.5.3", - "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.3.tgz", - "integrity": "sha512-OxepLK9EuNEIPxWNME+C6WwbRAOOI2o2BaQEGzz5Lu2e4Z5eDnEo+/aVEDMIXywoJitJ7xWd641wrGLZdtwRyw==", - "dev": true + "version": "7.5.8", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.8.tgz", + "integrity": "sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==", + "dev": true, + "license": "MIT" }, "node_modules/@types/unist": { - "version": "2.0.8", - "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.8.tgz", - "integrity": "sha512-d0XxK3YTObnWVp6rZuev3c49+j4Lo8g4L1ZRm9z5L0xpoZycUPshHgczK5gsUMaZOstjVYYi09p5gYvUtfChYw==" + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "license": "MIT" }, "node_modules/@typescript-eslint/eslint-plugin": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.7.4.tgz", - "integrity": "sha512-DAbgDXwtX+pDkAHwiGhqP3zWUGpW49B7eqmgpPtg+BKJXwdct79ut9+ifqOFPJGClGKSHXn2PTBatCnldJRUoA==", + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.21.0.tgz", + "integrity": "sha512-oy9+hTPCUFpngkEZUSzbf9MxI65wbKFoQYsgPdILTfbUldp5ovUuphZVe4i30emU9M/kP+T64Di0mxl7dSw3MA==", "dev": true, + "license": "MIT", "dependencies": { "@eslint-community/regexpp": "^4.5.1", - "@typescript-eslint/scope-manager": "6.7.4", - "@typescript-eslint/type-utils": "6.7.4", - "@typescript-eslint/utils": "6.7.4", - "@typescript-eslint/visitor-keys": "6.7.4", + "@typescript-eslint/scope-manager": "6.21.0", + "@typescript-eslint/type-utils": "6.21.0", + "@typescript-eslint/utils": "6.21.0", + "@typescript-eslint/visitor-keys": "6.21.0", "debug": "^4.3.4", "graphemer": "^1.4.0", "ignore": "^5.2.4", @@ -2732,16 +3328,30 @@ } } }, + "node_modules/@typescript-eslint/eslint-plugin/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/@typescript-eslint/parser": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.7.4.tgz", - "integrity": "sha512-I5zVZFY+cw4IMZUeNCU7Sh2PO5O57F7Lr0uyhgCJmhN/BuTlnc55KxPonR4+EM3GBdfiCyGZye6DgMjtubQkmA==", + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.21.0.tgz", + "integrity": "sha512-tbsV1jPne5CkFQCgPBcDOt30ItF7aJoZL997JSF7MhGQqOeT3svWRYxiqlfA5RUdlHN6Fi+EI9bxqbdyAUZjYQ==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { - "@typescript-eslint/scope-manager": "6.7.4", - "@typescript-eslint/types": "6.7.4", - "@typescript-eslint/typescript-estree": "6.7.4", - "@typescript-eslint/visitor-keys": "6.7.4", + "@typescript-eslint/scope-manager": "6.21.0", + "@typescript-eslint/types": "6.21.0", + "@typescript-eslint/typescript-estree": "6.21.0", + "@typescript-eslint/visitor-keys": "6.21.0", "debug": "^4.3.4" }, "engines": { @@ -2761,13 +3371,14 @@ } }, "node_modules/@typescript-eslint/scope-manager": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.7.4.tgz", - "integrity": "sha512-SdGqSLUPTXAXi7c3Ob7peAGVnmMoGzZ361VswK2Mqf8UOYcODiYvs8rs5ILqEdfvX1lE7wEZbLyELCW+Yrql1A==", + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.21.0.tgz", + "integrity": "sha512-OwLUIWZJry80O99zvqXVEioyniJMa+d2GrqpUTqi5/v5D5rOrppJVBPa0yKCblcigC0/aYAzxxqQ1B+DS2RYsg==", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/types": "6.7.4", - "@typescript-eslint/visitor-keys": "6.7.4" + "@typescript-eslint/types": "6.21.0", + "@typescript-eslint/visitor-keys": "6.21.0" }, "engines": { "node": "^16.0.0 || >=18.0.0" @@ -2778,13 +3389,14 @@ } }, "node_modules/@typescript-eslint/type-utils": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.7.4.tgz", - "integrity": "sha512-n+g3zi1QzpcAdHFP9KQF+rEFxMb2KxtnJGID3teA/nxKHOVi3ylKovaqEzGBbVY2pBttU6z85gp0D00ufLzViQ==", + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.21.0.tgz", + "integrity": "sha512-rZQI7wHfao8qMX3Rd3xqeYSMCL3SoiSQLBATSiVKARdFGCYSRvmViieZjqc58jKgs8Y8i9YvVVhRbHSTA4VBag==", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/typescript-estree": "6.7.4", - "@typescript-eslint/utils": "6.7.4", + "@typescript-eslint/typescript-estree": "6.21.0", + "@typescript-eslint/utils": "6.21.0", "debug": "^4.3.4", "ts-api-utils": "^1.0.1" }, @@ -2805,10 +3417,11 @@ } }, "node_modules/@typescript-eslint/types": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.7.4.tgz", - "integrity": "sha512-o9XWK2FLW6eSS/0r/tgjAGsYasLAnOWg7hvZ/dGYSSNjCh+49k5ocPN8OmG5aZcSJ8pclSOyVKP2x03Sj+RrCA==", + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.21.0.tgz", + "integrity": "sha512-1kFmZ1rOm5epu9NZEZm1kckCDGj5UJEf7P1kliH4LKu/RkwpsfqqGmY2OOcUs18lSlQBKLDYBOGxRVtrMN5lpg==", "dev": true, + "license": "MIT", "engines": { "node": "^16.0.0 || >=18.0.0" }, @@ -2818,16 +3431,18 @@ } }, "node_modules/@typescript-eslint/typescript-estree": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.7.4.tgz", - "integrity": "sha512-ty8b5qHKatlNYd9vmpHooQz3Vki3gG+3PchmtsA4TgrZBKWHNjWfkQid7K7xQogBqqc7/BhGazxMD5vr6Ha+iQ==", + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.21.0.tgz", + "integrity": "sha512-6npJTkZcO+y2/kr+z0hc4HwNfrrP4kNYh57ek7yCNlrBjWQ1Y0OS7jiZTkgumrvkX5HkEKXFZkkdFNkaW2wmUQ==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { - "@typescript-eslint/types": "6.7.4", - "@typescript-eslint/visitor-keys": "6.7.4", + "@typescript-eslint/types": "6.21.0", + "@typescript-eslint/visitor-keys": "6.21.0", "debug": "^4.3.4", "globby": "^11.1.0", "is-glob": "^4.0.3", + "minimatch": "9.0.3", "semver": "^7.5.4", "ts-api-utils": "^1.0.1" }, @@ -2844,18 +3459,58 @@ } } }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz", + "integrity": "sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/@typescript-eslint/utils": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.7.4.tgz", - "integrity": "sha512-PRQAs+HUn85Qdk+khAxsVV+oULy3VkbH3hQ8hxLRJXWBEd7iI+GbQxH5SEUSH7kbEoTp6oT1bOwyga24ELALTA==", + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.21.0.tgz", + "integrity": "sha512-NfWVaC8HP9T8cbKQxHcsJBY5YE1O33+jpMwN45qzWWaPDZgLIbo12toGMWnmhvCpd3sIxkpDw3Wv1B3dYrbDQQ==", "dev": true, + "license": "MIT", "dependencies": { "@eslint-community/eslint-utils": "^4.4.0", "@types/json-schema": "^7.0.12", "@types/semver": "^7.5.0", - "@typescript-eslint/scope-manager": "6.7.4", - "@typescript-eslint/types": "6.7.4", - "@typescript-eslint/typescript-estree": "6.7.4", + "@typescript-eslint/scope-manager": "6.21.0", + "@typescript-eslint/types": "6.21.0", + "@typescript-eslint/typescript-estree": "6.21.0", "semver": "^7.5.4" }, "engines": { @@ -2869,13 +3524,27 @@ "eslint": "^7.0.0 || ^8.0.0" } }, + "node_modules/@typescript-eslint/utils/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/@typescript-eslint/visitor-keys": { - "version": "6.7.4", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.7.4.tgz", - "integrity": "sha512-pOW37DUhlTZbvph50x5zZCkFn3xzwkGtNoJHzIM3svpiSkJzwOYr/kVBaXmf+RAQiUDs1AHEZVNPg6UJCJpwRA==", + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.21.0.tgz", + "integrity": "sha512-JJtkDduxLi9bivAB+cYOVMtbkqdPOhZ+ZI5LC47MIRrDV4Yn2o+ZnW10Nkmr28xRpSpdJ6Sm42Hjf2+REYXm0A==", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/types": "6.7.4", + "@typescript-eslint/types": "6.21.0", "eslint-visitor-keys": "^3.4.1" }, "engines": { @@ -2891,12 +3560,14 @@ "version": "0.0.115", "resolved": "https://registry.npmjs.org/@types/web/-/web-0.0.115.tgz", "integrity": "sha512-IBtUgtxnITC7WTCg4tv6kCnSP0T+fM+3PzQPIzLzJY1DDlhBFKM/9+uMURw14YweWPDiFNIZ94Gc1bJtwow97g==", - "dev": true + "dev": true, + "license": "Apache-2.0" }, "node_modules/@ungap/structured-clone": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz", - "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==" + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.1.tgz", + "integrity": "sha512-fEzPV3hSkSMltkw152tJKNARhOupqbH96MZWyRjNaYZOMIzbrTeQDG+MTc6Mr2pgzFQzFxAfmhGDNP5QK++2ZA==", + "license": "ISC" }, "node_modules/accepts": { "version": "1.3.8", @@ -2912,9 +3583,10 @@ } }, "node_modules/acorn": { - "version": "8.10.0", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.10.0.tgz", - "integrity": "sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==", + "version": "8.14.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz", + "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==", + "license": "MIT", "bin": { "acorn": "bin/acorn" }, @@ -2926,6 +3598,7 @@ "version": "5.3.2", "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "license": "MIT", "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } @@ -2935,6 +3608,7 @@ "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", "dev": true, + "license": "MIT", "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", @@ -2950,6 +3624,7 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/ansi-align/-/ansi-align-3.0.1.tgz", "integrity": "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==", + "license": "ISC", "dependencies": { "string-width": "^4.1.0" } @@ -2958,6 +3633,7 @@ "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", "engines": { "node": ">=8" } @@ -2965,12 +3641,14 @@ "node_modules/ansi-align/node_modules/emoji-regex": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" }, "node_modules/ansi-align/node_modules/string-width": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", @@ -2984,6 +3662,7 @@ "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, @@ -2992,9 +3671,10 @@ } }, "node_modules/ansi-regex": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz", - "integrity": "sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", + "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -3002,16 +3682,12 @@ "url": "https://github.com/chalk/ansi-regex?sponsor=1" } }, - "node_modules/ansi-sequence-parser": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/ansi-sequence-parser/-/ansi-sequence-parser-1.1.1.tgz", - "integrity": "sha512-vJXt3yiaUL4UU546s3rPXlsry/RnM730G1+HkpKE012AN0sx1eOrxSu95oKDIonskeLTijMgqWZ3uDEe3NFvyg==" - }, "node_modules/ansi-styles": { "version": "3.2.1", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, + "license": "MIT", "dependencies": { "color-convert": "^1.9.0" }, @@ -3022,12 +3698,14 @@ "node_modules/any-promise": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", - "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==" + "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==", + "license": "MIT" }, "node_modules/anymatch": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "license": "ISC", "dependencies": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" @@ -3036,23 +3714,38 @@ "node": ">= 8" } }, + "node_modules/anymatch/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/arg": { "version": "5.0.2", "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz", - "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==" + "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==", + "license": "MIT" }, "node_modules/argparse": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", - "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "license": "Python-2.0" }, "node_modules/aria-query": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz", - "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==", + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz", + "integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==", "dev": true, - "dependencies": { - "dequal": "^2.0.3" + "license": "Apache-2.0", + "engines": { + "node": ">= 0.4" } }, "node_modules/array-buffer-byte-length": { @@ -3079,15 +3772,17 @@ "license": "MIT" }, "node_modules/array-includes": { - "version": "3.1.7", - "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.7.tgz", - "integrity": "sha512-dlcsNBIiWhPkHdOEEKnehA+RNUWDc4UqFtnIXU4uuYDPtA4LDkr7qip2p0VvFAEXNDr0yWZ9PJyIRiGjRLQzwQ==", + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.8.tgz", + "integrity": "sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "get-intrinsic": "^1.2.1", + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.4", "is-string": "^1.0.7" }, "engines": { @@ -3101,6 +3796,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/array-iterate/-/array-iterate-2.0.1.tgz", "integrity": "sha512-I1jXZMjAgCMmxT4qxXfPXa6SthSoE8h6gkSI9BGGNv8mP8G/v0blc+qFnZu6K42vTOiuME596QaLO0TP3Lk0xg==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -3111,20 +3807,22 @@ "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/array.prototype.flat": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.2.tgz", - "integrity": "sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==", + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz", + "integrity": "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "es-shim-unscopables": "^1.0.0" + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-shim-unscopables": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -3134,15 +3832,16 @@ } }, "node_modules/array.prototype.flatmap": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.2.tgz", - "integrity": "sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==", + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz", + "integrity": "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "es-shim-unscopables": "^1.0.0" + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-shim-unscopables": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -3152,20 +3851,19 @@ } }, "node_modules/arraybuffer.prototype.slice": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.3.tgz", - "integrity": "sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz", + "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==", "dev": true, "license": "MIT", "dependencies": { "array-buffer-byte-length": "^1.0.1", - "call-bind": "^1.0.5", + "call-bind": "^1.0.8", "define-properties": "^1.2.1", - "es-abstract": "^1.22.3", - "es-errors": "^1.2.1", - "get-intrinsic": "^1.2.3", - "is-array-buffer": "^3.0.4", - "is-shared-array-buffer": "^1.0.2" + "es-abstract": "^1.23.5", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "is-array-buffer": "^3.0.4" }, "engines": { "node": ">= 0.4" @@ -3175,15 +3873,17 @@ } }, "node_modules/ast-types-flow": { - "version": "0.0.7", - "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.7.tgz", - "integrity": "sha512-eBvWn1lvIApYMhzQMsu9ciLfkBY499mFZlNqG+/9WR7PVlroQw0vG30cOQQbaKz3sCEc44TAOu2ykzqXSNnwag==", - "dev": true + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.8.tgz", + "integrity": "sha512-OH/2E5Fg20h2aPrbe+QL8JZQFko0YZaF+j4mnQ7BGhfavO7OpSLa8a0y9sBwomHdSbkhTS8TQNayBfnW5DwbvQ==", + "dev": true, + "license": "MIT" }, "node_modules/astring": { - "version": "1.8.6", - "resolved": "https://registry.npmjs.org/astring/-/astring-1.8.6.tgz", - "integrity": "sha512-ISvCdHdlTDlH5IpxQJIex7BWBywFWgjJSVdwst+/iQCoEYnyOaQ95+X1JGshuBjGp6nxKUy1jMgE3zPqN7fQdg==", + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/astring/-/astring-1.9.0.tgz", + "integrity": "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==", + "license": "MIT", "bin": { "astring": "bin/astring" } @@ -3192,6 +3892,7 @@ "version": "3.6.5", "resolved": "https://registry.npmjs.org/astro/-/astro-3.6.5.tgz", "integrity": "sha512-fyVubQfb6+Bc2/XigXNeJ06HHwNFB9EnAQohJcrja6RB1PhIcZRusyIamywHWjoJ4a1T0HxMkzBLNW96DBqpNw==", + "license": "MIT", "dependencies": { "@astrojs/compiler": "^2.3.0", "@astrojs/internal-helpers": "0.2.1", @@ -3264,16 +3965,18 @@ } }, "node_modules/astro-eslint-parser": { - "version": "0.16.0", - "resolved": "https://registry.npmjs.org/astro-eslint-parser/-/astro-eslint-parser-0.16.0.tgz", - "integrity": "sha512-k9ASvY8pa6qttM+fvNJCILxxjftfNg/ou5cjd25SVHsc7moplezGGM9fgMUyf24SRYt8ShO603oHRDn2KqwxMg==", + "version": "0.16.3", + "resolved": "https://registry.npmjs.org/astro-eslint-parser/-/astro-eslint-parser-0.16.3.tgz", + "integrity": "sha512-CGaBseNtunAV2DCpwBXqTKq8+9Tw65XZetMaC0FsMoZuLj0gxNIkbCf2QyKYScVrNOU7/ayfNdVw8ZCSHBiqCg==", "dev": true, + "license": "MIT", "dependencies": { "@astrojs/compiler": "^2.0.0", "@typescript-eslint/scope-manager": "^5.0.0", "@typescript-eslint/types": "^5.0.0", "astrojs-compiler-sync": "^0.3.0", "debug": "^4.3.4", + "entities": "^4.5.0", "eslint-visitor-keys": "^3.0.0", "espree": "^9.0.0", "semver": "^7.3.8" @@ -3290,6 +3993,7 @@ "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz", "integrity": "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==", "dev": true, + "license": "MIT", "dependencies": { "@typescript-eslint/types": "5.62.0", "@typescript-eslint/visitor-keys": "5.62.0" @@ -3307,6 +4011,7 @@ "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz", "integrity": "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==", "dev": true, + "license": "MIT", "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, @@ -3320,6 +4025,7 @@ "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz", "integrity": "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==", "dev": true, + "license": "MIT", "dependencies": { "@typescript-eslint/types": "5.62.0", "eslint-visitor-keys": "^3.3.0" @@ -3332,37 +4038,39 @@ "url": "https://opencollective.com/typescript-eslint" } }, - "node_modules/astro/node_modules/@astrojs/markdown-remark": { - "version": "3.5.0", - "resolved": "https://registry.npmjs.org/@astrojs/markdown-remark/-/markdown-remark-3.5.0.tgz", - "integrity": "sha512-q7vdIqzYhxpsfghg2YmkmSXCfp4w7lBTYP+SSHw89wVhC5Riltr3u8w2otBRxNLSByNi+ht/gGkFC23Shetytw==", - "dependencies": { - "@astrojs/prism": "^3.0.0", - "github-slugger": "^2.0.0", - "import-meta-resolve": "^3.0.0", - "mdast-util-definitions": "^6.0.0", - "rehype-raw": "^6.1.1", - "rehype-stringify": "^9.0.4", - "remark-gfm": "^3.0.1", - "remark-parse": "^10.0.2", - "remark-rehype": "^10.1.0", - "remark-smartypants": "^2.0.0", - "shikiji": "^0.6.8", - "unified": "^10.1.2", - "unist-util-visit": "^4.1.2", - "vfile": "^5.3.7" + "node_modules/astro-eslint-parser/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" }, - "peerDependencies": { - "astro": "^3.0.0" + "engines": { + "node": ">=10" + } + }, + "node_modules/astro/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" } }, "node_modules/astrojs-compiler-sync": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/astrojs-compiler-sync/-/astrojs-compiler-sync-0.3.3.tgz", - "integrity": "sha512-LbhchWgsvjvRBb5n5ez8/Q/f9ZKViuox27VxMDOdTUm8MRv9U7phzOiLue5KluqTmC0z1LId4gY2SekvoDrkuw==", + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/astrojs-compiler-sync/-/astrojs-compiler-sync-0.3.5.tgz", + "integrity": "sha512-y420rhIIJ2HHDkYeqKArBHSdJNIIGMztLH90KGIX3zjcJyt/cr9Z2wYA8CP5J1w6KE7xqMh0DAkhfjhNDpQb2Q==", "dev": true, + "license": "MIT", "dependencies": { - "synckit": "^0.8.0" + "synckit": "^0.9.0" }, "engines": { "node": "^14.18.0 || >=16.0.0" @@ -3377,7 +4085,8 @@ "node_modules/asynckit": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", - "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "license": "MIT" }, "node_modules/atob": { "version": "2.1.2", @@ -3393,9 +4102,9 @@ } }, "node_modules/autoprefixer": { - "version": "10.4.16", - "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.16.tgz", - "integrity": "sha512-7vd3UC6xKp0HLfua5IjZlcXvGAGy7cBAXTg2lyQ/8WpNhd6SiZ8Be+xm3FyBSYJx5GKcpRCzBh7RH4/0dnY+uQ==", + "version": "10.4.20", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.20.tgz", + "integrity": "sha512-XY25y5xSv/wEoqzDyXXME4AFfkZI0P23z6Fs3YgymDnKJkCGOnkL0iTxCa85UTqaSgfcqyf3UA6+c7wUvx/16g==", "funding": [ { "type": "opencollective", @@ -3410,12 +4119,13 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "dependencies": { - "browserslist": "^4.21.10", - "caniuse-lite": "^1.0.30001538", - "fraction.js": "^4.3.6", + "browserslist": "^4.23.3", + "caniuse-lite": "^1.0.30001646", + "fraction.js": "^4.3.7", "normalize-range": "^0.1.2", - "picocolors": "^1.0.0", + "picocolors": "^1.0.1", "postcss-value-parser": "^4.2.0" }, "bin": { @@ -3445,18 +4155,20 @@ } }, "node_modules/axe-core": { - "version": "4.8.2", - "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.8.2.tgz", - "integrity": "sha512-/dlp0fxyM3R8YW7MFzaHWXrf4zzbr0vaYb23VBFCl83R7nWNPg/yaQw2Dc8jzCMmDVLhSdzH8MjrsuIUuvX+6g==", + "version": "4.10.2", + "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.10.2.tgz", + "integrity": "sha512-RE3mdQ7P3FRSe7eqCWoeQ/Z9QXrtniSjp1wUjt5nRC3WIpz5rSCve6o3fsZ2aCpJtrZjSZgjwXAoTO5k4tEI0w==", "dev": true, + "license": "MPL-2.0", "engines": { "node": ">=4" } }, "node_modules/axios": { - "version": "1.7.2", - "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.2.tgz", - "integrity": "sha512-2A8QhOMrbomlDuiLeK9XibIBzuHeRcqqNOHp0Cyp5EoJ1IFDh+XZH3A6BkXtv0K4gFGCI0Y4BM7B1wOEi0Rmgw==", + "version": "1.7.9", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz", + "integrity": "sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==", + "license": "MIT", "dependencies": { "follow-redirects": "^1.15.6", "form-data": "^4.0.0", @@ -3464,29 +4176,33 @@ } }, "node_modules/axobject-query": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-3.2.1.tgz", - "integrity": "sha512-jsyHu61e6N4Vbz/v18DHwWYKK0bSWLqn47eeDSKPB7m8tqMHF9YJ+mhIk2lVteyZrY8tnSj/jHOv4YiTCuCJgg==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz", + "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==", "dev": true, - "dependencies": { - "dequal": "^2.0.3" + "license": "Apache-2.0", + "engines": { + "node": ">= 0.4" } }, "node_modules/b4a": { - "version": "1.6.4", - "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.4.tgz", - "integrity": "sha512-fpWrvyVHEKyeEvbKZTVOeZF3VSKKWtJxFIxX/jaVPf+cLbGUSitjb49pHLqPV2BUNNZ0LcoeEGfE/YCpyDYHIw==", + "version": "1.6.7", + "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz", + "integrity": "sha512-OnAYlL5b7LEkALw87fUVafQw5rVR9RjwGd4KUwNQ6DrrNmaVaUCgLipfVlzrPQ4tWOR9P0IXGNOx50jYCCdSJg==", + "license": "Apache-2.0", "optional": true }, "node_modules/babel-plugin-jsx-dom-expressions": { - "version": "0.36.18", - "resolved": "https://registry.npmjs.org/babel-plugin-jsx-dom-expressions/-/babel-plugin-jsx-dom-expressions-0.36.18.tgz", - "integrity": "sha512-8K0CHgzNMB0+1OC+GQf1O49Nc6DfHAoWDjY4YTW3W/3il5KrDKAj65723oPmya68kKKOkqDKuz+Zh1u7VFHthw==", + "version": "0.39.3", + "resolved": "https://registry.npmjs.org/babel-plugin-jsx-dom-expressions/-/babel-plugin-jsx-dom-expressions-0.39.3.tgz", + "integrity": "sha512-6RzmSu21zYPlV2gNwzjGG9FgODtt9hIWnx7L//OIioIEuRcnpDZoY8Tr+I81Cy1SrH4qoDyKpwHHo6uAMAeyPA==", + "license": "MIT", "dependencies": { "@babel/helper-module-imports": "7.18.6", "@babel/plugin-syntax-jsx": "^7.18.6", "@babel/types": "^7.20.7", "html-entities": "2.3.3", + "parse5": "^7.1.2", "validate-html-nesting": "^1.2.1" }, "peerDependencies": { @@ -3497,6 +4213,7 @@ "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz", "integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==", + "license": "MIT", "dependencies": { "@babel/types": "^7.18.6" }, @@ -3504,6 +4221,18 @@ "node": ">=6.9.0" } }, + "node_modules/babel-plugin-jsx-dom-expressions/node_modules/parse5": { + "version": "7.2.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.2.1.tgz", + "integrity": "sha512-BuBYQYlv1ckiPdQi/ohiivi9Sagc9JG+Ozs0r7b/0iK3sKmrb0b9FdWdBbOdx6hBCM/F9Ir82ofnBhtZOjCRPQ==", + "license": "MIT", + "dependencies": { + "entities": "^4.5.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, "node_modules/babel-plugin-polyfill-corejs2": { "version": "0.4.12", "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.12.tgz", @@ -3557,11 +4286,12 @@ } }, "node_modules/babel-preset-solid": { - "version": "1.7.12", - "resolved": "https://registry.npmjs.org/babel-preset-solid/-/babel-preset-solid-1.7.12.tgz", - "integrity": "sha512-vNZn34Dv6IsWK/F59HhZlN8gP0ihZfkhPp8Lx/nxlY+rKtSZEAmmYlXWtds6EDKSiXoj2TEHuCcuqp6cO7oLSg==", + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/babel-preset-solid/-/babel-preset-solid-1.9.3.tgz", + "integrity": "sha512-jvlx5wDp8s+bEF9sGFw/84SInXOA51ttkUEroQziKMbxplXThVKt83qB6bDTa1HuLNatdU9FHpFOiQWs1tLQIg==", + "license": "MIT", "dependencies": { - "babel-plugin-jsx-dom-expressions": "^0.36.18" + "babel-plugin-jsx-dom-expressions": "^0.39.3" }, "peerDependencies": { "@babel/core": "^7.0.0" @@ -3571,6 +4301,7 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz", "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -3579,7 +4310,54 @@ "node_modules/balanced-match": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", - "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "license": "MIT" + }, + "node_modules/bare-events": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.5.0.tgz", + "integrity": "sha512-/E8dDe9dsbLyh2qrZ64PEPadOQ0F4gbl1sUJOrmph7xOiIxfY8vwab/4bFLh4Y88/Hk/ujKcrQKc+ps0mv873A==", + "license": "Apache-2.0", + "optional": true + }, + "node_modules/bare-fs": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-2.3.5.tgz", + "integrity": "sha512-SlE9eTxifPDJrT6YgemQ1WGFleevzwY+XAP1Xqgl56HtcrisC2CHCZ2tq6dBpcH2TnNxwUEUGhweo+lrQtYuiw==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "bare-events": "^2.0.0", + "bare-path": "^2.0.0", + "bare-stream": "^2.0.0" + } + }, + "node_modules/bare-os": { + "version": "2.4.4", + "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-2.4.4.tgz", + "integrity": "sha512-z3UiI2yi1mK0sXeRdc4O1Kk8aOa/e+FNWZcTiPB/dfTWyLypuE99LibgRaQki914Jq//yAWylcAt+mknKdixRQ==", + "license": "Apache-2.0", + "optional": true + }, + "node_modules/bare-path": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-2.1.3.tgz", + "integrity": "sha512-lh/eITfU8hrj9Ru5quUp0Io1kJWIk1bTjzo7JH1P5dWmQ2EL4hFUlfI8FonAhSlgIfhn63p84CDY/x+PisgcXA==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "bare-os": "^2.1.0" + } + }, + "node_modules/bare-stream": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.6.1.tgz", + "integrity": "sha512-eVZbtKM+4uehzrsj49KtCy3Pbg7kO1pJ3SKZ1SFrIH/0pnj9scuGGgUlNDf/7qS8WKtGdiJY5Kyhs/ivYPTB/g==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "streamx": "^2.21.0" + } }, "node_modules/base64-js": { "version": "1.5.1", @@ -3598,34 +4376,32 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "MIT" }, "node_modules/before-after-hook": { "version": "2.2.3", "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz", - "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==" - }, - "node_modules/big-integer": { - "version": "1.6.51", - "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.51.tgz", - "integrity": "sha512-GPEid2Y9QU1Exl1rpO9B2IPJGHPSupF5GnVIP0blYvNOMer2bTvSWs1jGOUg04hTmu67nmLsQ9TBo1puaotBHg==", - "dev": true, - "engines": { - "node": ">=0.6" - } + "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==", + "license": "Apache-2.0" }, "node_modules/binary-extensions": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", - "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", + "license": "MIT", "engines": { "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/bl": { "version": "5.1.0", "resolved": "https://registry.npmjs.org/bl/-/bl-5.1.0.tgz", "integrity": "sha512-tv1ZJHLfTDnXE6tMHv73YgSJaWR2AFuPwMntBe7XL/GBFHnT0CLnsHMogfk5+GzCDC5ZWarSCYaIGATZt9dNsQ==", + "license": "MIT", "dependencies": { "buffer": "^6.0.3", "inherits": "^2.0.4", @@ -3675,6 +4451,7 @@ "version": "7.1.1", "resolved": "https://registry.npmjs.org/boxen/-/boxen-7.1.1.tgz", "integrity": "sha512-2hCgjEmP8YLWQ130n2FerGv7rYpfBmnmp9Uy2Le1vge6X3gZIfSmEzP5QTDElFxcvVcXlEn8Aq6MU/PZygIOog==", + "license": "MIT", "dependencies": { "ansi-align": "^3.0.1", "camelcase": "^7.0.1", @@ -3693,9 +4470,10 @@ } }, "node_modules/boxen/node_modules/chalk": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz", - "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==", + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.0.tgz", + "integrity": "sha512-ZkD35Mx92acjB2yNJgziGqT9oKHEOxjTBTDRpOsRWtdecL/0jM3z5kM/CTzHWvHIen1GvkM85p6TuFfDGfc8/Q==", + "license": "MIT", "engines": { "node": "^12.17.0 || ^14.13 || >=16.0.0" }, @@ -3707,6 +4485,7 @@ "version": "5.1.2", "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "license": "MIT", "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", @@ -3719,22 +4498,12 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/bplist-parser": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/bplist-parser/-/bplist-parser-0.2.0.tgz", - "integrity": "sha512-z0M+byMThzQmD9NILRniCUXYsYpjwnlO8N5uCFaCqIOpqRsJCrQL9NK3JsD67CN5a08nF5oIL2bD6loTdHOuKw==", - "dev": true, - "dependencies": { - "big-integer": "^1.6.44" - }, - "engines": { - "node": ">= 5.10.0" - } - }, "node_modules/brace-expansion": { "version": "1.1.11", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" @@ -3744,6 +4513,7 @@ "version": "3.0.3", "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "license": "MIT", "dependencies": { "fill-range": "^7.1.1" }, @@ -3752,9 +4522,9 @@ } }, "node_modules/browserslist": { - "version": "4.24.2", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.2.tgz", - "integrity": "sha512-ZIc+Q62revdMcqC6aChtW4jz3My3klmCO1fEmINZY/8J3EpBg5/A/D0AKmBveUh6pgoeycoMkVMko84tuYS+Gg==", + "version": "4.24.3", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.3.tgz", + "integrity": "sha512-1CPmv8iobE2fyRMV97dAcMVegvvWKxmq94hkLiAkUGwKVTyDLw33K+ZxiFrREKmmps4rIw6grcCFCnTMSZ/YiA==", "funding": [ { "type": "opencollective", @@ -3771,9 +4541,9 @@ ], "license": "MIT", "dependencies": { - "caniuse-lite": "^1.0.30001669", - "electron-to-chromium": "^1.5.41", - "node-releases": "^2.0.18", + "caniuse-lite": "^1.0.30001688", + "electron-to-chromium": "^1.5.73", + "node-releases": "^2.0.19", "update-browserslist-db": "^1.1.1" }, "bin": { @@ -3801,6 +4571,7 @@ "url": "https://feross.org/support" } ], + "license": "MIT", "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" @@ -3813,21 +4584,6 @@ "devOptional": true, "license": "MIT" }, - "node_modules/bundle-name": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-3.0.0.tgz", - "integrity": "sha512-PKA4BeSvBpQKQ8iPOGCSiell+N8P+Tf1DlwqmYhpe2gAhKPHn8EYOxVT+ShuGmhg8lN8XiSlS80yiExKXrURlw==", - "dev": true, - "dependencies": { - "run-applescript": "^5.0.0" - }, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/bytes": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", @@ -3841,6 +4597,7 @@ "version": "1.0.8", "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz", "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==", + "dev": true, "license": "MIT", "dependencies": { "call-bind-apply-helpers": "^1.0.0", @@ -3868,11 +4625,28 @@ "node": ">= 0.4" } }, + "node_modules/call-bound": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz", + "integrity": "sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/callsites": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } @@ -3881,6 +4655,7 @@ "version": "7.0.1", "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-7.0.1.tgz", "integrity": "sha512-xlx1yCK2Oc1APsPXDL2LdlNP6+uu8OCDdhOBSVT279M/S+y75O30C2VuD8T2ogdePBBl7PfPF4504tnLgX3zfw==", + "license": "MIT", "engines": { "node": ">=14.16" }, @@ -3892,14 +4667,15 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz", "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==", + "license": "MIT", "engines": { "node": ">= 6" } }, "node_modules/caniuse-lite": { - "version": "1.0.30001687", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001687.tgz", - "integrity": "sha512-0S/FDhf4ZiqrTUiQ39dKeUjYRjkv7lOZU1Dgif2rIqrTzX/1wV2hfKu9TOm1IHkdSijfLswxTFzl/cvir+SLSQ==", + "version": "1.0.30001690", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001690.tgz", + "integrity": "sha512-5ExiE3qQN6oF8Clf8ifIDcMRCRE/dMGcETG/XGMD8/XiXm6HXQgQTh1yZYLXXpSOsEUlJm1Xr7kGULZTuGtP/w==", "funding": [ { "type": "opencollective", @@ -3920,6 +4696,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz", "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -3930,6 +4707,7 @@ "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", "dev": true, + "license": "MIT", "dependencies": { "ansi-styles": "^3.2.1", "escape-string-regexp": "^1.0.5", @@ -3943,6 +4721,7 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz", "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -3952,6 +4731,7 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz", "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -3961,6 +4741,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz", "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -3970,21 +4751,17 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz", "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" } }, "node_modules/chokidar": { - "version": "3.5.3", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", - "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", - "funding": [ - { - "type": "individual", - "url": "https://paulmillr.com/funding/" - } - ], + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "license": "MIT", "dependencies": { "anymatch": "~3.1.2", "braces": "~3.0.2", @@ -3997,6 +4774,9 @@ "engines": { "node": ">= 8.10.0" }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, "optionalDependencies": { "fsevents": "~2.3.2" } @@ -4005,6 +4785,7 @@ "version": "1.1.4", "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz", "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==", + "license": "ISC", "optional": true }, "node_modules/ci-info": { @@ -4017,6 +4798,7 @@ "url": "https://github.com/sponsors/sibiraj-s" } ], + "license": "MIT", "engines": { "node": ">=8" } @@ -4025,6 +4807,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz", "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==", + "license": "MIT", "engines": { "node": ">=10" }, @@ -4036,6 +4819,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz", "integrity": "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==", + "license": "MIT", "dependencies": { "restore-cursor": "^4.0.0" }, @@ -4047,9 +4831,10 @@ } }, "node_modules/cli-spinners": { - "version": "2.9.1", - "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.1.tgz", - "integrity": "sha512-jHgecW0pxkonBJdrKsqxgRX9AcG+u/5k0Q7WPDfi8AogLAdwxEkyYYNWwZ5GvVFoFx2uiY1eNcSK00fh+1+FyQ==", + "version": "2.9.2", + "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz", + "integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==", + "license": "MIT", "engines": { "node": ">=6" }, @@ -4058,9 +4843,10 @@ } }, "node_modules/clsx": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.0.0.tgz", - "integrity": "sha512-rQ1+kcj+ttHG0MKVGBUXwayCCF1oh39BF5COIpRzuCEv8Mwjv0XucrI2ExNTOn9IlLifGClWQcU9BrZORvtw6Q==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", + "license": "MIT", "engines": { "node": ">=6" } @@ -4069,6 +4855,7 @@ "version": "4.2.3", "resolved": "https://registry.npmjs.org/color/-/color-4.2.3.tgz", "integrity": "sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==", + "license": "MIT", "optional": true, "dependencies": { "color-convert": "^2.0.1", @@ -4083,6 +4870,7 @@ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", "dev": true, + "license": "MIT", "dependencies": { "color-name": "1.1.3" } @@ -4091,12 +4879,14 @@ "version": "1.1.3", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", - "devOptional": true + "devOptional": true, + "license": "MIT" }, "node_modules/color-string": { "version": "1.9.1", "resolved": "https://registry.npmjs.org/color-string/-/color-string-1.9.1.tgz", "integrity": "sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==", + "license": "MIT", "optional": true, "dependencies": { "color-name": "^1.0.0", @@ -4107,6 +4897,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", "optional": true, "dependencies": { "color-name": "~1.1.4" @@ -4119,12 +4910,14 @@ "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT", "optional": true }, "node_modules/combined-stream": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "license": "MIT", "dependencies": { "delayed-stream": "~1.0.0" }, @@ -4136,6 +4929,7 @@ "version": "2.0.3", "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -4145,6 +4939,7 @@ "version": "4.1.1", "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", + "license": "MIT", "engines": { "node": ">= 6" } @@ -4152,7 +4947,8 @@ "node_modules/common-ancestor-path": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/common-ancestor-path/-/common-ancestor-path-1.0.1.tgz", - "integrity": "sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==" + "integrity": "sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==", + "license": "ISC" }, "node_modules/commondir": { "version": "1.0.1", @@ -4164,7 +4960,9 @@ "node_modules/concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", - "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==" + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" }, "node_modules/content-disposition": { "version": "0.5.4", @@ -4190,12 +4988,14 @@ "node_modules/convert-source-map": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", - "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==" + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "license": "MIT" }, "node_modules/cookie": { "version": "0.5.0", "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz", "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -4252,10 +5052,12 @@ "yarn": ">=1" } }, - "node_modules/cross-spawn": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", - "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "node_modules/cross-env/node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", @@ -4265,10 +5067,77 @@ "node": ">= 8" } }, - "node_modules/cssesc": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", - "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "node_modules/cross-env/node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cross-env/node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cross-env/node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cross-env/node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/cross-spawn": { + "version": "6.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.6.tgz", + "integrity": "sha512-VqCUuhcd1iB+dsv8gxPttb5iZh/D0iubSP21g36KXdEuf6I5JiioesUVjpCdHV9MZRUfVFlvwtIUyPfxo5trtw==", + "dev": true, + "license": "MIT", + "dependencies": { + "nice-try": "^1.0.4", + "path-key": "^2.0.1", + "semver": "^5.5.0", + "shebang-command": "^1.2.0", + "which": "^1.2.9" + }, + "engines": { + "node": ">=4.8" + } + }, + "node_modules/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "license": "MIT", "bin": { "cssesc": "bin/cssesc" }, @@ -4277,15 +5146,17 @@ } }, "node_modules/csstype": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.2.tgz", - "integrity": "sha512-I7K1Uu0MBPzaFKg4nI5Q7Vs2t+3gWWW648spaF+Rg7pI9ds18Ugn+lvg4SHczUdKlHI5LWBXyqfS8+DufyBsgQ==" + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "license": "MIT" }, "node_modules/damerau-levenshtein": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz", "integrity": "sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==", - "dev": true + "dev": true, + "license": "BSD-2-Clause" }, "node_modules/data-view-buffer": { "version": "1.0.1", @@ -4324,13 +5195,13 @@ } }, "node_modules/data-view-byte-offset": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.0.tgz", - "integrity": "sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==", + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz", + "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.6", + "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-data-view": "^1.0.1" }, @@ -4342,11 +5213,12 @@ } }, "node_modules/debug": { - "version": "4.3.4", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", - "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz", + "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==", + "license": "MIT", "dependencies": { - "ms": "2.1.2" + "ms": "^2.1.3" }, "engines": { "node": ">=6.0" @@ -4361,6 +5233,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.0.2.tgz", "integrity": "sha512-O8x12RzrUF8xyVcY0KJowWsmaJxQbmy0/EtnNtHRpsOcT7dFk5W598coHqBVpmWo1oQQfsCqfCmkZN5DJrZVdg==", + "license": "MIT", "dependencies": { "character-entities": "^2.0.0" }, @@ -4383,6 +5256,7 @@ "version": "6.0.0", "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "license": "MIT", "optional": true, "dependencies": { "mimic-response": "^3.1.0" @@ -4398,6 +5272,7 @@ "version": "0.6.0", "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "license": "MIT", "optional": true, "engines": { "node": ">=4.0.0" @@ -4407,7 +5282,8 @@ "version": "0.1.4", "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/deepmerge": { "version": "4.3.1", @@ -4419,94 +5295,11 @@ "node": ">=0.10.0" } }, - "node_modules/default-browser": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-4.0.0.tgz", - "integrity": "sha512-wX5pXO1+BrhMkSbROFsyxUm0i/cJEScyNhA4PPxc41ICuv05ZZB/MX28s8aZx6xjmatvebIapF6hLEKEcpneUA==", - "dev": true, - "dependencies": { - "bundle-name": "^3.0.0", - "default-browser-id": "^3.0.0", - "execa": "^7.1.1", - "titleize": "^3.0.0" - }, - "engines": { - "node": ">=14.16" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/default-browser-id": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-3.0.0.tgz", - "integrity": "sha512-OZ1y3y0SqSICtE8DE4S8YOE9UZOJ8wO16fKWVP5J1Qz42kV9jcnMVFrEE/noXb/ss3Q4pZIH79kxofzyNNtUNA==", - "dev": true, - "dependencies": { - "bplist-parser": "^0.2.0", - "untildify": "^4.0.0" - }, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/default-browser/node_modules/execa": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/execa/-/execa-7.2.0.tgz", - "integrity": "sha512-UduyVP7TLB5IcAQl+OzLyLcS/l32W/GLg+AhHJ+ow40FOk2U3SAllPwR44v4vmdFwIWqpdwxxpQbF1n5ta9seA==", - "dev": true, - "dependencies": { - "cross-spawn": "^7.0.3", - "get-stream": "^6.0.1", - "human-signals": "^4.3.0", - "is-stream": "^3.0.0", - "merge-stream": "^2.0.0", - "npm-run-path": "^5.1.0", - "onetime": "^6.0.0", - "signal-exit": "^3.0.7", - "strip-final-newline": "^3.0.0" - }, - "engines": { - "node": "^14.18.0 || ^16.14.0 || >=18.0.0" - }, - "funding": { - "url": "https://github.com/sindresorhus/execa?sponsor=1" - } - }, - "node_modules/default-browser/node_modules/get-stream": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", - "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", - "dev": true, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/default-browser/node_modules/human-signals": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-4.3.1.tgz", - "integrity": "sha512-nZXjEF2nbo7lIw3mgYjItAfgQXog3OjJogSbKa2CQIIvSGWcKgeJnQlNXip6NglNzYH45nSRiEVimMvYL8DDqQ==", - "dev": true, - "engines": { - "node": ">=14.18.0" - } - }, - "node_modules/default-browser/node_modules/signal-exit": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", - "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", - "dev": true - }, "node_modules/define-data-property": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "dev": true, "license": "MIT", "dependencies": { "es-define-property": "^1.0.0", @@ -4520,23 +5313,12 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/define-lazy-prop": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", - "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", - "dev": true, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/define-properties": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", "dev": true, + "license": "MIT", "dependencies": { "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", @@ -4553,6 +5335,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "license": "MIT", "engines": { "node": ">=0.4.0" } @@ -4561,6 +5344,7 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", "engines": { "node": ">= 0.8" } @@ -4568,12 +5352,14 @@ "node_modules/deprecation": { "version": "2.3.1", "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz", - "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==" + "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==", + "license": "ISC" }, "node_modules/dequal": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz", "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==", + "license": "MIT", "engines": { "node": ">=6" } @@ -4582,15 +5368,17 @@ "version": "1.2.0", "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "license": "MIT", "engines": { "node": ">= 0.8", "npm": "1.2.8000 || >= 1.4.16" } }, "node_modules/detect-libc": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.2.tgz", - "integrity": "sha512-UX6sGumvvqSaXgdKGUsgZWqcUyIXZ/vZTrlRT/iobiKhGL0zL4d3osHj3uqllWJK+i+sixDS/3COVEOFbupFyw==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.3.tgz", + "integrity": "sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==", + "license": "Apache-2.0", "optional": true, "engines": { "node": ">=8" @@ -4599,17 +5387,20 @@ "node_modules/deterministic-object-hash": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/deterministic-object-hash/-/deterministic-object-hash-1.3.1.tgz", - "integrity": "sha512-kQDIieBUreEgY+akq0N7o4FzZCr27dPG1xr3wq267vPwDlSXQ3UMcBXHqTGUBaM/5WDS1jwTYjxRhUzHeuiAvw==" + "integrity": "sha512-kQDIieBUreEgY+akq0N7o4FzZCr27dPG1xr3wq267vPwDlSXQ3UMcBXHqTGUBaM/5WDS1jwTYjxRhUzHeuiAvw==", + "license": "MIT" }, "node_modules/devalue": { - "version": "4.3.2", - "resolved": "https://registry.npmjs.org/devalue/-/devalue-4.3.2.tgz", - "integrity": "sha512-KqFl6pOgOW+Y6wJgu80rHpo2/3H07vr8ntR9rkkFIRETewbf5GaYYcakYfiKz89K+sLsuPkQIZaXDMjUObZwWg==" + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/devalue/-/devalue-4.3.3.tgz", + "integrity": "sha512-UH8EL6H2ifcY8TbD2QsxwCC/pr5xSwPvv85LrLXVihmHVC3T3YqTCIwnR5ak0yO1KYqlxrPVOA/JVZJYPy2ATg==", + "license": "MIT" }, "node_modules/devlop": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz", "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==", + "license": "MIT", "dependencies": { "dequal": "^2.0.0" }, @@ -4621,12 +5412,14 @@ "node_modules/didyoumean": { "version": "1.2.2", "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz", - "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==" + "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==", + "license": "Apache-2.0" }, "node_modules/diff": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/diff/-/diff-5.1.0.tgz", - "integrity": "sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz", + "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==", + "license": "BSD-3-Clause", "engines": { "node": ">=0.3.1" } @@ -4636,6 +5429,7 @@ "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", "dev": true, + "license": "MIT", "dependencies": { "path-type": "^4.0.0" }, @@ -4643,16 +5437,28 @@ "node": ">=8" } }, + "node_modules/dir-glob/node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/dlv": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz", - "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==" + "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==", + "license": "MIT" }, "node_modules/doctrine": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", "dev": true, + "license": "Apache-2.0", "dependencies": { "esutils": "^2.0.2" }, @@ -4661,20 +5467,21 @@ } }, "node_modules/dset": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/dset/-/dset-3.1.3.tgz", - "integrity": "sha512-20TuZZHCEZ2O71q9/+8BwKwZ0QtD9D8ObhrihJPr+vLLYlSuAU3/zL4cSlgbfeoGHTjCSJBa7NGcrF9/Bx/WJQ==", + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/dset/-/dset-3.1.4.tgz", + "integrity": "sha512-2QF/g9/zTaPDc3BjNcVTGoBbXBgYfMTTceLaYcFJ/W9kggFUkhxD/hMEeuLKbugyef9SqAx8cpgwlIP/jinUTA==", + "license": "MIT", "engines": { "node": ">=4" } }, "node_modules/dunder-proto": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.0.tgz", - "integrity": "sha512-9+Sj30DIu+4KvHqMfLUGLFYL2PkURSYMVXJyXe92nFRvlYq5hBjLEhblKB+vkd/WVlUYMWigiY07T91Fkk0+4A==", + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", "license": "MIT", "dependencies": { - "call-bind-apply-helpers": "^1.0.0", + "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" }, @@ -4685,28 +5492,32 @@ "node_modules/eastasianwidth": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", - "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==" + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", + "license": "MIT" }, "node_modules/ee-first": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", - "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" }, "node_modules/electron-to-chromium": { - "version": "1.5.71", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.71.tgz", - "integrity": "sha512-dB68l59BI75W1BUGVTAEJy45CEVuEGy9qPVVQ8pnHyHMn36PLPPoE1mjLH+lo9rKulO3HC2OhbACI/8tCqJBcA==", + "version": "1.5.74", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.74.tgz", + "integrity": "sha512-ck3//9RC+6oss/1Bh9tiAVFy5vfSKbRHAFh7Z3/eTRkEqJeWgymloShB17Vg3Z4nmDNp35vAd1BZ6CMW4Wt6Iw==", "license": "ISC" }, "node_modules/emoji-regex": { "version": "9.2.2", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", - "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==" + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", + "license": "MIT" }, "node_modules/encodeurl": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", - "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", "engines": { "node": ">= 0.8" } @@ -4715,6 +5526,7 @@ "version": "1.4.4", "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", + "license": "MIT", "optional": true, "dependencies": { "once": "^1.4.0" @@ -4724,6 +5536,7 @@ "version": "4.5.0", "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", + "license": "BSD-2-Clause", "engines": { "node": ">=0.12" }, @@ -4741,66 +5554,61 @@ "is-arrayish": "^0.2.1" } }, - "node_modules/error-ex/node_modules/is-arrayish": { - "version": "0.2.1", - "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", - "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", - "dev": true, - "license": "MIT" - }, "node_modules/es-abstract": { - "version": "1.23.5", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.23.5.tgz", - "integrity": "sha512-vlmniQ0WNPwXqA0BnmwV3Ng7HxiGlh6r5U6JcTMNx8OilcAGqVJBHJcPjqOMaczU9fRuRK5Px2BdVyPRnKMMVQ==", + "version": "1.23.6", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.23.6.tgz", + "integrity": "sha512-Ifco6n3yj2tMZDWNLyloZrytt9lqqlwvS83P3HtaETR0NUOYnIULGGHpktqYGObGy+8wc1okO25p8TjemhImvA==", "dev": true, "license": "MIT", "dependencies": { "array-buffer-byte-length": "^1.0.1", - "arraybuffer.prototype.slice": "^1.0.3", + "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", "data-view-buffer": "^1.0.1", "data-view-byte-length": "^1.0.1", "data-view-byte-offset": "^1.0.0", - "es-define-property": "^1.0.0", + "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "es-set-tostringtag": "^2.0.3", - "es-to-primitive": "^1.2.1", - "function.prototype.name": "^1.1.6", - "get-intrinsic": "^1.2.4", + "es-to-primitive": "^1.3.0", + "function.prototype.name": "^1.1.7", + "get-intrinsic": "^1.2.6", "get-symbol-description": "^1.0.2", "globalthis": "^1.0.4", - "gopd": "^1.0.1", + "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", - "has-proto": "^1.0.3", - "has-symbols": "^1.0.3", + "has-proto": "^1.2.0", + "has-symbols": "^1.1.0", "hasown": "^2.0.2", - "internal-slot": "^1.0.7", + "internal-slot": "^1.1.0", "is-array-buffer": "^3.0.4", "is-callable": "^1.2.7", - "is-data-view": "^1.0.1", + "is-data-view": "^1.0.2", "is-negative-zero": "^2.0.3", - "is-regex": "^1.1.4", + "is-regex": "^1.2.1", "is-shared-array-buffer": "^1.0.3", - "is-string": "^1.0.7", + "is-string": "^1.1.1", "is-typed-array": "^1.1.13", - "is-weakref": "^1.0.2", + "is-weakref": "^1.1.0", + "math-intrinsics": "^1.0.0", "object-inspect": "^1.13.3", "object-keys": "^1.1.1", "object.assign": "^4.1.5", "regexp.prototype.flags": "^1.5.3", - "safe-array-concat": "^1.1.2", - "safe-regex-test": "^1.0.3", - "string.prototype.trim": "^1.2.9", - "string.prototype.trimend": "^1.0.8", + "safe-array-concat": "^1.1.3", + "safe-regex-test": "^1.1.0", + "string.prototype.trim": "^1.2.10", + "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", "typed-array-buffer": "^1.0.2", "typed-array-byte-length": "^1.0.1", - "typed-array-byte-offset": "^1.0.2", - "typed-array-length": "^1.0.6", + "typed-array-byte-offset": "^1.0.3", + "typed-array-length": "^1.0.7", "unbox-primitive": "^1.0.2", - "which-typed-array": "^1.1.15" + "which-typed-array": "^1.1.16" }, "engines": { "node": ">= 0.4" @@ -4828,15 +5636,15 @@ } }, "node_modules/es-module-lexer": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.3.1.tgz", - "integrity": "sha512-JUFAyicQV9mXc3YRxPnDlrfBKpqt6hUYzz9/boprUJHs4e4KVr3XwOF70doO6gwXUor6EWZJAyWAfKki84t20Q==" + "version": "1.5.4", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.5.4.tgz", + "integrity": "sha512-MVNK56NiMrOwitFB7cqDwq0CQutbw+0BvLshJSse0MUNU+y1FC3bUS/AQg7oUng+/wKrrki7JfmwtVHkVfPLlw==", + "license": "MIT" }, "node_modules/es-object-atoms": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz", "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==", - "dev": true, "license": "MIT", "dependencies": { "es-errors": "^1.3.0" @@ -4861,23 +5669,25 @@ } }, "node_modules/es-shim-unscopables": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", - "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.2.tgz", + "integrity": "sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==", "dev": true, + "license": "MIT", "dependencies": { - "has": "^1.0.3" + "hasown": "^2.0.0" } }, "node_modules/es-to-primitive": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", - "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz", + "integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==", "dev": true, + "license": "MIT", "dependencies": { - "is-callable": "^1.1.4", - "is-date-object": "^1.0.1", - "is-symbol": "^1.0.2" + "is-callable": "^1.2.7", + "is-date-object": "^1.0.5", + "is-symbol": "^1.0.4" }, "engines": { "node": ">= 0.4" @@ -4887,10 +5697,11 @@ } }, "node_modules/esbuild": { - "version": "0.19.4", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.4.tgz", - "integrity": "sha512-x7jL0tbRRpv4QUyuDMjONtWFciygUxWaUM1kMX2zWxI0X2YWOt7MSA0g4UdeSiHM8fcYVzpQhKYOycZwxTdZkA==", + "version": "0.19.12", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.12.tgz", + "integrity": "sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg==", "hasInstallScript": true, + "license": "MIT", "bin": { "esbuild": "bin/esbuild" }, @@ -4898,28 +5709,29 @@ "node": ">=12" }, "optionalDependencies": { - "@esbuild/android-arm": "0.19.4", - "@esbuild/android-arm64": "0.19.4", - "@esbuild/android-x64": "0.19.4", - "@esbuild/darwin-arm64": "0.19.4", - "@esbuild/darwin-x64": "0.19.4", - "@esbuild/freebsd-arm64": "0.19.4", - "@esbuild/freebsd-x64": "0.19.4", - "@esbuild/linux-arm": "0.19.4", - "@esbuild/linux-arm64": "0.19.4", - "@esbuild/linux-ia32": "0.19.4", - "@esbuild/linux-loong64": "0.19.4", - "@esbuild/linux-mips64el": "0.19.4", - "@esbuild/linux-ppc64": "0.19.4", - "@esbuild/linux-riscv64": "0.19.4", - "@esbuild/linux-s390x": "0.19.4", - "@esbuild/linux-x64": "0.19.4", - "@esbuild/netbsd-x64": "0.19.4", - "@esbuild/openbsd-x64": "0.19.4", - "@esbuild/sunos-x64": "0.19.4", - "@esbuild/win32-arm64": "0.19.4", - "@esbuild/win32-ia32": "0.19.4", - "@esbuild/win32-x64": "0.19.4" + "@esbuild/aix-ppc64": "0.19.12", + "@esbuild/android-arm": "0.19.12", + "@esbuild/android-arm64": "0.19.12", + "@esbuild/android-x64": "0.19.12", + "@esbuild/darwin-arm64": "0.19.12", + "@esbuild/darwin-x64": "0.19.12", + "@esbuild/freebsd-arm64": "0.19.12", + "@esbuild/freebsd-x64": "0.19.12", + "@esbuild/linux-arm": "0.19.12", + "@esbuild/linux-arm64": "0.19.12", + "@esbuild/linux-ia32": "0.19.12", + "@esbuild/linux-loong64": "0.19.12", + "@esbuild/linux-mips64el": "0.19.12", + "@esbuild/linux-ppc64": "0.19.12", + "@esbuild/linux-riscv64": "0.19.12", + "@esbuild/linux-s390x": "0.19.12", + "@esbuild/linux-x64": "0.19.12", + "@esbuild/netbsd-x64": "0.19.12", + "@esbuild/openbsd-x64": "0.19.12", + "@esbuild/sunos-x64": "0.19.12", + "@esbuild/win32-arm64": "0.19.12", + "@esbuild/win32-ia32": "0.19.12", + "@esbuild/win32-x64": "0.19.12" } }, "node_modules/escalade": { @@ -4934,30 +5746,35 @@ "node_modules/escape-html": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", - "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==" + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" }, "node_modules/escape-string-regexp": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.8.0" } }, "node_modules/eslint": { - "version": "8.50.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.50.0.tgz", - "integrity": "sha512-FOnOGSuFuFLv/Sa+FDVRZl4GGVAAFFi8LecRsI5a1tMO5HIE8nCm4ivAlzt4dT3ol/PaaGC0rJEEXQmHJBGoOg==", + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz", + "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==", + "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", "dev": true, + "license": "MIT", "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.6.1", - "@eslint/eslintrc": "^2.1.2", - "@eslint/js": "8.50.0", - "@humanwhocodes/config-array": "^0.11.11", + "@eslint/eslintrc": "^2.1.4", + "@eslint/js": "8.57.1", + "@humanwhocodes/config-array": "^0.13.0", "@humanwhocodes/module-importer": "^1.0.1", "@nodelib/fs.walk": "^1.2.8", + "@ungap/structured-clone": "^1.2.0", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.2", @@ -5000,10 +5817,11 @@ } }, "node_modules/eslint-config-prettier": { - "version": "9.0.0", - "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-9.0.0.tgz", - "integrity": "sha512-IcJsTkJae2S35pRsRAwoCE+925rJJStOdkKnLVgtE+tEpqU0EVVM7OqrwxqgptKdX29NUwC82I5pXsGFIgSevw==", + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-9.1.0.tgz", + "integrity": "sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==", "dev": true, + "license": "MIT", "bin": { "eslint-config-prettier": "bin/cli.js" }, @@ -5016,6 +5834,7 @@ "resolved": "https://registry.npmjs.org/eslint-plugin-astro/-/eslint-plugin-astro-0.29.1.tgz", "integrity": "sha512-ffuUc7zFz8HavaAVaS5iRUzWqBf3/YbrFWUhx0GxXW3gVtnbri5UyvkN8EMOkZWkNXG1zqD2y9dlEsAezhbC0w==", "dev": true, + "license": "MIT", "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@jridgewell/sourcemap-codec": "^1.4.14", @@ -5039,6 +5858,7 @@ "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz", "integrity": "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==", "dev": true, + "license": "MIT", "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, @@ -5048,62 +5868,55 @@ } }, "node_modules/eslint-plugin-jsx-a11y": { - "version": "6.7.1", - "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.7.1.tgz", - "integrity": "sha512-63Bog4iIethyo8smBklORknVjB0T2dwB8Mr/hIC+fBS0uyHdYYpzM/Ed+YC8VxTjlXHEWFOdmgwcDn1U2L9VCA==", + "version": "6.10.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.10.2.tgz", + "integrity": "sha512-scB3nz4WmG75pV8+3eRUQOHZlNSUhFNq37xnpgRkCCELU3XMvXAxLk1eqWWyE22Ki4Q01Fnsw9BA3cJHDPgn2Q==", "dev": true, + "license": "MIT", "dependencies": { - "@babel/runtime": "^7.20.7", - "aria-query": "^5.1.3", - "array-includes": "^3.1.6", - "array.prototype.flatmap": "^1.3.1", - "ast-types-flow": "^0.0.7", - "axe-core": "^4.6.2", - "axobject-query": "^3.1.1", + "aria-query": "^5.3.2", + "array-includes": "^3.1.8", + "array.prototype.flatmap": "^1.3.2", + "ast-types-flow": "^0.0.8", + "axe-core": "^4.10.0", + "axobject-query": "^4.1.0", "damerau-levenshtein": "^1.0.8", "emoji-regex": "^9.2.2", - "has": "^1.0.3", - "jsx-ast-utils": "^3.3.3", - "language-tags": "=1.0.5", + "hasown": "^2.0.2", + "jsx-ast-utils": "^3.3.5", + "language-tags": "^1.0.9", "minimatch": "^3.1.2", - "object.entries": "^1.1.6", - "object.fromentries": "^2.0.6", - "semver": "^6.3.0" + "object.fromentries": "^2.0.8", + "safe-regex-test": "^1.0.3", + "string.prototype.includes": "^2.0.1" }, "engines": { "node": ">=4.0" }, "peerDependencies": { - "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8" - } - }, - "node_modules/eslint-plugin-jsx-a11y/node_modules/semver": { - "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", - "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", - "dev": true, - "bin": { - "semver": "bin/semver.js" + "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9" } }, "node_modules/eslint-plugin-prettier": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.0.0.tgz", - "integrity": "sha512-AgaZCVuYDXHUGxj/ZGu1u8H8CYgDY3iG6w5kUFw4AzMVXzB7VvbKgYR4nATIN+OvUrghMbiDLeimVjVY5ilq3w==", + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.2.1.tgz", + "integrity": "sha512-gH3iR3g4JfF+yYPaJYkN7jEl9QbweL/YfkoRlNnuIEHEz1vHVlCmWOS+eGGiRuzHQXdJFCOTxRgvju9b8VUmrw==", "dev": true, + "license": "MIT", "dependencies": { "prettier-linter-helpers": "^1.0.0", - "synckit": "^0.8.5" + "synckit": "^0.9.1" }, "engines": { "node": "^14.18.0 || >=16.0.0" }, "funding": { - "url": "https://opencollective.com/prettier" + "url": "https://opencollective.com/eslint-plugin-prettier" }, "peerDependencies": { "@types/eslint": ">=8.0.0", "eslint": ">=8.0.0", + "eslint-config-prettier": "*", "prettier": ">=3.0.0" }, "peerDependenciesMeta": { @@ -5116,14 +5929,15 @@ } }, "node_modules/eslint-plugin-solid": { - "version": "0.13.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-solid/-/eslint-plugin-solid-0.13.0.tgz", - "integrity": "sha512-Sutd+DxEGu9+Z9ITtHKXRAClxVe1a6C1XQZSuN8iBsMy0IAVEc6Tca1UYgc7tD2ZrRRjZKB9mohBOaZl5NJLgg==", + "version": "0.13.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-solid/-/eslint-plugin-solid-0.13.2.tgz", + "integrity": "sha512-Ndeuc6MEO11YVqzIzxtKKEG0t4HPJ4ob/WQyduwpTW//NtyZqWx/gPii5GF656DLqBbsfsmMaX0zkFQ8ElyOdQ==", "dev": true, + "license": "MIT", "dependencies": { "@typescript-eslint/utils": "^6.4.0", + "estraverse": "^5.3.0", "is-html": "^2.0.0", - "jsx-ast-utils": "^3.3.3", "kebab-case": "^1.0.2", "known-css-properties": "^0.24.0", "style-to-object": "^0.3.0" @@ -5140,6 +5954,7 @@ "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" @@ -5156,6 +5971,7 @@ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, @@ -5168,6 +5984,7 @@ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } @@ -5177,6 +5994,7 @@ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, + "license": "MIT", "dependencies": { "color-convert": "^2.0.1" }, @@ -5192,6 +6010,7 @@ "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, + "license": "MIT", "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" @@ -5208,6 +6027,7 @@ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, + "license": "MIT", "dependencies": { "color-name": "~1.1.4" }, @@ -5219,13 +6039,30 @@ "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", - "dev": true - }, - "node_modules/eslint/node_modules/escape-string-regexp": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", - "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true, + "license": "MIT" + }, + "node_modules/eslint/node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/eslint/node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", "engines": { "node": ">=10" }, @@ -5238,6 +6075,7 @@ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", "dev": true, + "license": "ISC", "dependencies": { "is-glob": "^4.0.3" }, @@ -5246,10 +6084,11 @@ } }, "node_modules/eslint/node_modules/globals": { - "version": "13.22.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.22.0.tgz", - "integrity": "sha512-H1Ddc/PbZHTDVJSnj8kWptIRSD6AM3pK+mKytuIVF4uoBV7rshFlhhvA58ceJ5wp3Er58w6zj7bykMpYXt3ETw==", + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", "dev": true, + "license": "MIT", "dependencies": { "type-fest": "^0.20.2" }, @@ -5265,6 +6104,40 @@ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/eslint/node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/eslint/node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/eslint/node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", "engines": { "node": ">=8" } @@ -5274,6 +6147,7 @@ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, @@ -5286,6 +6160,7 @@ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, + "license": "MIT", "dependencies": { "has-flag": "^4.0.0" }, @@ -5298,6 +6173,7 @@ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", "dev": true, + "license": "(MIT OR CC0-1.0)", "engines": { "node": ">=10" }, @@ -5305,11 +6181,28 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/eslint/node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, "node_modules/espree": { "version": "9.6.1", "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "acorn": "^8.9.0", "acorn-jsx": "^5.3.2", @@ -5326,6 +6219,7 @@ "version": "4.0.1", "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "license": "BSD-2-Clause", "bin": { "esparse": "bin/esparse.js", "esvalidate": "bin/esvalidate.js" @@ -5335,10 +6229,11 @@ } }, "node_modules/esquery": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", - "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", + "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", "dev": true, + "license": "BSD-3-Clause", "dependencies": { "estraverse": "^5.1.0" }, @@ -5351,6 +6246,7 @@ "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "estraverse": "^5.2.0" }, @@ -5363,6 +6259,7 @@ "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", "dev": true, + "license": "BSD-2-Clause", "engines": { "node": ">=4.0" } @@ -5371,6 +6268,7 @@ "version": "2.1.1", "resolved": "https://registry.npmjs.org/estree-util-attach-comments/-/estree-util-attach-comments-2.1.1.tgz", "integrity": "sha512-+5Ba/xGGS6mnwFbXIuQiDPTbuTxuMCooq3arVv7gPZtYpjp+VXH/NkHAP35OOefPhNG/UGqU3vt/LTABwcHX0w==", + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0" }, @@ -5383,6 +6281,7 @@ "version": "2.2.2", "resolved": "https://registry.npmjs.org/estree-util-build-jsx/-/estree-util-build-jsx-2.2.2.tgz", "integrity": "sha512-m56vOXcOBuaF+Igpb9OPAy7f9w9OIkb5yhjsZuaPm7HoGi4oTOQi0h2+yZ+AtKklYFZ+rPC4n0wYCJCEU1ONqg==", + "license": "MIT", "dependencies": { "@types/estree-jsx": "^1.0.0", "estree-util-is-identifier-name": "^2.0.0", @@ -5397,6 +6296,7 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-2.1.0.tgz", "integrity": "sha512-bEN9VHRyXAUOjkKVQVvArFym08BTWB0aJPppZZr0UNyAqWsLaVfAqP7hbaTJjzHifmB5ebnR8Wm7r7yGN/HonQ==", + "license": "MIT", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" @@ -5406,6 +6306,7 @@ "version": "1.2.0", "resolved": "https://registry.npmjs.org/estree-util-to-js/-/estree-util-to-js-1.2.0.tgz", "integrity": "sha512-IzU74r1PK5IMMGZXUVZbmiu4A1uhiPgW5hm1GjcOfr4ZzHaMPpLNJjR7HjXiIOzi25nZDrgFTobHTkV5Q6ITjA==", + "license": "MIT", "dependencies": { "@types/estree-jsx": "^1.0.0", "astring": "^1.8.0", @@ -5420,6 +6321,7 @@ "version": "1.2.1", "resolved": "https://registry.npmjs.org/estree-util-visit/-/estree-util-visit-1.2.1.tgz", "integrity": "sha512-xbgqcrkIVbIG+lI/gzbvd9SGTJL4zqJKBFttUl5pP27KhAjtMKbX/mQXJ7qgyXpMgVy/zvpm0xoQQaGL8OloOw==", + "license": "MIT", "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/unist": "^2.0.0" @@ -5433,6 +6335,7 @@ "version": "3.0.3", "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0" } @@ -5442,6 +6345,7 @@ "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", "dev": true, + "license": "BSD-2-Clause", "engines": { "node": ">=0.10.0" } @@ -5450,6 +6354,7 @@ "version": "1.8.1", "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -5457,12 +6362,14 @@ "node_modules/eventemitter3": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz", - "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==" + "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==", + "license": "MIT" }, "node_modules/execa": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz", "integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==", + "license": "MIT", "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^8.0.1", @@ -5481,10 +6388,70 @@ "url": "https://github.com/sindresorhus/execa?sponsor=1" } }, + "node_modules/execa/node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/execa/node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/execa/node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/execa/node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/execa/node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, "node_modules/expand-template": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz", "integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==", + "license": "(MIT OR WTFPL)", "optional": true, "engines": { "node": ">=6" @@ -5554,14 +6521,11 @@ "ms": "2.0.0" } }, - "node_modules/express/node_modules/encodeurl": { + "node_modules/express/node_modules/debug/node_modules/ms": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", - "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" }, "node_modules/express/node_modules/mime": { "version": "1.6.0", @@ -5575,12 +6539,6 @@ "node": ">=4" } }, - "node_modules/express/node_modules/ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", - "license": "MIT" - }, "node_modules/express/node_modules/path-to-regexp": { "version": "0.1.12", "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", @@ -5620,21 +6578,17 @@ "node": ">= 0.8" } }, - "node_modules/express/node_modules/send/node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", - "license": "MIT" - }, "node_modules/extend": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", - "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==" + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "license": "MIT" }, "node_modules/extend-shallow": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", "integrity": "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==", + "license": "MIT", "dependencies": { "is-extendable": "^0.1.0" }, @@ -5646,24 +6600,28 @@ "version": "3.1.3", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/fast-diff": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz", "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==", - "dev": true + "dev": true, + "license": "Apache-2.0" }, "node_modules/fast-fifo": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz", "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==", + "license": "MIT", "optional": true }, "node_modules/fast-glob": { - "version": "3.3.1", - "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.1.tgz", - "integrity": "sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg==", + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz", + "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==", + "license": "MIT", "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", @@ -5679,27 +6637,46 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/fast-levenshtein": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/fastq": { - "version": "1.15.0", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", - "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "version": "1.17.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz", + "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==", + "license": "ISC", "dependencies": { "reusify": "^1.0.4" } }, + "node_modules/fdir": { + "version": "6.4.2", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.2.tgz", + "integrity": "sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, "node_modules/file-entry-cache": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", "dev": true, + "license": "MIT", "dependencies": { "flat-cache": "^3.0.4" }, @@ -5711,6 +6688,7 @@ "version": "7.1.1", "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "license": "MIT", "dependencies": { "to-regex-range": "^5.0.1" }, @@ -5745,15 +6723,6 @@ "ms": "2.0.0" } }, - "node_modules/finalhandler/node_modules/encodeurl": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", - "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, "node_modules/finalhandler/node_modules/ms": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", @@ -5764,6 +6733,7 @@ "version": "5.0.0", "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "license": "MIT", "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" @@ -5779,41 +6749,45 @@ "version": "1.2.16", "resolved": "https://registry.npmjs.org/find-yarn-workspace-root2/-/find-yarn-workspace-root2-1.2.16.tgz", "integrity": "sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA==", + "license": "Apache-2.0", "dependencies": { "micromatch": "^4.0.2", "pkg-dir": "^4.2.0" } }, "node_modules/flat-cache": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.1.0.tgz", - "integrity": "sha512-OHx4Qwrrt0E4jEIcI5/Xb+f+QmJYNj2rrK8wiIdQOIrB9WrrJL8cjZvXdXuBTkkEwEqLycb5BeZDV1o2i9bTew==", + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz", + "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==", "dev": true, + "license": "MIT", "dependencies": { - "flatted": "^3.2.7", + "flatted": "^3.2.9", "keyv": "^4.5.3", "rimraf": "^3.0.2" }, "engines": { - "node": ">=12.0.0" + "node": "^10.12.0 || >=12.0.0" } }, "node_modules/flatted": { - "version": "3.2.9", - "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.9.tgz", - "integrity": "sha512-36yxDn5H7OFZQla0/jFJmbIKTdZAQHngCedGxiMmpNfEZM0sdEeT+WczLQrjK6D7o2aiyLYDnkw0R3JK0Qv1RQ==", - "dev": true + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.2.tgz", + "integrity": "sha512-AiwGJM8YcNOaobumgtng+6NHuOqC3A7MixFeDafM3X9cIUM+xUXoS5Vfgf+OihAYe20fxqNM9yPBXJzRtZ/4eA==", + "dev": true, + "license": "ISC" }, "node_modules/follow-redirects": { - "version": "1.15.6", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.6.tgz", - "integrity": "sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==", + "version": "1.15.9", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz", + "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==", "funding": [ { "type": "individual", "url": "https://github.com/sponsors/RubenVerborgh" } ], + "license": "MIT", "engines": { "node": ">=4.0" }, @@ -5833,58 +6807,153 @@ "is-callable": "^1.1.3" } }, - "node_modules/form-data": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz", - "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==", + "node_modules/foreground-child": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.0.tgz", + "integrity": "sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==", + "license": "ISC", "dependencies": { - "asynckit": "^0.4.0", - "combined-stream": "^1.0.8", - "mime-types": "^2.1.12" + "cross-spawn": "^7.0.0", + "signal-exit": "^4.0.1" }, "engines": { - "node": ">= 6" + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/forwarded": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", - "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "node_modules/foreground-child/node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, "engines": { - "node": ">= 0.6" + "node": ">= 8" } }, - "node_modules/fraction.js": { - "version": "4.3.6", - "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.6.tgz", - "integrity": "sha512-n2aZ9tNfYDwaHhvFTkhFErqOMIb8uyzSQ+vGJBjZyanAKZVbGUQ1sngfk9FdkBw7G26O7AgNjLcecLffD1c7eg==", + "node_modules/foreground-child/node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "license": "MIT", "engines": { - "node": "*" - }, - "funding": { - "type": "patreon", - "url": "https://github.com/sponsors/rawify" + "node": ">=8" } }, - "node_modules/fresh": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", - "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "node_modules/foreground-child/node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, "engines": { - "node": ">= 0.6" + "node": ">=8" } }, - "node_modules/fs-constants": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", + "node_modules/foreground-child/node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/foreground-child/node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/form-data": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.1.tgz", + "integrity": "sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fraction.js": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz", + "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==", + "license": "MIT", + "engines": { + "node": "*" + }, + "funding": { + "type": "patreon", + "url": "https://github.com/sponsors/rawify" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fs-constants": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==", + "license": "MIT", "optional": true }, "node_modules/fs.realpath": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", - "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==" + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } }, "node_modules/function-bind": { "version": "1.1.2", @@ -5896,15 +6965,17 @@ } }, "node_modules/function.prototype.name": { - "version": "1.1.6", - "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.6.tgz", - "integrity": "sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==", + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.7.tgz", + "integrity": "sha512-2g4x+HqTJKM9zcJqBSpjoRmdcPFtJM60J3xJisTQSXBWka5XqyBN/2tNUgma1mztTXyDuUsEtYe5qcs7xYzYQA==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "functions-have-names": "^1.2.3" + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "functions-have-names": "^1.2.3", + "hasown": "^2.0.2", + "is-callable": "^1.2.7" }, "engines": { "node": ">= 0.4" @@ -5918,6 +6989,7 @@ "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", "dev": true, + "license": "MIT", "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -5926,24 +6998,27 @@ "version": "1.0.0-beta.2", "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/get-intrinsic": { - "version": "1.2.5", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.5.tgz", - "integrity": "sha512-Y4+pKa7XeRUPWFNvOOYHkRYrfzW07oraURSvjDmRVOJ748OrVmeXtpE4+GCEHncjCjkTxPNRt8kEbxDhsn6VTg==", + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.6.tgz", + "integrity": "sha512-qxsEs+9A+u85HhllWJJFicJfPDhRmjzoYdl64aMWW9yRIJmSyxdn8IEkuIM530/7T+lv0TIHd8L6Q/ra0tEoeA==", "license": "MIT", "dependencies": { - "call-bind-apply-helpers": "^1.0.0", + "call-bind-apply-helpers": "^1.0.1", "dunder-proto": "^1.0.0", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", "function-bind": "^1.1.2", "gopd": "^1.2.0", "has-symbols": "^1.1.0", - "hasown": "^2.0.2" + "hasown": "^2.0.2", + "math-intrinsics": "^1.0.0" }, "engines": { "node": ">= 0.4" @@ -5956,6 +7031,7 @@ "version": "8.0.1", "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz", "integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==", + "license": "MIT", "engines": { "node": ">=16" }, @@ -5964,15 +7040,15 @@ } }, "node_modules/get-symbol-description": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.2.tgz", - "integrity": "sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz", + "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.5", + "call-bound": "^1.0.3", "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.4" + "get-intrinsic": "^1.2.6" }, "engines": { "node": ">= 0.4" @@ -5985,18 +7061,22 @@ "version": "0.0.0", "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz", "integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==", + "license": "MIT", "optional": true }, "node_modules/github-slugger": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-2.0.0.tgz", - "integrity": "sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw==" + "integrity": "sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw==", + "license": "ISC" }, "node_modules/glob": { "version": "7.2.3", "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", "dev": true, + "license": "ISC", "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", @@ -6016,6 +7096,7 @@ "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "license": "ISC", "dependencies": { "is-glob": "^4.0.1" }, @@ -6027,6 +7108,7 @@ "version": "11.12.0", "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "license": "MIT", "engines": { "node": ">=4" } @@ -6053,6 +7135,7 @@ "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", "dev": true, + "license": "MIT", "dependencies": { "array-union": "^2.1.0", "dir-glob": "^3.0.1", @@ -6083,18 +7166,21 @@ "node_modules/graceful-fs": { "version": "4.2.11", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", - "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==" + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "license": "ISC" }, "node_modules/graphemer": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/gray-matter": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/gray-matter/-/gray-matter-4.0.3.tgz", "integrity": "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q==", + "license": "MIT", "dependencies": { "js-yaml": "^3.13.1", "kind-of": "^6.0.2", @@ -6109,6 +7195,7 @@ "version": "1.0.10", "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "license": "MIT", "dependencies": { "sprintf-js": "~1.0.2" } @@ -6117,6 +7204,7 @@ "version": "3.14.1", "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "license": "MIT", "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" @@ -6125,22 +7213,15 @@ "js-yaml": "bin/js-yaml.js" } }, - "node_modules/has": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", - "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", - "dependencies": { - "function-bind": "^1.1.1" - }, - "engines": { - "node": ">= 0.4.0" - } - }, "node_modules/has-bigints": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", - "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz", + "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==", "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -6150,6 +7231,7 @@ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", "dev": true, + "license": "MIT", "engines": { "node": ">=4" } @@ -6158,6 +7240,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", + "dev": true, "license": "MIT", "dependencies": { "es-define-property": "^1.0.0" @@ -6226,6 +7309,7 @@ "version": "7.1.2", "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-7.1.2.tgz", "integrity": "sha512-Nz7FfPBuljzsN3tCQ4kCBKqdNhQE2l0Tn+X1ubgKBPRoiDIu1mL08Cfw4k7q71+Duyaw7DXDN+VTAp4Vh3oCOw==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "@types/unist": "^2.0.0", @@ -6244,6 +7328,7 @@ "version": "3.1.1", "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-3.1.1.tgz", "integrity": "sha512-jdlwBjEexy1oGz0aJ2f4GKMaVKkA9jwjr4MjAAI22E5fM/TXVZHuS5OpONtdeIkRKqAaryQ2E9xNQxijoThSZA==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0" }, @@ -6256,6 +7341,7 @@ "version": "7.2.3", "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-7.2.3.tgz", "integrity": "sha512-RujVQfVsOrxzPOPSzZFiwofMArbQke6DJjnFfceiEbFh7S05CbPt0cYN+A5YeD3pso0JQk6O1aHBnx9+Pm2uqg==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "@types/parse5": "^6.0.0", @@ -6278,6 +7364,7 @@ "version": "2.3.3", "resolved": "https://registry.npmjs.org/hast-util-to-estree/-/hast-util-to-estree-2.3.3.tgz", "integrity": "sha512-ihhPIUPxN0v0w6M5+IiAZZrn0LH2uZomeWwhn7uP7avZC6TE7lIiEh2yBMPr5+zi1aUCXq6VoYRgs2Bw9xmycQ==", + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0", "@types/estree-jsx": "^1.0.0", @@ -6301,9 +7388,10 @@ } }, "node_modules/hast-util-to-estree/node_modules/style-to-object": { - "version": "0.4.2", - "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-0.4.2.tgz", - "integrity": "sha512-1JGpfPB3lo42ZX8cuPrheZbfQ6kqPPnPHlKMyeRYtfKD+0jG+QsXgXN57O/dvJlzlB2elI6dGmrPnl5VPQFPaA==", + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-0.4.4.tgz", + "integrity": "sha512-HYNoHZa2GorYNyqiCaBgsxvcJIn7OHq6inEga+E6Ke3m5JkoqpQbnFssk4jwe+K7AhGa2fcha4wSOf1Kn01dMg==", + "license": "MIT", "dependencies": { "inline-style-parser": "0.1.1" } @@ -6312,6 +7400,7 @@ "version": "8.0.4", "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-8.0.4.tgz", "integrity": "sha512-4tpQTUOr9BMjtYyNlt0P50mH7xj0Ks2xpo8M943Vykljf99HW6EzulIoJP1N3eKOSScEHzyzi9dm7/cn0RfGwA==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "@types/unist": "^2.0.0", @@ -6334,6 +7423,7 @@ "version": "7.1.0", "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-7.1.0.tgz", "integrity": "sha512-YNRgAJkH2Jky5ySkIqFXTQiaqcAtJyVE+D5lkN6CdtOqrnkLfGYYrEcKuHOJZlp+MwjSwuD3fZuawI+sic/RBw==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "comma-separated-tokens": "^2.0.0", @@ -6351,6 +7441,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-2.0.1.tgz", "integrity": "sha512-nAxA0v8+vXSBDt3AnRUNjyRIQ0rD+ntpbAp4LnPkumc5M9yUbSMa4XDU9Q6etY4f1Wp4bNgvc1yjiZtsTTrSng==", + "license": "MIT", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" @@ -6360,6 +7451,7 @@ "version": "7.2.0", "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-7.2.0.tgz", "integrity": "sha512-TtYPq24IldU8iKoJQqvZOuhi5CyCQRAbvDOX0x1eW6rsHSxa/1i2CCiptNTotGHJ3VoHRGmqiv6/D3q113ikkw==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "comma-separated-tokens": "^2.0.0", @@ -6382,18 +7474,21 @@ "node_modules/html-entities": { "version": "2.3.3", "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.3.3.tgz", - "integrity": "sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA==" + "integrity": "sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA==", + "license": "MIT" }, "node_modules/html-escaper": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-3.0.3.tgz", - "integrity": "sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ==" + "integrity": "sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ==", + "license": "MIT" }, "node_modules/html-tags": { "version": "3.3.1", "resolved": "https://registry.npmjs.org/html-tags/-/html-tags-3.3.1.tgz", "integrity": "sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" }, @@ -6405,6 +7500,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-2.0.1.tgz", "integrity": "sha512-0quDb7s97CfemeJAnW9wC0hw78MtW7NU3hqtCD75g2vFlDLt36llsYD7uB7SUzojLMP24N5IatXf7ylGXiGG9A==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -6413,12 +7509,14 @@ "node_modules/http-cache-semantics": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz", - "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==" + "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==", + "license": "BSD-2-Clause" }, "node_modules/http-errors": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "license": "MIT", "dependencies": { "depd": "2.0.0", "inherits": "2.0.4", @@ -6434,6 +7532,7 @@ "version": "5.0.0", "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz", "integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==", + "license": "Apache-2.0", "engines": { "node": ">=16.17.0" } @@ -6442,6 +7541,7 @@ "version": "0.4.24", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", "dependencies": { "safer-buffer": ">= 2.1.2 < 3" }, @@ -6466,13 +7566,15 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "BSD-3-Clause" }, "node_modules/ignore": { - "version": "5.2.4", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", - "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", "dev": true, + "license": "MIT", "engines": { "node": ">= 4" } @@ -6489,6 +7591,7 @@ "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", "dev": true, + "license": "MIT", "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" @@ -6501,9 +7604,10 @@ } }, "node_modules/import-meta-resolve": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-3.0.0.tgz", - "integrity": "sha512-4IwhLhNNA8yy445rPjD/lWh++7hMDOml2eHtd58eG7h+qK3EryMuuRbsHGPikCoAgIkkDnckKfWSk2iDla/ejg==", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-3.1.1.tgz", + "integrity": "sha512-qeywsE/KC3w9Fd2ORrRDUw6nS/nLwZpXgfrOc2IILvZYnCaEMd+D56Vfg9k4G29gIeVi3XKql1RQatME8iYsiw==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -6514,6 +7618,7 @@ "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.8.19" } @@ -6522,6 +7627,9 @@ "version": "1.0.6", "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "license": "ISC", "dependencies": { "once": "^1.3.0", "wrappy": "1" @@ -6530,29 +7638,32 @@ "node_modules/inherits": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" }, "node_modules/ini": { "version": "1.3.8", "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", + "license": "ISC", "optional": true }, "node_modules/inline-style-parser": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.1.1.tgz", - "integrity": "sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==" + "integrity": "sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==", + "license": "MIT" }, "node_modules/internal-slot": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.7.tgz", - "integrity": "sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz", + "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==", "dev": true, "license": "MIT", "dependencies": { "es-errors": "^1.3.0", - "hasown": "^2.0.0", - "side-channel": "^1.0.4" + "hasown": "^2.0.2", + "side-channel": "^1.1.0" }, "engines": { "node": ">= 0.4" @@ -6571,6 +7682,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz", "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -6580,6 +7692,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz", "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==", + "license": "MIT", "dependencies": { "is-alphabetical": "^2.0.0", "is-decimal": "^2.0.0" @@ -6590,14 +7703,15 @@ } }, "node_modules/is-array-buffer": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.4.tgz", - "integrity": "sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==", + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz", + "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.2.1" + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" }, "engines": { "node": ">= 0.4" @@ -6607,10 +7721,11 @@ } }, "node_modules/is-arrayish": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz", - "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==", - "optional": true + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true, + "license": "MIT" }, "node_modules/is-async-function": { "version": "2.0.0", @@ -6629,12 +7744,16 @@ } }, "node_modules/is-bigint": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", - "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz", + "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==", "dev": true, + "license": "MIT", "dependencies": { - "has-bigints": "^1.0.1" + "has-bigints": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -6644,6 +7763,7 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "license": "MIT", "dependencies": { "binary-extensions": "^2.0.0" }, @@ -6652,13 +7772,14 @@ } }, "node_modules/is-boolean-object": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", - "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.1.tgz", + "integrity": "sha512-l9qO6eFlUETHtuihLcYOaLKByJ1f+N4kthcU9YjHy3N+B3hWv0y/2Nd0mu/7lTFnRQHTrSdXF50HQ3bl5fEnng==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.2", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -6685,6 +7806,7 @@ "url": "https://feross.org/support" } ], + "license": "MIT", "engines": { "node": ">=4" } @@ -6694,6 +7816,7 @@ "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", "dev": true, + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -6702,23 +7825,29 @@ } }, "node_modules/is-core-module": { - "version": "2.13.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.13.0.tgz", - "integrity": "sha512-Z7dk6Qo8pOCp3l4tsX2C5ZVas4V+UxwQodwZhLopL91TX8UyyHEXafPcyoeeWuLrwzHcr3igO78wNLwHJHsMCQ==", + "version": "2.16.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.0.tgz", + "integrity": "sha512-urTSINYfAYgcbLb0yDQ6egFm6h3Mo1DcF9EkyXSRjjzdHbsulg01qhwWuXdOoUBuTkbQ80KDboXa0vFJ+BDH+g==", + "license": "MIT", "dependencies": { - "has": "^1.0.3" + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-data-view": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.1.tgz", - "integrity": "sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz", + "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==", "dev": true, "license": "MIT", "dependencies": { + "call-bound": "^1.0.2", + "get-intrinsic": "^1.2.6", "is-typed-array": "^1.1.13" }, "engines": { @@ -6729,12 +7858,14 @@ } }, "node_modules/is-date-object": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", - "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz", + "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==", "dev": true, + "license": "MIT", "dependencies": { - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.2", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -6747,6 +7878,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz", "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -6756,6 +7888,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz", "integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==", + "license": "MIT", "bin": { "is-docker": "cli.js" }, @@ -6770,6 +7903,7 @@ "version": "0.1.1", "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", "integrity": "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==", + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -6778,18 +7912,19 @@ "version": "2.1.1", "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/is-finalizationregistry": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.0.tgz", - "integrity": "sha512-qfMdqbAQEwBw78ZyReKnlA8ezmPdb9BemzIIip/JkjaZUhitfXDkkr+3QTboW0JrSXT1QWyYShpvnNHGZ4c4yA==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz", + "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.7" + "call-bound": "^1.0.3" }, "engines": { "node": ">= 0.4" @@ -6802,6 +7937,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "license": "MIT", "engines": { "node": ">=8" } @@ -6826,6 +7962,7 @@ "version": "4.0.3", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "license": "MIT", "dependencies": { "is-extglob": "^2.1.1" }, @@ -6837,6 +7974,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz", "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -6847,6 +7985,7 @@ "resolved": "https://registry.npmjs.org/is-html/-/is-html-2.0.0.tgz", "integrity": "sha512-S+OpgB5i7wzIue/YSE5hg0e5ZYfG3hhpNh9KGl6ayJ38p7ED6wxQLd1TV91xHpcTvw90KMJ9EwN3F/iNflHBVg==", "dev": true, + "license": "MIT", "dependencies": { "html-tags": "^3.0.0" }, @@ -6858,6 +7997,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz", "integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==", + "license": "MIT", "dependencies": { "is-docker": "^3.0.0" }, @@ -6875,6 +8015,7 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz", "integrity": "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -6919,17 +8060,20 @@ "version": "7.0.0", "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "license": "MIT", "engines": { "node": ">=0.12.0" } }, "node_modules/is-number-object": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", - "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz", + "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==", "dev": true, + "license": "MIT", "dependencies": { - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -6943,6 +8087,7 @@ "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } @@ -6951,6 +8096,7 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz", "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -6958,31 +8104,25 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/is-plain-object": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", - "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/is-reference": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.2.tgz", - "integrity": "sha512-v3rht/LgVcsdZa3O2Nqs+NMowLOxeOm7Ay9+/ARQ2F+qEoANRcqrjAZKGN0v8ymUetZGgkp26LTnGT7H0Qo9Pg==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz", + "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==", + "dev": true, + "license": "MIT", "dependencies": { "@types/estree": "*" } }, "node_modules/is-regex": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.0.tgz", - "integrity": "sha512-B6ohK4ZmoftlUe+uvenXSbPJFo6U37BH7oO1B3nQH8f/7h27N56s85MhUtbFJAziz5dcmuR3i8ovUl35zp8pFA==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz", + "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", - "gopd": "^1.1.0", + "call-bound": "^1.0.2", + "gopd": "^1.2.0", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" }, @@ -7007,13 +8147,13 @@ } }, "node_modules/is-shared-array-buffer": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.3.tgz", - "integrity": "sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz", + "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.7" + "call-bound": "^1.0.3" }, "engines": { "node": ">= 0.4" @@ -7026,6 +8166,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz", "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==", + "license": "MIT", "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" }, @@ -7034,12 +8175,14 @@ } }, "node_modules/is-string": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", - "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz", + "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==", "dev": true, + "license": "MIT", "dependencies": { - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -7049,12 +8192,15 @@ } }, "node_modules/is-symbol": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", - "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz", + "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==", "dev": true, + "license": "MIT", "dependencies": { - "has-symbols": "^1.0.2" + "call-bound": "^1.0.2", + "has-symbols": "^1.1.0", + "safe-regex-test": "^1.1.0" }, "engines": { "node": ">= 0.4" @@ -7064,13 +8210,13 @@ } }, "node_modules/is-typed-array": { - "version": "1.1.13", - "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz", - "integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==", + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz", + "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==", "dev": true, "license": "MIT", "dependencies": { - "which-typed-array": "^1.1.14" + "which-typed-array": "^1.1.16" }, "engines": { "node": ">= 0.4" @@ -7083,6 +8229,7 @@ "version": "1.3.0", "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz", "integrity": "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -7104,26 +8251,30 @@ } }, "node_modules/is-weakref": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", - "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.0.tgz", + "integrity": "sha512-SXM8Nwyys6nT5WP6pltOwKytLV7FqQ4UiibxVmW+EIosHcmCqkkjViTb5SNssDlkCiEYRP1/pdWUKVvZBmsR2Q==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2" + "call-bound": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-weakset": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.3.tgz", - "integrity": "sha512-LvIm3/KWzS9oRFHugab7d+M/GcBXuXX5xZkzPmN+NxihdQlZUQ4dWuSV1xR/sq6upL1TJEDrfBgRepHFdBtSNQ==", + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz", + "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", - "get-intrinsic": "^1.2.4" + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" }, "engines": { "node": ">= 0.4" @@ -7133,9 +8284,10 @@ } }, "node_modules/is-what": { - "version": "4.1.15", - "resolved": "https://registry.npmjs.org/is-what/-/is-what-4.1.15.tgz", - "integrity": "sha512-uKua1wfy3Yt+YqsD6mTUEa2zSi3G1oPlqTflgaPJ7z63vUGN5pxFpnQfeSLMFnJDEsdvOtkp1rUWkYjB4YfhgA==", + "version": "4.1.16", + "resolved": "https://registry.npmjs.org/is-what/-/is-what-4.1.16.tgz", + "integrity": "sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==", + "license": "MIT", "engines": { "node": ">=12.13" }, @@ -7147,6 +8299,7 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.0.tgz", "integrity": "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==", + "license": "MIT", "dependencies": { "is-inside-container": "^1.0.0" }, @@ -7167,12 +8320,29 @@ "node_modules/isexe": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==" + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "license": "ISC" }, - "node_modules/jiti": { - "version": "1.20.0", - "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.20.0.tgz", - "integrity": "sha512-3TV69ZbrvV6U5DfQimop50jE9Dl6J8O1ja1dvBbMba/sZ3YBEQqJ2VZRoQPVnhlzjNtU1vaXRZVrVjU4qtm8yA==", + "node_modules/jackspeak": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", + "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, + "node_modules/jiti": { + "version": "1.21.7", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz", + "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==", + "license": "MIT", "bin": { "jiti": "bin/jiti.js" } @@ -7187,6 +8357,7 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "license": "MIT", "dependencies": { "argparse": "^2.0.1" }, @@ -7195,9 +8366,9 @@ } }, "node_modules/jsesc": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz", - "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", "license": "MIT", "bin": { "jsesc": "bin/jsesc" @@ -7210,7 +8381,8 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/json-parse-better-errors": { "version": "1.0.2", @@ -7223,18 +8395,21 @@ "version": "0.4.1", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/json-stable-stringify-without-jsonify": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/json5": { "version": "2.2.3", "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "license": "MIT", "bin": { "json5": "lib/cli.js" }, @@ -7242,16 +8417,12 @@ "node": ">=6" } }, - "node_modules/jsonc-parser": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz", - "integrity": "sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==" - }, "node_modules/jsx-ast-utils": { "version": "3.3.5", "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz", "integrity": "sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==", "dev": true, + "license": "MIT", "dependencies": { "array-includes": "^3.1.6", "array.prototype.flat": "^1.3.1", @@ -7266,13 +8437,15 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/kebab-case/-/kebab-case-1.0.2.tgz", "integrity": "sha512-7n6wXq4gNgBELfDCpzKc+mRrZFs7D+wgfF5WRFLNAr4DA/qtr9Js8uOAVAfHhuLMfAcQ0pRKqbpjx+TcJVdE1Q==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/keyv": { - "version": "4.5.3", - "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.3.tgz", - "integrity": "sha512-QCiSav9WaX1PgETJ+SpNnx2PRRapJ/oRSXM4VO5OGYGSjrxbKPVFVhB3l2OCbLCk329N8qyAtsJjSjvVBWzEug==", + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", "dev": true, + "license": "MIT", "dependencies": { "json-buffer": "3.0.1" } @@ -7281,6 +8454,7 @@ "version": "6.0.3", "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -7289,6 +8463,7 @@ "version": "4.1.5", "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz", "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==", + "license": "MIT", "engines": { "node": ">=6" } @@ -7297,21 +8472,27 @@ "version": "0.24.0", "resolved": "https://registry.npmjs.org/known-css-properties/-/known-css-properties-0.24.0.tgz", "integrity": "sha512-RTSoaUAfLvpR357vWzAz/50Q/BmHfmE6ETSWfutT0AJiw10e6CmcdYRQJlLRd95B53D0Y2aD1jSxD3V3ySF+PA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/language-subtag-registry": { - "version": "0.3.22", - "resolved": "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.22.tgz", - "integrity": "sha512-tN0MCzyWnoz/4nHS6uxdlFWoUZT7ABptwKPQ52Ea7URk6vll88bWBVhodtnlfEuCcKWNGoc+uGbw1cwa9IKh/w==", - "dev": true + "version": "0.3.23", + "resolved": "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.23.tgz", + "integrity": "sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ==", + "dev": true, + "license": "CC0-1.0" }, "node_modules/language-tags": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/language-tags/-/language-tags-1.0.5.tgz", - "integrity": "sha512-qJhlO9cGXi6hBGKoxEG/sKZDAHD5Hnu9Hs4WbOY3pCWXDhw0N8x1NenNzm2EnNLkLkk7J2SdxAkDSbb6ftT+UQ==", + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/language-tags/-/language-tags-1.0.9.tgz", + "integrity": "sha512-MbjN408fEndfiQXbFQ1vnd+1NoLDsnQW41410oQBXiyXDMYH5z505juWa4KUE1LqxRC7DgOgZDbKLxHIwm27hA==", "dev": true, + "license": "MIT", "dependencies": { - "language-subtag-registry": "~0.3.2" + "language-subtag-registry": "^0.3.20" + }, + "engines": { + "node": ">=0.10" } }, "node_modules/levn": { @@ -7319,6 +8500,7 @@ "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", "dev": true, + "license": "MIT", "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" @@ -7328,17 +8510,22 @@ } }, "node_modules/lilconfig": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz", - "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==", + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", + "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", + "license": "MIT", "engines": { - "node": ">=10" + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antonk52" } }, "node_modules/lines-and-columns": { "version": "1.2.4", "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", - "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==" + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "license": "MIT" }, "node_modules/load-json-file": { "version": "4.0.0", @@ -7356,20 +8543,11 @@ "node": ">=4" } }, - "node_modules/load-json-file/node_modules/pify": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", - "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, "node_modules/load-yaml-file": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/load-yaml-file/-/load-yaml-file-0.2.0.tgz", "integrity": "sha512-OfCBkGEw4nN6JLtgRidPX6QxjBQGQf72q3si2uvqyFEMbycSFFHwAZeXx6cJgFM9wmLrf9zBwCP3Ivqa+LLZPw==", + "license": "MIT", "dependencies": { "graceful-fs": "^4.1.5", "js-yaml": "^3.13.0", @@ -7384,6 +8562,7 @@ "version": "1.0.10", "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "license": "MIT", "dependencies": { "sprintf-js": "~1.0.2" } @@ -7392,6 +8571,7 @@ "version": "3.14.1", "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "license": "MIT", "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" @@ -7404,6 +8584,7 @@ "version": "4.0.1", "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", + "license": "MIT", "engines": { "node": ">=6" } @@ -7412,6 +8593,7 @@ "version": "6.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "license": "MIT", "dependencies": { "p-locate": "^5.0.0" }, @@ -7425,7 +8607,8 @@ "node_modules/lodash.castarray": { "version": "4.4.0", "resolved": "https://registry.npmjs.org/lodash.castarray/-/lodash.castarray-4.4.0.tgz", - "integrity": "sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q==" + "integrity": "sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q==", + "license": "MIT" }, "node_modules/lodash.debounce": { "version": "4.0.8", @@ -7437,17 +8620,20 @@ "node_modules/lodash.isplainobject": { "version": "4.0.6", "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", - "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==" + "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==", + "license": "MIT" }, "node_modules/lodash.merge": { "version": "4.6.2", "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", - "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==" + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "license": "MIT" }, "node_modules/log-symbols": { "version": "5.1.0", "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-5.1.0.tgz", "integrity": "sha512-l0x2DvrW294C9uDCoQe1VSU4gf529FkSZ6leBl4TiqZH/e+0R7hSfHQBNut2mNygDgHwvYHfFLn6Oxb3VWj2rA==", + "license": "MIT", "dependencies": { "chalk": "^5.0.0", "is-unicode-supported": "^1.1.0" @@ -7460,9 +8646,10 @@ } }, "node_modules/log-symbols/node_modules/chalk": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz", - "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==", + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.0.tgz", + "integrity": "sha512-ZkD35Mx92acjB2yNJgziGqT9oKHEOxjTBTDRpOsRWtdecL/0jM3z5kM/CTzHWvHIen1GvkM85p6TuFfDGfc8/Q==", + "license": "MIT", "engines": { "node": "^12.17.0 || ^14.13 || >=16.0.0" }, @@ -7474,6 +8661,7 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz", "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -7489,37 +8677,47 @@ } }, "node_modules/magic-string": { - "version": "0.30.4", - "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.4.tgz", - "integrity": "sha512-Q/TKtsC5BPm0kGqgBIF9oXAs/xEf2vRKiIB4wCRQTJOQIByZ1d+NnUOotvJOvNpi5RNIgVOMC3pOuaP1ZTDlVg==", + "version": "0.30.17", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz", + "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==", + "license": "MIT", "dependencies": { - "@jridgewell/sourcemap-codec": "^1.4.15" - }, - "engines": { - "node": ">=12" + "@jridgewell/sourcemap-codec": "^1.5.0" } }, "node_modules/markdown-extensions": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/markdown-extensions/-/markdown-extensions-1.1.1.tgz", "integrity": "sha512-WWC0ZuMzCyDHYCasEGs4IPvLyTGftYwh6wIEOULOF0HXcqZlhwRzrK0w2VUlxWA98xnvb/jszw4ZSkJ6ADpM6Q==", + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/markdown-table": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.3.tgz", - "integrity": "sha512-Z1NL3Tb1M9wH4XESsCDEksWoKTdlUafKc4pt0GRwjUyXaCFZ+dc3g2erqB6zm3szA2IUSi7VnPI+o/9jnxh9hw==", + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz", + "integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" } }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/mdast-util-definitions": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-6.0.0.tgz", "integrity": "sha512-scTllyX6pnYNZH/AIp/0ePz6s4cZtARxImwoPJ7kS42n+MnVsI4XbnG6d4ibehRIldYMWM2LD7ImQblVhUejVQ==", + "license": "MIT", "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", @@ -7531,14 +8729,16 @@ } }, "node_modules/mdast-util-definitions/node_modules/@types/unist": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.0.tgz", - "integrity": "sha512-MFETx3tbTjE7Uk6vvnWINA/1iJ7LuMdO4fcq8UfF0pRbj01aGLduVvQcRyswuACJdpnHgg8E3rQLhaRdNEJS0w==" + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "license": "MIT" }, "node_modules/mdast-util-definitions/node_modules/unist-util-is": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz", "integrity": "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0" }, @@ -7551,6 +8751,7 @@ "version": "5.0.0", "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz", "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", @@ -7565,6 +8766,7 @@ "version": "6.0.1", "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz", "integrity": "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" @@ -7578,6 +8780,7 @@ "version": "2.2.2", "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-2.2.2.tgz", "integrity": "sha512-MTtdFRz/eMDHXzeK6W3dO7mXUlF82Gom4y0oOgvHhh/HXZAGvIQDUvQ0SuUx+j2tv44b8xTHOm8K/9OoRFnXKw==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "escape-string-regexp": "^5.0.0", @@ -7590,9 +8793,10 @@ } }, "node_modules/mdast-util-find-and-replace/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7601,6 +8805,7 @@ "version": "5.0.0", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz", "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -7612,6 +8817,7 @@ "version": "1.3.1", "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-1.3.1.tgz", "integrity": "sha512-4xTO/M8c82qBcnQc1tgpNtubGUW/Y1tBQ1B0i5CtSoelOLKFYlElIr3bvgREYYO5iRqbMY1YuqZng0GVOI8Qww==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "@types/unist": "^2.0.0", @@ -7632,9 +8838,10 @@ } }, "node_modules/mdast-util-from-markdown/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7643,6 +8850,7 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-2.0.2.tgz", "integrity": "sha512-qvZ608nBppZ4icQlhQQIAdc6S3Ffj9RGmzwUKUWuEICFnd1LVkN3EktF7ZHAgfcEdvZB5owU9tQgt99e2TlLjg==", + "license": "MIT", "dependencies": { "mdast-util-from-markdown": "^1.0.0", "mdast-util-gfm-autolink-literal": "^1.0.0", @@ -7661,6 +8869,7 @@ "version": "1.0.3", "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-1.0.3.tgz", "integrity": "sha512-My8KJ57FYEy2W2LyNom4n3E7hKTuQk/0SES0u16tjA9Z3oFkF4RrC/hPAPgjlSpezsOvI8ObcXcElo92wn5IGA==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "ccount": "^2.0.0", @@ -7673,9 +8882,10 @@ } }, "node_modules/mdast-util-gfm-autolink-literal/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7684,6 +8894,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-1.0.2.tgz", "integrity": "sha512-56D19KOGbE00uKVj3sgIykpwKL179QsVFwx/DCW0u/0+URsryacI4MAdNJl0dh+u2PSsD9FtxPFbHCzJ78qJFQ==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "mdast-util-to-markdown": "^1.3.0", @@ -7695,9 +8906,10 @@ } }, "node_modules/mdast-util-gfm-footnote/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7706,6 +8918,7 @@ "version": "1.0.3", "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-1.0.3.tgz", "integrity": "sha512-DAPhYzTYrRcXdMjUtUjKvW9z/FNAMTdU0ORyMcbmkwYNbKocDpdk+PX1L1dQgOID/+vVs1uBQ7ElrBQfZ0cuiQ==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "mdast-util-to-markdown": "^1.3.0" @@ -7716,9 +8929,10 @@ } }, "node_modules/mdast-util-gfm-strikethrough/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7727,6 +8941,7 @@ "version": "1.0.7", "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-1.0.7.tgz", "integrity": "sha512-jjcpmNnQvrmN5Vx7y7lEc2iIOEytYv7rTvu+MeyAsSHTASGCCRA79Igg2uKssgOs1i1po8s3plW0sTu1wkkLGg==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "markdown-table": "^3.0.0", @@ -7739,9 +8954,10 @@ } }, "node_modules/mdast-util-gfm-table/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7750,6 +8966,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-1.0.2.tgz", "integrity": "sha512-PFTA1gzfp1B1UaiJVyhJZA1rm0+Tzn690frc/L8vNX1Jop4STZgOE6bxUhnzdVSB+vm2GU1tIsuQcA9bxTQpMQ==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "mdast-util-to-markdown": "^1.3.0" @@ -7760,9 +8977,10 @@ } }, "node_modules/mdast-util-gfm-task-list-item/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7771,6 +8989,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/mdast-util-mdx/-/mdast-util-mdx-2.0.1.tgz", "integrity": "sha512-38w5y+r8nyKlGvNjSEqWrhG0w5PmnRA+wnBvm+ulYCct7nsGYhFVb0lljS9bQav4psDAS1eGkP2LMVcZBi/aqw==", + "license": "MIT", "dependencies": { "mdast-util-from-markdown": "^1.0.0", "mdast-util-mdx-expression": "^1.0.0", @@ -7787,6 +9006,7 @@ "version": "1.3.2", "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-1.3.2.tgz", "integrity": "sha512-xIPmR5ReJDu/DHH1OoIT1HkuybIfRGYRywC+gJtI7qHjCJp/M9jrmBEJW22O8lskDWm562BX2W8TiAwRTb0rKA==", + "license": "MIT", "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^2.0.0", @@ -7800,9 +9020,10 @@ } }, "node_modules/mdast-util-mdx-expression/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7811,6 +9032,7 @@ "version": "2.1.4", "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-2.1.4.tgz", "integrity": "sha512-DtMn9CmVhVzZx3f+optVDF8yFgQVt7FghCRNdlIaS3X5Bnym3hZwPbg/XW86vdpKjlc1PVj26SpnLGeJBXD3JA==", + "license": "MIT", "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^2.0.0", @@ -7831,9 +9053,10 @@ } }, "node_modules/mdast-util-mdx-jsx/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7842,6 +9065,7 @@ "version": "1.3.1", "resolved": "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-1.3.1.tgz", "integrity": "sha512-SXqglS0HrEvSdUEfoXFtcg7DRl7S2cwOXc7jkuusG472Mmjag34DUDeOJUZtl+BVnyeO1frIgVpHlNRWc2gk/w==", + "license": "MIT", "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^2.0.0", @@ -7855,9 +9079,10 @@ } }, "node_modules/mdast-util-mdxjs-esm/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7866,6 +9091,7 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-3.0.1.tgz", "integrity": "sha512-WmI1gTXUBJo4/ZmSk79Wcb2HcjPJBzM1nlI/OUWA8yk2X9ik3ffNbBGsU+09BFmXaL1IBb9fiuvq6/KMiNycSg==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "unist-util-is": "^5.0.0" @@ -7876,9 +9102,10 @@ } }, "node_modules/mdast-util-phrasing/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7887,6 +9114,7 @@ "version": "12.3.0", "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-12.3.0.tgz", "integrity": "sha512-pits93r8PhnIoU4Vy9bjW39M2jJ6/tdHyja9rrot9uujkN7UTU9SDnE6WNJz/IGyQk3XHX6yNNtrBH6cQzm8Hw==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "@types/mdast": "^3.0.0", @@ -7903,9 +9131,10 @@ } }, "node_modules/mdast-util-to-hast/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7914,6 +9143,7 @@ "version": "5.1.2", "resolved": "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-5.1.2.tgz", "integrity": "sha512-8SVPMuHqlPME/z3gqVwWY4zVXn8lqKv/pAhC57FuJ40ImXyBpmO5ukh98zB2v7Blql2FiHjHv9LVztSIqjY+MA==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "@types/unist": "^2.0.0", @@ -7928,6 +9158,7 @@ "version": "1.5.0", "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-1.5.0.tgz", "integrity": "sha512-bbv7TPv/WC49thZPg3jXuqzuvI45IL2EVAr/KxF0BSdHsU0ceFHOmwQn6evxAh1GaoK/6GQ1wp4R4oW2+LFL/A==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "@types/unist": "^2.0.0", @@ -7944,9 +9175,10 @@ } }, "node_modules/mdast-util-to-markdown/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7955,6 +9187,7 @@ "version": "3.2.0", "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-3.2.0.tgz", "integrity": "sha512-V4Zn/ncyN1QNSqSBxTrMOLpjr+IKdHl2v3KVLoWmDPscP4r9GcCi71gjgvUV1SFSKh92AjAG4peFuBl2/YgCJg==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0" }, @@ -7964,9 +9197,10 @@ } }, "node_modules/mdast-util-to-string/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -7993,6 +9227,7 @@ "version": "5.1.7", "resolved": "https://registry.npmjs.org/merge-anything/-/merge-anything-5.1.7.tgz", "integrity": "sha512-eRtbOb1N5iyH0tkQDAoQ4Ipsp/5qSR79Dzrz8hEPxRX10RWWR/iQXdoKmBSRCThY1Fh5EhISDtpSc93fpxUniQ==", + "license": "MIT", "dependencies": { "is-what": "^4.1.8" }, @@ -8015,12 +9250,14 @@ "node_modules/merge-stream": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", - "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==" + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "license": "MIT" }, "node_modules/merge2": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "license": "MIT", "engines": { "node": ">= 8" } @@ -8048,6 +9285,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "@types/debug": "^4.0.0", "debug": "^4.0.0", @@ -8082,6 +9320,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "decode-named-character-reference": "^1.0.0", "micromark-factory-destination": "^1.0.0", @@ -8105,6 +9344,7 @@ "version": "2.0.3", "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-2.0.3.tgz", "integrity": "sha512-vb9OoHqrhCmbRidQv/2+Bc6pkP0FrtlhurxZofvOEy5o8RtuuvTq+RQ1Vw5ZDNrVraQZu3HixESqbG+0iKk/MQ==", + "license": "MIT", "dependencies": { "micromark-extension-gfm-autolink-literal": "^1.0.0", "micromark-extension-gfm-footnote": "^1.0.0", @@ -8124,6 +9364,7 @@ "version": "1.0.5", "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-1.0.5.tgz", "integrity": "sha512-z3wJSLrDf8kRDOh2qBtoTRD53vJ+CWIyo7uyZuxf/JAbNJjiHsOpG1y5wxk8drtv3ETAHutCu6N3thkOOgueWg==", + "license": "MIT", "dependencies": { "micromark-util-character": "^1.0.0", "micromark-util-sanitize-uri": "^1.0.0", @@ -8139,6 +9380,7 @@ "version": "1.1.2", "resolved": "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-1.1.2.tgz", "integrity": "sha512-Yxn7z7SxgyGWRNa4wzf8AhYYWNrwl5q1Z8ii+CSTTIqVkmGZF1CElX2JI8g5yGoM3GAman9/PVCUFUSJ0kB/8Q==", + "license": "MIT", "dependencies": { "micromark-core-commonmark": "^1.0.0", "micromark-factory-space": "^1.0.0", @@ -8158,6 +9400,7 @@ "version": "1.0.7", "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-1.0.7.tgz", "integrity": "sha512-sX0FawVE1o3abGk3vRjOH50L5TTLr3b5XMqnP9YDRb34M0v5OoZhG+OHFz1OffZ9dlwgpTBKaT4XW/AsUVnSDw==", + "license": "MIT", "dependencies": { "micromark-util-chunked": "^1.0.0", "micromark-util-classify-character": "^1.0.0", @@ -8175,6 +9418,7 @@ "version": "1.0.7", "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-1.0.7.tgz", "integrity": "sha512-3ZORTHtcSnMQEKtAOsBQ9/oHp9096pI/UvdPtN7ehKvrmZZ2+bbWhi0ln+I9drmwXMt5boocn6OlwQzNXeVeqw==", + "license": "MIT", "dependencies": { "micromark-factory-space": "^1.0.0", "micromark-util-character": "^1.0.0", @@ -8191,6 +9435,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-1.0.2.tgz", "integrity": "sha512-5XWB9GbAUSHTn8VPU8/1DBXMuKYT5uOgEjJb8gN3mW0PNW5OPHpSdojoqf+iq1xo7vWzw/P8bAHY0n6ijpXF7g==", + "license": "MIT", "dependencies": { "micromark-util-types": "^1.0.0" }, @@ -8203,6 +9448,7 @@ "version": "1.0.5", "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-1.0.5.tgz", "integrity": "sha512-RMFXl2uQ0pNQy6Lun2YBYT9g9INXtWJULgbt01D/x8/6yJ2qpKyzdZD3pi6UIkzF++Da49xAelVKUeUMqd5eIQ==", + "license": "MIT", "dependencies": { "micromark-factory-space": "^1.0.0", "micromark-util-character": "^1.0.0", @@ -8229,6 +9475,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0", "micromark-factory-mdx-expression": "^1.0.0", @@ -8244,6 +9491,7 @@ "version": "1.0.5", "resolved": "https://registry.npmjs.org/micromark-extension-mdx-jsx/-/micromark-extension-mdx-jsx-1.0.5.tgz", "integrity": "sha512-gPH+9ZdmDflbu19Xkb8+gheqEDqkSpdCEubQyxuz/Hn8DOXiXvrXeikOoBA71+e8Pfi0/UYmU3wW3H58kr7akA==", + "license": "MIT", "dependencies": { "@types/acorn": "^4.0.0", "@types/estree": "^1.0.0", @@ -8265,6 +9513,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/micromark-extension-mdx-md/-/micromark-extension-mdx-md-1.0.1.tgz", "integrity": "sha512-7MSuj2S7xjOQXAjjkbjBsHkMtb+mDGVW6uI2dBL9snOBCbZmoNgDAeZ0nSn9j3T42UE/g2xVNMn18PJxZvkBEA==", + "license": "MIT", "dependencies": { "micromark-util-types": "^1.0.0" }, @@ -8277,6 +9526,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/micromark-extension-mdxjs/-/micromark-extension-mdxjs-1.0.1.tgz", "integrity": "sha512-7YA7hF6i5eKOfFUzZ+0z6avRG52GpWR8DL+kN47y3f2KhxbBZMhmxe7auOeaTBrW2DenbbZTf1ea9tA2hDpC2Q==", + "license": "MIT", "dependencies": { "acorn": "^8.0.0", "acorn-jsx": "^5.0.0", @@ -8296,6 +9546,7 @@ "version": "1.0.5", "resolved": "https://registry.npmjs.org/micromark-extension-mdxjs-esm/-/micromark-extension-mdxjs-esm-1.0.5.tgz", "integrity": "sha512-xNRBw4aoURcyz/S69B19WnZAkWJMxHMT5hE36GtDAyhoyn/8TuAeqjFJQlwk+MKQsUD7b3l7kFX+vlfVWgcX1w==", + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0", "micromark-core-commonmark": "^1.0.0", @@ -8326,6 +9577,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-character": "^1.0.0", "micromark-util-symbol": "^1.0.0", @@ -8346,6 +9598,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-character": "^1.0.0", "micromark-util-symbol": "^1.0.0", @@ -8367,6 +9620,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0", "micromark-util-character": "^1.0.0", @@ -8392,6 +9646,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-character": "^1.0.0", "micromark-util-types": "^1.0.0" @@ -8411,6 +9666,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-factory-space": "^1.0.0", "micromark-util-character": "^1.0.0", @@ -8432,6 +9688,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-factory-space": "^1.0.0", "micromark-util-character": "^1.0.0", @@ -8453,6 +9710,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-symbol": "^1.0.0", "micromark-util-types": "^1.0.0" @@ -8472,6 +9730,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-symbol": "^1.0.0" } @@ -8490,6 +9749,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-character": "^1.0.0", "micromark-util-symbol": "^1.0.0", @@ -8510,6 +9770,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-chunked": "^1.0.0", "micromark-util-types": "^1.0.0" @@ -8529,6 +9790,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-symbol": "^1.0.0" } @@ -8547,6 +9809,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "decode-named-character-reference": "^1.0.0", "micromark-util-character": "^1.0.0", @@ -8567,7 +9830,8 @@ "type": "OpenCollective", "url": "https://opencollective.com/unified" } - ] + ], + "license": "MIT" }, "node_modules/micromark-util-events-to-acorn": { "version": "1.2.3", @@ -8583,6 +9847,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "@types/acorn": "^4.0.0", "@types/estree": "^1.0.0", @@ -8607,7 +9872,8 @@ "type": "OpenCollective", "url": "https://opencollective.com/unified" } - ] + ], + "license": "MIT" }, "node_modules/micromark-util-normalize-identifier": { "version": "1.1.0", @@ -8623,6 +9889,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-symbol": "^1.0.0" } @@ -8641,6 +9908,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-types": "^1.0.0" } @@ -8659,6 +9927,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-character": "^1.0.0", "micromark-util-encode": "^1.0.0", @@ -8679,6 +9948,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-chunked": "^1.0.0", "micromark-util-symbol": "^1.0.0", @@ -8699,7 +9969,8 @@ "type": "OpenCollective", "url": "https://opencollective.com/unified" } - ] + ], + "license": "MIT" }, "node_modules/micromark-util-types": { "version": "1.1.0", @@ -8714,24 +9985,39 @@ "type": "OpenCollective", "url": "https://opencollective.com/unified" } - ] + ], + "license": "MIT" }, "node_modules/micromatch": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", - "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "license": "MIT", "dependencies": { - "braces": "^3.0.2", + "braces": "^3.0.3", "picomatch": "^2.3.1" }, "engines": { "node": ">=8.6" } }, + "node_modules/micromatch/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/mime": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/mime/-/mime-3.0.0.tgz", "integrity": "sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A==", + "license": "MIT", "bin": { "mime": "cli.js" }, @@ -8743,6 +10029,7 @@ "version": "1.52.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -8751,6 +10038,7 @@ "version": "2.1.35", "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", "dependencies": { "mime-db": "1.52.0" }, @@ -8762,6 +10050,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz", "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -8773,6 +10062,7 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", + "license": "MIT", "optional": true, "engines": { "node": ">=10" @@ -8785,6 +10075,7 @@ "version": "1.4.4", "resolved": "https://registry.npmjs.org/mini-svg-data-uri/-/mini-svg-data-uri-1.4.4.tgz", "integrity": "sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg==", + "license": "MIT", "bin": { "mini-svg-data-uri": "cli.js" } @@ -8793,6 +10084,8 @@ "version": "3.1.2", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^1.1.7" }, @@ -8804,15 +10097,26 @@ "version": "1.2.8", "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "license": "MIT", "optional": true, "funding": { "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/minipass": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", + "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", + "license": "ISC", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, "node_modules/mkdirp-classic": { "version": "0.5.3", "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz", "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==", + "license": "MIT", "optional": true }, "node_modules/moq-player": { @@ -8820,27 +10124,31 @@ "link": true }, "node_modules/mp4box": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/mp4box/-/mp4box-0.5.2.tgz", - "integrity": "sha512-zRmGlvxy+YdW3Dmt+TR4xPHynbxwXtAQDTN/Fo9N3LMxaUlB2C5KmZpzYyGKy4c7k4Jf3RCR0A2pm9SZELOLXw==" + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/mp4box/-/mp4box-0.5.3.tgz", + "integrity": "sha512-RIvyFZdPDIg3+mL6vUdPBSyQRrEfKO3ryAeJ4xJJV7HBHQUH3KfLlZRzfSpBHCd/HqR63HfbrWQI/CwXDvYENQ==", + "license": "BSD-3-Clause" }, "node_modules/mri": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz", "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==", + "license": "MIT", "engines": { "node": ">=4" } }, "node_modules/ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" }, "node_modules/mz": { "version": "2.7.0", "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "license": "MIT", "dependencies": { "any-promise": "^1.0.0", "object-assign": "^4.0.1", @@ -8848,15 +10156,16 @@ } }, "node_modules/nanoid": { - "version": "3.3.6", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz", - "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==", + "version": "3.3.8", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz", + "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==", "funding": [ { "type": "github", "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "bin": { "nanoid": "bin/nanoid.cjs" }, @@ -8868,18 +10177,21 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-1.0.2.tgz", "integrity": "sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg==", + "license": "MIT", "optional": true }, "node_modules/natural-compare": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/needle": { "version": "2.9.1", "resolved": "https://registry.npmjs.org/needle/-/needle-2.9.1.tgz", "integrity": "sha512-6R9fqJ5Zcmf+uYaFgdIHmLwNldn5HbK8L5ybn7Uz+ylX/rnOsSp1AHcvQSrCaFN+qNM1wpymHqD7mVasEOlHGQ==", + "license": "MIT", "dependencies": { "debug": "^3.2.6", "iconv-lite": "^0.4.4", @@ -8896,6 +10208,7 @@ "version": "3.2.7", "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "license": "MIT", "dependencies": { "ms": "^2.1.1" } @@ -8920,6 +10233,7 @@ "version": "3.1.1", "resolved": "https://registry.npmjs.org/nlcst-to-string/-/nlcst-to-string-3.1.1.tgz", "integrity": "sha512-63mVyqaqt0cmn2VcI2aH6kxe1rLAmSROqHMA0i4qqg1tidkfExgpb0FGMikMCn86mw5dFtBtEANfmSSK7TjNHw==", + "license": "MIT", "dependencies": { "@types/nlcst": "^1.0.0" }, @@ -8929,9 +10243,10 @@ } }, "node_modules/node-abi": { - "version": "3.47.0", - "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.47.0.tgz", - "integrity": "sha512-2s6B2CWZM//kPgwnuI0KrYwNjfdByE25zvAaEpq9IH4zcNsarH8Ihu/UuX6XMPEogDAxkuUFeZn60pXNHAqn3A==", + "version": "3.71.0", + "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.71.0.tgz", + "integrity": "sha512-SZ40vRiy/+wRTf21hxkkEjPJZpARzUMVcJoQse2EF8qkUWbbO2z7vd5oA/H6bVH6SZQ5STGcu0KRDS7biNRfxw==", + "license": "MIT", "optional": true, "dependencies": { "semver": "^7.3.5" @@ -8940,41 +10255,36 @@ "node": ">=10" } }, + "node_modules/node-abi/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "license": "ISC", + "optional": true, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/node-addon-api": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-6.1.0.tgz", "integrity": "sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA==", + "license": "MIT", "optional": true }, - "node_modules/node-fetch": { - "version": "2.7.0", - "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", - "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", - "dependencies": { - "whatwg-url": "^5.0.0" - }, - "engines": { - "node": "4.x || >=6.0.0" - }, - "peerDependencies": { - "encoding": "^0.1.0" - }, - "peerDependenciesMeta": { - "encoding": { - "optional": true - } - } - }, "node_modules/node-releases": { - "version": "2.0.18", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz", - "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==", + "version": "2.0.19", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz", + "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==", "license": "MIT" }, "node_modules/nodemon": { - "version": "3.1.7", - "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.7.tgz", - "integrity": "sha512-hLj7fuMow6f0lbB0cD14Lz2xNjwsyruH251Pk4t/yIitCFJbmY1myuLlHm/q06aST4jg6EgAh74PIBBrRqpVAQ==", + "version": "3.1.9", + "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.9.tgz", + "integrity": "sha512-hdr1oIb2p6ZSxu3PB2JWWYS7ZQ0qvaZsc3hK8DR8f02kRzc8rjYmxAIvdz+aYC+8F2IjNaB7HMcSDg8nQpJxyg==", "dev": true, "license": "MIT", "dependencies": { @@ -9000,6 +10310,19 @@ "url": "https://opencollective.com/nodemon" } }, + "node_modules/nodemon/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/normalize-package-data": { "version": "2.5.0", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", @@ -9013,20 +10336,11 @@ "validate-npm-package-license": "^3.0.1" } }, - "node_modules/normalize-package-data/node_modules/semver": { - "version": "5.7.2", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", - "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver" - } - }, "node_modules/normalize-path": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -9035,6 +10349,7 @@ "version": "0.1.2", "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==", + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -9065,83 +10380,11 @@ "node": ">= 4" } }, - "node_modules/npm-run-all/node_modules/cross-spawn": { - "version": "6.0.6", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.6.tgz", - "integrity": "sha512-VqCUuhcd1iB+dsv8gxPttb5iZh/D0iubSP21g36KXdEuf6I5JiioesUVjpCdHV9MZRUfVFlvwtIUyPfxo5trtw==", - "dev": true, - "license": "MIT", - "dependencies": { - "nice-try": "^1.0.4", - "path-key": "^2.0.1", - "semver": "^5.5.0", - "shebang-command": "^1.2.0", - "which": "^1.2.9" - }, - "engines": { - "node": ">=4.8" - } - }, - "node_modules/npm-run-all/node_modules/path-key": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", - "integrity": "sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/npm-run-all/node_modules/semver": { - "version": "5.7.2", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", - "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver" - } - }, - "node_modules/npm-run-all/node_modules/shebang-command": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", - "integrity": "sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==", - "dev": true, - "license": "MIT", - "dependencies": { - "shebang-regex": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/npm-run-all/node_modules/shebang-regex": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", - "integrity": "sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/npm-run-all/node_modules/which": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", - "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", - "dev": true, - "license": "ISC", - "dependencies": { - "isexe": "^2.0.0" - }, - "bin": { - "which": "bin/which" - } - }, "node_modules/npm-run-path": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.1.0.tgz", - "integrity": "sha512-sJOdmRGrY2sjNTRMbSvluQqg+8X7ZK61yvzBEIDhz4f8z1TZFYABsqjjCBd/0PUNE9M6QDgHJXQkGUEm7Q+l9Q==", + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz", + "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==", + "license": "MIT", "dependencies": { "path-key": "^4.0.0" }, @@ -9156,6 +10399,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz", "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -9167,6 +10411,7 @@ "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -9175,6 +10420,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", + "license": "MIT", "engines": { "node": ">= 6" } @@ -9196,20 +10442,23 @@ "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", "dev": true, + "license": "MIT", "engines": { "node": ">= 0.4" } }, "node_modules/object.assign": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.5.tgz", - "integrity": "sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==", + "version": "4.1.7", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz", + "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.5", + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", "define-properties": "^1.2.1", - "has-symbols": "^1.0.3", + "es-object-atoms": "^1.0.0", + "has-symbols": "^1.1.0", "object-keys": "^1.1.1" }, "engines": { @@ -9219,29 +10468,17 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/object.entries": { - "version": "1.1.7", - "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.7.tgz", - "integrity": "sha512-jCBs/0plmPsOnrKAfFQXRG2NFjlhZgjjcBLSmTnEhU8U6vVTsVe8ANeQJCHTl3gSsI4J+0emOoCgoKlmQPMgmA==", - "dev": true, - "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1" - }, - "engines": { - "node": ">= 0.4" - } - }, "node_modules/object.fromentries": { - "version": "2.0.7", - "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.7.tgz", - "integrity": "sha512-UPbPHML6sL8PI/mOqPwsH4G6iyXcCGzLin8KvEPenOZN5lpCNBZZQ+V62vdjB1mQHrmqGQt5/OJzemUA+KJmEA==", + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz", + "integrity": "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1" + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-object-atoms": "^1.0.0" }, "engines": { "node": ">= 0.4" @@ -9251,14 +10488,16 @@ } }, "node_modules/object.values": { - "version": "1.1.7", - "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.7.tgz", - "integrity": "sha512-aU6xnDFYT3x17e/f0IiiwlGPTy2jzMySGfUB4fq6z7CV8l85CWHDk5ErhyhpfDHhrOMwGFhSQkhMGHaIotA6Ng==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.2.1.tgz", + "integrity": "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1" + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" }, "engines": { "node": ">= 0.4" @@ -9271,6 +10510,7 @@ "version": "2.4.1", "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", "dependencies": { "ee-first": "1.1.1" }, @@ -9282,6 +10522,7 @@ "version": "1.4.0", "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", "dependencies": { "wrappy": "1" } @@ -9290,6 +10531,7 @@ "version": "6.0.0", "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz", "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==", + "license": "MIT", "dependencies": { "mimic-fn": "^4.0.0" }, @@ -9300,63 +10542,19 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/open": { - "version": "9.1.0", - "resolved": "https://registry.npmjs.org/open/-/open-9.1.0.tgz", - "integrity": "sha512-OS+QTnw1/4vrf+9hh1jc1jnYjzSG4ttTBB8UxOwAnInG3Uo4ssetzC1ihqaIHjLJnA5GGlRl6QlZXOTQhRBUvg==", - "dev": true, - "dependencies": { - "default-browser": "^4.0.0", - "define-lazy-prop": "^3.0.0", - "is-inside-container": "^1.0.0", - "is-wsl": "^2.2.0" - }, - "engines": { - "node": ">=14.16" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/open/node_modules/is-docker": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz", - "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==", - "dev": true, - "bin": { - "is-docker": "cli.js" - }, - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/open/node_modules/is-wsl": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz", - "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==", - "dev": true, - "dependencies": { - "is-docker": "^2.0.0" - }, - "engines": { - "node": ">=8" - } - }, "node_modules/optionator": { - "version": "0.9.3", - "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz", - "integrity": "sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==", + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", "dev": true, + "license": "MIT", "dependencies": { - "@aashutoshrathi/word-wrap": "^1.2.3", "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", - "type-check": "^0.4.0" + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" }, "engines": { "node": ">= 0.8.0" @@ -9366,6 +10564,7 @@ "version": "7.0.1", "resolved": "https://registry.npmjs.org/ora/-/ora-7.0.1.tgz", "integrity": "sha512-0TUxTiFJWv+JnjWm4o9yvuskpEJLXTcng8MJuKd+SzAzp2o+OP3HWqNhB4OdJRt1Vsd9/mR0oyaEYlOnL7XIRw==", + "license": "MIT", "dependencies": { "chalk": "^5.3.0", "cli-cursor": "^4.0.0", @@ -9385,9 +10584,10 @@ } }, "node_modules/ora/node_modules/chalk": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz", - "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==", + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.0.tgz", + "integrity": "sha512-ZkD35Mx92acjB2yNJgziGqT9oKHEOxjTBTDRpOsRWtdecL/0jM3z5kM/CTzHWvHIen1GvkM85p6TuFfDGfc8/Q==", + "license": "MIT", "engines": { "node": "^12.17.0 || ^14.13 || >=16.0.0" }, @@ -9399,6 +10599,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz", "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==", + "license": "MIT", "dependencies": { "yocto-queue": "^1.0.0" }, @@ -9413,6 +10614,7 @@ "version": "5.0.0", "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "license": "MIT", "dependencies": { "p-limit": "^3.0.2" }, @@ -9427,6 +10629,7 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "license": "MIT", "dependencies": { "yocto-queue": "^0.1.0" }, @@ -9441,6 +10644,7 @@ "version": "0.1.0", "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "license": "MIT", "engines": { "node": ">=10" }, @@ -9452,6 +10656,7 @@ "version": "7.4.1", "resolved": "https://registry.npmjs.org/p-queue/-/p-queue-7.4.1.tgz", "integrity": "sha512-vRpMXmIkYF2/1hLBKisKeVYJZ8S2tZ0zEAmIJgdVKP2nq0nh4qCdf8bgw+ZgKrkh71AOCaqzwbJJk1WtdcF3VA==", + "license": "MIT", "dependencies": { "eventemitter3": "^5.0.1", "p-timeout": "^5.0.2" @@ -9467,6 +10672,7 @@ "version": "5.1.0", "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-5.1.0.tgz", "integrity": "sha512-auFDyzzzGZZZdHz3BtET9VEz0SE/uMEAx7uWfGPucfzEwwe/xH0iVeZibQmANYE/hp9T2+UUZT5m+BKyrDp3Ew==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -9478,15 +10684,23 @@ "version": "2.2.0", "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "license": "MIT", "engines": { "node": ">=6" } }, + "node_modules/package-json-from-dist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", + "license": "BlueOak-1.0.0" + }, "node_modules/parent-module": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", "dev": true, + "license": "MIT", "dependencies": { "callsites": "^3.0.0" }, @@ -9495,12 +10709,12 @@ } }, "node_modules/parse-entities": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.1.tgz", - "integrity": "sha512-SWzvYcSJh4d/SGLIOQfZ/CoNv6BTlI6YEQ7Nj82oDVnRpwe/Z/F1EMx42x3JAOwGBlCjeCH0BRJQbQ/opHL17w==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz", + "integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", - "character-entities": "^2.0.0", "character-entities-legacy": "^3.0.0", "character-reference-invalid": "^2.0.0", "decode-named-character-reference": "^1.0.0", @@ -9531,6 +10745,7 @@ "version": "5.0.1", "resolved": "https://registry.npmjs.org/parse-latin/-/parse-latin-5.0.1.tgz", "integrity": "sha512-b/K8ExXaWC9t34kKeDV8kGXBkXZ1HCSAZRYE7HR14eA1GlXX5L8iWhs8USJNhQU9q5ci413jCKF0gOyovvyRBg==", + "license": "MIT", "dependencies": { "nlcst-to-string": "^3.0.0", "unist-util-modify-children": "^3.0.0", @@ -9544,7 +10759,8 @@ "node_modules/parse5": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz", - "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==" + "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==", + "license": "MIT" }, "node_modules/parseurl": { "version": "1.3.3", @@ -9569,6 +10785,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "license": "MIT", "engines": { "node": ">=8" } @@ -9577,47 +10794,89 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/path-key": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", - "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=8" + "node": ">=4" } }, "node_modules/path-parse": { "version": "1.0.7", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", - "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==" + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "license": "MIT" + }, + "node_modules/path-scurry": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", + "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "engines": { + "node": ">=16 || 14 >=14.18" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/path-scurry/node_modules/lru-cache": { + "version": "10.4.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", + "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", + "license": "ISC" }, "node_modules/path-to-regexp": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.2.1.tgz", - "integrity": "sha512-JLyh7xT1kizaEvcaXOQwOc2/Yhw6KZOvPf1S8401UyLk86CU79LN3vl7ztXGm/pZ+YjoyAJ4rxmHwbkBXJX+yw==" + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz", + "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==", + "license": "MIT" }, "node_modules/path-type": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", - "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz", + "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==", "dev": true, + "license": "MIT", + "dependencies": { + "pify": "^3.0.0" + }, "engines": { - "node": ">=8" + "node": ">=4" } }, "node_modules/periscopic": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/periscopic/-/periscopic-3.1.0.tgz", "integrity": "sha512-vKiQ8RRtkl9P+r/+oefh25C3fhybptkHKCZSPlcXiJux2tJF55GnEj3BVn4A5gKfq9NWWXXrxkHBwVPUfH0opw==", + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^3.0.0", "is-reference": "^3.0.0" } }, + "node_modules/periscopic/node_modules/is-reference": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz", + "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.6" + } + }, "node_modules/picocolors": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", @@ -9625,11 +10884,13 @@ "license": "ISC" }, "node_modules/picomatch": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", + "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=8.6" + "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" @@ -9649,17 +10910,20 @@ } }, "node_modules/pify": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", - "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=0.10.0" + "node": ">=4" } }, "node_modules/pirates": { "version": "4.0.6", "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.6.tgz", "integrity": "sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==", + "license": "MIT", "engines": { "node": ">= 6" } @@ -9668,6 +10932,7 @@ "version": "4.2.0", "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "license": "MIT", "dependencies": { "find-up": "^4.0.0" }, @@ -9679,6 +10944,7 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "license": "MIT", "dependencies": { "locate-path": "^5.0.0", "path-exists": "^4.0.0" @@ -9691,6 +10957,7 @@ "version": "5.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "license": "MIT", "dependencies": { "p-locate": "^4.1.0" }, @@ -9702,6 +10969,7 @@ "version": "2.3.0", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "license": "MIT", "dependencies": { "p-try": "^2.0.0" }, @@ -9716,6 +10984,7 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "license": "MIT", "dependencies": { "p-limit": "^2.2.0" }, @@ -9734,9 +11003,9 @@ } }, "node_modules/postcss": { - "version": "8.4.31", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz", - "integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==", + "version": "8.4.49", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.49.tgz", + "integrity": "sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==", "funding": [ { "type": "opencollective", @@ -9751,10 +11020,11 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "dependencies": { - "nanoid": "^3.3.6", - "picocolors": "^1.0.0", - "source-map-js": "^1.0.2" + "nanoid": "^3.3.7", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" }, "engines": { "node": "^10 || ^12 || >=14" @@ -9764,6 +11034,7 @@ "version": "15.1.0", "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz", "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==", + "license": "MIT", "dependencies": { "postcss-value-parser": "^4.0.0", "read-cache": "^1.0.0", @@ -9780,6 +11051,7 @@ "version": "4.0.1", "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.1.tgz", "integrity": "sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==", + "license": "MIT", "dependencies": { "camelcase-css": "^2.0.1" }, @@ -9795,20 +11067,27 @@ } }, "node_modules/postcss-load-config": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.1.tgz", - "integrity": "sha512-vEJIc8RdiBRu3oRAI0ymerOn+7rPuMvRXslTvZUKZonDHFIczxztIyJ1urxM1x9JXEikvpWWTUUqal5j/8QgvA==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.2.tgz", + "integrity": "sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", "dependencies": { - "lilconfig": "^2.0.5", - "yaml": "^2.1.1" + "lilconfig": "^3.0.0", + "yaml": "^2.3.4" }, "engines": { "node": ">= 14" }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/postcss/" - }, "peerDependencies": { "postcss": ">=8.0.9", "ts-node": ">=9.0.0" @@ -9823,27 +11102,35 @@ } }, "node_modules/postcss-nested": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.0.1.tgz", - "integrity": "sha512-mEp4xPMi5bSWiMbsgoPfcP74lsWLHkQbZc3sY+jWYd65CUwXrUaTp0fmNpa01ZcETKlIgUdFN/MpS2xZtqL9dQ==", - "dependencies": { - "postcss-selector-parser": "^6.0.11" - }, - "engines": { - "node": ">=12.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/postcss/" - }, - "peerDependencies": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz", + "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.1.1" + }, + "engines": { + "node": ">=12.0" + }, + "peerDependencies": { "postcss": "^8.2.14" } }, "node_modules/postcss-nested/node_modules/postcss-selector-parser": { - "version": "6.0.13", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz", - "integrity": "sha512-EaV1Gl4mUEV4ddhDnv/xtj7sxwrwxdetHdWUGnT4VJQf+4d05v6lHYZr8N573k5Z0BViss7BDhfWtKS3+sfAqQ==", + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "license": "MIT", "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -9856,6 +11143,7 @@ "version": "6.0.10", "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.10.tgz", "integrity": "sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==", + "license": "MIT", "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -9867,12 +11155,14 @@ "node_modules/postcss-value-parser": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", - "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==" + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==", + "license": "MIT" }, "node_modules/prebuild-install": { - "version": "7.1.1", - "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.1.tgz", - "integrity": "sha512-jAXscXWMcCK8GgCoHOfIr0ODh5ai8mj63L2nWrjuAgXE6tDyYGnx4/8o/rCgU+B4JSyZBKbeZqzhtwtC3ovxjw==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.2.tgz", + "integrity": "sha512-UnNke3IQb6sgarcZIDU3gbMeTp/9SSU1DAIkil7PrqG1vZlBtY5msYccSKSHDqa3hNg436IXK+SNImReuA1wEQ==", + "license": "MIT", "optional": true, "dependencies": { "detect-libc": "^2.0.0", @@ -9899,6 +11189,7 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz", "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==", + "license": "MIT", "optional": true, "dependencies": { "buffer": "^5.5.0", @@ -9924,6 +11215,7 @@ "url": "https://feross.org/support" } ], + "license": "MIT", "optional": true, "dependencies": { "base64-js": "^1.3.1", @@ -9934,6 +11226,7 @@ "version": "2.1.1", "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.1.tgz", "integrity": "sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==", + "license": "MIT", "optional": true, "dependencies": { "chownr": "^1.1.1", @@ -9946,6 +11239,7 @@ "version": "2.2.0", "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz", "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==", + "license": "MIT", "optional": true, "dependencies": { "bl": "^4.0.3", @@ -9959,45 +11253,36 @@ } }, "node_modules/preferred-pm": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/preferred-pm/-/preferred-pm-3.1.2.tgz", - "integrity": "sha512-nk7dKrcW8hfCZ4H6klWcdRknBOXWzNQByJ0oJyX97BOupsYD+FzLS4hflgEu/uPUEHZCuRfMxzCBsuWd7OzT8Q==", + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/preferred-pm/-/preferred-pm-3.1.4.tgz", + "integrity": "sha512-lEHd+yEm22jXdCphDrkvIJQU66EuLojPPtvZkpKIkiD+l0DMThF/niqZKJSoU8Vl7iuvtmzyMhir9LdVy5WMnA==", + "license": "MIT", "dependencies": { "find-up": "^5.0.0", "find-yarn-workspace-root2": "1.2.16", "path-exists": "^4.0.0", - "which-pm": "2.0.0" + "which-pm": "^2.2.0" }, "engines": { "node": ">=10" } }, - "node_modules/preferred-pm/node_modules/which-pm": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/which-pm/-/which-pm-2.0.0.tgz", - "integrity": "sha512-Lhs9Pmyph0p5n5Z3mVnN0yWcbQYUAD7rbQUiMsQxOJ3T57k7RFe35SUwWMf7dsbDZks1uOmw4AecB/JMDj3v/w==", - "dependencies": { - "load-yaml-file": "^0.2.0", - "path-exists": "^4.0.0" - }, - "engines": { - "node": ">=8.15" - } - }, "node_modules/prelude-ls": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", "dev": true, + "license": "MIT", "engines": { "node": ">= 0.8.0" } }, "node_modules/prettier": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.0.3.tgz", - "integrity": "sha512-L/4pUDMxcNa8R/EthV08Zt42WBO4h1rarVtK0K+QJG0X187OLo7l699jWw0GKuwzkPQ//jMFA/8Xm6Fh3J/DAg==", + "version": "3.4.2", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.4.2.tgz", + "integrity": "sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ==", "dev": true, + "license": "MIT", "bin": { "prettier": "bin/prettier.cjs" }, @@ -10013,6 +11298,7 @@ "resolved": "https://registry.npmjs.org/prettier-config-standard/-/prettier-config-standard-7.0.0.tgz", "integrity": "sha512-NgZy4TYupJR6aMMuV/Aqs0ONnVhlFT8PXVkYRskxREq8EUhJHOddVfBxPV6fWpgcASpJSgvvhVLk0CBO5M3Hvw==", "dev": true, + "license": "BSD-3-Clause", "peerDependencies": { "prettier": "^2.6.0 || ^3.0.0" } @@ -10022,6 +11308,7 @@ "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz", "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==", "dev": true, + "license": "MIT", "dependencies": { "fast-diff": "^1.1.2" }, @@ -10030,10 +11317,11 @@ } }, "node_modules/prettier-plugin-astro": { - "version": "0.12.0", - "resolved": "https://registry.npmjs.org/prettier-plugin-astro/-/prettier-plugin-astro-0.12.0.tgz", - "integrity": "sha512-8E+9YQR6/5CPZJs8XsfBw579zrwZkc0Wb7x0fRVm/51JC8Iys4lBw4ecV8fHwpbQnzve86TUa4fJ08BJzqfWnA==", + "version": "0.12.3", + "resolved": "https://registry.npmjs.org/prettier-plugin-astro/-/prettier-plugin-astro-0.12.3.tgz", + "integrity": "sha512-GthUSu3zCvmtVyqlArosez0xE08vSJ0R1sWurxIWpABaCkNGYFANoUdFkqmIo54EV2uPLGcVJzOucWvCjPBWvg==", "dev": true, + "license": "MIT", "dependencies": { "@astrojs/compiler": "^1.5.5", "prettier": "^3.0.0", @@ -10047,13 +11335,15 @@ "version": "1.8.2", "resolved": "https://registry.npmjs.org/@astrojs/compiler/-/compiler-1.8.2.tgz", "integrity": "sha512-o/ObKgtMzl8SlpIdzaxFnt7SATKPxu4oIP/1NL+HDJRzxfJcAkOTAb/ZKMRyULbz4q+1t2/DAebs2Z1QairkZw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/prettier-plugin-tailwindcss": { - "version": "0.5.4", - "resolved": "https://registry.npmjs.org/prettier-plugin-tailwindcss/-/prettier-plugin-tailwindcss-0.5.4.tgz", - "integrity": "sha512-QZzzB1bID6qPsKHTeA9qPo1APmmxfFrA5DD3LQ+vbTmAnY40eJI7t9Q1ocqel2EKMWNPLJqdTDWZj1hKYgqSgg==", + "version": "0.5.14", + "resolved": "https://registry.npmjs.org/prettier-plugin-tailwindcss/-/prettier-plugin-tailwindcss-0.5.14.tgz", + "integrity": "sha512-Puaz+wPUAhFp8Lo9HuciYKM2Y2XExESjeT+9NQoVFXZsPPnc9VYss2SpxdQ6vbatmt8/4+SN0oe0I1cPDABg9Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=14.21.3" }, @@ -10061,15 +11351,17 @@ "@ianvs/prettier-plugin-sort-imports": "*", "@prettier/plugin-pug": "*", "@shopify/prettier-plugin-liquid": "*", - "@shufo/prettier-plugin-blade": "*", "@trivago/prettier-plugin-sort-imports": "*", + "@zackad/prettier-plugin-twig-melody": "*", "prettier": "^3.0", "prettier-plugin-astro": "*", "prettier-plugin-css-order": "*", "prettier-plugin-import-sort": "*", "prettier-plugin-jsdoc": "*", + "prettier-plugin-marko": "*", "prettier-plugin-organize-attributes": "*", "prettier-plugin-organize-imports": "*", + "prettier-plugin-sort-imports": "*", "prettier-plugin-style-order": "*", "prettier-plugin-svelte": "*" }, @@ -10083,10 +11375,10 @@ "@shopify/prettier-plugin-liquid": { "optional": true }, - "@shufo/prettier-plugin-blade": { + "@trivago/prettier-plugin-sort-imports": { "optional": true }, - "@trivago/prettier-plugin-sort-imports": { + "@zackad/prettier-plugin-twig-melody": { "optional": true }, "prettier-plugin-astro": { @@ -10110,13 +11402,13 @@ "prettier-plugin-organize-imports": { "optional": true }, - "prettier-plugin-style-order": { + "prettier-plugin-sort-imports": { "optional": true }, - "prettier-plugin-svelte": { + "prettier-plugin-style-order": { "optional": true }, - "prettier-plugin-twig-melody": { + "prettier-plugin-svelte": { "optional": true } } @@ -10125,6 +11417,7 @@ "version": "1.29.0", "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.29.0.tgz", "integrity": "sha512-Kx/1w86q/epKcmte75LNrEoT+lX8pBpavuAbvJWRXar7Hz8jrtF+e3vY751p0R8H9HdArwaCTNDDzHg/ScJK1Q==", + "license": "MIT", "engines": { "node": ">=6" } @@ -10133,6 +11426,7 @@ "version": "7.2.3", "resolved": "https://registry.npmjs.org/probe-image-size/-/probe-image-size-7.2.3.tgz", "integrity": "sha512-HubhG4Rb2UH8YtV4ba0Vp5bQ7L78RTONYu/ujmCu5nBI8wGv24s4E9xSKBi0N1MowRpxk76pFCpJtW0KPzOK0w==", + "license": "MIT", "dependencies": { "lodash.merge": "^4.6.2", "needle": "^2.5.2", @@ -10152,6 +11446,7 @@ "version": "2.4.2", "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==", + "license": "MIT", "dependencies": { "kleur": "^3.0.3", "sisteransi": "^1.0.5" @@ -10164,14 +11459,16 @@ "version": "3.0.3", "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", + "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/property-information": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/property-information/-/property-information-6.3.0.tgz", - "integrity": "sha512-gVNZ74nqhRMiIUYWGQdosYetaKc83x8oT41a0LlV3AAFCAZwCpg4vmGkq8t34+cUhp3cnM4XDiU/7xlgK7HGrg==", + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-6.5.0.tgz", + "integrity": "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -10193,7 +11490,8 @@ "node_modules/proxy-from-env": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", - "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==" + "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", + "license": "MIT" }, "node_modules/pstree.remy": { "version": "1.1.8", @@ -10203,9 +11501,10 @@ "license": "MIT" }, "node_modules/pump": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz", - "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.2.tgz", + "integrity": "sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==", + "license": "MIT", "optional": true, "dependencies": { "end-of-stream": "^1.1.0", @@ -10213,10 +11512,11 @@ } }, "node_modules/punycode": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", - "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } @@ -10253,12 +11553,14 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "MIT" }, "node_modules/queue-tick": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/queue-tick/-/queue-tick-1.0.1.tgz", "integrity": "sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==", + "license": "MIT", "optional": true }, "node_modules/randombytes": { @@ -10275,6 +11577,7 @@ "version": "1.2.1", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -10298,6 +11601,7 @@ "version": "1.2.8", "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "license": "(BSD-2-Clause OR MIT OR Apache-2.0)", "optional": true, "dependencies": { "deep-extend": "^0.6.0", @@ -10313,6 +11617,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", + "license": "MIT", "optional": true, "engines": { "node": ">=0.10.0" @@ -10322,10 +11627,20 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", + "license": "MIT", "dependencies": { "pify": "^2.3.0" } }, + "node_modules/read-cache/node_modules/pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/read-pkg": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz", @@ -10341,33 +11656,11 @@ "node": ">=4" } }, - "node_modules/read-pkg/node_modules/path-type": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz", - "integrity": "sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==", - "dev": true, - "license": "MIT", - "dependencies": { - "pify": "^3.0.0" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/read-pkg/node_modules/pify": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", - "integrity": "sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, "node_modules/readable-stream": { "version": "3.6.2", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", @@ -10381,6 +11674,7 @@ "version": "3.6.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "license": "MIT", "dependencies": { "picomatch": "^2.2.1" }, @@ -10388,21 +11682,33 @@ "node": ">=8.10.0" } }, + "node_modules/readdirp/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/reflect.getprototypeof": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.8.tgz", - "integrity": "sha512-B5dj6usc5dkk8uFliwjwDHM8To5/QwdKz9JcBZ8Ic4G1f0YmeeJTtE/ZTdgRFPAfxZFiUaPhZ1Jcs4qeagItGQ==", + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.9.tgz", + "integrity": "sha512-r0Ay04Snci87djAsI4U+WNRcSw5S4pOH7qFjd/veA5gC7TbqESR3tcj28ia95L/fYUDw11JKP7uqUKUAfVvV5Q==", "dev": true, "license": "MIT", "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", - "dunder-proto": "^1.0.0", - "es-abstract": "^1.23.5", + "dunder-proto": "^1.0.1", + "es-abstract": "^1.23.6", "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.4", + "get-intrinsic": "^1.2.6", "gopd": "^1.2.0", - "which-builtin-type": "^1.2.0" + "which-builtin-type": "^1.2.1" }, "engines": { "node": ">= 0.4" @@ -10432,10 +11738,11 @@ } }, "node_modules/regenerator-runtime": { - "version": "0.14.0", - "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.0.tgz", - "integrity": "sha512-srw17NI0TUWHuGa5CFGGmhfNIeja30WMBfbslPNhf6JrqQlLN5gcrvig1oqPxiVaXb0oW0XRKtH6Nngs5lKCIA==", - "dev": true + "version": "0.14.1", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz", + "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==", + "dev": true, + "license": "MIT" }, "node_modules/regenerator-transform": { "version": "0.15.2", @@ -10504,10 +11811,24 @@ "regjsparser": "bin/parser" } }, + "node_modules/regjsparser/node_modules/jsesc": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz", + "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, "node_modules/rehype": { "version": "12.0.1", "resolved": "https://registry.npmjs.org/rehype/-/rehype-12.0.1.tgz", "integrity": "sha512-ey6kAqwLM3X6QnMDILJthGvG1m1ULROS9NT4uG9IDCuv08SFyLlreSuvOa//DgEvbXx62DS6elGVqusWhRUbgw==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "rehype-parse": "^8.0.0", @@ -10523,6 +11844,7 @@ "version": "8.0.5", "resolved": "https://registry.npmjs.org/rehype-parse/-/rehype-parse-8.0.5.tgz", "integrity": "sha512-Ds3RglaY/+clEX2U2mHflt7NlMA72KspZ0JLUJgBBLpRddBcEw3H8uYZQliQriku22NZpYMfjDdSgHcjxue24A==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "hast-util-from-parse5": "^7.0.0", @@ -10538,6 +11860,7 @@ "version": "6.1.1", "resolved": "https://registry.npmjs.org/rehype-raw/-/rehype-raw-6.1.1.tgz", "integrity": "sha512-d6AKtisSRtDRX4aSPsJGTfnzrX2ZkHQLE5kiUuGOeEoLpbEulFF4hj0mLPbsa+7vmguDKOVVEQdHKDSwoaIDsQ==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "hast-util-raw": "^7.2.0", @@ -10552,6 +11875,7 @@ "version": "9.0.4", "resolved": "https://registry.npmjs.org/rehype-stringify/-/rehype-stringify-9.0.4.tgz", "integrity": "sha512-Uk5xu1YKdqobe5XpSskwPvo1XeHUUucWEQSl8hTrXt5selvca1e8K1EZ37E6YoZ4BT8BCqCdVfQW7OfHfthtVQ==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "hast-util-to-html": "^8.0.0", @@ -10566,6 +11890,7 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-3.0.1.tgz", "integrity": "sha512-lEFDoi2PICJyNrACFOfDD3JlLkuSbOa5Wd8EPt06HUdptv8Gn0bxYTdbU/XXQ3swAPkEaGxxPN9cbnMHvVu1Ig==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "mdast-util-gfm": "^2.0.0", @@ -10578,9 +11903,10 @@ } }, "node_modules/remark-gfm/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -10589,6 +11915,7 @@ "version": "2.3.0", "resolved": "https://registry.npmjs.org/remark-mdx/-/remark-mdx-2.3.0.tgz", "integrity": "sha512-g53hMkpM0I98MU266IzDFMrTD980gNF3BJnkyFcmN+dD873mQeD5rdMO3Y2X+x8umQfbSE0PcoEDl7ledSA+2g==", + "license": "MIT", "dependencies": { "mdast-util-mdx": "^2.0.0", "micromark-extension-mdxjs": "^1.0.0" @@ -10602,6 +11929,7 @@ "version": "10.0.2", "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-10.0.2.tgz", "integrity": "sha512-3ydxgHa/ZQzG8LvC7jTXccARYDcRld3VfcgIIFs7bI6vbRSxJJmzgLEIIoYKyrfhaY+ujuWaf/PJiMZXoiCXgw==", + "license": "MIT", "dependencies": { "@types/mdast": "^3.0.0", "mdast-util-from-markdown": "^1.0.0", @@ -10613,9 +11941,10 @@ } }, "node_modules/remark-parse/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } @@ -10624,6 +11953,7 @@ "version": "10.1.0", "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-10.1.0.tgz", "integrity": "sha512-EFmR5zppdBp0WQeDVZ/b66CWJipB2q2VLNFMabzDSGR66Z2fQii83G5gTBbgGEnEEA0QRussvrFHxk1HWGJskw==", + "license": "MIT", "dependencies": { "@types/hast": "^2.0.0", "@types/mdast": "^3.0.0", @@ -10636,38 +11966,92 @@ } }, "node_modules/remark-rehype/node_modules/@types/mdast": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.13.tgz", - "integrity": "sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-3.0.15.tgz", + "integrity": "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2" } }, "node_modules/remark-smartypants": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/remark-smartypants/-/remark-smartypants-2.0.0.tgz", - "integrity": "sha512-Rc0VDmr/yhnMQIz8n2ACYXlfw/P/XZev884QU1I5u+5DgJls32o97Vc1RbK3pfumLsJomS2yy8eT4Fxj/2MDVA==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/remark-smartypants/-/remark-smartypants-2.1.0.tgz", + "integrity": "sha512-qoF6Vz3BjU2tP6OfZqHOvCU0ACmu/6jhGaINSQRI9mM7wCxNQTKB3JUAN4SVoN2ybElEDTxBIABRep7e569iJw==", + "license": "MIT", "dependencies": { "retext": "^8.1.0", - "retext-smartypants": "^5.1.0", - "unist-util-visit": "^4.1.0" + "retext-smartypants": "^5.2.0", + "unist-util-visit": "^5.0.0" }, "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" } }, + "node_modules/remark-smartypants/node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "license": "MIT" + }, + "node_modules/remark-smartypants/node_modules/unist-util-is": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz", + "integrity": "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-smartypants/node_modules/unist-util-visit": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz", + "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-smartypants/node_modules/unist-util-visit-parents": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz", + "integrity": "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/resolve": { - "version": "1.22.6", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.6.tgz", - "integrity": "sha512-njhxM7mV12JfufShqGy3Rz8j11RPdLy4xi15UurGJeoHLfJpVXKdh3ueuOqbYUcDZnffr6X739JBo5LzyahEsw==", + "version": "1.22.10", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz", + "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==", + "license": "MIT", "dependencies": { - "is-core-module": "^2.13.0", + "is-core-module": "^2.16.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" }, + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -10677,6 +12061,7 @@ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", "dev": true, + "license": "MIT", "engines": { "node": ">=4" } @@ -10685,6 +12070,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz", "integrity": "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==", + "license": "MIT", "dependencies": { "onetime": "^5.1.0", "signal-exit": "^3.0.2" @@ -10700,6 +12086,7 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "license": "MIT", "engines": { "node": ">=6" } @@ -10708,6 +12095,7 @@ "version": "5.1.2", "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "license": "MIT", "dependencies": { "mimic-fn": "^2.1.0" }, @@ -10721,12 +12109,14 @@ "node_modules/restore-cursor/node_modules/signal-exit": { "version": "3.0.7", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", - "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==" + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "license": "ISC" }, "node_modules/retext": { "version": "8.1.0", "resolved": "https://registry.npmjs.org/retext/-/retext-8.1.0.tgz", "integrity": "sha512-N9/Kq7YTn6ZpzfiGW45WfEGJqFf1IM1q8OsRa1CGzIebCJBNCANDRmOrholiDRGKo/We7ofKR4SEvcGAWEMD3Q==", + "license": "MIT", "dependencies": { "@types/nlcst": "^1.0.0", "retext-latin": "^3.0.0", @@ -10742,6 +12132,7 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/retext-latin/-/retext-latin-3.1.0.tgz", "integrity": "sha512-5MrD1tuebzO8ppsja5eEu+ZbBeUNCjoEarn70tkXOS7Bdsdf6tNahsv2bY0Z8VooFF6cw7/6S+d3yI/TMlMVVQ==", + "license": "MIT", "dependencies": { "@types/nlcst": "^1.0.0", "parse-latin": "^5.0.0", @@ -10757,6 +12148,7 @@ "version": "5.2.0", "resolved": "https://registry.npmjs.org/retext-smartypants/-/retext-smartypants-5.2.0.tgz", "integrity": "sha512-Do8oM+SsjrbzT2UNIKgheP0hgUQTDDQYyZaIY3kfq0pdFzoPk+ZClYJ+OERNXveog4xf1pZL4PfRxNoVL7a/jw==", + "license": "MIT", "dependencies": { "@types/nlcst": "^1.0.0", "nlcst-to-string": "^3.0.0", @@ -10772,6 +12164,7 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/retext-stringify/-/retext-stringify-3.1.0.tgz", "integrity": "sha512-767TLOaoXFXyOnjx/EggXlb37ZD2u4P1n0GJqVdpipqACsQP+20W+BNpMYrlJkq7hxffnFk+jc6mAK9qrbuB8w==", + "license": "MIT", "dependencies": { "@types/nlcst": "^1.0.0", "nlcst-to-string": "^3.0.0", @@ -10786,6 +12179,7 @@ "version": "1.0.4", "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "license": "MIT", "engines": { "iojs": ">=1.0.0", "node": ">=0.10.0" @@ -10795,7 +12189,9 @@ "version": "3.0.2", "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "deprecated": "Rimraf versions prior to v4 are no longer supported", "dev": true, + "license": "ISC", "dependencies": { "glob": "^7.1.3" }, @@ -10807,17 +12203,41 @@ } }, "node_modules/rollup": { - "version": "3.29.4", - "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.29.4.tgz", - "integrity": "sha512-oWzmBZwvYrU0iJHtDmhsm662rC15FRXmcjCk1xD771dFDx5jJ02ufAQQTn0etB2emNk4J9EZg/yWKpsn9BWGRw==", + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.28.1.tgz", + "integrity": "sha512-61fXYl/qNVinKmGSTHAZ6Yy8I3YIJC/r2m9feHo6SwVAVcLT5MPwOUFe7EuURA/4m0NR8lXG4BBXuo/IZEsjMg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.6" + }, "bin": { "rollup": "dist/bin/rollup" }, "engines": { - "node": ">=14.18.0", + "node": ">=18.0.0", "npm": ">=8.0.0" }, "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.28.1", + "@rollup/rollup-android-arm64": "4.28.1", + "@rollup/rollup-darwin-arm64": "4.28.1", + "@rollup/rollup-darwin-x64": "4.28.1", + "@rollup/rollup-freebsd-arm64": "4.28.1", + "@rollup/rollup-freebsd-x64": "4.28.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.28.1", + "@rollup/rollup-linux-arm-musleabihf": "4.28.1", + "@rollup/rollup-linux-arm64-gnu": "4.28.1", + "@rollup/rollup-linux-arm64-musl": "4.28.1", + "@rollup/rollup-linux-loongarch64-gnu": "4.28.1", + "@rollup/rollup-linux-powerpc64le-gnu": "4.28.1", + "@rollup/rollup-linux-riscv64-gnu": "4.28.1", + "@rollup/rollup-linux-s390x-gnu": "4.28.1", + "@rollup/rollup-linux-x64-gnu": "4.28.1", + "@rollup/rollup-linux-x64-musl": "4.28.1", + "@rollup/rollup-win32-arm64-msvc": "4.28.1", + "@rollup/rollup-win32-ia32-msvc": "4.28.1", + "@rollup/rollup-win32-x64-msvc": "4.28.1", "fsevents": "~2.3.2" } }, @@ -10876,6 +12296,19 @@ "dev": true, "license": "MIT" }, + "node_modules/rollup-plugin-sourcemaps/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/rollup-plugin-web-worker-loader": { "version": "1.6.2", "resolved": "git+ssh://git@github.com/montevideo-tech/rollup-plugin-web-worker-loader.git#b07d05278c65c79fff58e93b4137cd2d57a3f646", @@ -10885,128 +12318,6 @@ "rollup": "^1.9.2 || ^2.0.0 || ^3.0.0 || ^4.0.0" } }, - "node_modules/run-applescript": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-5.0.0.tgz", - "integrity": "sha512-XcT5rBksx1QdIhlFOCtgZkB99ZEouFZ1E2Kc2LHqNW13U3/74YGdkQRmThTwxy4QIyookibDKYZOPqX//6BlAg==", - "dev": true, - "dependencies": { - "execa": "^5.0.0" - }, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/run-applescript/node_modules/execa": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", - "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", - "dev": true, - "dependencies": { - "cross-spawn": "^7.0.3", - "get-stream": "^6.0.0", - "human-signals": "^2.1.0", - "is-stream": "^2.0.0", - "merge-stream": "^2.0.0", - "npm-run-path": "^4.0.1", - "onetime": "^5.1.2", - "signal-exit": "^3.0.3", - "strip-final-newline": "^2.0.0" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sindresorhus/execa?sponsor=1" - } - }, - "node_modules/run-applescript/node_modules/get-stream": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", - "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", - "dev": true, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/run-applescript/node_modules/human-signals": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", - "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", - "dev": true, - "engines": { - "node": ">=10.17.0" - } - }, - "node_modules/run-applescript/node_modules/is-stream": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", - "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", - "dev": true, - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/run-applescript/node_modules/mimic-fn": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", - "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", - "dev": true, - "engines": { - "node": ">=6" - } - }, - "node_modules/run-applescript/node_modules/npm-run-path": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", - "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", - "dev": true, - "dependencies": { - "path-key": "^3.0.0" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/run-applescript/node_modules/onetime": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", - "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", - "dev": true, - "dependencies": { - "mimic-fn": "^2.1.0" - }, - "engines": { - "node": ">=6" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/run-applescript/node_modules/signal-exit": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", - "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", - "dev": true - }, - "node_modules/run-applescript/node_modules/strip-final-newline": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", - "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", - "dev": true, - "engines": { - "node": ">=6" - } - }, "node_modules/run-parallel": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", @@ -11025,6 +12336,7 @@ "url": "https://feross.org/support" } ], + "license": "MIT", "dependencies": { "queue-microtask": "^1.2.2" } @@ -11033,12 +12345,14 @@ "version": "0.0.15", "resolved": "https://registry.npmjs.org/s.color/-/s.color-0.0.15.tgz", "integrity": "sha512-AUNrbEUHeKY8XsYr/DYpl+qk5+aM+DChopnWOPEzn8YKzOhv4l2zH6LzZms3tOZP3wwdOyc0RmTciyi46HLIuA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/sade": { "version": "1.8.1", "resolved": "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz", "integrity": "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==", + "license": "MIT", "dependencies": { "mri": "^1.1.0" }, @@ -11047,15 +12361,16 @@ } }, "node_modules/safe-array-concat": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.2.tgz", - "integrity": "sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==", + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz", + "integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", - "get-intrinsic": "^1.2.4", - "has-symbols": "^1.0.3", + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "get-intrinsic": "^1.2.6", + "has-symbols": "^1.1.0", "isarray": "^2.0.5" }, "engines": { @@ -11082,18 +12397,19 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "MIT" }, "node_modules/safe-regex-test": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.3.tgz", - "integrity": "sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz", + "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.6", + "call-bound": "^1.0.2", "es-errors": "^1.3.0", - "is-regex": "^1.1.4" + "is-regex": "^1.2.1" }, "engines": { "node": ">= 0.4" @@ -11105,26 +12421,30 @@ "node_modules/safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", - "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" }, "node_modules/sass-formatter": { - "version": "0.7.8", - "resolved": "https://registry.npmjs.org/sass-formatter/-/sass-formatter-0.7.8.tgz", - "integrity": "sha512-7fI2a8THglflhhYis7k06eUf92VQuJoXzEs2KRP0r1bluFxKFvLx0Ns7c478oYGM0fPfrr846ZRWVi2MAgHt9Q==", + "version": "0.7.9", + "resolved": "https://registry.npmjs.org/sass-formatter/-/sass-formatter-0.7.9.tgz", + "integrity": "sha512-CWZ8XiSim+fJVG0cFLStwDvft1VI7uvXdCNJYXhDvowiv+DsbD1nXLiQ4zrE5UBvj5DWZJ93cwN0NX5PMsr1Pw==", "dev": true, + "license": "MIT", "dependencies": { "suf-log": "^2.5.3" } }, "node_modules/sax": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.3.0.tgz", - "integrity": "sha512-0s+oAmw9zLl1V1cS9BtZN7JAd0cW5e0QH4W3LWEK6a4LaLEA2OTpGYWDY+6XasBLtz6wkm3u1xRw95mRuJ59WA==" + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.1.tgz", + "integrity": "sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==", + "license": "ISC" }, "node_modules/section-matter": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz", "integrity": "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA==", + "license": "MIT", "dependencies": { "extend-shallow": "^2.0.1", "kind-of": "^6.0.0" @@ -11134,39 +12454,20 @@ } }, "node_modules/semver": { - "version": "7.5.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz", - "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==", - "dependencies": { - "lru-cache": "^6.0.0" - }, + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", + "dev": true, + "license": "ISC", "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/semver/node_modules/lru-cache": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", - "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", - "dependencies": { - "yallist": "^4.0.0" - }, - "engines": { - "node": ">=10" + "semver": "bin/semver" } }, - "node_modules/semver/node_modules/yallist": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" - }, "node_modules/send": { "version": "0.18.0", "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz", "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==", + "license": "MIT", "dependencies": { "debug": "2.6.9", "depd": "2.0.0", @@ -11190,6 +12491,7 @@ "version": "2.6.9", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", "dependencies": { "ms": "2.0.0" } @@ -11197,12 +12499,23 @@ "node_modules/send/node_modules/debug/node_modules/ms": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/send/node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } }, "node_modules/send/node_modules/mime": { "version": "1.6.0", "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", "bin": { "mime": "cli.js" }, @@ -11210,11 +12523,6 @@ "node": ">=4" } }, - "node_modules/send/node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" - }, "node_modules/serialize-javascript": { "version": "6.0.2", "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz", @@ -11226,11 +12534,24 @@ } }, "node_modules/seroval": { - "version": "0.5.1", - "resolved": "https://registry.npmjs.org/seroval/-/seroval-0.5.1.tgz", - "integrity": "sha512-ZfhQVB59hmIauJG5Ydynupy8KHyr5imGNtdDhbZG68Ufh1Ynkv9KOYOAABf71oVbQxJ8VkWnMHAjEHE7fWkH5g==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/seroval/-/seroval-1.1.1.tgz", + "integrity": "sha512-rqEO6FZk8mv7Hyv4UCj3FD3b6Waqft605TLfsCe/BiaylRpyyMC0b+uA5TJKawX3KzMrdi3wsLbCaLplrQmBvQ==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/seroval-plugins": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/seroval-plugins/-/seroval-plugins-1.1.1.tgz", + "integrity": "sha512-qNSy1+nUj7hsCOon7AO4wdAIo9P0jrzAMp18XhiOzA6/uO5TKtP7ScozVJ8T293oRIvi5wyCHSM4TrJo/c/GJA==", + "license": "MIT", "engines": { "node": ">=10" + }, + "peerDependencies": { + "seroval": "^1.0" } }, "node_modules/serve-static": { @@ -11263,15 +12584,6 @@ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", "license": "MIT" }, - "node_modules/serve-static/node_modules/encodeurl": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", - "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, "node_modules/serve-static/node_modules/mime": { "version": "1.6.0", "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", @@ -11284,12 +12596,6 @@ "node": ">=4" } }, - "node_modules/serve-static/node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", - "license": "MIT" - }, "node_modules/serve-static/node_modules/send": { "version": "0.19.0", "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", @@ -11326,12 +12632,14 @@ "node_modules/server-destroy": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/server-destroy/-/server-destroy-1.0.1.tgz", - "integrity": "sha512-rb+9B5YBIEzYcD6x2VKidaa+cqYBJQKnU4oe4E3ANwRRN56yk/ua1YCJT1n21NTS8w6CcOclAKNP3PhdCXKYtQ==" + "integrity": "sha512-rb+9B5YBIEzYcD6x2VKidaa+cqYBJQKnU4oe4E3ANwRRN56yk/ua1YCJT1n21NTS8w6CcOclAKNP3PhdCXKYtQ==", + "license": "ISC" }, "node_modules/set-function-length": { "version": "1.2.2", "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + "dev": true, "license": "MIT", "dependencies": { "define-data-property": "^1.1.4", @@ -11364,13 +12672,15 @@ "node_modules/setprototypeof": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", - "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==" + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" }, "node_modules/sharp": { "version": "0.32.6", "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.32.6.tgz", "integrity": "sha512-KyLTWwgcR9Oe4d9HwCwNM2l7+J0dUQwn/yf7S0EnTtb0eVS4RxO0eUSvxPtzT4F3SY+C4K6fqdv/DO27sJ/v/w==", "hasInstallScript": true, + "license": "Apache-2.0", "optional": true, "dependencies": { "color": "^4.2.3", @@ -11389,23 +12699,40 @@ "url": "https://opencollective.com/libvips" } }, + "node_modules/sharp/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "license": "ISC", + "optional": true, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/shebang-command": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", - "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==", + "dev": true, + "license": "MIT", "dependencies": { - "shebang-regex": "^3.0.0" + "shebang-regex": "^1.0.0" }, "engines": { - "node": ">=8" + "node": ">=0.10.0" } }, "node_modules/shebang-regex": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", - "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=8" + "node": ">=0.10.0" } }, "node_modules/shell-quote": { @@ -11421,21 +12748,12 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/shiki": { - "version": "0.14.4", - "resolved": "https://registry.npmjs.org/shiki/-/shiki-0.14.4.tgz", - "integrity": "sha512-IXCRip2IQzKwxArNNq1S+On4KPML3Yyn8Zzs/xRgcgOWIr8ntIK3IKzjFPfjy/7kt9ZMjc+FItfqHRBg8b6tNQ==", - "dependencies": { - "ansi-sequence-parser": "^1.1.0", - "jsonc-parser": "^3.2.0", - "vscode-oniguruma": "^1.7.0", - "vscode-textmate": "^8.0.0" - } - }, "node_modules/shikiji": { "version": "0.6.13", "resolved": "https://registry.npmjs.org/shikiji/-/shikiji-0.6.13.tgz", "integrity": "sha512-4T7X39csvhT0p7GDnq9vysWddf2b6BeioiN3Ymhnt3xcy9tXmDcnsEFVxX18Z4YcQgEE/w48dLJ4pPPUcG9KkA==", + "deprecated": "Shikiji is merged back to Shiki v1.0, please migrate over to get the latest updates", + "license": "MIT", "dependencies": { "hast-util-to-html": "^9.0.0" } @@ -11444,38 +12762,45 @@ "version": "3.0.4", "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz", "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==", + "license": "MIT", "dependencies": { "@types/unist": "*" } }, "node_modules/shikiji/node_modules/@types/unist": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.2.tgz", - "integrity": "sha512-dqId9J8K/vGi5Zr7oo212BGii5m3q5Hxlkwy3WpYuKPklmBEvsbMYYyLxAQpSffdLl/gdW0XUpKWFvYmyoWCoQ==" + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "license": "MIT" }, - "node_modules/shikiji/node_modules/hast-util-from-parse5": { - "version": "8.0.1", - "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.1.tgz", - "integrity": "sha512-Er/Iixbc7IEa7r/XLtuG52zoqn/b3Xng/w6aZQ0xGVxzhw5xUFxcRqdPzP6yFi/4HBYRaifaI5fQ1RH8n0ZeOQ==", + "node_modules/shikiji/node_modules/hast-util-to-html": { + "version": "9.0.4", + "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.4.tgz", + "integrity": "sha512-wxQzXtdbhiwGAUKrnQJXlOPmHnEehzphwkK7aluUPQ+lEc1xefC8pblMgpp2w5ldBTEfveRIrADcrhGIWrlTDA==", + "license": "MIT", "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", - "devlop": "^1.0.0", - "hastscript": "^8.0.0", + "ccount": "^2.0.0", + "comma-separated-tokens": "^2.0.0", + "hast-util-whitespace": "^3.0.0", + "html-void-elements": "^3.0.0", + "mdast-util-to-hast": "^13.0.0", "property-information": "^6.0.0", - "vfile": "^6.0.0", - "vfile-location": "^5.0.0", - "web-namespaces": "^2.0.0" + "space-separated-tokens": "^2.0.0", + "stringify-entities": "^4.0.0", + "zwitch": "^2.0.4" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, - "node_modules/shikiji/node_modules/hast-util-parse-selector": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz", - "integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==", + "node_modules/shikiji/node_modules/hast-util-whitespace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", + "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", + "license": "MIT", "dependencies": { "@types/hast": "^3.0.0" }, @@ -11484,122 +12809,31 @@ "url": "https://opencollective.com/unified" } }, - "node_modules/shikiji/node_modules/hast-util-raw": { - "version": "9.0.4", - "resolved": "https://registry.npmjs.org/hast-util-raw/-/hast-util-raw-9.0.4.tgz", - "integrity": "sha512-LHE65TD2YiNsHD3YuXcKPHXPLuYh/gjp12mOfU8jxSrm1f/yJpsb0F/KKljS6U9LJoP0Ux+tCe8iJ2AsPzTdgA==", + "node_modules/shikiji/node_modules/html-void-elements": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz", + "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/shikiji/node_modules/mdast-util-to-hast": { + "version": "13.2.0", + "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz", + "integrity": "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==", + "license": "MIT", "dependencies": { "@types/hast": "^3.0.0", - "@types/unist": "^3.0.0", + "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", - "hast-util-from-parse5": "^8.0.0", - "hast-util-to-parse5": "^8.0.0", - "html-void-elements": "^3.0.0", - "mdast-util-to-hast": "^13.0.0", - "parse5": "^7.0.0", + "devlop": "^1.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", - "vfile": "^6.0.0", - "web-namespaces": "^2.0.0", - "zwitch": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/shikiji/node_modules/hast-util-to-html": { - "version": "9.0.1", - "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.1.tgz", - "integrity": "sha512-hZOofyZANbyWo+9RP75xIDV/gq+OUKx+T46IlwERnKmfpwp81XBFbT9mi26ws+SJchA4RVUQwIBJpqEOBhMzEQ==", - "dependencies": { - "@types/hast": "^3.0.0", - "@types/unist": "^3.0.0", - "ccount": "^2.0.0", - "comma-separated-tokens": "^2.0.0", - "hast-util-raw": "^9.0.0", - "hast-util-whitespace": "^3.0.0", - "html-void-elements": "^3.0.0", - "mdast-util-to-hast": "^13.0.0", - "property-information": "^6.0.0", - "space-separated-tokens": "^2.0.0", - "stringify-entities": "^4.0.0", - "zwitch": "^2.0.4" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/shikiji/node_modules/hast-util-to-parse5": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-8.0.0.tgz", - "integrity": "sha512-3KKrV5ZVI8if87DVSi1vDeByYrkGzg4mEfeu4alwgmmIeARiBLKCZS2uw5Gb6nU9x9Yufyj3iudm6i7nl52PFw==", - "dependencies": { - "@types/hast": "^3.0.0", - "comma-separated-tokens": "^2.0.0", - "devlop": "^1.0.0", - "property-information": "^6.0.0", - "space-separated-tokens": "^2.0.0", - "web-namespaces": "^2.0.0", - "zwitch": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/shikiji/node_modules/hast-util-whitespace": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", - "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", - "dependencies": { - "@types/hast": "^3.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/shikiji/node_modules/hastscript": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-8.0.0.tgz", - "integrity": "sha512-dMOtzCEd3ABUeSIISmrETiKuyydk1w0pa+gE/uormcTpSYuaNJPbX1NU3JLyscSLjwAQM8bWMhhIlnCqnRvDTw==", - "dependencies": { - "@types/hast": "^3.0.0", - "comma-separated-tokens": "^2.0.0", - "hast-util-parse-selector": "^4.0.0", - "property-information": "^6.0.0", - "space-separated-tokens": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/shikiji/node_modules/html-void-elements": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz", - "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==", - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" - } - }, - "node_modules/shikiji/node_modules/mdast-util-to-hast": { - "version": "13.2.0", - "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz", - "integrity": "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==", - "dependencies": { - "@types/hast": "^3.0.0", - "@types/mdast": "^4.0.0", - "@ungap/structured-clone": "^1.0.0", - "devlop": "^1.0.0", - "micromark-util-sanitize-uri": "^2.0.0", - "trim-lines": "^3.0.0", - "unist-util-position": "^5.0.0", - "unist-util-visit": "^5.0.0", - "vfile": "^6.0.0" + "vfile": "^6.0.0" }, "funding": { "type": "opencollective", @@ -11607,9 +12841,9 @@ } }, "node_modules/shikiji/node_modules/micromark-util-character": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.0.tgz", - "integrity": "sha512-KvOVV+X1yLBfs9dCBSopq/+G1PcgT3lAK07mC4BzXi5E7ahzMAF8oIupDDJ6mievI6F+lAATkbQQlQixJfT3aQ==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz", + "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==", "funding": [ { "type": "GitHub Sponsors", @@ -11620,15 +12854,16 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "node_modules/shikiji/node_modules/micromark-util-encode": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.0.tgz", - "integrity": "sha512-pS+ROfCXAGLWCOc8egcBvT0kf27GoWMqtdarNfDcjb6YLuV5cM3ioG45Ys2qOVqeqSbjaKg72vU+Wby3eddPsA==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz", + "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==", "funding": [ { "type": "GitHub Sponsors", @@ -11638,12 +12873,13 @@ "type": "OpenCollective", "url": "https://opencollective.com/unified" } - ] + ], + "license": "MIT" }, "node_modules/shikiji/node_modules/micromark-util-sanitize-uri": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.0.tgz", - "integrity": "sha512-WhYv5UEcZrbAtlsnPuChHUAsu/iBPOVaEVsntLBIdpibO0ddy8OzavZz3iL2xVvBZOpolujSliP65Kq0/7KIYw==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz", + "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==", "funding": [ { "type": "GitHub Sponsors", @@ -11654,6 +12890,7 @@ "url": "https://opencollective.com/unified" } ], + "license": "MIT", "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-encode": "^2.0.0", @@ -11661,9 +12898,9 @@ } }, "node_modules/shikiji/node_modules/micromark-util-symbol": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.0.tgz", - "integrity": "sha512-8JZt9ElZ5kyTnO94muPxIGS8oyElRJaiJO8EzV6ZSyGQ1Is8xwl4Q45qU5UOg+bGH4AikWziz0iN4sFLWs8PGw==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz", + "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==", "funding": [ { "type": "GitHub Sponsors", @@ -11673,12 +12910,13 @@ "type": "OpenCollective", "url": "https://opencollective.com/unified" } - ] + ], + "license": "MIT" }, "node_modules/shikiji/node_modules/micromark-util-types": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.0.tgz", - "integrity": "sha512-oNh6S2WMHWRZrmutsRmDDfkzKtxF+bc2VxLC9dvtrDIRFln627VsFP6fLMgTryGDljgLPjkrzQSDcPrjPyDJ5w==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.1.tgz", + "integrity": "sha512-534m2WhVTddrcKVepwmVEVnUAmtrx9bfIjNoQHRqfnvdaHQiFytEhJoTgpWJvDEXCO5gLTQh3wYC1PgOJA4NSQ==", "funding": [ { "type": "GitHub Sponsors", @@ -11688,23 +12926,14 @@ "type": "OpenCollective", "url": "https://opencollective.com/unified" } - ] - }, - "node_modules/shikiji/node_modules/parse5": { - "version": "7.1.2", - "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.1.2.tgz", - "integrity": "sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==", - "dependencies": { - "entities": "^4.4.0" - }, - "funding": { - "url": "https://github.com/inikulin/parse5?sponsor=1" - } + ], + "license": "MIT" }, "node_modules/shikiji/node_modules/unist-util-is": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz", "integrity": "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0" }, @@ -11717,6 +12946,7 @@ "version": "5.0.0", "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz", "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0" }, @@ -11729,6 +12959,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz", "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0" }, @@ -11741,6 +12972,7 @@ "version": "5.0.0", "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz", "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", @@ -11755,6 +12987,7 @@ "version": "6.0.1", "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz", "integrity": "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" @@ -11765,12 +12998,12 @@ } }, "node_modules/shikiji/node_modules/vfile": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.1.tgz", - "integrity": "sha512-1bYqc7pt6NIADBJ98UiG0Bn/CHIVOoZ/IyEkqIruLg0mE1BKzkOXY2D6CSqQIcKqgadppE5lrxgWXJmXd7zZJw==", + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz", + "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0", - "unist-util-stringify-position": "^4.0.0", "vfile-message": "^4.0.0" }, "funding": { @@ -11778,23 +13011,11 @@ "url": "https://opencollective.com/unified" } }, - "node_modules/shikiji/node_modules/vfile-location": { - "version": "5.0.2", - "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.2.tgz", - "integrity": "sha512-NXPYyxyBSH7zB5U6+3uDdd6Nybz6o6/od9rk8bp9H8GR3L+cm/fC0uUTbqBmUTnMCUDslAGBOIKNfvvb+gGlDg==", - "dependencies": { - "@types/unist": "^3.0.0", - "vfile": "^6.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, "node_modules/shikiji/node_modules/vfile-message": { "version": "4.0.2", "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.2.tgz", "integrity": "sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==", + "license": "MIT", "dependencies": { "@types/unist": "^3.0.0", "unist-util-stringify-position": "^4.0.0" @@ -11805,15 +13026,69 @@ } }, "node_modules/side-channel": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz", - "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.4", - "object-inspect": "^1.13.1" + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" }, "engines": { "node": ">= 0.4" @@ -11826,6 +13101,7 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "license": "ISC", "engines": { "node": ">=14" }, @@ -11851,6 +13127,7 @@ "url": "https://feross.org/support" } ], + "license": "MIT", "optional": true }, "node_modules/simple-get": { @@ -11871,6 +13148,7 @@ "url": "https://feross.org/support" } ], + "license": "MIT", "optional": true, "dependencies": { "decompress-response": "^6.0.0", @@ -11886,11 +13164,19 @@ "version": "0.2.2", "resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.2.tgz", "integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==", + "license": "MIT", "optional": true, "dependencies": { "is-arrayish": "^0.3.1" } }, + "node_modules/simple-swizzle/node_modules/is-arrayish": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz", + "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ==", + "license": "MIT", + "optional": true + }, "node_modules/simple-update-notifier": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz", @@ -11904,16 +13190,31 @@ "node": ">=10" } }, + "node_modules/simple-update-notifier/node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/sisteransi": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", - "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==" + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", + "license": "MIT" }, "node_modules/slash": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } @@ -11926,22 +13227,25 @@ "license": "MIT" }, "node_modules/solid-js": { - "version": "1.7.12", - "resolved": "https://registry.npmjs.org/solid-js/-/solid-js-1.7.12.tgz", - "integrity": "sha512-QoyoOUKu14iLoGxjxWFIU8+/1kLT4edQ7mZESFPonsEXZ//VJtPKD8Ud1aTKzotj+MNWmSs9YzK6TdY+fO9Eww==", + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/solid-js/-/solid-js-1.9.3.tgz", + "integrity": "sha512-5ba3taPoZGt9GY3YlsCB24kCg0Lv/rie/HTD4kG6h4daZZz7+yK02xn8Vx8dLYBc9i6Ps5JwAbEiqjmKaLB3Ag==", + "license": "MIT", "dependencies": { "csstype": "^3.1.0", - "seroval": "^0.5.0" + "seroval": "^1.1.0", + "seroval-plugins": "^1.1.0" } }, "node_modules/solid-refresh": { - "version": "0.5.3", - "resolved": "https://registry.npmjs.org/solid-refresh/-/solid-refresh-0.5.3.tgz", - "integrity": "sha512-Otg5it5sjOdZbQZJnvo99TEBAr6J7PQ5AubZLNU6szZzg3RQQ5MX04oteBIIGDs0y2Qv8aXKm9e44V8z+UnFdw==", + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/solid-refresh/-/solid-refresh-0.6.3.tgz", + "integrity": "sha512-F3aPsX6hVw9ttm5LYlth8Q15x6MlI/J3Dn+o3EQyRTtTxidepSTwAYdozt01/YA+7ObcciagGEyXIopGZzQtbA==", + "license": "MIT", "dependencies": { - "@babel/generator": "^7.21.1", - "@babel/helper-module-imports": "^7.18.6", - "@babel/types": "^7.21.2" + "@babel/generator": "^7.23.6", + "@babel/helper-module-imports": "^7.22.15", + "@babel/types": "^7.23.6" }, "peerDependencies": { "solid-js": "^1.3" @@ -11951,14 +13255,16 @@ "version": "0.7.4", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz", "integrity": "sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==", + "license": "BSD-3-Clause", "engines": { "node": ">= 8" } }, "node_modules/source-map-js": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz", - "integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "license": "BSD-3-Clause", "engines": { "node": ">=0.10.0" } @@ -12000,6 +13306,7 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -12044,12 +13351,14 @@ "node_modules/sprintf-js": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", - "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==" + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "license": "BSD-3-Clause" }, "node_modules/statuses": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "license": "MIT", "engines": { "node": ">= 0.8" } @@ -12058,6 +13367,7 @@ "version": "0.1.0", "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.1.0.tgz", "integrity": "sha512-xhV7w8S+bUwlPTb4bAOUQhv8/cSS5offJuX8GQGq32ONF0ZtDWKfkdomM3HMRA+LhX6um/FZ0COqlwsjD53LeQ==", + "license": "MIT", "dependencies": { "bl": "^5.0.0" }, @@ -12072,6 +13382,7 @@ "version": "0.3.1", "resolved": "https://registry.npmjs.org/stream-parser/-/stream-parser-0.3.1.tgz", "integrity": "sha512-bJ/HgKq41nlKvlhccD5kaCr/P+Hu0wPNKPJOH7en+YrJu/9EgqUF+88w5Jb6KNcjOFMhfX4B2asfeAtIGuHObQ==", + "license": "MIT", "dependencies": { "debug": "2" } @@ -12080,6 +13391,7 @@ "version": "2.6.9", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", "dependencies": { "ms": "2.0.0" } @@ -12087,22 +13399,29 @@ "node_modules/stream-parser/node_modules/ms": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" }, "node_modules/streamx": { - "version": "2.15.1", - "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.15.1.tgz", - "integrity": "sha512-fQMzy2O/Q47rgwErk/eGeLu/roaFWV0jVsogDmrszM9uIw8L5OA+t+V93MgYlufNptfjmYR1tOMWhei/Eh7TQA==", + "version": "2.21.1", + "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.21.1.tgz", + "integrity": "sha512-PhP9wUnFLa+91CPy3N6tiQsK+gnYyUNuk15S3YG/zjYE7RuPeCjJngqnzpC31ow0lzBHQ+QGO4cNJnd0djYUsw==", + "license": "MIT", "optional": true, "dependencies": { - "fast-fifo": "^1.1.0", - "queue-tick": "^1.0.1" + "fast-fifo": "^1.3.2", + "queue-tick": "^1.0.1", + "text-decoder": "^1.1.0" + }, + "optionalDependencies": { + "bare-events": "^2.2.0" } }, "node_modules/string_decoder": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "license": "MIT", "dependencies": { "safe-buffer": "~5.2.0" } @@ -12111,6 +13430,7 @@ "version": "6.1.0", "resolved": "https://registry.npmjs.org/string-width/-/string-width-6.1.0.tgz", "integrity": "sha512-k01swCJAgQmuADB0YIc+7TuatfNvTBVOoaUWJjTB9R4VJzR5vNWzf5t42ESVZFPS8xTySF7CAdV4t/aaIm3UnQ==", + "license": "MIT", "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^10.2.1", @@ -12123,60 +13443,125 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/string-width/node_modules/emoji-regex": { - "version": "10.2.1", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.2.1.tgz", - "integrity": "sha512-97g6QgOk8zlDRdgq1WxwgTMgEWGVAQvB5Fdpgc1MkNy56la5SKP9GsMXKDOdqwn90/41a8yPwIGk1Y6WVbeMQA==" - }, - "node_modules/string.prototype.padend": { - "version": "3.1.6", - "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.1.6.tgz", - "integrity": "sha512-XZpspuSB7vJWhvJc9DLSlrXl1mcA2BdoY5jjnS135ydXqLoqhs96JjDtCkjJEQHvfqZIp9hBuBMgI589peyx9Q==", - "dev": true, + "node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", - "define-properties": "^1.2.1", - "es-abstract": "^1.23.2", - "es-object-atoms": "^1.0.0" + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" }, "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "node": ">=8" } }, - "node_modules/string.prototype.trim": { - "version": "1.2.9", - "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.9.tgz", - "integrity": "sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==", - "dev": true, + "node_modules/string-width-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "license": "MIT", - "dependencies": { - "call-bind": "^1.0.7", - "define-properties": "^1.2.1", - "es-abstract": "^1.23.0", - "es-object-atoms": "^1.0.0" - }, "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" + "node": ">=8" } }, - "node_modules/string.prototype.trimend": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.8.tgz", - "integrity": "sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==", + "node_modules/string-width-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/string-width-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width/node_modules/emoji-regex": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz", + "integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==", + "license": "MIT" + }, + "node_modules/string.prototype.includes": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/string.prototype.includes/-/string.prototype.includes-2.0.1.tgz", + "integrity": "sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.3" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/string.prototype.padend": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/string.prototype.padend/-/string.prototype.padend-3.1.6.tgz", + "integrity": "sha512-XZpspuSB7vJWhvJc9DLSlrXl1mcA2BdoY5jjnS135ydXqLoqhs96JjDtCkjJEQHvfqZIp9hBuBMgI589peyx9Q==", "dev": true, "license": "MIT", "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trim": { + "version": "1.2.10", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz", + "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "define-data-property": "^1.1.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-object-atoms": "^1.0.0", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz", + "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" }, + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -12200,9 +13585,10 @@ } }, "node_modules/stringify-entities": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.3.tgz", - "integrity": "sha512-BP9nNHMhhfcMbiuQKCqMjhDP5yBCAxsPu4pHFFzJ6Alo9dZgY4VLDPutXqIjpRiMoKdp7Av85Gr73Q5uH9k7+g==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz", + "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==", + "license": "MIT", "dependencies": { "character-entities-html4": "^2.0.0", "character-entities-legacy": "^3.0.0" @@ -12216,6 +13602,7 @@ "version": "7.1.0", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "license": "MIT", "dependencies": { "ansi-regex": "^6.0.1" }, @@ -12226,6 +13613,28 @@ "url": "https://github.com/chalk/strip-ansi?sponsor=1" } }, + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/strip-bom": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", @@ -12239,6 +13648,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz", "integrity": "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==", + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -12247,6 +13657,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz", "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -12259,6 +13670,7 @@ "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" }, @@ -12271,18 +13683,20 @@ "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-0.3.0.tgz", "integrity": "sha512-CzFnRRXhzWIdItT3OmF8SQfWyahHhjq3HwcMNCNLn+N7klOOqPjMeG/4JSu77D7ypZdGvSzvkrbyeTMizz2VrA==", "dev": true, + "license": "MIT", "dependencies": { "inline-style-parser": "0.1.1" } }, "node_modules/sucrase": { - "version": "3.34.0", - "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.34.0.tgz", - "integrity": "sha512-70/LQEZ07TEcxiU2dz51FKaE6hCTWC6vr7FOk3Gr0U60C3shtAN+H+BFr9XlYe5xqf3RA8nrc+VIwzCfnxuXJw==", + "version": "3.35.0", + "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.0.tgz", + "integrity": "sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==", + "license": "MIT", "dependencies": { "@jridgewell/gen-mapping": "^0.3.2", "commander": "^4.0.0", - "glob": "7.1.6", + "glob": "^10.3.10", "lines-and-columns": "^1.1.6", "mz": "^2.7.0", "pirates": "^4.0.1", @@ -12293,23 +13707,48 @@ "sucrase-node": "bin/sucrase-node" }, "engines": { - "node": ">=8" + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/sucrase/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" } }, "node_modules/sucrase/node_modules/glob": { - "version": "7.1.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", - "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", + "version": "10.4.5", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz", + "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==", + "license": "ISC", "dependencies": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" + "foreground-child": "^3.1.0", + "jackspeak": "^3.1.2", + "minimatch": "^9.0.4", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^1.11.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/sucrase/node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" }, "engines": { - "node": "*" + "node": ">=16 || 14 >=14.17" }, "funding": { "url": "https://github.com/sponsors/isaacs" @@ -12320,6 +13759,7 @@ "resolved": "https://registry.npmjs.org/suf-log/-/suf-log-2.5.3.tgz", "integrity": "sha512-KvC8OPjzdNOe+xQ4XWJV2whQA0aM1kGVczMQ8+dStAO6KfEB140JEVQ9dE76ONZ0/Ylf67ni4tILPJB41U0eow==", "dev": true, + "license": "MIT", "dependencies": { "s.color": "0.0.15" } @@ -12329,6 +13769,7 @@ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", "dev": true, + "license": "MIT", "dependencies": { "has-flag": "^3.0.0" }, @@ -12340,6 +13781,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -12348,13 +13790,14 @@ } }, "node_modules/synckit": { - "version": "0.8.5", - "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.8.5.tgz", - "integrity": "sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==", + "version": "0.9.2", + "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.9.2.tgz", + "integrity": "sha512-vrozgXDQwYO72vHjUb/HnFbQx1exDjoKzqx23aXEg2a9VIg2TSFZ8FmeZpTjUCFMYw7mpX4BE2SFu8wI7asYsw==", "dev": true, + "license": "MIT", "dependencies": { - "@pkgr/utils": "^2.3.1", - "tslib": "^2.5.0" + "@pkgr/core": "^0.1.0", + "tslib": "^2.6.2" }, "engines": { "node": "^14.18.0 || >=16.0.0" @@ -12364,32 +13807,33 @@ } }, "node_modules/tailwindcss": { - "version": "3.3.3", - "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.3.3.tgz", - "integrity": "sha512-A0KgSkef7eE4Mf+nKJ83i75TMyq8HqY3qmFIJSWy8bNt0v1lG7jUcpGpoTFxAwYcWOphcTBLPPJg+bDfhDf52w==", + "version": "3.4.17", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.17.tgz", + "integrity": "sha512-w33E2aCvSDP0tW9RZuNXadXlkHXqFzSkQew/aIa2i/Sj8fThxwovwlXHSPXTbAHwEIhBFXAedUhP2tueAKP8Og==", + "license": "MIT", "dependencies": { "@alloc/quick-lru": "^5.2.0", "arg": "^5.0.2", - "chokidar": "^3.5.3", + "chokidar": "^3.6.0", "didyoumean": "^1.2.2", "dlv": "^1.1.3", - "fast-glob": "^3.2.12", + "fast-glob": "^3.3.2", "glob-parent": "^6.0.2", "is-glob": "^4.0.3", - "jiti": "^1.18.2", - "lilconfig": "^2.1.0", - "micromatch": "^4.0.5", + "jiti": "^1.21.6", + "lilconfig": "^3.1.3", + "micromatch": "^4.0.8", "normalize-path": "^3.0.0", "object-hash": "^3.0.0", - "picocolors": "^1.0.0", - "postcss": "^8.4.23", + "picocolors": "^1.1.1", + "postcss": "^8.4.47", "postcss-import": "^15.1.0", "postcss-js": "^4.0.1", - "postcss-load-config": "^4.0.1", - "postcss-nested": "^6.0.1", - "postcss-selector-parser": "^6.0.11", - "resolve": "^1.22.2", - "sucrase": "^3.32.0" + "postcss-load-config": "^4.0.2", + "postcss-nested": "^6.2.0", + "postcss-selector-parser": "^6.1.2", + "resolve": "^1.22.8", + "sucrase": "^3.35.0" }, "bin": { "tailwind": "lib/cli.js", @@ -12403,6 +13847,7 @@ "version": "6.0.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "license": "ISC", "dependencies": { "is-glob": "^4.0.3" }, @@ -12411,9 +13856,10 @@ } }, "node_modules/tailwindcss/node_modules/postcss-selector-parser": { - "version": "6.0.13", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz", - "integrity": "sha512-EaV1Gl4mUEV4ddhDnv/xtj7sxwrwxdetHdWUGnT4VJQf+4d05v6lHYZr8N573k5Z0BViss7BDhfWtKS3+sfAqQ==", + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "license": "MIT", "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -12423,20 +13869,25 @@ } }, "node_modules/tar-fs": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.0.4.tgz", - "integrity": "sha512-5AFQU8b9qLfZCX9zp2duONhPmZv0hGYiBPJsyUdqMjzq/mqVpy/rEUSeHk1+YitmxugaptgBh5oDGU3VsAJq4w==", + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.0.6.tgz", + "integrity": "sha512-iokBDQQkUyeXhgPYaZxmczGPhnhXZ0CmrqI+MOb/WFGS9DW5wnfrLgtjUJBvz50vQ3qfRwJ62QVoCFu8mPVu5w==", + "license": "MIT", "optional": true, "dependencies": { - "mkdirp-classic": "^0.5.2", "pump": "^3.0.0", "tar-stream": "^3.1.5" + }, + "optionalDependencies": { + "bare-fs": "^2.1.1", + "bare-path": "^2.1.0" } }, "node_modules/tar-stream": { - "version": "3.1.6", - "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.6.tgz", - "integrity": "sha512-B/UyjYwPpMBv+PaFSWAmtYjwdrlEaZQEhMIBFNC5oEG8lpiW8XjcSdmEaClj28ArfKScKHs2nshz3k2le6crsg==", + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.7.tgz", + "integrity": "sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==", + "license": "MIT", "optional": true, "dependencies": { "b4a": "^1.6.4", @@ -12470,16 +13921,28 @@ "devOptional": true, "license": "MIT" }, + "node_modules/text-decoder": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.3.tgz", + "integrity": "sha512-3/o9z3X0X0fTupwsYvR03pJ/DjWuqqrfwBgTQzdWDiQSm9KitAyz/9WqsT2JQW7KV2m+bC2ol/zqpW37NHxLaA==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "b4a": "^1.6.4" + } + }, "node_modules/text-table": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/thenify": { "version": "3.3.1", "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz", "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", + "license": "MIT", "dependencies": { "any-promise": "^1.0.0" } @@ -12488,6 +13951,7 @@ "version": "1.6.0", "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==", + "license": "MIT", "dependencies": { "thenify": ">= 3.1.0 < 4" }, @@ -12495,22 +13959,11 @@ "node": ">=0.8" } }, - "node_modules/titleize": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/titleize/-/titleize-3.0.0.tgz", - "integrity": "sha512-KxVu8EYHDPBdUYdKZdKtU2aj2XfEx9AfjXxE/Aj0vT06w2icA09Vus1rh6eSu1y01akYg6BjIK/hxyLJINoMLQ==", - "dev": true, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "license": "MIT", "dependencies": { "is-number": "^7.0.0" }, @@ -12522,6 +13975,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", "engines": { "node": ">=0.6" } @@ -12536,36 +13990,34 @@ "nodetouch": "bin/nodetouch.js" } }, - "node_modules/tr46": { - "version": "0.0.3", - "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", - "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==" - }, "node_modules/trim-lines": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz", "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" } }, "node_modules/trough": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/trough/-/trough-2.1.0.tgz", - "integrity": "sha512-AqTiAOLcj85xS7vQ8QkAV41hPDIJ71XJB4RCUrzo/1GM2CQwhkJGaf9Hgr7BOugMRpgGUrqRg/DrBDl4H40+8g==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz", + "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" } }, "node_modules/ts-api-utils": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.0.3.tgz", - "integrity": "sha512-wNMeqtMz5NtwpT/UZGY5alT+VoKdSsOOP/kqHFcUW1P/VRhH2wJ48+DN2WwUliNbQ976ETwDL0Ifd2VVvgonvg==", + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.4.3.tgz", + "integrity": "sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==", "dev": true, + "license": "MIT", "engines": { - "node": ">=16.13.0" + "node": ">=16" }, "peerDependencies": { "typescript": ">=4.2.0" @@ -12574,12 +14026,14 @@ "node_modules/ts-interface-checker": { "version": "0.1.13", "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz", - "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==" + "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==", + "license": "Apache-2.0" }, "node_modules/tsconfck": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/tsconfck/-/tsconfck-3.1.1.tgz", - "integrity": "sha512-00eoI6WY57SvZEVjm13stEVE90VkEdJAFGgpFLTsZbJyW/LwFQ7uQxJHWpZ2hzSWgCPKc9AnBnNP+0X7o3hAmQ==", + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/tsconfck/-/tsconfck-3.1.4.tgz", + "integrity": "sha512-kdqWFGVJqe+KGYvlSO9NIaWn9jT1Ny4oKVzAJsKii5eoE9snzTJzL4+MMVOMn+fikWGFmKEylcXL710V/kIPJQ==", + "license": "MIT", "bin": { "tsconfck": "bin/tsconfck.js" }, @@ -12606,6 +14060,7 @@ "version": "0.6.0", "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", "integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==", + "license": "Apache-2.0", "optional": true, "dependencies": { "safe-buffer": "^5.0.1" @@ -12619,6 +14074,7 @@ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", "dev": true, + "license": "MIT", "dependencies": { "prelude-ls": "^1.2.1" }, @@ -12630,6 +14086,7 @@ "version": "2.19.0", "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-2.19.0.tgz", "integrity": "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==", + "license": "(MIT OR CC0-1.0)", "engines": { "node": ">=12.20" }, @@ -12651,32 +14108,32 @@ } }, "node_modules/typed-array-buffer": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.2.tgz", - "integrity": "sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==", + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz", + "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", + "call-bound": "^1.0.3", "es-errors": "^1.3.0", - "is-typed-array": "^1.1.13" + "is-typed-array": "^1.1.14" }, "engines": { "node": ">= 0.4" } }, "node_modules/typed-array-byte-length": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.1.tgz", - "integrity": "sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==", + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz", + "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", "for-each": "^0.3.3", - "gopd": "^1.0.1", - "has-proto": "^1.0.3", - "is-typed-array": "^1.1.13" + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.14" }, "engines": { "node": ">= 0.4" @@ -12686,19 +14143,19 @@ } }, "node_modules/typed-array-byte-offset": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.3.tgz", - "integrity": "sha512-GsvTyUHTriq6o/bHcTd0vM7OQ9JEdlvluu9YISaA7+KzDzPaIzEeDFNkTfhdE3MYcNhNi0vq/LlegYgIs5yPAw==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz", + "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==", "dev": true, "license": "MIT", "dependencies": { "available-typed-arrays": "^1.0.7", - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", "for-each": "^0.3.3", - "gopd": "^1.0.1", - "has-proto": "^1.0.3", - "is-typed-array": "^1.1.13", - "reflect.getprototypeof": "^1.0.6" + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.15", + "reflect.getprototypeof": "^1.0.9" }, "engines": { "node": ">= 0.4" @@ -12743,15 +14200,19 @@ } }, "node_modules/unbox-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", - "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz", + "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==", "dev": true, + "license": "MIT", "dependencies": { - "call-bind": "^1.0.2", + "call-bound": "^1.0.3", "has-bigints": "^1.0.2", - "has-symbols": "^1.0.3", - "which-boxed-primitive": "^1.0.2" + "has-symbols": "^1.1.0", + "which-boxed-primitive": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -12768,6 +14229,7 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/unherit/-/unherit-3.0.1.tgz", "integrity": "sha512-akOOQ/Yln8a2sgcLj4U0Jmx0R5jpIg2IUyRrWOzmEbjBtGzBdHtSeFKgoEcoH4KYIG/Pb8GQ/BwtYm0GCq1Sqg==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -12821,6 +14283,7 @@ "version": "10.1.2", "resolved": "https://registry.npmjs.org/unified/-/unified-10.1.2.tgz", "integrity": "sha512-pUSWAi/RAnVy1Pif2kAoeWNBa3JVrx0MId2LASj8G+7AiHWoKZNTomq6LG326T68U7/e263X6fTdcXIy7XnF7Q==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", "bail": "^2.0.0", @@ -12839,6 +14302,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-2.0.1.tgz", "integrity": "sha512-qF72kLmPxAw0oN2fwpWIqbXAVyEqUzDHMsbtPvOudIlUzXYFIeQIuxXQCRCFh22B7cixvU0MG7m3MW8FTq/S+A==", + "license": "MIT", "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" @@ -12848,6 +14312,7 @@ "version": "5.2.1", "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-5.2.1.tgz", "integrity": "sha512-u9njyyfEh43npf1M+yGKDGVPbY/JWEemg5nH05ncKPfi+kBbKBJoTdsogMu33uhytuLlv9y0O7GH7fEdwLdLQw==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0" }, @@ -12860,6 +14325,7 @@ "version": "3.1.1", "resolved": "https://registry.npmjs.org/unist-util-modify-children/-/unist-util-modify-children-3.1.1.tgz", "integrity": "sha512-yXi4Lm+TG5VG+qvokP6tpnk+r1EPwyYL04JWDxLvgvPV40jANh7nm3udk65OOWquvbMDe+PL9+LmkxDpTv/7BA==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", "array-iterate": "^2.0.0" @@ -12873,6 +14339,7 @@ "version": "4.0.4", "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-4.0.4.tgz", "integrity": "sha512-kUBE91efOWfIVBo8xzh/uZQ7p9ffYRtUbMRZBNFYwf0RK8koUMx6dGUfwylLOKmaT2cs4wSW96QoYUSXAyEtpg==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0" }, @@ -12885,6 +14352,7 @@ "version": "1.1.2", "resolved": "https://registry.npmjs.org/unist-util-position-from-estree/-/unist-util-position-from-estree-1.1.2.tgz", "integrity": "sha512-poZa0eXpS+/XpoQwGwl79UUdea4ol2ZuCYguVaJS4qzIOMDzbqz8a3erUCOmubSZkaOuGamb3tX790iwOIROww==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0" }, @@ -12897,6 +14365,7 @@ "version": "4.0.2", "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-4.0.2.tgz", "integrity": "sha512-TkBb0HABNmxzAcfLf4qsIbFbaPDvMO6wa3b3j4VcEzFVaw1LBKwnW4/sRJ/atSLSzoIg41JWEdnE7N6DIhGDGQ==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", "unist-util-visit": "^4.0.0" @@ -12910,6 +14379,7 @@ "version": "3.0.3", "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-3.0.3.tgz", "integrity": "sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0" }, @@ -12922,6 +14392,7 @@ "version": "4.1.2", "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-4.1.2.tgz", "integrity": "sha512-MSd8OUGISqHdVvfY9TPhyK2VdUrPgxkUtWSuMHF6XAAFuL4LokseigBnZtPnJMu+FbynTkFNnFlyjxpVKujMRg==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", "unist-util-is": "^5.0.0", @@ -12936,6 +14407,7 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/unist-util-visit-children/-/unist-util-visit-children-2.0.2.tgz", "integrity": "sha512-+LWpMFqyUwLGpsQxpumsQ9o9DG2VGLFrpz+rpVXYIEdPy57GSy5HioC0g3bg/8WP9oCLlapQtklOzQ8uLS496Q==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0" }, @@ -12948,6 +14420,7 @@ "version": "5.1.3", "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-5.1.3.tgz", "integrity": "sha512-x6+y8g7wWMyQhL1iZfhIPhDAs7Xwbn9nRosDXl7qoPTSCy0yNxnKc+hWokFifWQIDGi154rdUqKvbCa4+1kLhg==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", "unist-util-is": "^5.0.0" @@ -12958,9 +14431,10 @@ } }, "node_modules/universal-user-agent": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz", - "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w==" + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.1.tgz", + "integrity": "sha512-yCzhz6FN2wU1NiiQRogkTQszlQSlpWaw8SvVegAc+bDxbzHgh1vX8uIe8OYyMH6DwH+sdTJsgMl36+mSMdRJIQ==", + "license": "ISC" }, "node_modules/unpipe": { "version": "1.0.0", @@ -12971,15 +14445,6 @@ "node": ">= 0.8" } }, - "node_modules/untildify": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", - "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==", - "dev": true, - "engines": { - "node": ">=8" - } - }, "node_modules/update-browserslist-db": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz", @@ -13015,6 +14480,7 @@ "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "punycode": "^2.1.0" } @@ -13031,7 +14497,8 @@ "node_modules/util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", - "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "license": "MIT" }, "node_modules/util/node_modules/inherits": { "version": "2.0.3", @@ -13052,6 +14519,7 @@ "version": "0.5.6", "resolved": "https://registry.npmjs.org/uvu/-/uvu-0.5.6.tgz", "integrity": "sha512-+g8ENReyr8YsOc6fv/NVJs2vFdHBnBNdfE49rshrTzDWOlUx4Gq7KOS2GD8eqhy2j+Ejq29+SbKH8yjkAqXqoA==", + "license": "MIT", "dependencies": { "dequal": "^2.0.0", "diff": "^5.0.0", @@ -13068,7 +14536,8 @@ "node_modules/validate-html-nesting": { "version": "1.2.2", "resolved": "https://registry.npmjs.org/validate-html-nesting/-/validate-html-nesting-1.2.2.tgz", - "integrity": "sha512-hGdgQozCsQJMyfK5urgFcWEqsSSrK63Awe0t/IMR0bZ0QMtnuaiHzThW81guu3qx9abLi99NEuiaN6P9gVYsNg==" + "integrity": "sha512-hGdgQozCsQJMyfK5urgFcWEqsSSrK63Awe0t/IMR0bZ0QMtnuaiHzThW81guu3qx9abLi99NEuiaN6P9gVYsNg==", + "license": "ISC" }, "node_modules/validate-npm-package-license": { "version": "3.0.4", @@ -13094,6 +14563,7 @@ "version": "5.3.7", "resolved": "https://registry.npmjs.org/vfile/-/vfile-5.3.7.tgz", "integrity": "sha512-r7qlzkgErKjobAmyNIkkSpizsFPYiUPuJb5pNW1RB4JcYVZhs4lIbVqk8XPk033CV/1z8ss5pkax8SuhGpcG8g==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", "is-buffer": "^2.0.0", @@ -13109,6 +14579,7 @@ "version": "4.1.0", "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-4.1.0.tgz", "integrity": "sha512-YF23YMyASIIJXpktBa4vIGLJ5Gs88UB/XePgqPmTa7cDA+JeO3yclbpheQYCHjVHBn/yePzrXuygIL+xbvRYHw==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", "vfile": "^5.0.0" @@ -13122,6 +14593,7 @@ "version": "3.1.4", "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-3.1.4.tgz", "integrity": "sha512-fa0Z6P8HUrQN4BZaX05SIVXic+7kE3b05PWAtPuYP9QLHsLKYR7/AlLW3NtOrpXRLeawpDLMsVkmk5DG0NXgWw==", + "license": "MIT", "dependencies": { "@types/unist": "^2.0.0", "unist-util-stringify-position": "^3.0.0" @@ -13131,110 +14603,474 @@ "url": "https://opencollective.com/unified" } }, - "node_modules/vite": { - "version": "4.5.3", - "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.3.tgz", - "integrity": "sha512-kQL23kMeX92v3ph7IauVkXkikdDRsYMGTVl5KY2E9OY4ONLvkHf04MDTbnfo6NKxZiDLWzVpP5oTa8hQD8U3dg==", - "dependencies": { - "esbuild": "^0.18.10", - "postcss": "^8.4.27", - "rollup": "^3.27.1" - }, - "bin": { - "vite": "bin/vite.js" - }, + "node_modules/vite": { + "version": "4.5.5", + "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.5.tgz", + "integrity": "sha512-ifW3Lb2sMdX+WU91s3R0FyQlAyLxOzCSCP37ujw0+r5POeHPwe6udWVIElKQq8gk3t7b8rkmvqC6IHBpCff4GQ==", + "license": "MIT", + "dependencies": { + "esbuild": "^0.18.10", + "postcss": "^8.4.27", + "rollup": "^3.27.1" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + }, + "peerDependencies": { + "@types/node": ">= 14", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/vite-plugin-cross-origin-isolation": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/vite-plugin-cross-origin-isolation/-/vite-plugin-cross-origin-isolation-0.1.6.tgz", + "integrity": "sha512-OY0naW9nPUDrKTffYnY7FRYXOgZdHoNwMGpPxUmj/n32mGZi01fcq+J536jkmwGWX7DLT95XBQVHHbrAJzTvrw==", + "license": "MIT" + }, + "node_modules/vite-plugin-mkcert": { + "version": "1.17.6", + "resolved": "https://registry.npmjs.org/vite-plugin-mkcert/-/vite-plugin-mkcert-1.17.6.tgz", + "integrity": "sha512-4JR1RN0HEg/w17eRQJ/Ve2pSa6KCVQcQO6yKtIaKQCFDyd63zGfXHWpygBkvvRSpqa0GcqNKf0fjUJ0HiJQXVQ==", + "license": "MIT", + "dependencies": { + "@octokit/rest": "^20.1.1", + "axios": "^1.7.4", + "debug": "^4.3.6", + "picocolors": "^1.0.1" + }, + "engines": { + "node": ">=v16.7.0" + }, + "peerDependencies": { + "vite": ">=3" + } + }, + "node_modules/vite-plugin-solid": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/vite-plugin-solid/-/vite-plugin-solid-2.11.0.tgz", + "integrity": "sha512-G+NiwDj4EAeUE0wt3Ur9f+Lt9oMUuLd0FIxYuqwJSqRacKQRteCwUFzNy8zMEt88xWokngQhiFjfJMhjc1fDXw==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.23.3", + "@types/babel__core": "^7.20.4", + "babel-preset-solid": "^1.8.4", + "merge-anything": "^5.1.7", + "solid-refresh": "^0.6.3", + "vitefu": "^1.0.4" + }, + "peerDependencies": { + "@testing-library/jest-dom": "^5.16.6 || ^5.17.0 || ^6.*", + "solid-js": "^1.7.2", + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0" + }, + "peerDependenciesMeta": { + "@testing-library/jest-dom": { + "optional": true + } + } + }, + "node_modules/vite-plugin-solid/node_modules/vitefu": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.0.4.tgz", + "integrity": "sha512-y6zEE3PQf6uu/Mt6DTJ9ih+kyJLr4XcSgHR2zUkM8SWDhuixEJxfJ6CZGMHh1Ec3vPLoEA0IHU5oWzVqw8ulow==", + "license": "MIT", + "workspaces": [ + "tests/deps/*", + "tests/projects/*" + ], + "peerDependencies": { + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0" + }, + "peerDependenciesMeta": { + "vite": { + "optional": true + } + } + }, + "node_modules/vite/node_modules/@esbuild/android-arm": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz", + "integrity": "sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/android-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz", + "integrity": "sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/android-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.20.tgz", + "integrity": "sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/darwin-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz", + "integrity": "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/darwin-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.20.tgz", + "integrity": "sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/freebsd-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.20.tgz", + "integrity": "sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/freebsd-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.20.tgz", + "integrity": "sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-arm": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.20.tgz", + "integrity": "sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==", + "cpu": [ + "arm" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.20.tgz", + "integrity": "sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-ia32": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.20.tgz", + "integrity": "sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-loong64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.20.tgz", + "integrity": "sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==", + "cpu": [ + "loong64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-mips64el": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.20.tgz", + "integrity": "sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==", + "cpu": [ + "mips64el" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-ppc64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.20.tgz", + "integrity": "sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==", + "cpu": [ + "ppc64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-riscv64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.20.tgz", + "integrity": "sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==", + "cpu": [ + "riscv64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-s390x": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.20.tgz", + "integrity": "sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==", + "cpu": [ + "s390x" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz", + "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/netbsd-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.20.tgz", + "integrity": "sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/openbsd-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.20.tgz", + "integrity": "sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/sunos-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.20.tgz", + "integrity": "sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], "engines": { - "node": "^14.18.0 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/vitejs/vite?sponsor=1" - }, - "optionalDependencies": { - "fsevents": "~2.3.2" - }, - "peerDependencies": { - "@types/node": ">= 14", - "less": "*", - "lightningcss": "^1.21.0", - "sass": "*", - "stylus": "*", - "sugarss": "*", - "terser": "^5.4.0" - }, - "peerDependenciesMeta": { - "@types/node": { - "optional": true - }, - "less": { - "optional": true - }, - "lightningcss": { - "optional": true - }, - "sass": { - "optional": true - }, - "stylus": { - "optional": true - }, - "sugarss": { - "optional": true - }, - "terser": { - "optional": true - } + "node": ">=12" } }, - "node_modules/vite-plugin-cross-origin-isolation": { - "version": "0.1.6", - "resolved": "https://registry.npmjs.org/vite-plugin-cross-origin-isolation/-/vite-plugin-cross-origin-isolation-0.1.6.tgz", - "integrity": "sha512-OY0naW9nPUDrKTffYnY7FRYXOgZdHoNwMGpPxUmj/n32mGZi01fcq+J536jkmwGWX7DLT95XBQVHHbrAJzTvrw==" - }, - "node_modules/vite-plugin-mkcert": { - "version": "1.16.0", - "resolved": "https://registry.npmjs.org/vite-plugin-mkcert/-/vite-plugin-mkcert-1.16.0.tgz", - "integrity": "sha512-5r+g8SB9wZzLNUFekGwZo3e0P6QlS6rbxK5p9z/itxNAimsYohgjK/YfVPVxM9EuglP9hjridq0lUejo9v1nVg==", - "dependencies": { - "@octokit/rest": "^19.0.5", - "axios": "^1.2.2", - "debug": "^4.3.4", - "picocolors": "^1.0.0" - }, + "node_modules/vite/node_modules/@esbuild/win32-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.20.tgz", + "integrity": "sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], "engines": { - "node": ">=v16.7.0" - }, - "peerDependencies": { - "vite": ">=3" + "node": ">=12" } }, - "node_modules/vite-plugin-solid": { - "version": "2.7.0", - "resolved": "https://registry.npmjs.org/vite-plugin-solid/-/vite-plugin-solid-2.7.0.tgz", - "integrity": "sha512-avp/Jl5zOp/Itfo67xtDB2O61U7idviaIp4mLsjhCa13PjKNasz+IID0jYTyqUp9SFx6/PmBr6v4KgDppqompg==", - "dependencies": { - "@babel/core": "^7.20.5", - "@babel/preset-typescript": "^7.18.6", - "@types/babel__core": "^7.1.20", - "babel-preset-solid": "^1.7.2", - "merge-anything": "^5.1.4", - "solid-refresh": "^0.5.0", - "vitefu": "^0.2.3" - }, - "peerDependencies": { - "solid-js": "^1.7.2", - "vite": "^3.0.0 || ^4.0.0" + "node_modules/vite/node_modules/@esbuild/win32-ia32": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.20.tgz", + "integrity": "sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==", + "cpu": [ + "ia32" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" } }, - "node_modules/vite/node_modules/@esbuild/linux-x64": { + "node_modules/vite/node_modules/@esbuild/win32-x64": { "version": "0.18.20", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz", - "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.20.tgz", + "integrity": "sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==", "cpu": [ "x64" ], + "license": "MIT", "optional": true, "os": [ - "linux" + "win32" ], "engines": { "node": ">=12" @@ -13245,6 +15081,7 @@ "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz", "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==", "hasInstallScript": true, + "license": "MIT", "bin": { "esbuild": "bin/esbuild" }, @@ -13276,12 +15113,29 @@ "@esbuild/win32-x64": "0.18.20" } }, + "node_modules/vite/node_modules/rollup": { + "version": "3.29.5", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.29.5.tgz", + "integrity": "sha512-GVsDdsbJzzy4S/v3dqWPJ7EfvZJfCHiDqe80IyrF59LYuP+e6U1LJoUqeuqRbwAWoMNoXivMNeNAOf5E22VA1w==", + "license": "MIT", + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=14.18.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, "node_modules/vitefu": { - "version": "0.2.4", - "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-0.2.4.tgz", - "integrity": "sha512-fanAXjSaf9xXtOOeno8wZXIhgia+CZury481LsDaV++lSvcU2R9Ch2bPh3PYFyoHW+w9LqAeYRISVQjUIew14g==", + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-0.2.5.tgz", + "integrity": "sha512-SgHtMLoqaeeGnd2evZ849ZbACbnwQCIwRH57t18FxcXoZop0uQu0uzlIhJBlF/eWVzuce0sHeqPcDo+evVcg8Q==", + "license": "MIT", "peerDependencies": { - "vite": "^3.0.0 || ^4.0.0" + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0" }, "peerDependenciesMeta": { "vite": { @@ -13289,16 +15143,6 @@ } } }, - "node_modules/vscode-oniguruma": { - "version": "1.7.0", - "resolved": "https://registry.npmjs.org/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz", - "integrity": "sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==" - }, - "node_modules/vscode-textmate": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/vscode-textmate/-/vscode-textmate-8.0.0.tgz", - "integrity": "sha512-AFbieoL7a5LMqcnOF04ji+rpXadgOXnZsxQr//r83kLPr7biP7am3g9zbaZIaBGwBRWeSvoMD4mgPdX3e4NWBg==" - }, "node_modules/web": { "resolved": "web", "link": true @@ -13307,75 +15151,65 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz", "integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" } }, - "node_modules/webidl-conversions": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", - "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" - }, - "node_modules/whatwg-url": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", - "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", - "dependencies": { - "tr46": "~0.0.3", - "webidl-conversions": "^3.0.0" - } - }, "node_modules/which": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", - "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dev": true, + "license": "ISC", "dependencies": { "isexe": "^2.0.0" }, "bin": { - "node-which": "bin/node-which" - }, - "engines": { - "node": ">= 8" + "which": "bin/which" } }, "node_modules/which-boxed-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", - "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz", + "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==", "dev": true, + "license": "MIT", "dependencies": { - "is-bigint": "^1.0.1", - "is-boolean-object": "^1.1.0", - "is-number-object": "^1.0.4", - "is-string": "^1.0.5", - "is-symbol": "^1.0.3" + "is-bigint": "^1.1.0", + "is-boolean-object": "^1.2.1", + "is-number-object": "^1.1.1", + "is-string": "^1.1.1", + "is-symbol": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/which-builtin-type": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.0.tgz", - "integrity": "sha512-I+qLGQ/vucCby4tf5HsLmGueEla4ZhwTBSqaooS+Y0BuxN4Cp+okmGuV+8mXZ84KDI9BA+oklo+RzKg0ONdSUA==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz", + "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==", "dev": true, "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", + "call-bound": "^1.0.2", "function.prototype.name": "^1.1.6", "has-tostringtag": "^1.0.2", "is-async-function": "^2.0.0", - "is-date-object": "^1.0.5", + "is-date-object": "^1.1.0", "is-finalizationregistry": "^1.1.0", "is-generator-function": "^1.0.10", - "is-regex": "^1.1.4", + "is-regex": "^1.2.1", "is-weakref": "^1.0.2", "isarray": "^2.0.5", - "which-boxed-primitive": "^1.0.2", + "which-boxed-primitive": "^1.1.0", "which-collection": "^1.0.2", - "which-typed-array": "^1.1.15" + "which-typed-array": "^1.1.16" }, "engines": { "node": ">= 0.4" @@ -13404,9 +15238,10 @@ } }, "node_modules/which-pm": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/which-pm/-/which-pm-2.1.1.tgz", - "integrity": "sha512-xzzxNw2wMaoCWXiGE8IJ9wuPMU+EYhFksjHxrRT8kMT5SnocBPRg69YAMtyV4D12fP582RA+k3P8H9J5EMdIxQ==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/which-pm/-/which-pm-2.2.0.tgz", + "integrity": "sha512-MOiaDbA5ZZgUjkeMWM5EkJp4loW5ZRoa5bc3/aeMox/PJelMhE6t7S/mLuiY43DBupyxH+S0U1bTui9kWUlmsw==", + "license": "MIT", "dependencies": { "load-yaml-file": "^0.2.0", "path-exists": "^4.0.0" @@ -13419,21 +15254,23 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/which-pm-runs/-/which-pm-runs-1.1.0.tgz", "integrity": "sha512-n1brCuqClxfFfq/Rb0ICg9giSZqCS+pLtccdag6C2HyufBrh3fBOiy9nb6ggRMvWOVH5GrdJskj5iGTZNxd7SA==", + "license": "MIT", "engines": { "node": ">=4" } }, "node_modules/which-typed-array": { - "version": "1.1.16", - "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.16.tgz", - "integrity": "sha512-g+N+GAWiRj66DngFwHvISJd+ITsyphZvD1vChfVg6cEdnzy53GzB3oy0fUNlvhz7H7+MiqhYr26qxQShCpKTTQ==", + "version": "1.1.18", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.18.tgz", + "integrity": "sha512-qEcY+KJYlWyLH9vNbsr6/5j59AXk5ni5aakf8ldzBvGde6Iz4sxZGkJyWSAueTG7QhOvNRYb1lDdFmL5Td0QKA==", "dev": true, "license": "MIT", "dependencies": { "available-typed-arrays": "^1.0.7", - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", "for-each": "^0.3.3", - "gopd": "^1.0.1", + "gopd": "^1.2.0", "has-tostringtag": "^1.0.2" }, "engines": { @@ -13447,6 +15284,7 @@ "version": "4.0.1", "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-4.0.1.tgz", "integrity": "sha512-o0cyEG0e8GPzT4iGHphIOh0cJOV8fivsXxddQasHPHfoZf1ZexrfeA21w2NaEN1RHE+fXlfISmOE8R9N3u3Qig==", + "license": "MIT", "dependencies": { "string-width": "^5.0.1" }, @@ -13461,6 +15299,7 @@ "version": "5.1.2", "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "license": "MIT", "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", @@ -13473,10 +15312,21 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/wrap-ansi": { "version": "8.1.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "license": "MIT", "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", @@ -13489,10 +15339,103 @@ "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, + "node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT" + }, + "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/wrap-ansi-cjs/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/wrap-ansi/node_modules/ansi-styles": { "version": "6.2.1", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "license": "MIT", "engines": { "node": ">=12" }, @@ -13504,6 +15447,7 @@ "version": "5.1.2", "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "license": "MIT", "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", @@ -13519,7 +15463,8 @@ "node_modules/wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" }, "node_modules/yallist": { "version": "3.1.1", @@ -13528,9 +15473,13 @@ "license": "ISC" }, "node_modules/yaml": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.3.2.tgz", - "integrity": "sha512-N/lyzTPaJasoDmfV7YTrYCI0G/3ivm/9wdG0aHuheKowWQwGTsK0Eoiw6utmzAnI6pkJa0DUVygvp3spqqEKXg==", + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.6.1.tgz", + "integrity": "sha512-7r0XPzioN/Q9kXBro/XPnA6kznR73DHq+GXh5ON7ZozRO6aMjbmiBuKste2wslTFkC5d1dw0GooOCepZXJ2SAg==", + "license": "ISC", + "bin": { + "yaml": "bin.mjs" + }, "engines": { "node": ">= 14" } @@ -13539,14 +15488,16 @@ "version": "21.1.1", "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "license": "ISC", "engines": { "node": ">=12" } }, "node_modules/yocto-queue": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.0.0.tgz", - "integrity": "sha512-9bnSc/HEW2uRy67wc+T8UwauLuPJVn28jb+GtJY16iiKWyvmYJRXVT4UamsAEGQfPohgr2q4Tq0sQbQlxTfi1g==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.1.1.tgz", + "integrity": "sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g==", + "license": "MIT", "engines": { "node": ">=12.20" }, @@ -13555,9 +15506,10 @@ } }, "node_modules/zod": { - "version": "3.23.8", - "resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz", - "integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==", + "version": "3.24.1", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.1.tgz", + "integrity": "sha512-muH7gBL9sI1nciMZV67X5fTKKBLtwpZ5VBp1vsOQzj1MhrBZ4wlVCm3gedKZWLp0Oyel8sIGfeiz54Su+OVT+A==", + "license": "MIT", "funding": { "url": "https://github.com/sponsors/colinhacks" } @@ -13566,6 +15518,7 @@ "version": "2.0.4", "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" From 22a11e1889df55d9e7b8f2f6608427f3a4f39d12 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Fri, 20 Dec 2024 16:52:59 -0300 Subject: [PATCH 13/14] fix: set trackNum to 0 in simple-web --- simple-web/public/index.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/simple-web/public/index.html b/simple-web/public/index.html index 5c488cd..9353623 100644 --- a/simple-web/public/index.html +++ b/simple-web/public/index.html @@ -13,7 +13,7 @@ namespace: "bbb", }; var player = null; - moqplayer.create(config, 1).then((p) => { + moqplayer.create(config, 0).then((p) => { player = p; }); playButton.addEventListener("click", () => { From adfb0588d74b5fad8ee96f0d25c08a909800cef6 Mon Sep 17 00:00:00 2001 From: Joaquin Bartaburu Date: Tue, 7 Jan 2025 10:40:56 -0300 Subject: [PATCH 14/14] fix: linter problem fixed --- lib/.eslintrc.cjs | 1 - lib/common/async.ts | 2 ++ lib/contribute/container.ts | 2 +- lib/media/mp4/index.ts | 4 ++-- lib/rollup.config.js | 1 + lib/transport/control.ts | 2 +- lib/tsconfig.json | 2 +- 7 files changed, 8 insertions(+), 6 deletions(-) diff --git a/lib/.eslintrc.cjs b/lib/.eslintrc.cjs index c771093..7c9ac59 100644 --- a/lib/.eslintrc.cjs +++ b/lib/.eslintrc.cjs @@ -45,7 +45,6 @@ module.exports = { "@typescript-eslint/no-unsafe-member-access": "off", "@typescript-eslint/no-unsafe-assignment": "off", "@typescript-eslint/no-unsafe-return": "off", - "@typescript-eslint/no-var-requires": "off", // Make formatting errors into warnings "prettier/prettier": 1, diff --git a/lib/common/async.ts b/lib/common/async.ts index a0fa0b4..2a9d35c 100644 --- a/lib/common/async.ts +++ b/lib/common/async.ts @@ -26,6 +26,7 @@ export class Watch { constructor(init: T) { this.#next = new Deferred>() + // eslint-disable-next-line @typescript-eslint/no-floating-promises this.#current = [init, this.#next.promise] } @@ -44,6 +45,7 @@ export class Watch { } const next = new Deferred>() + // eslint-disable-next-line @typescript-eslint/no-floating-promises this.#current = [v, next.promise] this.#next.resolve(this.#current) this.#next = next diff --git a/lib/contribute/container.ts b/lib/contribute/container.ts index ab1b4f1..a1f853c 100644 --- a/lib/contribute/container.ts +++ b/lib/contribute/container.ts @@ -74,7 +74,7 @@ export class Container { this.#track = this.#mp4.addTrack(options) if (!this.#track) throw new Error("failed to initialize MP4 track") - const buffer = MP4.ISOFile.writeInitializationSegment(this.#mp4.ftyp!, this.#mp4.moov!, 0, 0) + const buffer = MP4.ISOFile.writeInitializationSegment(this.#mp4.ftyp, this.#mp4.moov, 0, 0) const data = new Uint8Array(buffer) controller.enqueue({ diff --git a/lib/media/mp4/index.ts b/lib/media/mp4/index.ts index 5301db3..f12087c 100644 --- a/lib/media/mp4/index.ts +++ b/lib/media/mp4/index.ts @@ -28,8 +28,8 @@ MP4.BoxParser.dOpsBox.prototype.write = function (stream: MP4.Stream) { stream.writeUint8(this.ChannelMappingFamily) if (this.ChannelMappingFamily !== 0) { - stream.writeUint8(this.StreamCount!) - stream.writeUint8(this.CoupledCount!) + stream.writeUint8(this.StreamCount) + stream.writeUint8(this.CoupledCount) for (const mapping of this.ChannelMapping!) { stream.writeUint8(mapping) } diff --git a/lib/rollup.config.js b/lib/rollup.config.js index c077621..8a4f09b 100644 --- a/lib/rollup.config.js +++ b/lib/rollup.config.js @@ -1,3 +1,4 @@ +/* eslint-disable @typescript-eslint/no-var-requires */ "use strict" const resolve = require("@rollup/plugin-node-resolve") const commonjs = require("@rollup/plugin-commonjs") diff --git a/lib/transport/control.ts b/lib/transport/control.ts index c2a2268..d3e22e6 100644 --- a/lib/transport/control.ts +++ b/lib/transport/control.ts @@ -211,7 +211,7 @@ export class Decoder { private async msg(): Promise { const t = await this.r.u53() - switch (t) { + switch (t as Id) { case Id.Subscribe: return Msg.Subscribe case Id.SubscribeOk: diff --git a/lib/tsconfig.json b/lib/tsconfig.json index 66be865..08dc503 100644 --- a/lib/tsconfig.json +++ b/lib/tsconfig.json @@ -4,7 +4,7 @@ "moduleResolution": "node", "module": "es2022", "target": "es2022", - "lib": ["es2022", "dom"], + "lib": ["es2022", "dom", "dom.iterable"], "outDir": "./dist", "strict": true, "allowJs": false,