@psnext/slingcli 2.4.20260520-3 → 2.4.20260520-5

package/node_modules/fd-slicer/test/test.js

@@ -1,350 +0,0 @@
-var fdSlicer = require('../');
-var fs = require('fs');
-var crypto = require('crypto');
-var path = require('path');
-var streamEqual = require('stream-equal');
-var assert = require('assert');
-var Pend = require('pend');
-var StreamSink = require('streamsink');
-
-var describe = global.describe;
-var it = global.it;
-var before = global.before;
-var beforeEach = global.beforeEach;
-var after = global.after;
-
-var testBlobFile = path.join(__dirname, "test-blob.bin");
-var testBlobFileSize = 20 * 1024 * 1024;
-var testOutBlobFile = path.join(__dirname, "test-blob-out.bin");
-
-describe("FdSlicer", function() {
-  before(function(done) {
-    var out = fs.createWriteStream(testBlobFile);
-    for (var i = 0; i < testBlobFileSize / 1024; i += 1) {
-      out.write(crypto.pseudoRandomBytes(1024));
-    }
-    out.end();
-    out.on('close', done);
-  });
-  beforeEach(function() {
-    try {
-      fs.unlinkSync(testOutBlobFile);
-    } catch (err) {
-    }
-  });
-  after(function() {
-    try {
-      fs.unlinkSync(testBlobFile);
-      fs.unlinkSync(testOutBlobFile);
-    } catch (err) {
-    }
-  });
-  it("reads a 20MB file (autoClose on)", function(done) {
-    fs.open(testBlobFile, 'r', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      var actualStream = slicer.createReadStream();
-      var expectedStream = fs.createReadStream(testBlobFile);
-
-      var pend = new Pend();
-      pend.go(function(cb) {
-        slicer.on('close', cb);
-      });
-      pend.go(function(cb) {
-        streamEqual(expectedStream, actualStream, function(err, equal) {
-          if (err) return done(err);
-          assert.ok(equal);
-          cb();
-        });
-      });
-      pend.wait(done);
-    });
-  });
-  it("reads 4 chunks simultaneously", function(done) {
-    fs.open(testBlobFile, 'r', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd);
-      var actualPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
-      var actualPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
-      var actualPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
-      var actualPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
-      var expectedPart1 = slicer.createReadStream({start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
-      var expectedPart2 = slicer.createReadStream({start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
-      var expectedPart3 = slicer.createReadStream({start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
-      var expectedPart4 = slicer.createReadStream({start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
-      var pend = new Pend();
-      pend.go(function(cb) {
-        streamEqual(expectedPart1, actualPart1, function(err, equal) {
-          assert.ok(equal);
-          cb(err);
-        });
-      });
-      pend.go(function(cb) {
-        streamEqual(expectedPart2, actualPart2, function(err, equal) {
-          assert.ok(equal);
-          cb(err);
-        });
-      });
-      pend.go(function(cb) {
-        streamEqual(expectedPart3, actualPart3, function(err, equal) {
-          assert.ok(equal);
-          cb(err);
-        });
-      });
-      pend.go(function(cb) {
-        streamEqual(expectedPart4, actualPart4, function(err, equal) {
-          assert.ok(equal);
-          cb(err);
-        });
-      });
-      pend.wait(function(err) {
-        if (err) return done(err);
-        fs.close(fd, done);
-      });
-    });
-  });
-
-  it("writes a 20MB file (autoClose on)", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      var actualStream = slicer.createWriteStream();
-      var inStream = fs.createReadStream(testBlobFile);
-
-      slicer.on('close', function() {
-        var expected = fs.createReadStream(testBlobFile);
-        var actual = fs.createReadStream(testOutBlobFile);
-
-        streamEqual(expected, actual, function(err, equal) {
-          if (err) return done(err);
-          assert.ok(equal);
-          done();
-        });
-      });
-      inStream.pipe(actualStream);
-    });
-  });
-
-  it("writes 4 chunks simultaneously", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd);
-      var actualPart1 = slicer.createWriteStream({start: testBlobFileSize * 0/4});
-      var actualPart2 = slicer.createWriteStream({start: testBlobFileSize * 1/4});
-      var actualPart3 = slicer.createWriteStream({start: testBlobFileSize * 2/4});
-      var actualPart4 = slicer.createWriteStream({start: testBlobFileSize * 3/4});
-      var in1 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 0/4, end: testBlobFileSize * 1/4});
-      var in2 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 1/4, end: testBlobFileSize * 2/4});
-      var in3 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 2/4, end: testBlobFileSize * 3/4});
-      var in4 = fs.createReadStream(testBlobFile, {start: testBlobFileSize * 3/4, end: testBlobFileSize * 4/4});
-      var pend = new Pend();
-      pend.go(function(cb) {
-        actualPart1.on('finish', cb);
-      });
-      pend.go(function(cb) {
-        actualPart2.on('finish', cb);
-      });
-      pend.go(function(cb) {
-        actualPart3.on('finish', cb);
-      });
-      pend.go(function(cb) {
-        actualPart4.on('finish', cb);
-      });
-      in1.pipe(actualPart1);
-      in2.pipe(actualPart2);
-      in3.pipe(actualPart3);
-      in4.pipe(actualPart4);
-      pend.wait(function() {
-        fs.close(fd, function(err) {
-          if (err) return done(err);
-          var expected = fs.createReadStream(testBlobFile);
-          var actual = fs.createReadStream(testOutBlobFile);
-          streamEqual(expected, actual, function(err, equal) {
-            if (err) return done(err);
-            assert.ok(equal);
-            done();
-          });
-        });
-      });
-    });
-  });
-
-  it("throws on invalid ref", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      assert.throws(function() {
-        slicer.unref();
-      }, /invalid unref/);
-      fs.close(fd, done);
-    });
-  });
-
-  it("write stream emits error when max size exceeded", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      var ws = slicer.createWriteStream({start: 0, end: 1000});
-      ws.on('error', function(err) {
-        assert.strictEqual(err.code, 'ETOOBIG');
-        slicer.on('close', done);
-      });
-      ws.end(new Buffer(1001));
-    });
-  });
-
-  it("write stream does not emit error when max size not exceeded", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      var ws = slicer.createWriteStream({end: 1000});
-      slicer.on('close', done);
-      ws.end(new Buffer(1000));
-    });
-  });
-
-  it("write stream start and end work together", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      var ws = slicer.createWriteStream({start: 1, end: 1000});
-      ws.on('error', function(err) {
-        assert.strictEqual(err.code, 'ETOOBIG');
-        slicer.on('close', done);
-      });
-      ws.end(new Buffer(1000));
-    });
-  });
-
-  it("write stream emits progress events", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      var ws = slicer.createWriteStream();
-      var progressEventCount = 0;
-      var prevBytesWritten = 0;
-      ws.on('progress', function() {
-        progressEventCount += 1;
-        assert.ok(ws.bytesWritten > prevBytesWritten);
-        prevBytesWritten = ws.bytesWritten;
-      });
-      slicer.on('close', function() {
-        assert.ok(progressEventCount > 5);
-        done();
-      });
-      for (var i = 0; i < 10; i += 1) {
-        ws.write(new Buffer(16 * 1024 * 2));
-      }
-      ws.end();
-    });
-  });
-
-  it("write stream unrefs when destroyed", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      var ws = slicer.createWriteStream();
-      slicer.on('close', done);
-      ws.write(new Buffer(1000));
-      ws.destroy();
-    });
-  });
-
-  it("read stream unrefs when destroyed", function(done) {
-    fs.open(testBlobFile, 'r', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd, {autoClose: true});
-      var rs = slicer.createReadStream();
-      rs.on('error', function(err) {
-        assert.strictEqual(err.message, "stream destroyed");
-        slicer.on('close', done);
-      });
-      rs.destroy();
-    });
-  });
-
-  it("fdSlicer.read", function(done) {
-    fs.open(testBlobFile, 'r', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd);
-      var outBuf = new Buffer(1024);
-      slicer.read(outBuf, 0, 10, 0, function(err, bytesRead, buf) {
-        assert.strictEqual(bytesRead, 10);
-        fs.close(fd, done);
-      });
-    });
-  });
-
-  it("fdSlicer.write", function(done) {
-    fs.open(testOutBlobFile, 'w', function(err, fd) {
-      if (err) return done(err);
-      var slicer = fdSlicer.createFromFd(fd);
-      slicer.write(new Buffer("blah\n"), 0, 5, 0, function() {
-        if (err) return done(err);
-        fs.close(fd, done);
-      });
-    });
-  });
-});
-
-describe("BufferSlicer", function() {
-  it("invalid ref", function() {
-    var slicer = fdSlicer.createFromBuffer(new Buffer(16));
-    slicer.ref();
-    slicer.unref();
-    assert.throws(function() {
-      slicer.unref();
-    }, /invalid unref/);
-  });
-  it("read and write", function(done) {
-    var buf = new Buffer("through the tangled thread the needle finds its way");
-    var slicer = fdSlicer.createFromBuffer(buf);
-    var outBuf = new Buffer(1024);
-    slicer.read(outBuf, 10, 11, 8, function(err) {
-      if (err) return done(err);
-      assert.strictEqual(outBuf.toString('utf8', 10, 21), "the tangled");
-      slicer.write(new Buffer("derp"), 0, 4, 7, function(err) {
-        if (err) return done(err);
-        assert.strictEqual(buf.toString('utf8', 7, 19), "derp tangled");
-        done();
-      });
-    });
-  });
-  it("createReadStream", function(done) {
-    var str = "I never conquered rarely came, 16 just held such better days";
-    var buf = new Buffer(str);
-    var slicer = fdSlicer.createFromBuffer(buf);
-    var inStream = slicer.createReadStream();
-    var sink = new StreamSink();
-    inStream.pipe(sink);
-    sink.on('finish', function() {
-      assert.strictEqual(sink.toString(), str);
-      inStream.destroy();
-      done();
-    });
-  });
-  it("createWriteStream exceed buffer size", function(done) {
-    var slicer = fdSlicer.createFromBuffer(new Buffer(4));
-    var outStream = slicer.createWriteStream();
-    outStream.on('error', function(err) {
-      assert.strictEqual(err.code, 'ETOOBIG');
-      done();
-    });
-    outStream.write("hi!\n");
-    outStream.write("it warked\n");
-    outStream.end();
-  });
-  it("createWriteStream ok", function(done) {
-    var buf = new Buffer(1024);
-    var slicer = fdSlicer.createFromBuffer(buf);
-    var outStream = slicer.createWriteStream();
-    outStream.on('finish', function() {
-      assert.strictEqual(buf.toString('utf8', 0, "hi!\nit warked\n".length), "hi!\nit warked\n");
-      outStream.destroy();
-      done();
-    });
-    outStream.write("hi!\n");
-    outStream.write("it warked\n");
-    outStream.end();
-  });
-});

