react-native-kookit 0.1.1 → 0.1.4

package/plugin/node_modules/big-integer/bower.json

@@ -0,0 +1,29 @@
+{
+  "name": "big-integer",
+  "description": "An arbitrary length integer library for Javascript",
+  "main": "./BigInteger.js",
+  "authors": [
+    "Peter Olson"
+  ],
+  "license": "Unlicense",
+  "keywords": [
+    "math",
+    "big",
+    "bignum",
+    "bigint",
+    "biginteger",
+    "integer",
+    "arbitrary",
+    "precision",
+    "arithmetic"
+  ],
+  "homepage": "https://github.com/peterolson/BigInteger.js",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "coverage",
+    "tests"
+  ]
+}

package/plugin/node_modules/big-integer/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "big-integer",
+  "version": "1.6.52",
+  "author": "Peter Olson <peter.e.c.olson+npm@gmail.com>",
+  "description": "An arbitrary length integer library for Javascript",
+  "contributors": [],
+  "bin": {},
+  "scripts": {
+    "test": "tsc && karma start my.conf.js && node spec/tsDefinitions.js",
+    "minify": "uglifyjs BigInteger.js -o BigInteger.min.js"
+  },
+  "main": "./BigInteger",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:peterolson/BigInteger.js.git"
+  },
+  "keywords": [
+    "math",
+    "big",
+    "bignum",
+    "bigint",
+    "biginteger",
+    "integer",
+    "arbitrary",
+    "precision",
+    "arithmetic"
+  ],
+  "devDependencies": {
+    "@types/lodash": "^4.14.175",
+    "@types/node": "^7.10.2",
+    "coveralls": "^3.0.6",
+    "jasmine": "3.5.0",
+    "jasmine-core": "^3.5.0",
+    "karma": "^6.3.4",
+    "karma-cli": "^2.0.0",
+    "karma-coverage": "^2.0.3",
+    "karma-jasmine": "^4.0.1",
+    "karma-phantomjs-launcher": "^1.0.4",
+    "lodash": "^4.17.21",
+    "typescript": "^5.3.2",
+    "uglify-js": "^3.17.4"
+  },
+  "license": "Unlicense",
+  "engines": {
+    "node": ">=0.6"
+  },
+  "typings": "./BigInteger.d.ts"
+}

package/plugin/node_modules/big-integer/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "target": "esnext",
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": false,
+        "baseUrl": "./",
+        "moduleResolution": "node",
+        "allowJs": true,
+        "typeRoots": [
+            "./"
+        ],
+        "types": [],
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "BigInteger.d.ts",
+        "spec/tsDefinitions.ts"
+    ]
+}

package/plugin/node_modules/bplist-creator/LICENSE

@@ -0,0 +1,18 @@
+(The MIT License)
+
+Copyright (c) 2012 Near Infinity Corporation
+
+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/plugin/node_modules/bplist-creator/README.md

