appium-mac2-driver 4.3.5 → 4.3.6

package/node_modules/b4a/index.d.ts

@@ -0,0 +1,144 @@
+import { BufferEncoding } from './runtime'
+
+export function isBuffer(value: unknown): value is Uint8Array
+
+export function isEncoding(encoding: unknown): encoding is BufferEncoding
+
+export function alloc(size: number, fill: string, encoding?: BufferEncoding): Uint8Array
+export function alloc(size: number, fill?: Uint8Array | number | boolean): Uint8Array
+
+export function allocUnsafe(size: number): Uint8Array
+
+export function allocUnsafeSlow(size: number): Uint8Array
+
+export function byteLength(
+  string: ArrayBufferView | ArrayBufferLike | string,
+  encoding?: BufferEncoding
+): number
+
+export function compare(a: Uint8Array, b: Uint8Array): number
+
+export function concat<T extends Uint8Array>(buffers: T[], totalLength?: number): Uint8Array
+
+export function copy(
+  source: Uint8Array,
+  target: Uint8Array,
+  targetStart?: number,
+  start?: number,
+  end?: number
+): number
+
+export function equals(a: Uint8Array, b: Uint8Array): boolean
+
+export function fill<T extends Uint8Array>(buffer: T, value: string, encoding?: BufferEncoding): T
+export function fill<T extends Uint8Array>(
+  buffer: T,
+  value: string,
+  offset?: number,
+  encoding?: BufferEncoding
+): T
+export function fill<T extends Uint8Array>(
+  buffer: T,
+  value: string,
+  offset?: number,
+  end?: number,
+  encoding?: BufferEncoding
+): T
+export function fill<T extends Uint8Array>(
+  buffer: T,
+  value: Uint8Array | number | boolean,
+  offset?: number,
+  end?: number
+): T
+
+export function from(value: Iterable<number>): Uint8Array
+export function from(value: ArrayLike<number>): Uint8Array
+export function from(value: string, encodingOrOffset?: BufferEncoding): Uint8Array
+export function from(value: ArrayBufferLike, encodingOrOffset?: number, length?: number): Uint8Array
+
+export function includes(buffer: Uint8Array, value: string, encoding?: BufferEncoding): boolean
+export function includes(
+  buffer: Uint8Array,
+  value: string,
+  offset?: number,
+  encoding?: BufferEncoding
+): boolean
+export function includes(
+  buffer: Uint8Array,
+  value: Uint8Array | number | boolean,
+  offset?: number
+): boolean
+
+export function indexOf(buffer: Uint8Array, value: string, encoding?: BufferEncoding): number
+export function indexOf(
+  buffer: Uint8Array,
+  value: string,
+  byfeOffset?: number,
+  encoding?: BufferEncoding
+): number
+export function indexOf(
+  buffer: Uint8Array,
+  value: Uint8Array | number | boolean,
+  byfeOffset?: number
+): number
+
+export function lastIndexOf(buffer: Uint8Array, value: string, encoding?: BufferEncoding): number
+export function lastIndexOf(
+  buffer: Uint8Array,
+  value: string,
+  offset?: number,
+  encoding?: BufferEncoding
+): number
+export function lastIndexOf(
+  buffer: Uint8Array,
+  value: Uint8Array | number | boolean,
+  offset?: number
+): number
+
+export function swap16<T extends Uint8Array>(buffer: T): T
+export function swap32<T extends Uint8Array>(buffer: T): T
+export function swap64<T extends Uint8Array>(buffer: T): T
+
+export function toBuffer(buffer: Uint8Array): Uint8Array
+
+export function toString(
+  buffer: Uint8Array,
+  encoding?: BufferEncoding,
+  start?: number,
+  end?: number
+): string
+
+export function toHex(buffer: Uint8Array, start?: number, end?: number): string
+
+export function write(buffer: Uint8Array, string: string, encoding?: BufferEncoding): number
+export function write(
+  buffer: Uint8Array,
+  string: string,
+  offset?: number,
+  encoding?: BufferEncoding
+): number
+export function write(
+  buffer: Uint8Array,
+  string: string,
+  offset?: number,
+  length?: number,
+  encoding?: BufferEncoding
+): number
+
+export function readDoubleBE(buffer: Uint8Array, offset?: number): number
+export function readDoubleLE(buffer: Uint8Array, offset?: number): number
+export function readFloatBE(buffer: Uint8Array, offset?: number): number
+export function readFloatLE(buffer: Uint8Array, offset?: number): number
+export function readInt32BE(buffer: Uint8Array, offset?: number): number
+export function readInt32LE(buffer: Uint8Array, offset?: number): number
+export function readUInt32BE(buffer: Uint8Array, offset?: number): number
+export function readUInt32LE(buffer: Uint8Array, offset?: number): number
+
+export function writeDoubleBE(buffer: Uint8Array, value: number, offset?: number): number
+export function writeDoubleLE(buffer: Uint8Array, value: number, offset?: number): number
+export function writeFloatBE(buffer: Uint8Array, value: number, offset?: number): number
+export function writeFloatLE(buffer: Uint8Array, value: number, offset?: number): number
+export function writeInt32BE(buffer: Uint8Array, value: number, offset?: number): number
+export function writeInt32LE(buffer: Uint8Array, value: number, offset?: number): number
+export function writeUInt32BE(buffer: Uint8Array, value: number, offset?: number): number
+export function writeUInt32LE(buffer: Uint8Array, value: number, offset?: number): number