package/node_modules/file-type/core.d.ts

@@ -1,253 +0,0 @@
-/**
-Typings for primary entry point, Node.js specific typings can be found in index.d.ts
-*/
-
-import type {ReadableStream as WebReadableStream} from 'node:stream/web';
-import type {ITokenizer, AnyWebByteStream} from 'strtok3';
-
-/**
-Either the Node.js ReadableStream or the `lib.dom.d.ts` ReadableStream.
-Related issue: https://github.com/DefinitelyTyped/DefinitelyTyped/pull/60377
-*/
-export type AnyWebReadableStream<G> = WebReadableStream<G> | ReadableStream<G>;
-
-export type FileTypeResult = {
-	/**
-	One of the supported [file types](https://github.com/sindresorhus/file-type#supported-file-types).
-	*/
-	readonly ext: string;
-
-	/**
-	The detected [MIME type](https://en.wikipedia.org/wiki/Internet_media_type).
-	*/
-	readonly mime: string;
-};
-
-/**
-Detect the file type of a `Uint8Array` or `ArrayBuffer`.
-
-The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
-
-If file access is available, it is recommended to use `.fromFile()` instead.
-
-@param buffer - An Uint8Array or ArrayBuffer representing file data. It works best if the buffer contains the entire file. It may work with a smaller portion as well.
-@param options - Options to override default behavior.
-@returns The detected file type, or `undefined` when there is no match.
-*/
-export function fileTypeFromBuffer(buffer: Uint8Array | ArrayBuffer, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
-
-/**
-Detect the file type of a [web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream).
-
-The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
-
-@param stream - A [web `ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) streaming a file to examine.
-@param options - Options to override default behavior.
-@returns A `Promise` for an object with the detected file type, or `undefined` when there is no match.
-*/
-export function fileTypeFromStream(stream: AnyWebByteStream, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
-
-/**
-Detect the file type from an [`ITokenizer`](https://github.com/Borewit/strtok3#tokenizer) source.
-
-This method is used internally, but can also be used for a special "tokenizer" reader.
-
-A tokenizer propagates the internal read functions, allowing alternative transport mechanisms, to access files, to be implemented and used.
-
-@param tokenizer - File source implementing the tokenizer interface.
-@param options - Options to override default behavior.
-@returns The detected file type, or `undefined` when there is no match.
-
-An example is [`@tokenizer/http`](https://github.com/Borewit/tokenizer-http), which requests data using [HTTP-range-requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests). A difference with a conventional stream and the [*tokenizer*](https://github.com/Borewit/strtok3#tokenizer), is that it is able to *ignore* (seek, fast-forward) in the stream. For example, you may only need and read the first 6 bytes, and the last 128 bytes, which may be an advantage in case reading the entire file would take longer.
-
-@example
-```
-import {makeTokenizer} from '@tokenizer/http';
-import {fileTypeFromTokenizer} from 'file-type';
-
-const audioTrackUrl = 'https://test-audio.netlify.com/Various%20Artists%20-%202009%20-%20netBloc%20Vol%2024_%20tiuqottigeloot%20%5BMP3-V2%5D/01%20-%20Diablo%20Swing%20Orchestra%20-%20Heroines.mp3';
-
-const httpTokenizer = await makeTokenizer(audioTrackUrl);
-const fileType = await fileTypeFromTokenizer(httpTokenizer);
-
-console.log(fileType);
-//=> {ext: 'mp3', mime: 'audio/mpeg'}
-```
-*/
-export function fileTypeFromTokenizer(tokenizer: ITokenizer, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
-
-/**
-Supported file extensions.
-*/
-export const supportedExtensions: ReadonlySet<string>;
-
-/**
-Supported MIME types.
-*/
-export const supportedMimeTypes: ReadonlySet<string>;
-
-export type StreamOptions = {
-	/**
-	The default sample size in bytes.
-
-	@default 4100
-	*/
-	readonly sampleSize?: number;
-};
-
-/**
-Detect the file type of a [`Blob`](https://nodejs.org/api/buffer.html#class-blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).
-
-@param blob - The [`Blob`](https://nodejs.org/api/buffer.html#class-blob) used for file detection.
-@param options - Options to override default behavior.
-@returns The detected file type, or `undefined` when there is no match.
-
-@example
-```
-import {fileTypeFromBlob} from 'file-type';
-
-const blob = new Blob(['<?xml version="1.0" encoding="ISO-8859-1" ?>'], {
-	type: 'text/plain',
-	endings: 'native'
-});
-
-console.log(await fileTypeFromBlob(blob));
-//=> {ext: 'txt', mime: 'text/plain'}
-```
-*/
-export declare function fileTypeFromBlob(blob: Blob, options?: FileTypeOptions): Promise<FileTypeResult | undefined>;
-
-/**
-A custom file type detector.
-
-Custom file type detectors are plugins designed to extend the default detection capabilities.
-They allow support for uncommon file types, non-binary formats, or customized detection behavior.
-
-Detectors can be added via the constructor options or by modifying `FileTypeParser#detectors` directly.
-Detectors provided through the constructor are executed before the default ones.
-
-Detectors can be added via the constructor options or by directly modifying `FileTypeParser#detectors`.
-
-### Example adding a detector
-
-```js
-import {FileTypeParser} from 'file-type';
-import {detectXml} from '@file-type/xml';
-
-const parser = new FileTypeParser({customDetectors: [detectXml]});
-const fileType = await parser.fromFile('sample.kml');
-console.log(fileType);
-```
-
-### Available-third party file-type detectors
-
-- [@file-type/xml](https://github.com/Borewit/file-type-xml): Detects common XML file types, such as GLM, KML, MusicXML, RSS, SVG, and XHTML
-
-### Detector execution flow
-
-If a detector returns `undefined`, the following rules apply:
-
-1. **No Tokenizer Interaction**: If the detector does not modify the tokenizer's position, the next detector in the sequence is executed.
-2. **Tokenizer Interaction**: If the detector modifies the tokenizer's position (`tokenizer.position` is advanced), no further detectors are executed. In this case, the file type remains `undefined`, as subsequent detectors cannot evaluate the content. This is an exceptional scenario, as it prevents any other detectors from determining the file type.
-
-### Example writing a custom detector
-
-Below is an example of a custom detector array. This can be passed to the `FileTypeParser` via the `fileTypeOptions` argument.
-
-```
-import {FileTypeParser} from 'file-type';
-
-const customDetectors = [
-	async tokenizer => {
-		const unicornHeader = [85, 78, 73, 67, 79, 82, 78]; // "UNICORN" in ASCII decimal
-
-		const buffer = new Uint8Array(unicornHeader.length);
-		await tokenizer.peekBuffer(buffer, {length: unicornHeader.length, mayBeLess: true});
-		if (unicornHeader.every((value, index) => value === buffer[index])) {
-			return {ext: 'unicorn', mime: 'application/unicorn'};
-		}
-
-		return undefined;
-	},
-];
-
-const buffer = new Uint8Array([85, 78, 73, 67, 79, 82, 78]);
-const parser = new FileTypeParser({customDetectors});
-const fileType = await parser.fromBuffer(buffer);
-console.log(fileType); // {ext: 'unicorn', mime: 'application/unicorn'}
-```
-
-@param tokenizer - The [tokenizer](https://github.com/Borewit/strtok3#tokenizer) used to read file content.
-@param fileType - The file type detected by standard or previous custom detectors, or `undefined` if no match is found.
-@returns The detected file type, or `undefined` if no match is found.
-*/
-export type Detector = {
-	id: string;
-	detect: (tokenizer: ITokenizer, fileType?: FileTypeResult) => Promise<FileTypeResult | undefined>;
-};
-
-export type FileTypeOptions = {
-	customDetectors?: Iterable<Detector>;
-
-	/**
-	Specifies the byte tolerance for locating the first MPEG audio frame (e.g. `.mp1`, `.mp2`, `.mp3`, `.aac`).
-
-	Allows detection to handle slight sync offsets between the expected and actual frame start. Common in malformed or incorrectly muxed files, which, while technically invalid, do occur in the wild.
-
-	A tolerance of 10 bytes covers most cases.
-
- 	@default 0
-	*/
-	mpegOffsetTolerance?: number;
-};
-
-export declare class TokenizerPositionError extends Error {
-	constructor(message?: string);
-}
-
-export type AnyWebReadableByteStreamWithFileType = AnyWebReadableStream<Uint8Array> & {
-	readonly fileType?: FileTypeResult;
-};
-
-/**
-Workaround for using `bundler` as the module-resolution in TypeScript.
-*/
-export function fileTypeFromFile(filePath: string, options?: {customDetectors?: Iterable<Detector>}): Promise<FileTypeResult | undefined>;
-
-/**
-Returns a `Promise` which resolves to the original readable stream argument, but with an added `fileType` property, which is an object like the one returned from `fileTypeFromFile()`.
-
-This method can be handy to put in a stream pipeline, but it comes with a price. Internally `stream()` builds up a buffer of `sampleSize` bytes, used as a sample, to determine the file type. The sample size impacts the file detection resolution. A smaller sample size will result in lower probability of the best file type detection.
-*/
-export function fileTypeStream(webStream: AnyWebReadableStream<Uint8Array>, options?: StreamOptions): Promise<AnyWebReadableByteStreamWithFileType>;
-
-export declare class FileTypeParser {
-	/**
-	File type detectors.
-
-	Initialized with a single entry holding the built-in detector function.
-	*/
-	detectors: Detector[];
-
-	constructor(options?: {customDetectors?: Iterable<Detector>; signal?: AbortSignal});
-
-	/**
-	Works the same way as {@link fileTypeFromBuffer}, additionally taking into account custom detectors (if any were provided to the constructor).
-	*/
-	fromBuffer(buffer: Uint8Array | ArrayBuffer): Promise<FileTypeResult | undefined>;
-
-	/**
-	Works the same way as {@link fileTypeFromTokenizer}, additionally taking into account custom detectors (if any were provided to the constructor).
-	*/
-	fromTokenizer(tokenizer: ITokenizer): Promise<FileTypeResult | undefined>;
-
-	/**
-	Works the same way as {@link fileTypeFromBlob}, additionally taking into account custom detectors (if any were provided to the constructor).
-	*/
-	fromBlob(blob: Blob): Promise<FileTypeResult | undefined>;
-
-	/**
-	Works the same way as {@link fileTypeStream}, additionally taking into account custom detectors (if any were provided to the constructor).
-	*/
-	toDetectionStream(webStream: AnyWebReadableStream<Uint8Array>, options?: StreamOptions): Promise<AnyWebReadableByteStreamWithFileType>;
-}