appium-mac2-driver 4.5.0 → 4.6.0

package/node_modules/wbuf/test/wbuf-test.js

@@ -0,0 +1,357 @@
+var assert = require('assert');
+var WriteBuffer = require('../');
+
+describe('WriteBuffer', function() {
+  var w;
+  beforeEach(function() {
+    w = new WriteBuffer();
+  });
+
+  function join(arr) {
+    return arr.map(function(buf) {
+      return buf.toString('hex');
+    }).join('');
+  }
+
+  describe('.writeUInt8', function() {
+    it('should write bytes', function() {
+      w.writeUInt8(1);
+      w.writeUInt8(2);
+      w.writeUInt8(3);
+      w.writeUInt8(4);
+      assert.equal(join(w.render()), '01020304');
+    });
+
+    it('should correctly handle overflow', function() {
+      w.reserve(3);
+      w.writeUInt8(1);
+      w.writeUInt8(2);
+      w.writeUInt8(3);
+      w.writeUInt8(4);
+      assert.equal(join(w.render()), '01020304');
+    });
+  });
+
+  describe('.writeInt8', function() {
+    it('should write bytes', function() {
+      w.writeInt8(-1);
+      w.writeInt8(2);
+      assert.equal(join(w.render()), 'ff02');
+    });
+  });
+
+  describe('.writeUInt16BE', function() {
+    it('should write bytes', function() {
+      w.writeUInt16BE(0x0102);
+      w.writeUInt16BE(0x0304);
+      assert.equal(join(w.render()), '01020304');
+    });
+
+    it('should correctly handle overflow', function() {
+      w.reserve(2);
+      w.reserve(3);
+      w.writeUInt16BE(0x0102);
+      w.writeUInt16BE(0x0304);
+      w.writeUInt16BE(0x0506);
+      assert.equal(join(w.render()), '010203040506');
+    });
+  });
+
+  describe('.writeInt16BE', function() {
+    it('should write bytes', function() {
+      w.writeInt16BE(-0x0102);
+      w.writeInt16BE(0x0304);
+      assert.equal(join(w.render()), 'fefe0304');
+    });
+  });
+
+  describe('.writeUInt16LE', function() {
+    it('should write bytes', function() {
+      w.writeUInt16LE(0x0102);
+      w.writeUInt16LE(0x0304);
+      assert.equal(join(w.render()), '02010403');
+    });
+
+    it('should correctly handle overflow', function() {
+      w.reserve(2);
+      w.reserve(3);
+      w.writeUInt16LE(0x0102);
+      w.writeUInt16LE(0x0304);
+      w.writeUInt16LE(0x0506);
+      assert.equal(join(w.render()), '020104030605');
+    });
+  });
+
+  describe('.writeInt16LE', function() {
+    it('should write bytes', function() {
+      w.writeInt16LE(-0x0201);
+      w.writeInt16LE(0x0304);
+      assert.equal(join(w.render()), 'fffd0403');
+    });
+  });
+
+  describe('.writeUInt24BE', function() {
+    it('should write bytes', function() {
+      w.writeUInt24BE(0x010203);
+      w.writeUInt24BE(0x040506);
+      assert.equal(join(w.render()), '010203040506');
+    });
+
+    it('should correctly set avail on boundary', function() {
+      w = new WriteBuffer();
+      w.reserveRate = 4;
+      w.writeUInt16BE(1);
+      w.writeUInt24BE(1);
+      assert.equal(w.avail, 3);
+    });
+  });
+
+  describe('.writeInt24BE', function() {
+    it('should write bytes', function() {
+      w.writeInt24BE(-0x010203);
+      w.writeInt24BE(0x040506);
+      assert.equal(join(w.render()), 'fefdfd040506');
+    });
+  });
+
+  describe('.writeUInt24LE', function() {
+    it('should write bytes', function() {
+      w.writeUInt24LE(0x010203);
+      w.writeUInt24LE(0x040506);
+      assert.equal(join(w.render()), '030201060504');
+    });
+  });
+
+  describe('.writeInt24LE', function() {
+    it('should write bytes', function() {
+      w.writeInt24LE(-0x010203);
+      w.writeInt24LE(0x040506);
+      assert.equal(join(w.render()), 'fdfdfe060504');
+    });
+  });
+
+  describe('.writeUInt32BE', function() {
+    it('should write bytes', function() {
+      w.writeUInt32BE(0x01020304);
+      w.writeUInt32BE(0x05060708);
+      assert.equal(join(w.render()), '0102030405060708');
+    });
+
+    it('should write bytes on the boundary', function() {
+      w.reserve(4);
+      w.writeUInt8(0x00);
+      w.writeUInt32BE(0x01020304);
+      assert.equal(join(w.render()), '0001020304');
+    });
+  });
+
+  describe('.writeInt32BE', function() {
+    it('should write bytes', function() {
+      w.writeInt32BE(-0x01020304);
+      w.writeInt32BE(0x05060708);
+      assert.equal(join(w.render()), 'fefdfcfc05060708');
+    });
+  });
+
+  describe('.writeUInt32LE', function() {
+    it('should write bytes', function() {
+      w.writeUInt32LE(0x01020304);
+      w.writeUInt32LE(0x05060708);
+      assert.equal(join(w.render()), '0403020108070605');
+    });
+
+    it('should write max uint32 value', function() {
+      w.writeUInt32LE(0xffffffff);
+      assert.equal(join(w.render()), 'ffffffff');
+    });
+  });
+
+  describe('.combWrite', function() {
+    it('should write bytes', function() {
+      w.writeComb(1, 'le', 0x01);
+      w.writeComb(1, 'be', 0x02);
+      w.writeComb(2, 'le', 0x0102);
+      w.writeComb(2, 'be', 0x0304);
+      w.writeComb(3, 'le', 0x010203);
+      w.writeComb(3, 'be', 0x040506);
+      w.writeComb(4, 'le', 0x01020304);
+      w.writeComb(4, 'be', 0x05060708);
+      assert.equal(join(w.render()),
+                   '0102020103040302010405060403020105060708');
+    });
+
+    it('should write max uint32 value', function() {
+      w.writeUInt32LE(0xffffffff);
+      assert.equal(join(w.render()), 'ffffffff');
+    });
+  });
+
+  describe('.writeInt32LE', function() {
+    it('should write bytes', function() {
+      w.writeInt32LE(-0x01020304);
+      w.writeInt32LE(0x05060708);
+      assert.equal(join(w.render()), 'fcfcfdfe08070605');
+    });
+  });
+
+  describe('.skip', function() {
+    it('should skip bytes', function() {
+      w.skip(4);
+      w.writeUInt32BE(0xdeadbeef);
+      assert(/^.{8}deadbeef$/.test(join(w.render())));
+    });
+
+    it('should skip 0 bytes', function() {
+      var skip = w.skip(0);
+      assert.equal(skip.size, 0);
+      w.writeUInt32BE(0xdeadbeef);
+      assert(/^deadbeef$/.test(join(w.render())));
+    });
+
+    it('should skip bytes on the boundary', function() {
+      w.reserve(4);
+      w.writeUInt8(0x01);
+      var skip = w.skip(4);
+      w.writeUInt32BE(0xdeadbeef);
+      skip.writeUInt32BE(0xabbabaab);
+      assert(/^01abbabaabdeadbeef$/.test(join(w.render())));
+    });
+
+    it('should skip bytes on the boundary in two chunks', function() {
+      w.reserve(4);
+      var skip1 = w.skip(2);
+      var skip2 = w.skip(2);
+      w.writeUInt32BE(0xdeadbeef);
+      skip1.writeUInt16BE(0xabba);
+      skip2.writeUInt16BE(0xbaba);
+      assert(/^abbababadeadbeef$/.test(join(w.render())));
+    });
+  });
+
+  describe('.slice', function() {
+    it('should return empty slice', function() {
+      w.writeUInt32BE(0xabbadead);
+      assert.equal(join(w.slice(4, 4).render()), '');
+      assert.equal(join(w.render()), 'abbadead');
+    });
+
+    it('should return full slice', function() {
+      w.writeUInt32BE(0xabbadead);
+      var slice = w.slice(0, 4);
+      slice.writeUInt32BE(0xdeadbeef);
+      assert.equal(join(slice.render()), 'deadbeef');
+      assert.equal(join(w.render()), 'deadbeef');
+    });
+
+    it('should return partial slice', function() {
+      w.writeUInt32BE(0xabbadead);
+      var slice = w.slice(0, 3);
+      slice.writeUInt24BE(0xdeadbe);
+      assert.equal(join(slice.render()), 'deadbe');
+      assert.equal(join(w.render()), 'deadbead');
+    });
+
+    it('should return over-the-boundary slice', function() {
+      for (var i = 0; i < 16; i++) {
+        w.reserve(3);
+        w.writeUInt24BE(i);
+      }
+      assert.equal(join(w.render()),
+                   '000000000001000002000003000004000005000006000007' +
+                       '00000800000900000a00000b00000c00000d00000e00000f');
+
+      var slice = w.slice(5, 12);
+      slice.writeUInt24BE(0xaaabac);
+      slice.writeUInt24BE(0xbabbbc);
+      slice.writeUInt8(0xcc);
+
+      assert.equal(join(slice.render()), 'aaabacbabbbccc');
+      assert.equal(join(w.render()),
+                   '0000000000aaabacbabbbccc000004000005000006000007' +
+                       '00000800000900000a00000b00000c00000d00000e00000f');
+    });
+  });
+
+  describe('.copyFrom', function() {
+    it('should copy bytes', function() {
+      var tmp = new Buffer(128);
+      for (var i = 0; i < tmp.length; i++)
+        tmp[i] = i;
+      w.writeUInt32BE(0xdeadbeef);
+      w.copyFrom(tmp);
+      w.writeUInt32BE(0xabbadead);
+
+      assert.equal(
+        join(w.render()),
+        'deadbeef000102030405060708090a0b0c0d0e0f101112131415161718191a1b' +
+        '1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b' +
+        '3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b' +
+        '5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b' +
+        '7c7d7e7fabbadead');
+    });
+
+    it('should copy bytes using offset', function() {
+      var tmp = new Buffer(128);
+      for (var i = 0; i < tmp.length; i++)
+        tmp[i] = i;
+      w.writeUInt32BE(0xdeadbeef);
+      w.copyFrom(tmp, 10, 12);
+      w.writeUInt32BE(0xabbadead);
+
+      assert.equal(
+        join(w.render()),
+        'deadbeef0a0babbadead');
+    });
+  });
+
+  describe('.write', function() {
+    it('should write utf8 string', function() {
+      w.writeUInt32BE(0xdeadbeef);
+      w.write('ohai\u1023');
+      w.writeUInt32BE(0xabbadead);
+
+      assert.equal(
+        join(w.render()),
+        'deadbeef' +
+            '6f6861691023' +
+            'abbadead');
+    });
+
+    it('should copy bytes using offset', function() {
+      var tmp = new Buffer(128);
+      for (var i = 0; i < tmp.length; i++)
+        tmp[i] = i;
+      w.writeUInt32BE(0xdeadbeef);
+      w.copyFrom(tmp, 10, 12);
+      w.writeUInt32BE(0xabbadead);
+
+      assert.equal(
+        join(w.render()),
+        'deadbeef0a0babbadead');
+    });
+  });
+
+  describe('.skip', function() {
+    it('should copy bytes', function() {
+      w.reserve(5);
+      var h = w.skip(4);
+      w.writeUInt32BE(0xabbadead);
+      h.writeUInt32BE(0xdeadbeef);
+
+      assert.equal(
+        join(w.render()),
+        'deadbeefabbadead');
+    });
+  });
+
+  describe('.forceReserve = true', function() {
+    it('should allocate more bytes', function() {
+      w.forceReserve = true;
+      w.reserve(4);
+      w.writeUInt32BE(0xabbadead);
+      w.writeUInt32BE(0xabbadead);
+
+      assert.equal(w.render().length, 1);
+    });
+  });
+});