package/node_modules/b4a/index.js

@@ -79,6 +79,10 @@ function toString(buffer, encoding, start, end) {
   return toBuffer(buffer).toString(encoding, start, end)
 }
 
+function toHex(buffer, start, end) {
+  return toBuffer(buffer).toString('hex', start, end)
+}
+
 function write(buffer, string, offset, length, encoding) {
   return toBuffer(buffer).write(string, offset, length, encoding)
 }
@@ -168,6 +172,7 @@ module.exports = {
   swap64,
   toBuffer,
   toString,
+  toHex,
   write,
   readDoubleBE,
   readDoubleLE,

package/node_modules/b4a/package.json

@@ -1,10 +1,11 @@
 {
   "name": "b4a",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "Bridging the gap between buffers and typed arrays",
   "exports": {
     "./package": "./package.json",
     ".": {
+      "types": "index.d.ts",
       "react-native": "./react-native.js",
       "browser": "./browser.js",
       "default": "./index.js"
@@ -13,7 +14,9 @@
   "files": [
     "browser.js",
     "index.js",
+    "index.d.ts",
     "react-native.js",
+    "runtime.d.ts",
     "lib"
   ],
   "scripts": {

package/node_modules/b4a/runtime.d.ts

@@ -0,0 +1,14 @@
+type BufferEncoding =
+  | 'ascii'
+  | 'base64'
+  | 'binary'
+  | 'hex'
+  | 'latin1'
+  | 'ucs-2'
+  | 'ucs2'
+  | 'utf-16le'
+  | 'utf-8'
+  | 'utf16le'
+  | 'utf8'
+
+export { BufferEncoding }

package/node_modules/bare-fs/binding.c

@@ -2489,13 +2489,18 @@ bare_fs__on_watcher_event(uv_fs_event_t *handle, const char *filename, int event
     err = js_create_int32(env, events, &args[1]);
     assert(err == 0);
 
-    size_t len = strlen(filename);
-
-    void *data;
-    err = js_create_arraybuffer(env, len, &data, &args[2]);
-    assert(err == 0);
-
-    memcpy(data, (void *) filename, len);
+    if (filename == NULL) {
+      err = js_get_null(env, &args[2]);
+      assert(err == 0);
+    } else {
+      size_t len = strlen(filename);
+
+      void *data;
+      err = js_create_arraybuffer(env, len, &data, &args[2]);
+      assert(err == 0);
+
+      memcpy(data, (void *) filename, len);
+    }
   }
 
   err = js_call_function(env, ctx, on_event, 3, args, NULL);
@@ -2572,21 +2577,13 @@ static js_value_t *
 bare_fs_watcher_init(js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 5;
-  js_value_t *argv[5];
+  size_t argc = 3;
+  js_value_t *argv[3];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 5);
-
-  bare_fs_path_t path;
-  err = js_get_value_string_utf8(env, argv[0], path, sizeof(bare_fs_path_t), NULL);
-  assert(err == 0);
-
-  bool recursive;
-  err = js_get_value_bool(env, argv[1], &recursive);
-  assert(err == 0);
+  assert(argc == 3);
 
   js_value_t *result;
 
@@ -2607,20 +2604,17 @@ bare_fs_watcher_init(js_env_t *env, js_callback_info_t *info) {
     return NULL;
   }
 
-  err = uv_fs_event_start(&watcher->handle, bare_fs__on_watcher_event, (char *) path, recursive ? UV_FS_EVENT_RECURSIVE : 0);
-  assert(err == 0);
-
   watcher->env = env;
   watcher->closing = false;
   watcher->exiting = false;
 
-  err = js_create_reference(env, argv[2], 1, &watcher->ctx);
+  err = js_create_reference(env, argv[0], 1, &watcher->ctx);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[3], 1, &watcher->on_event);
+  err = js_create_reference(env, argv[1], 1, &watcher->on_event);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[4], 1, &watcher->on_close);
+  err = js_create_reference(env, argv[2], 1, &watcher->on_close);
   assert(err == 0);
 
   err = js_add_deferred_teardown_callback(env, bare_fs__on_watcher_teardown, (void *) watcher, &watcher->teardown);
@@ -2629,6 +2623,40 @@ bare_fs_watcher_init(js_env_t *env, js_callback_info_t *info) {
   return result;
 }
 
+static js_value_t *
+bare_fs_watcher_start(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 3;
+  js_value_t *argv[3];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 3);
+
+  bare_fs_watcher_t *watcher;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &watcher, NULL);
+  assert(err == 0);
+
+  bare_fs_path_t path;
+  err = js_get_value_string_utf8(env, argv[1], path, sizeof(bare_fs_path_t), NULL);
+  assert(err == 0);
+
+  bool recursive;
+  err = js_get_value_bool(env, argv[2], &recursive);
+  assert(err == 0);
+
+  err = uv_fs_event_start(&watcher->handle, bare_fs__on_watcher_event, (char *) path, recursive ? UV_FS_EVENT_RECURSIVE : 0);
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+  }
+
+  return NULL;
+}
+
 static js_value_t *
 bare_fs_watcher_close(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -2792,6 +2820,7 @@ bare_fs_exports(js_env_t *env, js_value_t *exports) {
   V("fdatasyncSync", bare_fs_fdatasync_sync)
 
   V("watcherInit", bare_fs_watcher_init)
+  V("watcherStart", bare_fs_watcher_start)
   V("watcherClose", bare_fs_watcher_close)
   V("watcherRef", bare_fs_watcher_ref)
   V("watcherUnref", bare_fs_watcher_unref)

package/node_modules/bare-fs/index.d.ts

@@ -262,7 +262,7 @@ export type WatcherEventType = 'rename' | 'change'
 
 export interface WatcherEvents<T extends string | Buffer = string | Buffer> extends EventMap {
   error: [err: Error]
-  change: [eventType: WatcherEventType, filename: T]
+  change: [eventType: WatcherEventType, filename: T | null]
   /** Emitted once the watcher has stopped watching. */
   close: []
 }
@@ -270,7 +270,7 @@ export interface WatcherEvents<T extends string | Buffer = string | Buffer> exte
 export interface Watcher<T extends string | Buffer = string | Buffer>
   extends
     EventEmitter<WatcherEvents<T>>,
-    AsyncIterable<{ eventType: WatcherEventType; filename: T }> {
+    AsyncIterable<{ eventType: WatcherEventType; filename: T | null }> {
   /** Stop watching for further changes. Once closed, a `close` event is emitted. */
   close(): void
   /** Prevent the event loop from exiting while the watcher is active. */
@@ -1306,7 +1306,9 @@ export function unlinkSync(filepath: Path): void
 
 /**
  * Watch a file or directory for changes. Returns a `Watcher` object. The `callback`, if provided,
- * is called with `(eventType, filename)` on each change.
+ * is called with `(eventType, filename)` on each change. `filename` is `null` when the platform
+ * could not report which file changed, such as when events were dropped, in which case the watched
+ * path should be rescanned.
  * @param opts - `persistent` defaults to `true`; `recursive` (default `false`) also watches
  * subdirectories; `encoding` defaults to `'utf8'`.
  * @param cb - Called with `(eventType, filename)` on each change; equivalent to listening for the
@@ -1315,42 +1317,42 @@ export function unlinkSync(filepath: Path): void
 export function watch(
   filepath: Path,
   opts: WatcherOptions & { encoding?: BufferEncoding },
-  cb: (eventType: WatcherEventType, filename: string) => void
+  cb: (eventType: WatcherEventType, filename: string | null) => void
 ): Watcher<string>
 
 export function watch(
   filepath: Path,
   opts: WatcherOptions & { encoding: 'buffer' },
-  cb: (eventType: WatcherEventType, filename: Buffer) => void
+  cb: (eventType: WatcherEventType, filename: Buffer | null) => void
 ): Watcher<Buffer>
 
 export function watch(
   filepath: Path,
   opts: WatcherOptions,
-  cb: (eventType: WatcherEventType, filename: string | Buffer) => void
+  cb: (eventType: WatcherEventType, filename: string | Buffer | null) => void
 ): Watcher
 
 export function watch(
   filepath: Path,
   encoding: BufferEncoding,
-  cb: (eventType: WatcherEventType, filename: string) => void
+  cb: (eventType: WatcherEventType, filename: string | null) => void
 ): Watcher<string>
 
 export function watch(
   filepath: Path,
   encoding: 'buffer',
-  cb: (eventType: WatcherEventType, filename: Buffer) => void
+  cb: (eventType: WatcherEventType, filename: Buffer | null) => void
 ): Watcher<Buffer>
 
 export function watch(
   filepath: Path,
   encoding: BufferEncoding | 'buffer',
-  cb: (eventType: WatcherEventType, filename: string | Buffer) => void
+  cb: (eventType: WatcherEventType, filename: string | Buffer | null) => void
 ): Watcher
 
 export function watch(
   filepath: Path,
-  cb: (eventType: WatcherEventType, filename: string) => void
+  cb: (eventType: WatcherEventType, filename: string | null) => void
 ): Watcher<string>
 
 /**

package/node_modules/bare-fs/index.js

@@ -2592,7 +2592,14 @@ class Watcher extends EventEmitter {
 
     this._closed = false
     this._encoding = encoding
-    this._handle = binding.watcherInit(path, recursive, this, this._onevent, this._onclose)
+    this._handle = binding.watcherInit(this, this._onevent, this._onclose)
+
+    try {
+      binding.watcherStart(this._handle, path, recursive)
+    } catch (err) {
+      this.close()
+      throw err
+    }
 
     if (!persistent) this.unref()
 
@@ -2668,9 +2675,11 @@ class Watcher extends EventEmitter {
       this.emit('error', err)
     } else {
       const path =
-        this._encoding === 'buffer'
-          ? Buffer.from(filename)
-          : Buffer.from(filename).toString(this._encoding)
+        filename === null
+          ? null
+          : this._encoding === 'buffer'
+            ? Buffer.from(filename)
+            : Buffer.from(filename).toString(this._encoding)
 
       if (events & binding.UV_RENAME) {
         this.emit('change', 'rename', path)

package/node_modules/bare-fs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-fs",
-  "version": "4.8.1",
+  "version": "4.8.2",
   "description": "Native file system operations for Bare",
   "exports": {
     "./package": "./package.json",
@@ -57,6 +57,7 @@
   "devDependencies": {
     "bare-buffer": "^3.0.2",
     "bare-crypto": "^1.11.2",
+    "bare-thread": "^1.2.6",
     "brittle": "^3.1.1",
     "cmake-bare": "^1.1.7",
     "lunte": "^1.6.0",

package/node_modules/bplist-creator/README.md

@@ -1,6 +1,8 @@
 bplist-creator
 ==============
 
+[![CI](https://github.com/joeferner/node-bplist-creator/actions/workflows/ci.yml/badge.svg)](https://github.com/joeferner/node-bplist-creator/actions/workflows/ci.yml)
+
 Binary Mac OS X Plist (property list) creator.
 
 ## Installation
@@ -11,10 +13,22 @@ $ npm install bplist-creator
 
 ## Quick Examples
 
+This package ships both ES module and CommonJS builds, so either import style works.
+
+```javascript
+// ESM
+import bplist from 'bplist-creator';
+
+const buffer = bplist({
+  key1: [1, 2, 3]
+});
+```
+
 ```javascript
-var bplist = require('bplist-creator');
+// CommonJS
+const bplist = require('bplist-creator');
 
-var buffer = bplist({
+const buffer = bplist({
   key1: [1, 2, 3]
 });
 ```
@@ -29,15 +43,21 @@ If you need to force a value to be written with the `real` type pass
 an instance of `Real`.
 
 ```javascript
-var buffer = bplist({
-  backgroundRed: new bplist.Real(1),
-  backgroundGreen: new bplist.Real(0),
-  backgroundBlue: new bplist.Real(0)
+// ESM: import bplist, { Real } from 'bplist-creator';
+// CommonJS: Real is also available as bplist.Real
+const buffer = bplist({
+  backgroundRed: new Real(1),
+  backgroundGreen: new Real(0),
+  backgroundBlue: new Real(0)
 });
 ```
 
 In `xml` the corresponding tags is `<integer>` and `<real>`.
 
+## Requirements
+
+Node.js 20.19 or newer.
+
 ## License
 
 (The MIT License)