@tickernelz/paperclip-pro-adapter-utils 2026.925.0

package/node_modules/streamx/lib/errors.d.ts

@@ -0,0 +1,13 @@
+declare class StreamError extends Error {
+  readonly code: string
+
+  static isStreamDestroyed(err: Error | null): boolean
+  static isPrematureClose(err: Error | null): boolean
+  static isAborted(err: Error | null): boolean
+
+  static STREAM_DESTROYED(): StreamError
+  static PREMATURE_CLOSE(): StreamError
+  static ABORTED(): StreamError
+}
+
+export = StreamError

package/node_modules/streamx/lib/errors.js

@@ -0,0 +1,47 @@
+module.exports = class StreamError extends Error {
+  constructor(msg, code, fn = StreamError) {
+    super(msg)
+
+    this.code = code
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, fn)
+    }
+  }
+
+  static isStreamDestroyed(err) {
+    return err && err.code === 'STREAM_DESTROYED'
+  }
+
+  static isPrematureClose(err) {
+    return err && err.code === 'PREMATURE_CLOSE'
+  }
+
+  static isAborted(err) {
+    return err && err.code === 'ABORTED'
+  }
+
+  static isBadArgument(err) {
+    return err && err.code === 'BAD_ARGUMENT'
+  }
+
+  get name() {
+    return 'StreamError'
+  }
+
+  static STREAM_DESTROYED() {
+    return new StreamError('Stream was destroyed', 'STREAM_DESTROYED', StreamError.STREAM_DESTROYED)
+  }
+
+  static PREMATURE_CLOSE(msg = 'Premature close') {
+    return new StreamError(msg, 'PREMATURE_CLOSE', StreamError.PREMATURE_CLOSE)
+  }
+
+  static ABORTED() {
+    return new StreamError('Stream aborted', 'ABORTED', StreamError.ABORTED)
+  }
+
+  static BAD_ARGUMENT(msg = 'Bad argument') {
+    return new StreamError(msg, 'BAD_ARGUMENT', StreamError.BAD_ARGUMENT)
+  }
+}

package/node_modules/streamx/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "streamx",
+  "version": "2.28.1",
+  "description": "An iteration of the Node.js core streams with a series of improvements",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package": "./package.json",
+    "./errors": {
+      "types": "./lib/errors.d.ts",
+      "default": "./lib/errors"
+    }
+  },
+  "dependencies": {
+    "events-universal": "^1.0.0",
+    "fast-fifo": "^1.3.2",
+    "text-decoder": "^1.1.0"
+  },
+  "devDependencies": {
+    "b4a": "^1.6.6",
+    "brittle": "^3.1.1",
+    "end-of-stream": "^1.4.4",
+    "lunte": "^1.8.0",
+    "prettier": "^3.6.2",
+    "prettier-config-holepunch": "^2.0.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "runtime.d.ts",
+    "lib"
+  ],
+  "scripts": {
+    "format": "prettier . --write",
+    "test": "brittle test/all.js && brittle-bare test/all.js",
+    "lint": "prettier . --check && lunte"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mafintosh/streamx.git"
+  },
+  "author": "Mathias Buus (@mafintosh)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mafintosh/streamx/issues"
+  },
+  "homepage": "https://github.com/mafintosh/streamx"
+}

package/node_modules/streamx/runtime.d.ts

