larkup 0.1.46 → 0.1.47

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

@@ -1,212 +0,0 @@
-/*jshint node:true*/
-'use strict';
-
-var utils = require('../utils');
-
-
-/*
- *! Custom options methods
- */
-
-module.exports = function(proto) {
-  /**
-   * Add custom input option(s)
-   *
-   * When passing a single string or an array, each string containing two
-   * words is split (eg. inputOptions('-option value') is supported) for
-   * compatibility reasons.  This is not the case when passing more than
-   * one argument.
-   *
-   * @example
-   * command.inputOptions('option1');
-   *
-   * @example
-   * command.inputOptions('option1', 'option2');
-   *
-   * @example
-   * command.inputOptions(['option1', 'option2']);
-   *
-   * @method FfmpegCommand#inputOptions
-   * @category Custom options
-   * @aliases addInputOption,addInputOptions,withInputOption,withInputOptions,inputOption
-   *
-   * @param {...String} options option string(s) or string array
-   * @return FfmpegCommand
-   */
-  proto.addInputOption =
-  proto.addInputOptions =
-  proto.withInputOption =
-  proto.withInputOptions =
-  proto.inputOption =
-  proto.inputOptions = function(options) {
-    if (!this._currentInput) {
-      throw new Error('No input specified');
-    }
-
-    var doSplit = true;
-
-    if (arguments.length > 1) {
-      options = [].slice.call(arguments);
-      doSplit = false;
-    }
-
-    if (!Array.isArray(options)) {
-      options = [options];
-    }
-
-    this._currentInput.options(options.reduce(function(options, option) {
-      var split = String(option).split(' ');
-
-      if (doSplit && split.length === 2) {
-        options.push(split[0], split[1]);
-      } else {
-        options.push(option);
-      }
-
-      return options;
-    }, []));
-    return this;
-  };
-
-
-  /**
-   * Add custom output option(s)
-   *
-   * @example
-   * command.outputOptions('option1');
-   *
-   * @example
-   * command.outputOptions('option1', 'option2');
-   *
-   * @example
-   * command.outputOptions(['option1', 'option2']);
-   *
-   * @method FfmpegCommand#outputOptions
-   * @category Custom options
-   * @aliases addOutputOption,addOutputOptions,addOption,addOptions,withOutputOption,withOutputOptions,withOption,withOptions,outputOption
-   *
-   * @param {...String} options option string(s) or string array
-   * @return FfmpegCommand
-   */
-  proto.addOutputOption =
-  proto.addOutputOptions =
-  proto.addOption =
-  proto.addOptions =
-  proto.withOutputOption =
-  proto.withOutputOptions =
-  proto.withOption =
-  proto.withOptions =
-  proto.outputOption =
-  proto.outputOptions = function(options) {
-    var doSplit = true;
-
-    if (arguments.length > 1) {
-      options = [].slice.call(arguments);
-      doSplit = false;
-    }
-
-    if (!Array.isArray(options)) {
-      options = [options];
-    }
-
-    this._currentOutput.options(options.reduce(function(options, option) {
-      var split = String(option).split(' ');
-
-      if (doSplit && split.length === 2) {
-        options.push(split[0], split[1]);
-      } else {
-        options.push(option);
-      }
-
-      return options;
-    }, []));
-    return this;
-  };
-
-
-  /**
-   * Specify a complex filtergraph
-   *
-   * Calling this method will override any previously set filtergraph, but you can set
-   * as many filters as needed in one call.
-   *
-   * @example <caption>Overlay an image over a video (using a filtergraph string)</caption>
-   *   ffmpeg()
-   *     .input('video.avi')
-   *     .input('image.png')
-   *     .complexFilter('[0:v][1:v]overlay[out]', ['out']);
-   *
-   * @example <caption>Overlay an image over a video (using a filter array)</caption>
-   *   ffmpeg()
-   *     .input('video.avi')
-   *     .input('image.png')
-   *     .complexFilter([{
-   *       filter: 'overlay',
-   *       inputs: ['0:v', '1:v'],
-   *       outputs: ['out']
-   *     }], ['out']);
-   *
-   * @example <caption>Split video into RGB channels and output a 3x1 video with channels side to side</caption>
-   *  ffmpeg()
-   *    .input('video.avi')
-   *    .complexFilter([
-   *      // Duplicate video stream 3 times into streams a, b, and c
-   *      { filter: 'split', options: '3', outputs: ['a', 'b', 'c'] },
-   *
-   *      // Create stream 'red' by cancelling green and blue channels from stream 'a'
-   *      { filter: 'lutrgb', options: { g: 0, b: 0 }, inputs: 'a', outputs: 'red' },
-   *
-   *      // Create stream 'green' by cancelling red and blue channels from stream 'b'
-   *      { filter: 'lutrgb', options: { r: 0, b: 0 }, inputs: 'b', outputs: 'green' },
-   *
-   *      // Create stream 'blue' by cancelling red and green channels from stream 'c'
-   *      { filter: 'lutrgb', options: { r: 0, g: 0 }, inputs: 'c', outputs: 'blue' },
-   *
-   *      // Pad stream 'red' to 3x width, keeping the video on the left, and name output 'padded'
-   *      { filter: 'pad', options: { w: 'iw*3', h: 'ih' }, inputs: 'red', outputs: 'padded' },
-   *
-   *      // Overlay 'green' onto 'padded', moving it to the center, and name output 'redgreen'
-   *      { filter: 'overlay', options: { x: 'w', y: 0 }, inputs: ['padded', 'green'], outputs: 'redgreen'},
-   *
-   *      // Overlay 'blue' onto 'redgreen', moving it to the right
-   *      { filter: 'overlay', options: { x: '2*w', y: 0 }, inputs: ['redgreen', 'blue']},
-   *    ]);
-   *
-   * @method FfmpegCommand#complexFilter
-   * @category Custom options
-   * @aliases filterGraph
-   *
-   * @param {String|Array} spec filtergraph string or array of filter specification
-   *   objects, each having the following properties:
-   * @param {String} spec.filter filter name
-   * @param {String|Array} [spec.inputs] (array of) input stream specifier(s) for the filter,
-   *   defaults to ffmpeg automatically choosing the first unused matching streams
-   * @param {String|Array} [spec.outputs] (array of) output stream specifier(s) for the filter,
-   *   defaults to ffmpeg automatically assigning the output to the output file
-   * @param {Object|String|Array} [spec.options] filter options, can be omitted to not set any options
-   * @param {Array} [map] (array of) stream specifier(s) from the graph to include in
-   *   ffmpeg output, defaults to ffmpeg automatically choosing the first matching streams.
-   * @return FfmpegCommand
-   */
-  proto.filterGraph =
-  proto.complexFilter = function(spec, map) {
-    this._complexFilters.clear();
-
-    if (!Array.isArray(spec)) {
-      spec = [spec];
-    }
-
-    this._complexFilters('-filter_complex', utils.makeFilterStrings(spec).join(';'));
-
-    if (Array.isArray(map)) {
-      var self = this;
-      map.forEach(function(streamSpec) {
-        self._complexFilters('-map', streamSpec.replace(utils.streamRegexp, '[$1]'));
-      });
-    } else if (typeof map === 'string') {
-      this._complexFilters('-map', map.replace(utils.streamRegexp, '[$1]'));
-    }
-
-    return this;
-  };
-};

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

