appium-mac2-driver 4.3.5 → 4.3.6

package/node_modules/stream-buffers/.codeclimate.yml

@@ -0,0 +1,12 @@
+---
+engines:
+  eslint:
+    enabled: true
+  fixme:
+    enabled: true
+ratings:
+  paths:
+  - "**.js"
+exclude_paths:
+- node_modules/**/*
+- test/**/*

package/node_modules/stream-buffers/.eslintignore

@@ -0,0 +1 @@
+coverage/

package/node_modules/stream-buffers/.eslintrc

@@ -0,0 +1,25 @@
+{
+  "rules": {
+    "indent": [
+      2,
+      2
+    ],
+    "quotes": [
+      2,
+      "single"
+    ],
+    "linebreak-style": [
+      2,
+      "unix"
+    ],
+    "semi": [
+      2,
+      "always"
+    ]
+  },
+  "env": {
+    "node": true,
+    "mocha": true
+  },
+  "extends": "eslint:recommended"
+}

package/node_modules/stream-buffers/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '41 19 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

package/node_modules/stream-buffers/.github/workflows/node.js.yml

@@ -0,0 +1,31 @@
+# This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [22.x, 20.x, 18.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test

package/node_modules/stream-buffers/.mailmap

@@ -1,2 +1,3 @@
 Sam Day <sam.c.day@gmail.com>
 Sam Day <me@samcday.com.au>
+Sam Day <me@samcday.com>

package/node_modules/stream-buffers/.nvmrc

@@ -0,0 +1 @@
+v8.4

package/node_modules/stream-buffers/README.md

@@ -1,39 +1,40 @@
 # Node Stream Buffers
 
-[![Build Status][badge-travis-img]][badge-travis-url]
-[![Code Climate][badge-climate-img]][badge-climate-url]
-[![Code Coverage][badge-coverage-img]][badge-coverage-url]
+[![Build Status][badge-actions-img]][badge-actions-url]
+[![npm][badge-npm-img]][badge-npm-url]
 