@@ -0,0 +1,55 @@
+type BufferEncoding =
+  | 'ascii'
+  | 'base64'
+  | 'binary'
+  | 'hex'
+  | 'latin1'
+  | 'ucs-2'
+  | 'ucs2'
+  | 'utf-16le'
+  | 'utf-8'
+  | 'utf16le'
+  | 'utf8'
+
+interface EventMap {
+  [event: string | symbol]: unknown[]
+}
+
+interface EventHandler<in A extends unknown[] = unknown[], out R = unknown> {
+  (...args: A): R
+}
+
+interface EventEmitter<in out M extends EventMap = EventMap> {
+  addListener<E extends keyof M, R>(name: E, fn: EventHandler<M[E], R>): this
+
+  addOnceListener<E extends keyof M, R>(name: E, fn: EventHandler<M[E], R>): this
+
+  prependListener<E extends keyof M, R>(name: E, fn: EventHandler<M[E], R>): this
+
+  prependOnceListener<E extends keyof M, R>(name: E, fn: EventHandler<M[E], R>): this
+
+  removeListener<E extends keyof M, R>(name: E, fn: EventHandler<M[E], R>): this
+
+  removeAllListeners<E extends keyof M>(name?: E): this
+
+  on<E extends keyof M, R>(name: E, fn: EventHandler<M[E], R>): this
+
+  once<E extends keyof M, R>(name: E, fn: EventHandler<M[E], R>): this
+
+  off<E extends keyof M, R>(name: E, fn: EventHandler<M[E], R>): this
+
+  emit<E extends keyof M>(name: E, ...args: M[E]): boolean
+
+  listeners<E extends keyof M, R>(name: E): EventHandler<M[E], R>[]
+
+  rawListeners<E extends keyof M, R>(name: E): EventHandler<M[E], R>[]
+
+  eventNames(): (string | symbol)[]
+
+  listenerCount<E extends keyof M>(name: E): number
+
+  getMaxListeners(): number
+  setMaxListeners(n: number): this
+}
+
+export { BufferEncoding, EventMap, EventEmitter }

package/node_modules/tar-stream/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mathias Buus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/tar-stream/README.md