@@ -1,178 +0,0 @@
-/*jshint node:true*/
-'use strict';
-
-var utils = require('../utils');
-
-/*
- *! Input-related methods
- */
-
-module.exports = function(proto) {
-  /**
-   * Add an input to command
-   *
-   * Also switches "current input", that is the input that will be affected
-   * by subsequent input-related methods.
-   *
-   * Note: only one stream input is supported for now.
-   *
-   * @method FfmpegCommand#input
-   * @category Input
-   * @aliases mergeAdd,addInput
-   *
-   * @param {String|Readable} source input file path or readable stream
-   * @return FfmpegCommand
-   */
-  proto.mergeAdd =
-  proto.addInput =
-  proto.input = function(source) {
-    var isFile = false;
-    var isStream = false;
-
-    if (typeof source !== 'string') {
-      if (!('readable' in source) || !(source.readable)) {
-        throw new Error('Invalid input');
-      }
-
-      var hasInputStream = this._inputs.some(function(input) {
-        return input.isStream;
-      });
-
-      if (hasInputStream) {
-        throw new Error('Only one input stream is supported');
-      }
-
-      isStream = true;
-      source.pause();
-    } else {
-      var protocol = source.match(/^([a-z]{2,}):/i);
-      isFile = !protocol || protocol[0] === 'file';
-    }
-
-    this._inputs.push(this._currentInput = {
-      source: source,
-      isFile: isFile,
-      isStream: isStream,
-      options: utils.args()
-    });
-
-    return this;
-  };
-
-
-  /**
-   * Specify input format for the last specified input
-   *
-   * @method FfmpegCommand#inputFormat
-   * @category Input
-   * @aliases withInputFormat,fromFormat
-   *
-   * @param {String} format input format
-   * @return FfmpegCommand
-   */
-  proto.withInputFormat =
-  proto.inputFormat =
-  proto.fromFormat = function(format) {
-    if (!this._currentInput) {
-      throw new Error('No input specified');
-    }
-
-    this._currentInput.options('-f', format);
-    return this;
-  };
-
-
-  /**
-   * Specify input FPS for the last specified input
-   * (only valid for raw video formats)
-   *
-   * @method FfmpegCommand#inputFps
-   * @category Input
-   * @aliases withInputFps,withInputFPS,withFpsInput,withFPSInput,inputFPS,inputFps,fpsInput
-   *
-   * @param {Number} fps input FPS
-   * @return FfmpegCommand
-   */
-  proto.withInputFps =
-  proto.withInputFPS =
-  proto.withFpsInput =
-  proto.withFPSInput =
-  proto.inputFPS =
-  proto.inputFps =
-  proto.fpsInput =
-  proto.FPSInput = function(fps) {
-    if (!this._currentInput) {
-      throw new Error('No input specified');
-    }
-
-    this._currentInput.options('-r', fps);
-    return this;
-  };
-
-
-  /**
-   * Use native framerate for the last specified input
-   *
-   * @method FfmpegCommand#native
-   * @category Input
-   * @aliases nativeFramerate,withNativeFramerate
-   *
-   * @return FfmmegCommand
-   */
-  proto.nativeFramerate =
-  proto.withNativeFramerate =
-  proto.native = function() {
-    if (!this._currentInput) {
-      throw new Error('No input specified');
-    }
-
-    this._currentInput.options('-re');
-    return this;
-  };
-
-
-  /**
-   * Specify input seek time for the last specified input
-   *
-   * @method FfmpegCommand#seekInput
-   * @category Input
-   * @aliases setStartTime,seekTo
-   *
-   * @param {String|Number} seek seek time in seconds or as a '[hh:[mm:]]ss[.xxx]' string
-   * @return FfmpegCommand
-   */
-  proto.setStartTime =
-  proto.seekInput = function(seek) {
-    if (!this._currentInput) {
-      throw new Error('No input specified');
-    }
-
-    this._currentInput.options('-ss', seek);
-
-    return this;
-  };
-
-
-  /**
-   * Loop over the last specified input
-   *
-   * @method FfmpegCommand#loop
-   * @category Input
-   *
-   * @param {String|Number} [duration] loop duration in seconds or as a '[[hh:]mm:]ss[.xxx]' string
-   * @return FfmpegCommand
-   */
-  proto.loop = function(duration) {
-    if (!this._currentInput) {
-      throw new Error('No input specified');
-    }
-
-    this._currentInput.options('-loop', '1');
-
-    if (typeof duration !== 'undefined') {
-      this.duration(duration);
-    }
-
-    return this;
-  };
-};

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