-Simple Readable and Writable Streams that use a [Buffer][node-buffer-docs] to store received data, or for data to send out. Useful for test code, debugging, and a wide range of other utilities.
+**!! Consider using [Node 16+ Utility Consumers](https://nodejs.org/dist/latest-v16.x/docs/api/webstreams.html#utility-consumers) rather than this library. !!**
 
-## Installation
+Simple Readable and Writable Streams that use a [Buffer][node-buffer-docs] to store received data, or for data to send out. Useful for test code, debugging, and a wide range of other utilities.
 
-[![NPM][badge-npm-img]][badge-npm-url]
+```
+npm install stream-buffers --save
+```
 
 ## Usage
 
 To use the stream buffers in your module, simply import it and away you go.
 
 ```js
-var streamBuffers = require("stream-buffers");
+var streamBuffers = require('stream-buffers');
 ```
 
-### Writable StreamBuffer
+### WritableStreamBuffer
 
-Writable Stream Buffers implement the standardized writable stream interface. All write()'s to this object will accumulate in an internal Buffer. If the Buffer overflows it will be resized larger automatically. The initial size of the Buffer and the amount in which it grows can be configured in the constructor.
+`WritableStreamBuffer` implements the standard [`stream.Writable`](https://nodejs.org/api/stream.html#stream_class_stream_writable) interface. All writes to this stream will accumulate in an internal [`Buffer`](https://nodejs.org/api/buffer.html). If the internal buffer overflows it will be resized automatically. The initial size of the Buffer and the amount in which it grows can be configured in the constructor.
 
 ```js
 var myWritableStreamBuffer = new streamBuffers.WritableStreamBuffer({
-	initialSize: (100 * 1024),		// start as 100 kilobytes.
-	incrementAmount: (10 * 1024)	// grow by 10 kilobytes each time buffer overflows.
+	initialSize: (100 * 1024),   // start at 100 kilobytes.
+	incrementAmount: (10 * 1024) // grow by 10 kilobytes each time buffer overflows.
 });
 ```
 
 The default initial size and increment amount are stored in the following constants:
 
 ```js
-streamBuffers.DEFAULT_INITIAL_SIZE 		// (8 * 1024)
-streamBuffers.DEFAULT_INCREMENT_AMOUNT	// (8 * 1024)
+streamBuffers.DEFAULT_INITIAL_SIZE      // (8 * 1024)
+streamBuffers.DEFAULT_INCREMENT_AMOUNT  // (8 * 1024)
 ```
 
 Writing is standard Stream stuff:
@@ -41,117 +42,116 @@ Writing is standard Stream stuff:
 ```js
 myWritableStreamBuffer.write(myBuffer);
 // - or -
-myWritableStreamBuffer.write("\u00bd + \u00bc = \u00be", "utf8");
+myWritableStreamBuffer.write('\u00bd + \u00bc = \u00be', 'utf8');
 ```
 
 You can query the size of the data being held in the Buffer, and also how big the Buffer's max capacity currently is: 
 
 ```js
-myWritableStreamBuffer.write("ASDF");
-streamBuffers.size();			// 4.
-streamBuffers.maxSize();		// Whatever was configured as initial size. In our example: (100 * 1024).
+myWritableStreamBuffer.write('ASDF');
+streamBuffers.size();     // 4.
+streamBuffers.maxSize();  // Whatever was configured as initial size. In our example: (100 * 1024).
 ```
 
-Retrieving the contents of the Buffer is simple:
+Retrieving the contents of the Buffer is simple.
 
 ```js
-myWritableStreamBuffer.getContents();					// Gets all held data as a Buffer.
-myWritableStreamBuffer.getContentsAsString("utf8");		// Gets all held data as a utf8 string.
-myWritableStreamBuffer.getContents(5);					// Gets first 5 bytes as a Buffer.
-myWritableStreamBuffer.getContentsAsString("utf8", 5);	// Gets first 5 bytes as a utf8 string.
+// Gets all held data as a Buffer.
+myWritableStreamBuffer.getContents();
+
+// Gets all held data as a utf8 string.
+myWritableStreamBuffer.getContentsAsString('utf8');
+
+// Gets first 5 bytes as a Buffer.
+myWritableStreamBuffer.getContents(5);
+
+// Gets first 5 bytes as a utf8 string.
+myWritableStreamBuffer.getContentsAsString('utf8', 5);
 ```
 
-Care should be taken when getting encoded strings from WritableStream, as it doesn't really care about the contents (multi-byte characters will not be respected).
- 
-Destroying or ending the WritableStream will not delete the contents of Buffer, but will disallow any further writes:
+**Care should be taken when getting encoded strings from WritableStream, as it doesn't really care about the contents (multi-byte characters will not be respected).**
 
-```js
-myWritableStreamBuffer.write("ASDF");
-myWritableStreamBuffer.destroy();
+Destroying or ending the WritableStream will not delete the contents of Buffer, but will disallow any further writes.
 
-myWritableStreamBuffer.getContents();		// Returns ASDF in Buffer.
-myWritableStreamBuffer.write("Yeah?");		// No effect.
+```js
+myWritableStreamBuffer.write('ASDF');
+myWritableStreamBuffer.end();
+myWritableStreamBuffer.getContentsAsString(); // -> 'ASDF'
 ```	
 
-### Readable StreamBuffer
+### ReadableStreamBuffer
 
-Readable Stream Buffers can have data inserted in them, which will then be pumped out via standard readable stream data events. The data to be sent out is held in a Buffer, which can grow in much the same way as a WritableStream Buffer does, if data is being put in Buffer faster than it's being pumped out. 
+`ReadableStreamBuffer` implements the standard [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable), but can have data inserted into it. This data will then be pumped out in chunks as readable events. The data to be sent out is held in a Buffer, which can grow in much the same way as a `WritableStreamBuffer` does, if data is being put in Buffer faster than it is being pumped out. 
 
-The frequency in which chunks are pumped out, and the size of the chunks themselves can be configured in the constructor. The initial size and increment amount of internal Buffer can be configured too.
+The frequency in which chunks are pumped out, and the size of the chunks themselves can be configured in the constructor. The initial size and increment amount of internal Buffer can be configured too. In the following example 2kb chunks will be output every 10 milliseconds:
 
 ```js
 var myReadableStreamBuffer = new streamBuffers.ReadableStreamBuffer({
-	frequency: 10,		// in milliseconds.
-	chunkSize: 2048		// in bytes.
+	frequency: 10,   // in milliseconds.
+	chunkSize: 2048  // in bytes.
 });
 ```
 
 Default frequency and chunk size:
 
 ```js
-streamBuffers.DEFAULT_CHUNK_SIZE 		// (1024)
-streamBuffers.DEFAULT_FREQUENCY			// (1)
+streamBuffers.DEFAULT_CHUNK_SIZE  // (1024)
+streamBuffers.DEFAULT_FREQUENCY   // (1)
 ```
 
 Putting data in Buffer to be pumped out is easy:
 
 ```js
 myReadableStreamBuffer.put(aBuffer);
-myReadableStreamBuffer.put("A String", "utf8");
+myReadableStreamBuffer.put('A String', 'utf8');
 ```
 
-Chunks are pumped out via standard readable stream spec: 
+Chunks are pumped out via standard `stream.Readable` semantics. This means you can use the old streams1 way:
 
 ```js
-myReadableStreamBuffer.on("data", function(data) {
-	// Yup.
-	assert.isTrue(data instanceof Buffer);
+myReadableStreamBuffer.on('data', function(data) {
+  // streams1.x style data
+  assert.isTrue(data instanceof Buffer);
 });
 ```
 
-Chunks are pumped out by the interval that you specified in frequency. Setting the frequency to 0 will immediately stream the data (also in chunks), even if the stream has not been piped to a destination. This is useful for unit testing. 
-
-setEncoding() for streams is respected too:
+Or the streams2+ way:
 
 ```js
-myReadableStreamBuffer.setEncoding("utf8");
-myReadableStreamBuffer.on("data", function(data) {
-	assert.isTrue(data instanceof String);
+myReadableStreamBuffer.on('readable', function(data) {
+  var chunk;
+  while((chunk = myReadableStreamBuffer.read()) !== null) {
+    assert.isTrue(chunk instanceof Buffer);
+  }
 });
 ```
 
-Pause and resume are also implemented. pause()'ing stream will allow buffer to continue accumulating, but will not pump any of that data out until it is resume()'d again. 
+Because `ReadableStreamBuffer` is simply an implementation of [`stream.Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable), it implements pause / resume / setEncoding / etc.
 
-Destroying the stream will immediately purge the buffer, unless destroySoon() is called, in which case the rest of the buffer will be written out. Either way, any further attempts to put data in the Buffer will be silently ignored. 
+Once you're done putting data into a `ReadableStreamBuffer`, you can call `stop()` on it.
 
 ```js
-myReadableStreamBuffer.destroySoon();
-myReadableStreamBuffer.put("A String!");
-myReadableStreamBuffer.size();			// will be 0.
+myReadableStreamBuffer.put('the last data this stream will ever see');
+myReadableStreamBuffer.stop();
 ```
 
+Once the `ReadableStreamBuffer` is done pumping out the data in its internal buffer, it will emit the usual [`end`](https://nodejs.org/api/stream.html#stream_event_end) event. You cannot write any more data to the stream once you've called `stop()` on it.
+
 ## Disclaimer
 
 Not supposed to be a speed demon, it's more for tests/debugging or weird edge cases. It works with an internal buffer that it copies contents to/from/around.
 
 ## Contributors
 
-Thanks to the following people for taking some time to contribute to this project.
-
- * Igor Dralyuk <idralyuk@ebay.com>
- * Simon Koudijs <simon.koudijs@intellifi.nl>
+Thank you to all the [wonderful contributors](https://github.com/samcday/node-stream-buffer/graphs/contributors) who have kept this package alive throughout the years.
 
 ## License
 
 node-stream-buffer is free and unencumbered public domain software. For more information, see the accompanying UNLICENSE file.
 
-[badge-travis-img]: http://img.shields.io/travis/samcday/node-stream-buffer.svg?style=flat-square
-[badge-travis-url]: https://travis-ci.org/samcday/node-stream-buffer
-[badge-climate-img]: http://img.shields.io/codeclimate/github/samcday/node-stream-buffer.svg?style=flat-square
-[badge-climate-url]: https://codeclimate.com/github/samcday/node-stream-buffer
-[badge-coverage-img]: http://img.shields.io/codeclimate/coverage/github/samcday/node-stream-buffer.svg?style=flat-square
-[badge-coverage-url]: https://codeclimate.com/github/samcday/node-stream-buffer
-[badge-npm-img]: https://nodei.co/npm/stream-buffers.png?downloads=true&downloadRank=true&stars=true
-[badge-npm-url]: https://npmjs.org/package/stream-buffers
+[badge-actions-img]: https://github.com/samcday/node-stream-buffer/actions/workflows/node.js.yml/badge.svg
+[badge-actions-url]: https://github.com/samcday/node-stream-buffer/actions/workflows/node.js.yml
+[badge-npm-img]: https://img.shields.io/npm/dm/stream-buffers.svg
+[badge-npm-url]: https://www.npmjs.org/package/stream-buffers
 
 [node-buffer-docs]: http://nodejs.org/api/buffer.html

package/node_modules/stream-buffers/lib/constants.js

@@ -1,6 +1,8 @@
-module.exports = {
-	DEFAULT_INITIAL_SIZE: (8 * 1024),
-	DEFAULT_INCREMENT_AMOUNT: (8 * 1024),
-	DEFAULT_FREQUENCY: 1,
-	DEFAULT_CHUNK_SIZE: 1024
-};
+'use strict';
+
+module.exports = {
+  DEFAULT_INITIAL_SIZE: (8 * 1024),
+  DEFAULT_INCREMENT_AMOUNT: (8 * 1024),
+  DEFAULT_FREQUENCY: 1,
+  DEFAULT_CHUNK_SIZE: 1024
+};

package/node_modules/stream-buffers/lib/readable_streambuffer.js

@@ -1,136 +1,114 @@
-var stream = require("stream"),
-	constants = require("./constants"),
-	util = require("util");
-
-var ReadableStreamBuffer = module.exports = function(opts) {
-	var that = this;
-
-	stream.Stream.call(this);
-
-	opts = opts || {};
-	var frequency = opts.hasOwnProperty("frequency") ? opts.frequency : constants.DEFAULT_FREQUENCY;
-	var chunkSize = opts.chunkSize || constants.DEFAULT_CHUNK_SIZE;
-	var initialSize = opts.initialSize || constants.DEFAULT_INITIAL_SIZE;
-	var incrementAmount = opts.incrementAmount || constants.DEFAULT_INCREMENT_AMOUNT;
-
-	var size = 0;
-	var buffer = new Buffer(initialSize);
-	var encoding = null;
-
-	this.readable = true;
-	this.writable = false;
-
-	var sendData = function() {
-		var amount = Math.min(chunkSize, size);
-
-		if (amount > 0) {
-			var chunk = null;
-			if(encoding) {
-				chunk = buffer.toString(encoding, 0, amount);
-			}
-			else {
-				chunk = new Buffer(amount);
-				buffer.copy(chunk, 0, 0, amount);
-			}
-
-			that.emit("data", chunk);
-
-			if(amount < buffer.length)
-				buffer.copy(buffer, 0, amount, size);
-			size -= amount;
-		}
-
-		if(size === 0 && !that.readable) {
-			that.emit("end");
-			that.emit("close");
-			if (sendData && sendData.interval) {
-				clearInterval(sendData.interval);
-				sendData.interval = null;
-			}
-		}
-	};
-
-	this.size = function() {
-		return size;
-	};
-
-	this.maxSize = function() {
-		return buffer.length;
-	};
-
-	var increaseBufferIfNecessary = function(incomingDataSize) {
-		if((buffer.length - size) < incomingDataSize) {
-			var factor = Math.ceil((incomingDataSize - (buffer.length - size)) / incrementAmount);
-
-			var newBuffer = new Buffer(buffer.length + (incrementAmount * factor));
-			buffer.copy(newBuffer, 0, 0, size);
-			buffer = newBuffer;
-		}
-	};
-
-	this.put = function(data, encoding) {
-		if(!that.readable) return;
-
-		var wasEmpty = size === 0;
-		if(Buffer.isBuffer(data)) {
-			increaseBufferIfNecessary(data.length);
-			data.copy(buffer, size, 0);
-			size += data.length;
-		}
-		else {
-			data = data + "";
-			var dataSizeInBytes = Buffer.byteLength(data);
-			increaseBufferIfNecessary(dataSizeInBytes);
-			buffer.write(data, size, encoding || "utf8");
-			size += dataSizeInBytes;
-		}
-
-		if (wasEmpty && size > 0) {
-			this.emit('readable')
-		}
-
-		if (!this.isPaused && !frequency) {
-			while (size > 0) {
-				sendData();
-			}
-		}
-	};
-
-	this.pause = function() {
-		this.isPaused = true;
-		if(sendData && sendData.interval) {
-			clearInterval(sendData.interval);
-			delete sendData.interval;
-		}
-	};
-
-	this.resume = function() {
-		this.isPaused = false;
-		if(sendData && !sendData.interval && frequency > 0) {
-			sendData.interval = setInterval(sendData, frequency);
-		}
-	};
-
-	this.destroy = function() {
-		that.emit("end");
-		if(sendData.interval) clearInterval(sendData.interval);
-		sendData = null;
-		that.readable = false;
-		that.emit("close");
-	};
-
-	this.destroySoon = function() {
-		that.readable = false;
-		if (!sendData.interval) {
-			that.emit("end");
-			that.emit("close");
-		}
-	};
-
-	this.setEncoding = function(_encoding) {
-		encoding = _encoding;
-	};
-
-	this.resume();
-};
-util.inherits(ReadableStreamBuffer, stream.Stream);
+'use strict';
+
+var stream = require('stream');
+var constants = require('./constants');
+var util = require('util');
+
+var ReadableStreamBuffer = module.exports = function(opts) {
+  var that = this;
+  opts = opts || {};
+
+  stream.Readable.call(this, opts);
+
+  this.stopped = false;
+
+  var frequency = opts.hasOwnProperty('frequency') ? opts.frequency : constants.DEFAULT_FREQUENCY;
+  var chunkSize = opts.chunkSize || constants.DEFAULT_CHUNK_SIZE;
+  var initialSize = opts.initialSize || constants.DEFAULT_INITIAL_SIZE;
+  var incrementAmount = opts.incrementAmount || constants.DEFAULT_INCREMENT_AMOUNT;
+
+  var size = 0;
+  var buffer = new Buffer(initialSize);
+  var allowPush = false;
+
+  var sendData = function() {
+    var amount = Math.min(chunkSize, size);
+    var sendMore = false;
+
+    if (amount > 0) {
+      var chunk = null;
+      chunk = new Buffer(amount);
+      buffer.copy(chunk, 0, 0, amount);
+
+      sendMore = that.push(chunk) !== false;
+      allowPush = sendMore;
+
+      buffer.copy(buffer, 0, amount, size);
+      size -= amount;
+    }
+
+    if(size === 0 && that.stopped) {
+      that.push(null);
+    }
+
+    if (sendMore) {
+      sendData.timeout = setTimeout(sendData, frequency);
+    }
+    else {
+      sendData.timeout = null;
+    }
+  };
+
+  this.stop = function() {
+    if (this.stopped) {
+      throw new Error('stop() called on already stopped ReadableStreamBuffer');
+    }
+    this.stopped = true;
+
+    if (size === 0) {
+      this.push(null);
+    }
+  };
+
+  this.size = function() {
+    return size;
+  };
+
+  this.maxSize = function() {
+    return buffer.length;
+  };
+
+  var increaseBufferIfNecessary = function(incomingDataSize) {
+    if((buffer.length - size) < incomingDataSize) {
+      var factor = Math.ceil((incomingDataSize - (buffer.length - size)) / incrementAmount);
+
+      var newBuffer = new Buffer(buffer.length + (incrementAmount * factor));
+      buffer.copy(newBuffer, 0, 0, size);
+      buffer = newBuffer;
+    }
+  };
+
+  var kickSendDataTask = function () {
+    if (!sendData.timeout && allowPush) {
+      sendData.timeout = setTimeout(sendData, frequency);
+    }
+  }
+
+  this.put = function(data, encoding) {
+    if (that.stopped) {
+      throw new Error('Tried to write data to a stopped ReadableStreamBuffer');
+    }
+
+    if(Buffer.isBuffer(data)) {
+      increaseBufferIfNecessary(data.length);
+      data.copy(buffer, size, 0);
+      size += data.length;
+    }
+    else {
+      data = data + '';
+      var dataSizeInBytes = Buffer.byteLength(data);
+      increaseBufferIfNecessary(dataSizeInBytes);
+      buffer.write(data, size, encoding || 'utf8');
+      size += dataSizeInBytes;
+    }
+
+    kickSendDataTask();
+  };
+
+  this._read = function() {
+    allowPush = true;
+    kickSendDataTask();
+  };
+};
+
+util.inherits(ReadableStreamBuffer, stream.Readable);

package/node_modules/stream-buffers/lib/streambuffer.js

@@ -1,3 +1,5 @@
-module.exports = require("./constants");
-module.exports.ReadableStreamBuffer = require("./readable_streambuffer");
-module.exports.WritableStreamBuffer = require("./writable_streambuffer");
+'use strict';
+
+module.exports = require('./constants');
+module.exports.ReadableStreamBuffer = require('./readable_streambuffer');
+module.exports.WritableStreamBuffer = require('./writable_streambuffer');