larkup 0.1.46 → 0.1.47

package/.next/standalone/node_modules/.pnpm/fluent-ffmpeg@2.1.3/node_modules/fluent-ffmpeg/lib/ffprobe.js

@@ -1,261 +0,0 @@
-/*jshint node:true, laxcomma:true*/
-'use strict';
-
-var spawn = require('child_process').spawn;
-
-
-function legacyTag(key) { return key.match(/^TAG:/); }
-function legacyDisposition(key) { return key.match(/^DISPOSITION:/); }
-
-function parseFfprobeOutput(out) {
-  var lines = out.split(/\r\n|\r|\n/);
-
-  lines = lines.filter(function (line) {
-    return line.length > 0;
-  });
-
-  var data = {
-    streams: [],
-    format: {},
-    chapters: []
-  };
-
-  function parseBlock(name) {
-    var data = {};
-
-    var line = lines.shift();
-    while (typeof line !== 'undefined') {
-      if (line.toLowerCase() == '[/'+name+']') {
-        return data;
-      } else if (line.match(/^\[/)) {
-        line = lines.shift();
-        continue;
-      }
-
-      var kv = line.match(/^([^=]+)=(.*)$/);
-      if (kv) {
-        if (!(kv[1].match(/^TAG:/)) && kv[2].match(/^[0-9]+(\.[0-9]+)?$/)) {
-          data[kv[1]] = Number(kv[2]);
-        } else {
-          data[kv[1]] = kv[2];
-        }
-      }
-
-      line = lines.shift();
-    }
-
-    return data;
-  }
-
-  var line = lines.shift();
-  while (typeof line !== 'undefined') {
-    if (line.match(/^\[stream/i)) {
-      var stream = parseBlock('stream');
-      data.streams.push(stream);
-    } else if (line.match(/^\[chapter/i)) {
-      var chapter = parseBlock('chapter');
-      data.chapters.push(chapter);
-    } else if (line.toLowerCase() === '[format]') {
-      data.format = parseBlock('format');
-    }
-
-    line = lines.shift();
-  }
-
-  return data;
-}
-
-
-
-module.exports = function(proto) {
-  /**
-   * A callback passed to the {@link FfmpegCommand#ffprobe} method.
-   *
-   * @callback FfmpegCommand~ffprobeCallback
-   *
-   * @param {Error|null} err error object or null if no error happened
-   * @param {Object} ffprobeData ffprobe output data; this object
-   *   has the same format as what the following command returns:
-   *
-   *     `ffprobe -print_format json -show_streams -show_format INPUTFILE`
-   * @param {Array} ffprobeData.streams stream information
-   * @param {Object} ffprobeData.format format information
-   */
-
-  /**
-   * Run ffprobe on last specified input
-   *
-   * @method FfmpegCommand#ffprobe
-   * @category Metadata
-   *
-   * @param {?Number} [index] 0-based index of input to probe (defaults to last input)
-   * @param {?String[]} [options] array of output options to return
-   * @param {FfmpegCommand~ffprobeCallback} callback callback function
-   *
-   */
-  proto.ffprobe = function() {
-    var input, index = null, options = [], callback;
-
-    // the last argument should be the callback
-    var callback = arguments[arguments.length - 1];
-
-    var ended = false
-    function handleCallback(err, data) {
-      if (!ended) {
-        ended = true;
-        callback(err, data);
-      }
-    };
-
-    // map the arguments to the correct variable names
-    switch (arguments.length) {
-      case 3:
-        index = arguments[0];
-        options = arguments[1];
-        break;
-      case 2:
-        if (typeof arguments[0] === 'number') {
-          index = arguments[0];
-        } else if (Array.isArray(arguments[0])) {
-          options = arguments[0];
-        }
-        break;
-    }
-
-
-    if (index === null) {
-      if (!this._currentInput) {
-        return handleCallback(new Error('No input specified'));
-      }
-
-      input = this._currentInput;
-    } else {
-      input = this._inputs[index];
-
-      if (!input) {
-        return handleCallback(new Error('Invalid input index'));
-      }
-    }
-
-    // Find ffprobe
-    this._getFfprobePath(function(err, path) {
-      if (err) {
-        return handleCallback(err);
-      } else if (!path) {
-        return handleCallback(new Error('Cannot find ffprobe'));
-      }
-
-      var stdout = '';
-      var stdoutClosed = false;
-      var stderr = '';
-      var stderrClosed = false;
-
-      // Spawn ffprobe
-      var src = input.isStream ? 'pipe:0' : input.source;
-      var ffprobe = spawn(path, ['-show_streams', '-show_format'].concat(options, src), {windowsHide: true});
-
-      if (input.isStream) {
-        // Skip errors on stdin. These get thrown when ffprobe is complete and
-        // there seems to be no way hook in and close stdin before it throws.
-        ffprobe.stdin.on('error', function(err) {
-          if (['ECONNRESET', 'EPIPE', 'EOF'].indexOf(err.code) >= 0) { return; }
-          handleCallback(err);
-        });
-
-        // Once ffprobe's input stream closes, we need no more data from the
-        // input
-        ffprobe.stdin.on('close', function() {
-            input.source.pause();
-            input.source.unpipe(ffprobe.stdin);
-        });
-
-        input.source.pipe(ffprobe.stdin);
-      }
-
-      ffprobe.on('error', callback);
-
-      // Ensure we wait for captured streams to end before calling callback
-      var exitError = null;
-      function handleExit(err) {
-        if (err) {
-          exitError = err;
-        }
-
-        if (processExited && stdoutClosed && stderrClosed) {
-          if (exitError) {
-            if (stderr) {
-              exitError.message += '\n' + stderr;
-            }
-
-            return handleCallback(exitError);
-          }
-
-          // Process output
-          var data = parseFfprobeOutput(stdout);
-
-          // Handle legacy output with "TAG:x" and "DISPOSITION:x" keys
-          [data.format].concat(data.streams).forEach(function(target) {
-            if (target) {
-              var legacyTagKeys = Object.keys(target).filter(legacyTag);
-
-              if (legacyTagKeys.length) {
-                target.tags = target.tags || {};
-
-                legacyTagKeys.forEach(function(tagKey) {
-                  target.tags[tagKey.substr(4)] = target[tagKey];
-                  delete target[tagKey];
-                });
-              }
-
-              var legacyDispositionKeys = Object.keys(target).filter(legacyDisposition);
-
-              if (legacyDispositionKeys.length) {
-                target.disposition = target.disposition || {};
-
-                legacyDispositionKeys.forEach(function(dispositionKey) {
-                  target.disposition[dispositionKey.substr(12)] = target[dispositionKey];
-                  delete target[dispositionKey];
-                });
-              }
-            }
-          });
-
-          handleCallback(null, data);
-        }
-      }
-
-      // Handle ffprobe exit
-      var processExited = false;
-      ffprobe.on('exit', function(code, signal) {
-        processExited = true;
-
-        if (code) {
-          handleExit(new Error('ffprobe exited with code ' + code));
-        } else if (signal) {
-          handleExit(new Error('ffprobe was killed with signal ' + signal));
-        } else {
-          handleExit();
-        }
-      });
-
-      // Handle stdout/stderr streams
-      ffprobe.stdout.on('data', function(data) {
-        stdout += data;
-      });
-
-      ffprobe.stdout.on('close', function() {
-        stdoutClosed = true;
-        handleExit();
-      });
-
-      ffprobe.stderr.on('data', function(data) {
-        stderr += data;
-      });
-
-      ffprobe.stderr.on('close', function() {
-        stderrClosed = true;
-        handleExit();
-      });
-    });
-  };
-};

package/.next/standalone/node_modules/.pnpm/fluent-ffmpeg@2.1.3/node_modules/fluent-ffmpeg/lib/fluent-ffmpeg.js

@@ -1,226 +0,0 @@
-/*jshint node:true*/
-'use strict';
-
-var path = require('path');
-var util = require('util');
-var EventEmitter = require('events').EventEmitter;
-
-var utils = require('./utils');
-var ARGLISTS = ['_global', '_audio', '_audioFilters', '_video', '_videoFilters', '_sizeFilters', '_complexFilters'];
-
-
-/**
- * Create an ffmpeg command
- *
- * Can be called with or without the 'new' operator, and the 'input' parameter
- * may be specified as 'options.source' instead (or passed later with the
- * addInput method).
- *
- * @constructor
- * @param {String|ReadableStream} [input] input file path or readable stream
- * @param {Object} [options] command options
- * @param {Object} [options.logger=<no logging>] logger object with 'error', 'warning', 'info' and 'debug' methods
- * @param {Number} [options.niceness=0] ffmpeg process niceness, ignored on Windows
- * @param {Number} [options.priority=0] alias for `niceness`
- * @param {String} [options.presets="fluent-ffmpeg/lib/presets"] directory to load presets from
- * @param {String} [options.preset="fluent-ffmpeg/lib/presets"] alias for `presets`
- * @param {String} [options.stdoutLines=100] maximum lines of ffmpeg output to keep in memory, use 0 for unlimited
- * @param {Number} [options.timeout=<no timeout>] ffmpeg processing timeout in seconds
- * @param {String|ReadableStream} [options.source=<no input>] alias for the `input` parameter
- */
-function FfmpegCommand(input, options) {
-  // Make 'new' optional
-  if (!(this instanceof FfmpegCommand)) {
-    return new FfmpegCommand(input, options);
-  }
-
-  EventEmitter.call(this);
-
-  if (typeof input === 'object' && !('readable' in input)) {
-    // Options object passed directly
-    options = input;
-  } else {
-    // Input passed first
-    options = options || {};
-    options.source = input;
-  }
-
-  // Add input if present
-  this._inputs = [];
-  if (options.source) {
-    this.input(options.source);
-  }
-
-  // Add target-less output for backwards compatibility
-  this._outputs = [];
-  this.output();
-
-  // Create argument lists
-  var self = this;
-  ['_global', '_complexFilters'].forEach(function(prop) {
-    self[prop] = utils.args();
-  });
-
-  // Set default option values
-  options.stdoutLines = 'stdoutLines' in options ? options.stdoutLines : 100;
-  options.presets = options.presets || options.preset || path.join(__dirname, 'presets');
-  options.niceness = options.niceness || options.priority || 0;
-
-  // Save options
-  this.options = options;
-
-  // Setup logger
-  this.logger = options.logger || {
-    debug: function() {},
-    info: function() {},
-    warn: function() {},
-    error: function() {}
-  };
-}
-util.inherits(FfmpegCommand, EventEmitter);
-module.exports = FfmpegCommand;
-
-
-/**
- * Clone an ffmpeg command
- *
- * This method is useful when you want to process the same input multiple times.
- * It returns a new FfmpegCommand instance with the exact same options.
- *
- * All options set _after_ the clone() call will only be applied to the instance
- * it has been called on.
- *
- * @example
- *   var command = ffmpeg('/path/to/source.avi')
- *     .audioCodec('libfaac')
- *     .videoCodec('libx264')
- *     .format('mp4');
- *
- *   command.clone()
- *     .size('320x200')
- *     .save('/path/to/output-small.mp4');
- *
- *   command.clone()
- *     .size('640x400')
- *     .save('/path/to/output-medium.mp4');
- *
- *   command.save('/path/to/output-original-size.mp4');
- *
- * @method FfmpegCommand#clone
- * @return FfmpegCommand
- */
-FfmpegCommand.prototype.clone = function() {
-  var clone = new FfmpegCommand();
-  var self = this;
-
-  // Clone options and logger
-  clone.options = this.options;
-  clone.logger = this.logger;
-
-  // Clone inputs
-  clone._inputs = this._inputs.map(function(input) {
-    return {
-      source: input.source,
-      options: input.options.clone()
-    };
-  });
-
-  // Create first output
-  if ('target' in this._outputs[0]) {
-    // We have outputs set, don't clone them and create first output
-    clone._outputs = [];
-    clone.output();
-  } else {
-    // No outputs set, clone first output options
-    clone._outputs = [
-      clone._currentOutput = {
-        flags: {}
-      }
-    ];
-
-    ['audio', 'audioFilters', 'video', 'videoFilters', 'sizeFilters', 'options'].forEach(function(key) {
-      clone._currentOutput[key] = self._currentOutput[key].clone();
-    });
-
-    if (this._currentOutput.sizeData) {
-      clone._currentOutput.sizeData = {};
-      utils.copy(this._currentOutput.sizeData, clone._currentOutput.sizeData);
-    }
-
-    utils.copy(this._currentOutput.flags, clone._currentOutput.flags);
-  }
-
-  // Clone argument lists
-  ['_global', '_complexFilters'].forEach(function(prop) {
-    clone[prop] = self[prop].clone();
-  });
-
-  return clone;
-};
-
-
-/* Add methods from options submodules */
-
-require('./options/inputs')(FfmpegCommand.prototype);
-require('./options/audio')(FfmpegCommand.prototype);
-require('./options/video')(FfmpegCommand.prototype);
-require('./options/videosize')(FfmpegCommand.prototype);
-require('./options/output')(FfmpegCommand.prototype);
-require('./options/custom')(FfmpegCommand.prototype);
-require('./options/misc')(FfmpegCommand.prototype);
-
-
-/* Add processor methods */
-
-require('./processor')(FfmpegCommand.prototype);
-
-
-/* Add capabilities methods */
-
-require('./capabilities')(FfmpegCommand.prototype);
-
-FfmpegCommand.setFfmpegPath = function(path) {
-  (new FfmpegCommand()).setFfmpegPath(path);
-};
-
-FfmpegCommand.setFfprobePath = function(path) {
-  (new FfmpegCommand()).setFfprobePath(path);
-};
-
-FfmpegCommand.setFlvtoolPath = function(path) {
-  (new FfmpegCommand()).setFlvtoolPath(path);
-};
-
-FfmpegCommand.availableFilters =
-FfmpegCommand.getAvailableFilters = function(callback) {
-  (new FfmpegCommand()).availableFilters(callback);
-};
-
-FfmpegCommand.availableCodecs =
-FfmpegCommand.getAvailableCodecs = function(callback) {
-  (new FfmpegCommand()).availableCodecs(callback);
-};
-
-FfmpegCommand.availableFormats =
-FfmpegCommand.getAvailableFormats = function(callback) {
-  (new FfmpegCommand()).availableFormats(callback);
-};
-
-FfmpegCommand.availableEncoders =
-FfmpegCommand.getAvailableEncoders = function(callback) {
-  (new FfmpegCommand()).availableEncoders(callback);
-};
-
-
-/* Add ffprobe methods */
-
-require('./ffprobe')(FfmpegCommand.prototype);
-
-FfmpegCommand.ffprobe = function(file) {
-  var instance = new FfmpegCommand(file);
-  instance.ffprobe.apply(instance, Array.prototype.slice.call(arguments, 1));
-};
-
-/* Add processing recipes */
-
-require('./recipes')(FfmpegCommand.prototype);

package/.next/standalone/node_modules/.pnpm/fluent-ffmpeg@2.1.3/node_modules/fluent-ffmpeg/lib/options/audio.js

@@ -1,178 +0,0 @@
-/*jshint node:true*/
-'use strict';
-
-var utils = require('../utils');
-
-
-/*
- *! Audio-related methods
- */
-
-module.exports = function(proto) {
-  /**
-   * Disable audio in the output
-   *
-   * @method FfmpegCommand#noAudio
-   * @category Audio
-   * @aliases withNoAudio
-   * @return FfmpegCommand
-   */
-  proto.withNoAudio =
-  proto.noAudio = function() {
-    this._currentOutput.audio.clear();
-    this._currentOutput.audioFilters.clear();
-    this._currentOutput.audio('-an');
-
-    return this;
-  };
-
-
-  /**
-   * Specify audio codec
-   *
-   * @method FfmpegCommand#audioCodec
-   * @category Audio
-   * @aliases withAudioCodec
-   *
-   * @param {String} codec audio codec name
-   * @return FfmpegCommand
-   */
-  proto.withAudioCodec =
-  proto.audioCodec = function(codec) {
-    this._currentOutput.audio('-acodec', codec);
-
-    return this;
-  };
-
-
-  /**
-   * Specify audio bitrate
-   *
-   * @method FfmpegCommand#audioBitrate
-   * @category Audio
-   * @aliases withAudioBitrate
-   *
-   * @param {String|Number} bitrate audio bitrate in kbps (with an optional 'k' suffix)
-   * @return FfmpegCommand
-   */
-  proto.withAudioBitrate =
-  proto.audioBitrate = function(bitrate) {
-    this._currentOutput.audio('-b:a', ('' + bitrate).replace(/k?$/, 'k'));
-    return this;
-  };
-
-
-  /**
-   * Specify audio channel count
-   *
-   * @method FfmpegCommand#audioChannels
-   * @category Audio
-   * @aliases withAudioChannels
-   *
-   * @param {Number} channels channel count
-   * @return FfmpegCommand
-   */
-  proto.withAudioChannels =
-  proto.audioChannels = function(channels) {
-    this._currentOutput.audio('-ac', channels);
-    return this;
-  };
-
-
-  /**
-   * Specify audio frequency
-   *
-   * @method FfmpegCommand#audioFrequency
-   * @category Audio
-   * @aliases withAudioFrequency
-   *
-   * @param {Number} freq audio frequency in Hz
-   * @return FfmpegCommand
-   */
-  proto.withAudioFrequency =
-  proto.audioFrequency = function(freq) {
-    this._currentOutput.audio('-ar', freq);
-    return this;
-  };
-
-
-  /**
-   * Specify audio quality
-   *
-   * @method FfmpegCommand#audioQuality
-   * @category Audio
-   * @aliases withAudioQuality
-   *
-   * @param {Number} quality audio quality factor
-   * @return FfmpegCommand
-   */
-  proto.withAudioQuality =
-  proto.audioQuality = function(quality) {
-    this._currentOutput.audio('-aq', quality);
-    return this;
-  };
-
-
-  /**
-   * Specify custom audio filter(s)
-   *
-   * Can be called both with one or many filters, or a filter array.
-   *
-   * @example
-   * command.audioFilters('filter1');
-   *
-   * @example
-   * command.audioFilters('filter1', 'filter2=param1=value1:param2=value2');
-   *
-   * @example
-   * command.audioFilters(['filter1', 'filter2']);
-   *
-   * @example
-   * command.audioFilters([
-   *   {
-   *     filter: 'filter1'
-   *   },
-   *   {
-   *     filter: 'filter2',
-   *     options: 'param=value:param=value'
-   *   }
-   * ]);
-   *
-   * @example
-   * command.audioFilters(
-   *   {
-   *     filter: 'filter1',
-   *     options: ['value1', 'value2']
-   *   },
-   *   {
-   *     filter: 'filter2',
-   *     options: { param1: 'value1', param2: 'value2' }
-   *   }
-   * );
-   *
-   * @method FfmpegCommand#audioFilters
-   * @aliases withAudioFilter,withAudioFilters,audioFilter
-   * @category Audio
-   *
-   * @param {...String|String[]|Object[]} filters audio filter strings, string array or
-   *   filter specification array, each with the following properties:
-   * @param {String} filters.filter filter name
-   * @param {String|String[]|Object} [filters.options] filter option string, array, or object
-   * @return FfmpegCommand
-   */
-  proto.withAudioFilter =
-  proto.withAudioFilters =
-  proto.audioFilter =
-  proto.audioFilters = function(filters) {
-    if (arguments.length > 1) {
-      filters = [].slice.call(arguments);
-    }
-
-    if (!Array.isArray(filters)) {
-      filters = [filters];
-    }
-
-    this._currentOutput.audioFilters(utils.makeFilterStrings(filters));
-    return this;
-  };
-};