@@ -1,41 +0,0 @@
-/*jshint node:true*/
-'use strict';
-
-var path = require('path');
-
-/*
- *! Miscellaneous methods
- */
-
-module.exports = function(proto) {
-  /**
-   * Use preset
-   *
-   * @method FfmpegCommand#preset
-   * @category Miscellaneous
-   * @aliases usingPreset
-   *
-   * @param {String|Function} preset preset name or preset function
-   */
-  proto.usingPreset =
-  proto.preset = function(preset) {
-    if (typeof preset === 'function') {
-      preset(this);
-    } else {
-      try {
-        var modulePath = path.join(this.options.presets, preset);
-        var module = require(modulePath);
-
-        if (typeof module.load === 'function') {
-          module.load(this);
-        } else {
-          throw new Error('preset ' + modulePath + ' has no load() function');
-        }
-      } catch (err) {
-        throw new Error('preset ' + modulePath + ' could not be loaded: ' + err.message);
-      }
-    }
-
-    return this;
-  };
-};

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

@@ -1,162 +0,0 @@
-/*jshint node:true*/
-'use strict';
-
-var utils = require('../utils');
-
-
-/*
- *! Output-related methods
- */
-
-module.exports = function(proto) {
-  /**
-   * Add output
-   *
-   * @method FfmpegCommand#output
-   * @category Output
-   * @aliases addOutput
-   *
-   * @param {String|Writable} target target file path or writable stream
-   * @param {Object} [pipeopts={}] pipe options (only applies to streams)
-   * @return FfmpegCommand
-   */
-  proto.addOutput =
-  proto.output = function(target, pipeopts) {
-    var isFile = false;
-
-    if (!target && this._currentOutput) {
-      // No target is only allowed when called from constructor
-      throw new Error('Invalid output');
-    }
-
-    if (target && typeof target !== 'string') {
-      if (!('writable' in target) || !(target.writable)) {
-        throw new Error('Invalid output');
-      }
-    } else if (typeof target === 'string') {
-      var protocol = target.match(/^([a-z]{2,}):/i);
-      isFile = !protocol || protocol[0] === 'file';
-    }
-
-    if (target && !('target' in this._currentOutput)) {
-      // For backwards compatibility, set target for first output
-      this._currentOutput.target = target;
-      this._currentOutput.isFile = isFile;
-      this._currentOutput.pipeopts = pipeopts || {};
-    } else {
-      if (target && typeof target !== 'string') {
-        var hasOutputStream = this._outputs.some(function(output) {
-          return typeof output.target !== 'string';
-        });
-
-        if (hasOutputStream) {
-          throw new Error('Only one output stream is supported');
-        }
-      }
-
-      this._outputs.push(this._currentOutput = {
-        target: target,
-        isFile: isFile,
-        flags: {},
-        pipeopts: pipeopts || {}
-      });
-
-      var self = this;
-      ['audio', 'audioFilters', 'video', 'videoFilters', 'sizeFilters', 'options'].forEach(function(key) {
-        self._currentOutput[key] = utils.args();
-      });
-
-      if (!target) {
-        // Call from constructor: remove target key
-        delete this._currentOutput.target;
-      }
-    }
-
-    return this;
-  };
-
-
-  /**
-   * Specify output seek time
-   *
-   * @method FfmpegCommand#seek
-   * @category Input
-   * @aliases seekOutput
-   *
-   * @param {String|Number} seek seek time in seconds or as a '[hh:[mm:]]ss[.xxx]' string
-   * @return FfmpegCommand
-   */
-  proto.seekOutput =
-  proto.seek = function(seek) {
-    this._currentOutput.options('-ss', seek);
-    return this;
-  };
-
-
-  /**
-   * Set output duration
-   *
-   * @method FfmpegCommand#duration
-   * @category Output
-   * @aliases withDuration,setDuration
-   *
-   * @param {String|Number} duration duration in seconds or as a '[[hh:]mm:]ss[.xxx]' string
-   * @return FfmpegCommand
-   */
-  proto.withDuration =
-  proto.setDuration =
-  proto.duration = function(duration) {
-    this._currentOutput.options('-t', duration);
-    return this;
-  };
-
-
-  /**
-   * Set output format
-   *
-   * @method FfmpegCommand#format
-   * @category Output
-   * @aliases toFormat,withOutputFormat,outputFormat
-   *
-   * @param {String} format output format name
-   * @return FfmpegCommand
-   */
-  proto.toFormat =
-  proto.withOutputFormat =
-  proto.outputFormat =
-  proto.format = function(format) {
-    this._currentOutput.options('-f', format);
-    return this;
-  };
-
-
-  /**
-   * Add stream mapping to output
-   *
-   * @method FfmpegCommand#map
-   * @category Output
-   *
-   * @param {String} spec stream specification string, with optional square brackets
-   * @return FfmpegCommand
-   */
-  proto.map = function(spec) {
-    this._currentOutput.options('-map', spec.replace(utils.streamRegexp, '[$1]'));
-    return this;
-  };
-
-
-  /**
-   * Run flvtool2/flvmeta on output
-   *
-   * @method FfmpegCommand#flvmeta
-   * @category Output
-   * @aliases updateFlvMetadata
-   *
-   * @return FfmpegCommand
-   */
-  proto.updateFlvMetadata =
-  proto.flvmeta = function() {
-    this._currentOutput.flags.flvmeta = true;
-    return this;
-  };
-};