@@ -0,0 +1,183 @@
+# tar-stream
+
+tar-stream is a streaming tar parser and generator and nothing else. It operates purely using streams which means you can easily extract/parse tarballs without ever hitting the file system.
+
+Note that you still need to gunzip your data if you have a `.tar.gz`. We recommend using [gunzip-maybe](https://github.com/mafintosh/gunzip-maybe) in conjunction with this.
+
+```
+npm install tar-stream
+```
+
+[![build status](https://secure.travis-ci.org/mafintosh/tar-stream.png)](http://travis-ci.org/mafintosh/tar-stream)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)
+
+## Usage
+
+tar-stream exposes two streams, [pack](https://github.com/mafintosh/tar-stream#packing) which creates tarballs and [extract](https://github.com/mafintosh/tar-stream#extracting) which extracts tarballs. To [modify an existing tarball](https://github.com/mafintosh/tar-stream#modifying-existing-tarballs) use both.
+
+
+It implementes USTAR with additional support for pax extended headers. It should be compatible with all popular tar distributions out there (gnutar, bsdtar etc)
+
+## Related
+
+If you want to pack/unpack directories on the file system check out [tar-fs](https://github.com/mafintosh/tar-fs) which provides file system bindings to this module.
+
+## Packing
+
+To create a pack stream use `tar.pack()` and call `pack.entry(header, [callback])` to add tar entries.
+
+``` js
+const tar = require('tar-stream')
+const pack = tar.pack() // pack is a stream
+
+// add a file called my-test.txt with the content "Hello World!"
+pack.entry({ name: 'my-test.txt' }, 'Hello World!')
+
+// add a file called my-stream-test.txt from a stream
+const entry = pack.entry({ name: 'my-stream-test.txt', size: 11 }, function(err) {
+  // the stream was added
+  // no more entries
+  pack.finalize()
+})
+
+entry.write('hello')
+entry.write(' ')
+entry.write('world')
+entry.end()
+
+// pipe the pack stream somewhere
+pack.pipe(process.stdout)
+```
+
+## Extracting
+
+To extract a stream use `tar.extract()` and listen for `extract.on('entry', (header, stream, next) )`
+
+``` js
+const extract = tar.extract()
+
+extract.on('entry', function (header, stream, next) {
+  // header is the tar header
+  // stream is the content body (might be an empty stream)
+  // call next when you are done with this entry
+
+  stream.on('end', function () {
+    next() // ready for next entry
+  })
+
+  stream.resume() // just auto drain the stream
+})
+
+extract.on('finish', function () {
+  // all entries read
+})
+
+pack.pipe(extract)
+```
+
+The tar archive is streamed sequentially, meaning you **must** drain each entry's stream as you get them or else the main extract stream will receive backpressure and stop reading.
+
+## Extracting as an async iterator
+
+The extraction stream in addition to being a writable stream is also an async iterator
+
+``` js
+const extract = tar.extract()
+
+someStream.pipe(extract)
+
+for await (const entry of extract) {
+  entry.header // the tar header
+  entry.resume() // the entry is the stream also
+}
+```
+
+## Headers
+
+The header object using in `entry` should contain the following properties.
+Most of these values can be found by stat'ing a file.
+
+``` js
+{
+  name: 'path/to/this/entry.txt',
+  size: 1314,        // entry size. defaults to 0
+  mode: 0o644,       // entry mode. defaults to to 0o755 for dirs and 0o644 otherwise
+  mtime: new Date(), // last modified date for entry. defaults to now.
+  type: 'file',      // type of entry. defaults to file. can be:
+                     // file | link | symlink | directory | block-device
+                     // character-device | fifo | contiguous-file
+  linkname: 'path',  // linked file name
+  uid: 0,            // uid of entry owner. defaults to 0
+  gid: 0,            // gid of entry owner. defaults to 0
+  uname: 'maf',      // uname of entry owner. defaults to null
+  gname: 'staff',    // gname of entry owner. defaults to null
+  devmajor: 0,       // device major version. defaults to 0
+  devminor: 0        // device minor version. defaults to 0
+}
+```
+
+## Modifying existing tarballs
+
+Using tar-stream it is easy to rewrite paths / change modes etc in an existing tarball.
+
+``` js
+const extract = tar.extract()
+const pack = tar.pack()
+const path = require('path')
+
+extract.on('entry', function (header, stream, callback) {
+  // let's prefix all names with 'tmp'
+  header.name = path.join('tmp', header.name)
+  // write the new entry to the pack stream
+  stream.pipe(pack.entry(header, callback))
+})
+
+extract.on('finish', function () {
+  // all entries done - lets finalize it
+  pack.finalize()
+})
+
+// pipe the old tarball to the extractor
+oldTarballStream.pipe(extract)
+
+// pipe the new tarball the another stream
+pack.pipe(newTarballStream)
+```
+
+## Saving tarball to fs
+
+
+``` js
+const fs = require('fs')
+const tar = require('tar-stream')
+
+const pack = tar.pack() // pack is a stream
+const path = 'YourTarBall.tar'
+const yourTarball = fs.createWriteStream(path)
+
+// add a file called YourFile.txt with the content "Hello World!"
+pack.entry({ name: 'YourFile.txt' }, 'Hello World!', function (err) {
+  if (err) throw err
+  pack.finalize()
+})
+
+// pipe the pack stream to your file
+pack.pipe(yourTarball)
+
+yourTarball.on('close', function () {
+  console.log(path + ' has been written')
+  fs.stat(path, function(err, stats) {
+    if (err) throw err
+    console.log(stats)
+    console.log('Got file info successfully!')
+  })
+})
+```
+
+## Performance
+
+[See tar-fs for a performance comparison with node-tar](https://github.com/mafintosh/tar-fs/blob/master/README.md#performance)
+
+# License
+
+MIT

package/node_modules/tar-stream/constants.js

@@ -0,0 +1,14 @@
+const constants = { // just for envs without fs
+  S_IFMT: 61440,
+  S_IFDIR: 16384,
+  S_IFCHR: 8192,
+  S_IFBLK: 24576,
+  S_IFIFO: 4096,
+  S_IFLNK: 40960
+}
+
+try {
+  module.exports = require('fs').constants || constants
+} catch {
+  module.exports = constants
+}