package/node_modules/xpath/LICENSE

@@ -0,0 +1,22 @@
+MIT License 
+
+Copyright (c) 2018 Cameron McCormack 
+
+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/xpath/README.md

@@ -0,0 +1,133 @@
+## xpath
+DOM 3 XPath 1.0 implemention and helper for JavaScript, with node.js support.
+
+Originally written by Cameron McCormack ([blog](http://mcc.id.au/xpathjs)).
+
+Additional contributions from  
+Yaron Naveh ([blog](http://webservices20.blogspot.com/))  
+goto100  
+Thomas Weinert  
+Jimmy Rishe  
+and [others](https://github.com/goto100/xpath/graphs/contributors)
+
+## Install
+Install with [npm](http://github.com/isaacs/npm):
+
+    npm install xpath
+
+xpath is xml engine agnostic but we recommend [xmldom](https://github.com/xmldom/xmldom):
+
+    npm install @xmldom/xmldom
+
+## API Documentation
+
+Can be found [here](https://github.com/goto100/xpath/blob/master/docs/xpath%20methods.md). See below for example usage.
+
+## Your first xpath:
+`````javascript
+var xpath = require('xpath');
+var dom = require('@xmldom/xmldom').DOMParser;
+
+var xml = "<book><title>Harry Potter</title></book>";
+var doc = new dom().parseFromString(xml, 'text/xml');
+var nodes = xpath.select("//title", doc);
+
+console.log(nodes[0].localName + ": " + nodes[0].firstChild.data);
+console.log("Node: " + nodes[0].toString());
+`````
+➡
+
+    title: Harry Potter
+    Node: <title>Harry Potter</title>
+
+### Alternatively
+
+Using the same interface you have on modern browsers ([MDN])
+
+`````javascript
+var node = null;
+var xml = "<book author='J. K. Rowling'><title>Harry Potter</title></book>";
+var doc = new dom().parseFromString(xml, 'text/xml');
+var result = xpath.evaluate(
+    "/book/title",            // xpathExpression
+    doc,                        // contextNode
+    null,                       // namespaceResolver
+    xpath.XPathResult.ANY_TYPE, // resultType
+    null                        // result
+);
+
+node = result.iterateNext();
+while (node) {
+    console.log(node.localName + ": " + node.firstChild.data);
+    console.log("Node: " + node.toString());
+
+    node = result.iterateNext();
+}
+`````
+➡
+
+    title: Harry Potter
+    Node: <title>Harry Potter</title>
+
+## Evaluate string values directly:
+`````javascript
+var xml = "<book><title>Harry Potter</title></book>";
+var doc = new dom().parseFromString(xml, 'text/xml');
+var title = xpath.select("string(//title)", doc);
+
+console.log(title);
+`````
+➡
+
+    Harry Potter
+
+## Namespaces
+`````javascript
+var xml = "<book><title xmlns='myns'>Harry Potter</title></book>";
+var doc = new dom().parseFromString(xml, 'text/xml');
+var node = xpath.select("//*[local-name(.)='title' and namespace-uri(.)='myns']", doc)[0];
+
+console.log(node.namespaceURI);
+`````
+➡
+
+    myns
+
+## Namespaces with easy mappings
+`````javascript
+var xml = "<book xmlns:bookml='http://example.com/book'><bookml:title>Harry Potter</bookml:title></book>"
+var select = xpath.useNamespaces({"bookml": "http://example.com/book"});
+
+console.log(select('//bookml:title/text()', doc)[0].nodeValue);
+`````
+➡
+
+    Harry Potter
+
+## Default namespace with mapping
+`````javascript
+var xml = "<book xmlns='http://example.com/book'><title>Harry Potter</title></book>"
+var select = xpath.useNamespaces({"bookml": "http://example.com/book"});
+
+console.log(select('//bookml:title/text()', doc)[0].nodeValue);
+`````
+➡
+
+    Harry Potter
+
+## Attributes
+`````javascript
+var xml = "<book author='J. K. Rowling'><title>Harry Potter</title></book>";
+var doc = new dom().parseFromString(xml, 'text/xml');
+var author = xpath.select1("/book/@author", doc).value;
+
+console.log(author);
+`````
+➡
+
+    J. K. Rowling
+
+[MDN]: https://developer.mozilla.org/en/docs/Web/API/Document/evaluate
+
+## License
+MIT

package/node_modules/xpath/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "xpath",
+  "version": "0.0.36",
+  "description": "DOM 3 XPath implemention and helper for node.js and the web",
+  "engines": {
+    "node": ">=0.6.0"
+  },
+  "author": {
+    "name": "Cameron McCormack"
+  },
+  "contributors": [
+    {
+      "name": "goto100"
+    },
+    {
+      "name": "James Rishe"
+    }
+  ],
+  "devDependencies": {
+    "@xmldom/xmldom": "^0.8.9",
+    "es-check": "^7.1.1",
+    "func-xml": "^0.0.10",
+    "mocha": "^9.0.2"
+  },
+  "typings": "./xpath.d.ts",
+  "scripts": {
+    "test": "mocha",
+    "validate": "es-check es5 xpath.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/goto100/xpath.git"
+  },
+  "main": "xpath.js",
+  "files": [
+    "xpath.d.ts"
+  ],
+  "keywords": [
+    "xpath",
+    "xml"
+  ],
+  "license": "MIT"
+}

package/node_modules/xpath/xpath.d.ts

@@ -0,0 +1,110 @@
+/// <reference lib="dom" />
+
+export type SelectedValue = Node | string | number | boolean | null;
+
+export type SelectReturnType = Array<Node> | SelectedValue;
+export type SelectSingleReturnType = SelectedValue;
+
+export interface XPathSelect {
+    (expression: string, node: Node): SelectReturnType;
+    (expression: string, node: Node, single: false): SelectReturnType;
+    (expression: string, node: Node, single: true): SelectSingleReturnType;
+}
+
+/**
+ * Evaluate an XPath expression against a DOM node.
+ */
+export function select(expression: string, node: Node): SelectReturnType;
+export function select(expression: string, node: Node, single: false): SelectReturnType;
+export function select(expression: string, node: Node, single: true): SelectSingleReturnType;
+
+/**
+ * Evaluate an xpath expression against a DOM node, returning the first result only.
+ */
+export function select1(expression: string, node: Node): SelectSingleReturnType;
+
+/**
+ * Evaluate an XPath expression against a DOM node using a given namespace resolver.
+ */
+export function selectWithResolver(expression: string, node: Node, resolver?: XPathNSResolver | null): SelectReturnType;
+export function selectWithResolver(expression: string, node: Node, resolver: XPathNSResolver | null, single: false): SelectReturnType;
+export function selectWithResolver(expression: string, node: Node, resolver: XPathNSResolver | null, single: true): SelectSingleReturnType;
+
+/**
+ * Creates a `select` function that uses the given namespace prefix to URI mappings when evaluating queries.
+ * @param namespaceMap an object mapping namespace prefixes to namespace URIs.  Each key is a prefix; each value is a URI.
+ * @return a function with the same signature as `xpath.select`
+ */
+export function useNamespaces(namespaceMap: Record<string, string>): XPathSelect;
+
+// Type guards to narrow down the type of the selected type of a returned Node object
+export function isNodeLike(value: SelectedValue): value is Node;
+export function isArrayOfNodes(value: SelectReturnType): value is Node[];
+export function isElement(value: SelectedValue): value is Element;
+export function isAttribute(value: SelectedValue): value is Attr;
+export function isTextNode(value: SelectedValue): value is Text;
+export function isCDATASection(value: SelectedValue): value is CDATASection;
+export function isProcessingInstruction(value: SelectedValue): value is ProcessingInstruction;
+export function isComment(value: SelectedValue): value is Comment;
+export function isDocumentNode(value: SelectedValue): value is Document;
+export function isDocumentTypeNode(value: SelectedValue): value is DocumentType;
+export function isDocumentFragment(value: SelectedValue): value is DocumentFragment;
+
+export function parse(expression: string): XPathEvaluator;
+
+export interface XPathEvaluator {
+    evaluate(options?: XPathEvaluateOptions): XPathResult;
+    evaluateBoolean(options?: XPathEvaluateOptions): boolean;
+    evaluateNumber(options?: XPathEvaluateOptions): number;
+    evaluateString(options?: XPathEvaluateOptions): string;
+    evaluateNodeSet(options?: XPathEvaluateOptions): XPathNodeSet;
+    select(options?: XPathEvaluateOptions): Node[];
+    select1(options?: XPathEvaluateOptions): Node | undefined;
+}
+
+export interface XPathEvaluateOptions {
+    node?: Node;
+    namespaces?: XPathNamespaceResolver;
+    variables?: XPathVariableResolver;
+    functions?: Record<string, XPathFunction> | XPathFunctionResolver;
+    position?: number;
+    size?: number;
+    allowAnyNamespaceForNoPrefix?: boolean;
+    isHtml?: boolean;
+}
+
+export type XPathNamespaceResolver = Record<string, string> | XPathNamespaceBasicResolver | {
+    getNamespace: XPathNamespaceBasicResolver
+};
+export type XPathNamespaceBasicResolver = (prefix: string, node: Node) => string | null | undefined;
+
+export type XPathVariableResolver = Record<string, XPathValue> | XPathVariableBasicResolver | {
+    getVariable: XPathVariableBasicResolver
+};
+export type XPathVariableBasicResolver = (name: string, namespace: string | null) => XPathValue;
+
+export type XPathFunctionResolver = XPathFunctionBasicResolver | {
+    getFunction: XPathFunctionBasicResolver
+};
+export type XPathFunctionBasicResolver = (name: string, namespace: string | null) => XPathFunction | null | undefined;
+
+export type XPathFunction = (context: XPathFunctionContext, ...args: XPathResult[]) => XPathValue;
+
+export interface XPathFunctionContext {
+    contextNode: Node;
+}
+
+/** Values that variables and custom functions may produce; nodes and arrays of nodes become node sets. */
+export type XPathValue = string | number | boolean | Node | Node[] | XPathResult | null | undefined;
+
+export interface XPathResult {
+    booleanValue(): boolean;
+    numberValue(): number;
+    stringValue(): string;
+}
+
+export interface XPathNodeSet extends XPathResult {
+    readonly size: number;
+    first(): Node | null;
+    toArray(): Node[];
+}