@@ -0,0 +1,64 @@
+bplist-creator
+==============
+
+Binary Mac OS X Plist (property list) creator.
+
+## Installation
+
+```bash
+$ npm install bplist-creator
+```
+
+## Quick Examples
+
+```javascript
+var bplist = require('bplist-creator');
+
+var buffer = bplist({
+  key1: [1, 2, 3]
+});
+```
+
+## Real/Double/Float handling
+
+Javascript don't have different types for `1` and `1.0`. This package
+will automatically store numbers as the appropriate type, but can't
+detect floats that is also integers.
+
+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)
+});
+```
+
+In `xml` the corresponding tags is `<integer>` and `<real>`.
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2012 Near Infinity Corporation
+
+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/plugin/node_modules/bplist-creator/bplistCreator.js

@@ -0,0 +1,460 @@
+'use strict';
+
+// adapted from http://code.google.com/p/plist/source/browse/trunk/src/main/java/com/dd/plist/BinaryPropertyListWriter.java
+
+var streamBuffers = require("stream-buffers");
+
+var debug = false;
+
+function Real(value) {
+  this.value = value;
+}
+
+module.exports = function(dicts) {
+  var buffer = new streamBuffers.WritableStreamBuffer();
+  buffer.write(Buffer.from("bplist00"));
+
+  if (debug) {
+    console.log('create', require('util').inspect(dicts, false, 10));
+  }
+
+  if (dicts instanceof Array && dicts.length === 1) {
+    dicts = dicts[0];
+  }
+
+  var entries = toEntries(dicts);
+  if (debug) {
+    console.log('entries', entries);
+  }
+  var idSizeInBytes = computeIdSizeInBytes(entries.length);
+  var offsets = [];
+  var offsetSizeInBytes;
+  var offsetTableOffset;
+
+  updateEntryIds();
+
+  entries.forEach(function(entry, entryIdx) {
+    offsets[entryIdx] = buffer.size();
+    if (!entry) {
+      buffer.write(0x00);
+    } else {
+      write(entry);
+    }
+  });
+
+  writeOffsetTable();
+  writeTrailer();
+  return buffer.getContents();
+
+  function updateEntryIds() {
+    var strings = {};
+    var entryId = 0;
+    entries.forEach(function(entry) {
+      if (entry.id) {
+        return;
+      }
+      if (entry.type === 'string') {
+        if (!entry.bplistOverride && strings.hasOwnProperty(entry.value)) {
+          entry.type = 'stringref';
+          entry.id = strings[entry.value];
+        } else {
+          strings[entry.value] = entry.id = entryId++;
+        }
+      } else {
+        entry.id = entryId++;
+      }
+    });
+
+    entries = entries.filter(function(entry) {
+      return (entry.type !== 'stringref');
+    });
+  }
+
+  function writeTrailer() {
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeTrailer');
+    }
+    // 6 null bytes
+    buffer.write(Buffer.from([0, 0, 0, 0, 0, 0]));
+
+    // size of an offset
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeTrailer(offsetSizeInBytes):', offsetSizeInBytes);
+    }
+    writeByte(offsetSizeInBytes);
+
+    // size of a ref
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeTrailer(offsetSizeInBytes):', idSizeInBytes);
+    }
+    writeByte(idSizeInBytes);
+
+    // number of objects
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeTrailer(number of objects):', entries.length);
+    }
+    writeLong(entries.length);
+
+    // top object
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeTrailer(top object)');
+    }
+    writeLong(0);
+
+    // offset table offset
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeTrailer(offset table offset):', offsetTableOffset);
+    }
+    writeLong(offsetTableOffset);
+  }
+
+  function writeOffsetTable() {
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeOffsetTable');
+    }
+    offsetTableOffset = buffer.size();
+    offsetSizeInBytes = computeOffsetSizeInBytes(offsetTableOffset);
+    offsets.forEach(function(offset) {
+      writeBytes(offset, offsetSizeInBytes);
+    });
+  }
+
+  function write(entry) {
+    switch (entry.type) {
+    case 'dict':
+      writeDict(entry);
+      break;
+    case 'number':
+    case 'double':
+      writeNumber(entry);
+      break;
+    case 'UID':
+      writeUID(entry);
+      break;
+    case 'array':
+      writeArray(entry);
+      break;
+    case 'boolean':
+      writeBoolean(entry);
+      break;
+    case 'string':
+    case 'string-utf16':
+      writeString(entry);
+      break;
+    case 'date':
+      writeDate(entry);
+      break;
+    case 'data':
+      writeData(entry);
+      break;
+    default:
+      throw new Error("unhandled entry type: " + entry.type);
+    }
+  }
+
+  function writeDate(entry) {
+    writeByte(0x33);
+    var date = (Date.parse(entry.value)/1000) - 978307200
+    writeDouble(date)
+  }
+
+  function writeDict(entry) {
+    if (debug) {
+      var keysStr = entry.entryKeys.map(function(k) {return k.id;});
+      var valsStr = entry.entryValues.map(function(k) {return k.id;});
+      console.log('0x' + buffer.size().toString(16), 'writeDict', '(id: ' + entry.id + ')', '(keys: ' + keysStr + ')', '(values: ' + valsStr + ')');
+    }
+    writeIntHeader(0xD, entry.entryKeys.length);
+    entry.entryKeys.forEach(function(entry) {
+      writeID(entry.id);
+    });
+    entry.entryValues.forEach(function(entry) {
+      writeID(entry.id);
+    });
+  }
+
+  function writeNumber(entry) {
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeNumber', entry.value, ' (type: ' + entry.type + ')', '(id: ' + entry.id + ')');
+    }
+
+    if (typeof entry.value === 'bigint') {
+      var width = 16;
+      var hex = entry.value.toString(width);
+      var buf = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+      writeByte(0x14);
+      buffer.write(buf);
+    } else if (entry.type !== 'double' && parseFloat(entry.value).toFixed() == entry.value) {
+      if (entry.value < 0) {
+        writeByte(0x13);
+        writeBytes(entry.value, 8, true);
+      } else if (entry.value <= 0xff) {
+        writeByte(0x10);
+        writeBytes(entry.value, 1);
+      } else if (entry.value <= 0xffff) {
+        writeByte(0x11);
+        writeBytes(entry.value, 2);
+      } else if (entry.value <= 0xffffffff) {
+        writeByte(0x12);
+        writeBytes(entry.value, 4);
+      } else {
+        writeByte(0x13);
+        writeBytes(entry.value, 8);
+      }
+    } else {
+      writeByte(0x23);
+      writeDouble(entry.value);
+    }
+  }
+
+  function writeUID(entry) {
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeUID', entry.value, ' (type: ' + entry.type + ')', '(id: ' + entry.id + ')');
+    }
+
+    writeIntHeader(0x8, 0x0);
+    writeID(entry.value);
+  }
+
+  function writeArray(entry) {
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeArray (length: ' + entry.entries.length + ')', '(id: ' + entry.id + ')');
+    }
+    writeIntHeader(0xA, entry.entries.length);
+    entry.entries.forEach(function(e) {
+      writeID(e.id);
+    });
+  }
+
+  function writeBoolean(entry) {
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeBoolean', entry.value, '(id: ' + entry.id + ')');
+    }
+    writeByte(entry.value ? 0x09 : 0x08);
+  }
+
+  function writeString(entry) {
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeString', entry.value, '(id: ' + entry.id + ')');
+    }
+    if (entry.type === 'string-utf16' || mustBeUtf16(entry.value)) {
+      var utf16 = Buffer.from(entry.value, 'ucs2');
+      writeIntHeader(0x6, utf16.length / 2);
+      // needs to be big endian so swap the bytes
+      for (var i = 0; i < utf16.length; i += 2) {
+        var t = utf16[i + 0];
+        utf16[i + 0] = utf16[i + 1];
+        utf16[i + 1] = t;
+      }
+      buffer.write(utf16);
+    } else {
+      var utf8 = Buffer.from(entry.value, 'ascii');
+      writeIntHeader(0x5, utf8.length);
+      buffer.write(utf8);
+    }
+  }
+
+  function writeData(entry) {
+    if (debug) {
+      console.log('0x' + buffer.size().toString(16), 'writeData', entry.value, '(id: ' + entry.id + ')');
+    }
+    writeIntHeader(0x4, entry.value.length);
+    buffer.write(entry.value);
+  }
+
+  function writeLong(l) {
+    writeBytes(l, 8);
+  }
+
+  function writeByte(b) {
+    buffer.write(Buffer.from([b]));
+  }
+
+  function writeDouble(v) {
+    var buf = Buffer.alloc(8);
+    buf.writeDoubleBE(v, 0);
+    buffer.write(buf);
+  }
+
+  function writeIntHeader(kind, value) {
+    if (value < 15) {
+      writeByte((kind << 4) + value);
+    } else if (value < 256) {
+      writeByte((kind << 4) + 15);
+      writeByte(0x10);
+      writeBytes(value, 1);
+    } else if (value < 65536) {
+      writeByte((kind << 4) + 15);
+      writeByte(0x11);
+      writeBytes(value, 2);
+    } else {
+      writeByte((kind << 4) + 15);
+      writeByte(0x12);
+      writeBytes(value, 4);
+    }
+  }
+
+  function writeID(id) {
+    writeBytes(id, idSizeInBytes);
+  }
+
+  function writeBytes(value, bytes, is_signedint) {
+    // write low-order bytes big-endian style
+    var buf = Buffer.alloc(bytes);
+    var z = 0;
+
+    // javascript doesn't handle large numbers
+    while (bytes > 4) {
+      buf[z++] = is_signedint ? 0xff : 0;
+      bytes--;
+    }
+
+    for (var i = bytes - 1; i >= 0; i--) {
+      buf[z++] = value >> (8 * i);
+    }
+    buffer.write(buf);
+  }
+
+  function mustBeUtf16(string) {
+    return Buffer.byteLength(string, 'utf8') != string.length;
+  }
+};
+
+function toEntries(dicts) {
+  if (dicts.bplistOverride) {
+    return [dicts];
+  }
+
+  if (dicts instanceof Array) {
+    return toEntriesArray(dicts);
+  } else if (dicts instanceof Buffer) {
+    return [
+      {
+        type: 'data',
+        value: dicts
+      }
+    ];
+  } else if (dicts instanceof Real) {
+    return [
+      {
+        type: 'double',
+        value: dicts.value
+      }
+    ];
+  } else if (typeof(dicts) === 'object') {
+    if (dicts instanceof Date) {
+      return [
+        {
+          type: 'date',
+          value: dicts
+        }
+      ]
+    } else if (Object.keys(dicts).length == 1 && typeof(dicts.UID) === 'number') {
+      return [
+        {
+          type: 'UID',
+          value: dicts.UID
+        }
+      ]
+    } else {
+      return toEntriesObject(dicts);
+    }
+  } else if (typeof(dicts) === 'string') {
+    return [
+      {
+        type: 'string',
+        value: dicts
+      }
+    ];
+  } else if (typeof(dicts) === 'number') {
+    return [
+      {
+        type: 'number',
+        value: dicts
+      }
+    ];
+  } else if (typeof(dicts) === 'boolean') {
+    return [
+      {
+        type: 'boolean',
+        value: dicts
+      }
+    ];
+  } else if (typeof(dicts) === 'bigint') {
+    return [
+      {
+        type: 'number',
+        value: dicts
+      }
+    ];
+  } else {
+    throw new Error('unhandled entry: ' + dicts);
+  }
+}
+
+function toEntriesArray(arr) {
+  if (debug) {
+    console.log('toEntriesArray');
+  }
+  var results = [
+    {
+      type: 'array',
+      entries: []
+    }
+  ];
+  arr.forEach(function(v) {
+    var entry = toEntries(v);
+    results[0].entries.push(entry[0]);
+    results = results.concat(entry);
+  });
+  return results;
+}
+
+function toEntriesObject(dict) {
+  if (debug) {
+    console.log('toEntriesObject');
+  }
+  var results = [
+    {
+      type: 'dict',
+      entryKeys: [],
+      entryValues: []
+    }
+  ];
+  Object.keys(dict).forEach(function(key) {
+    var entryKey = toEntries(key);
+    results[0].entryKeys.push(entryKey[0]);
+    results = results.concat(entryKey[0]);
+  });
+  Object.keys(dict).forEach(function(key) {
+    var entryValue = toEntries(dict[key]);
+    results[0].entryValues.push(entryValue[0]);
+    results = results.concat(entryValue);
+  });
+  return results;
+}
+
+function computeOffsetSizeInBytes(maxOffset) {
+  if (maxOffset < 256) {
+    return 1;
+  }
+  if (maxOffset < 65536) {
+    return 2;
+  }
+  if (maxOffset < 4294967296) {
+    return 4;
+  }
+  return 8;
+}
+
+function computeIdSizeInBytes(numberOfIds) {
+  if (numberOfIds < 256) {
+    return 1;
+  }
+  if (numberOfIds < 65536) {
+    return 2;
+  }
+  return 4;
+}
+
+module.exports.Real = Real;

package/plugin/node_modules/bplist-creator/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "bplist-creator",
+  "version": "0.1.0",
+  "description": "Binary Mac OS X Plist (property list) creator.",
+  "main": "bplistCreator.js",
+  "scripts": {
+    "test": "./node_modules/nodeunit/bin/nodeunit test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nearinfinity/node-bplist-creator.git"
+  },
+  "keywords": [
+    "bplist",
+    "plist",
+    "creator"
+  ],
+  "author": "Joe Ferner",
+  "license": "MIT",
+  "devDependencies": {
+    "bplist-parser": "0.3.0",
+    "is-buffer": "1.1.x",
+    "nodeunit": "0.9.x"
+  },
+  "dependencies": {
+    "stream-buffers": "2.2.x"
+  }
+}