@pdftron/pdfnet-node 10.1.0-beta → 10.1.0

package/node_modules/underscore/cjs/_createReduce.js

@@ -0,0 +1,30 @@
+var keys = require('./keys.js');
+var _optimizeCb = require('./_optimizeCb.js');
+var _isArrayLike = require('./_isArrayLike.js');
+
+// Internal helper to create a reducing function, iterating left or right.
+function createReduce(dir) {
+  // Wrap code that reassigns argument variables in a separate function than
+  // the one that accesses `arguments.length` to avoid a perf hit. (#1991)
+  var reducer = function(obj, iteratee, memo, initial) {
+    var _keys = !_isArrayLike(obj) && keys(obj),
+        length = (_keys || obj).length,
+        index = dir > 0 ? 0 : length - 1;
+    if (!initial) {
+      memo = obj[_keys ? _keys[index] : index];
+      index += dir;
+    }
+    for (; index >= 0 && index < length; index += dir) {
+      var currentKey = _keys ? _keys[index] : index;
+      memo = iteratee(memo, obj[currentKey], currentKey, obj);
+    }
+    return memo;
+  };
+
+  return function(obj, iteratee, memo, context) {
+    var initial = arguments.length >= 3;
+    return reducer(obj, _optimizeCb(iteratee, context, 4), memo, initial);
+  };
+}
+
+module.exports = createReduce;

package/node_modules/underscore/cjs/_createSizePropertyCheck.js

@@ -0,0 +1,11 @@
+var _setup = require('./_setup.js');
+
+// Common internal logic for `isArrayLike` and `isBufferLike`.
+function createSizePropertyCheck(getSizeProperty) {
+  return function(collection) {
+    var sizeProperty = getSizeProperty(collection);
+    return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= _setup.MAX_ARRAY_INDEX;
+  }
+}
+
+module.exports = createSizePropertyCheck;

package/node_modules/underscore/cjs/_deepGet.js

@@ -0,0 +1,11 @@
+// Internal function to obtain a nested property in `obj` along `path`.
+function deepGet(obj, path) {
+  var length = path.length;
+  for (var i = 0; i < length; i++) {
+    if (obj == null) return void 0;
+    obj = obj[path[i]];
+  }
+  return length ? obj : void 0;
+}
+
+module.exports = deepGet;

package/node_modules/underscore/cjs/_escapeMap.js

@@ -0,0 +1,11 @@
+// Internal list of HTML entities for escaping.
+var escapeMap = {
+  '&': '&',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#x27;',
+  '`': '&#x60;'
+};
+
+module.exports = escapeMap;

package/node_modules/underscore/cjs/_executeBound.js

@@ -0,0 +1,15 @@
+var isObject = require('./isObject.js');
+var _baseCreate = require('./_baseCreate.js');
+
+// Internal function to execute `sourceFunc` bound to `context` with optional
+// `args`. Determines whether to execute a function as a constructor or as a
+// normal function.
+function executeBound(sourceFunc, boundFunc, context, callingContext, args) {
+  if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
+  var self = _baseCreate(sourceFunc.prototype);
+  var result = sourceFunc.apply(self, args);
+  if (isObject(result)) return result;
+  return self;
+}
+
+module.exports = executeBound;

package/node_modules/underscore/cjs/_extremum.js

@@ -0,0 +1,35 @@
+var identity = require('./identity.js');
+var _cb = require('./_cb.js');
+var find = require('./find.js');
+
+// The general algorithm behind `_.min` and `_.max`. `compare` should return
+// `true` if its first argument is more extreme than (i.e., should be preferred
+// over) its second argument, `false` otherwise. `iteratee` and `context`, like
+// in other collection functions, let you map the actual values in `collection`
+// to the values to `compare`. `decide` is an optional customization point
+// which is only present for historical reasons; please don't use it, as it will
+// likely be removed in the future.
+function extremum(collection, compare, iteratee, context, decide) {
+  decide || (decide = identity);
+  // `extremum` is essentially a combined map+reduce with **two** accumulators:
+  // `result` and `iterResult`, respectively the unmapped and the mapped version
+  // corresponding to the same element.
+  var result, iterResult;
+  iteratee = _cb(iteratee, context);
+  var first = true;
+  find(collection, function(value, key) {
+    var iterValue = iteratee(value, key, collection);
+    if (first || compare(iterValue, iterResult)) {
+      result = value;
+      iterResult = iterValue;
+      first = false;
+    }
+  });
+  // `extremum` normally returns an unmapped element from `collection`. However,
+  // `_.min` and `_.max` forcibly return a number even if there is no element
+  // that maps to a numeric value. Passing both accumulators through `decide`
+  // before returning enables this behavior.
+  return decide(result, iterResult);
+}
+
+module.exports = extremum;

package/node_modules/underscore/cjs/_flatten.js

@@ -0,0 +1,33 @@
+var isArray = require('./isArray.js');
+var _getLength = require('./_getLength.js');
+var _isArrayLike = require('./_isArrayLike.js');
+var isArguments = require('./isArguments.js');
+
+// Internal implementation of a recursive `flatten` function.
+function flatten(input, depth, strict, output) {
+  output = output || [];
+  if (!depth && depth !== 0) {
+    depth = Infinity;
+  } else if (depth <= 0) {
+    return output.concat(input);
+  }
+  var idx = output.length;
+  for (var i = 0, length = _getLength(input); i < length; i++) {
+    var value = input[i];
+    if (_isArrayLike(value) && (isArray(value) || isArguments(value))) {
+      // Flatten current level of array or arguments object.
+      if (depth > 1) {
+        flatten(value, depth - 1, strict, output);
+        idx = output.length;
+      } else {
+        var j = 0, len = value.length;
+        while (j < len) output[idx++] = value[j++];
+      }
+    } else if (!strict) {
+      output[idx++] = value;
+    }
+  }
+  return output;
+}
+
+module.exports = flatten;

package/node_modules/underscore/cjs/_forceNumericMinMax.js

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _isNaN = require('./isNaN.js');
+
+// Internal `extremum` return value adapter for `_.min` and `_.max`.
+// Ensures that a number is returned even if no element of the
+// collection maps to a numeric value.
+function decideNumeric(fallback) {
+  return function(result, iterResult) {
+    return _isNaN(+iterResult) ? fallback : result;
+  }
+}
+
+exports.decideNumeric = decideNumeric;

package/node_modules/underscore/cjs/_getByteLength.js

@@ -0,0 +1,6 @@
+var _shallowProperty = require('./_shallowProperty.js');
+
+// Internal helper to obtain the `byteLength` property of an object.
+var getByteLength = _shallowProperty('byteLength');
+
+module.exports = getByteLength;

package/node_modules/underscore/cjs/_getLength.js

@@ -0,0 +1,6 @@
+var _shallowProperty = require('./_shallowProperty.js');
+
+// Internal helper to obtain the `length` property of an object.
+var getLength = _shallowProperty('length');
+
+module.exports = getLength;

package/node_modules/underscore/cjs/_greater.js

@@ -0,0 +1,6 @@
+// A version of the `>` operator that can be passed around as a function.
+function greater(left, right) {
+  return left > right;
+}
+
+module.exports = greater;

package/node_modules/underscore/cjs/_group.js

@@ -0,0 +1,17 @@
+var _cb = require('./_cb.js');
+var each = require('./each.js');
+
+// An internal function used for aggregate "group by" operations.
+function group(behavior, partition) {
+  return function(obj, iteratee, context) {
+    var result = partition ? [[], []] : {};
+    iteratee = _cb(iteratee, context);
+    each(obj, function(value, index) {
+      var key = iteratee(value, index, obj);
+      behavior(result, value, key);
+    });
+    return result;
+  };
+}
+
+module.exports = group;

package/node_modules/underscore/cjs/_has.js

@@ -0,0 +1,8 @@
+var _setup = require('./_setup.js');
+
+// Internal function to check whether `key` is an own property name of `obj`.
+function has(obj, key) {
+  return obj != null && _setup.hasOwnProperty.call(obj, key);
+}
+
+module.exports = has;

package/node_modules/underscore/cjs/_hasObjectTag.js

@@ -0,0 +1,5 @@
+var _tagTester = require('./_tagTester.js');
+
+var hasObjectTag = _tagTester('Object');
+
+module.exports = hasObjectTag;

package/node_modules/underscore/cjs/_isArrayLike.js

@@ -0,0 +1,10 @@
+var _getLength = require('./_getLength.js');
+var _createSizePropertyCheck = require('./_createSizePropertyCheck.js');
+
+// Internal helper for collection methods to determine whether a collection
+// should be iterated as an array or as an object.
+// Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
+// Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
+var isArrayLike = _createSizePropertyCheck(_getLength);
+
+module.exports = isArrayLike;

package/node_modules/underscore/cjs/_isBufferLike.js

@@ -0,0 +1,8 @@
+var _createSizePropertyCheck = require('./_createSizePropertyCheck.js');
+var _getByteLength = require('./_getByteLength.js');
+
+// Internal helper to determine whether we should spend extensive checks against
+// `ArrayBuffer` et al.
+var isBufferLike = _createSizePropertyCheck(_getByteLength);
+
+module.exports = isBufferLike;

package/node_modules/underscore/cjs/_keyInObj.js

@@ -0,0 +1,7 @@
+// Internal `_.pick` helper function to determine whether `key` is an enumerable
+// property name of `obj`.
+function keyInObj(value, key, obj) {
+  return key in obj;
+}
+
+module.exports = keyInObj;

package/node_modules/underscore/cjs/_less.js

@@ -0,0 +1,6 @@
+// A version of the `<` operator that can be passed around as a function.
+function less(left, right) {
+  return left < right;
+}
+
+module.exports = less;

package/node_modules/underscore/cjs/_lessEqual.js

@@ -0,0 +1,6 @@
+// A version of the `<=` operator that can be passed around as a function.
+function lessEqual(left, right) {
+  return left <= right;
+}
+
+module.exports = lessEqual;

package/node_modules/underscore/cjs/_linearSearch.js

@@ -0,0 +1,30 @@
+var _getLength = require('./_getLength.js');
+var isFunction = require('./isFunction.js');
+
+// Internal function for linearly iterating over arrays.
+function linearSearch(array, predicate, dir, start) {
+  var target, length = _getLength(array);
+  dir || (dir = 1);
+  start = (
+    start == null ? (dir > 0 ? 0 : length - 1) :
+    start < 0 ? (dir > 0 ? Math.max(0, start + length) : start + length) :
+    dir > 0 ? start : Math.min(start, length - 1)
+  );
+  // As a special case, in order to elide the `predicate` invocation on every
+  // loop iteration, we allow the caller to pass a value that should be found by
+  // strict equality comparison. This is somewhat like a rudimentary iteratee
+  // shorthand. It is used in `_.indexof` and `_.lastIndexOf`.
+  if (!isFunction(predicate)) {
+    target = predicate && predicate.value;
+    predicate = false;
+  }
+  for (; start >= 0 && start < length; start += dir) {
+    if (
+      predicate ? predicate(array[start], start, array) :
+      array[start] === target
+    ) return start;
+  }
+  return -1;
+}
+
+module.exports = linearSearch;

package/node_modules/underscore/cjs/_mapReduce.js

@@ -0,0 +1 @@
+

package/node_modules/underscore/cjs/_methodFingerprint.js

@@ -0,0 +1,44 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isFunction = require('./isFunction.js');
+var _getLength = require('./_getLength.js');
+var allKeys = require('./allKeys.js');
+
+// Since the regular `Object.prototype.toString` type tests don't work for
+// some types in IE 11, we use a fingerprinting heuristic instead, based
+// on the methods. It's not great, but it's the best we got.
+// The fingerprint method lists are defined below.
+function ie11fingerprint(methods) {
+  var length = _getLength(methods);
+  return function(obj) {
+    if (obj == null) return false;
+    // `Map`, `WeakMap` and `Set` have no enumerable keys.
+    var keys = allKeys(obj);
+    if (_getLength(keys)) return false;
+    for (var i = 0; i < length; i++) {
+      if (!isFunction(obj[methods[i]])) return false;
+    }
+    // If we are testing against `WeakMap`, we need to ensure that
+    // `obj` doesn't have a `forEach` method in order to distinguish
+    // it from a regular `Map`.
+    return methods !== weakMapMethods || !isFunction(obj[forEachName]);
+  };
+}
+
+// In the interest of compact minification, we write
+// each string in the fingerprints only once.
+var forEachName = 'forEach',
+    hasName = 'has',
+    commonInit = ['clear', 'delete'],
+    mapTail = ['get', hasName, 'set'];
+
+// `Map`, `WeakMap` and `Set` each have slightly different
+// combinations of the above sublists.
+var mapMethods = commonInit.concat(forEachName, mapTail),
+    weakMapMethods = commonInit.concat(mapTail),
+    setMethods = ['add'].concat(commonInit, forEachName, hasName);
+
+exports.ie11fingerprint = ie11fingerprint;
+exports.mapMethods = mapMethods;
+exports.setMethods = setMethods;
+exports.weakMapMethods = weakMapMethods;

package/node_modules/underscore/cjs/_optimizeCb.js

@@ -0,0 +1,23 @@
+// Internal function that returns an efficient (for current engines) version
+// of the passed-in callback, to be repeatedly applied in other Underscore
+// functions.
+function optimizeCb(func, context, argCount) {
+  if (context === void 0) return func;
+  switch (argCount == null ? 3 : argCount) {
+    case 1: return function(value) {
+      return func.call(context, value);
+    };
+    // The 2-argument case is omitted because we’re not using it.
+    case 3: return function(value, index, collection) {
+      return func.call(context, value, index, collection);
+    };
+    case 4: return function(accumulator, value, index, collection) {
+      return func.call(context, accumulator, value, index, collection);
+    };
+  }
+  return function() {
+    return func.apply(context, arguments);
+  };
+}
+
+module.exports = optimizeCb;

package/node_modules/underscore/cjs/_push.js

@@ -0,0 +1,6 @@
+var _setup = require('./_setup.js');
+var _unmethodize = require('./_unmethodize.js');
+
+var push = _unmethodize(_setup.ArrayProto.push);
+
+module.exports = push;

package/node_modules/underscore/cjs/_pusher.js

@@ -0,0 +1,9 @@
+// Internal helper to generate a callback that will append
+// its first argument to the closed-over `array`.
+function pusher(array) {
+  return function(arg) {
+    array.push(arg);
+  };
+}
+
+module.exports = pusher;

package/node_modules/underscore/cjs/_sequence.js

@@ -0,0 +1,14 @@
+function sequence(iteratee, start, stop, step) {
+  if (stop == null) {
+    stop = start || 0;
+    start = 0;
+  }
+  if (!step) {
+    step = stop < start ? -1 : 1;
+  }
+  var rest = (stop - start) % step;
+  stop += (rest && step - rest);
+  for ( ; start != stop ; start += step) if (iteratee(start)) return start;
+}
+
+module.exports = sequence;

package/node_modules/underscore/cjs/_setup.js

@@ -0,0 +1,66 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// Current version.
+var VERSION = '1.12.1';
+
+// Establish the root object, `window` (`self`) in the browser, `global`
+// on the server, or `this` in some virtual machines. We use `self`
+// instead of `window` for `WebWorker` support.
+var root = typeof self == 'object' && self.self === self && self ||
+          typeof global == 'object' && global.global === global && global ||
+          Function('return this')() ||
+          {};
+
+// Save bytes in the minified (but not gzipped) version:
+var ArrayProto = Array.prototype, ObjProto = Object.prototype;
+var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;
+
+// Create quick reference variables for speed access to core prototypes.
+var push = ArrayProto.push,
+    slice = ArrayProto.slice,
+    toString = ObjProto.toString,
+    hasOwnProperty = ObjProto.hasOwnProperty;
+
+// Modern feature detection.
+var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',
+    supportsDataView = typeof DataView !== 'undefined';
+
+// All **ECMAScript 5+** native function implementations that we hope to use
+// are declared here.
+var nativeIsArray = Array.isArray,
+    nativeKeys = Object.keys,
+    nativeCreate = Object.create,
+    nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;
+
+// Create references to these builtin functions because we override them.
+var _isNaN = isNaN,
+    _isFinite = isFinite;
+
+// Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
+var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
+var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
+  'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
+
+// The largest integer that can be represented exactly.
+var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
+
+exports.ArrayProto = ArrayProto;
+exports.MAX_ARRAY_INDEX = MAX_ARRAY_INDEX;
+exports.ObjProto = ObjProto;
+exports.SymbolProto = SymbolProto;
+exports.VERSION = VERSION;
+exports._isFinite = _isFinite;
+exports._isNaN = _isNaN;
+exports.hasEnumBug = hasEnumBug;
+exports.hasOwnProperty = hasOwnProperty;
+exports.nativeCreate = nativeCreate;
+exports.nativeIsArray = nativeIsArray;
+exports.nativeIsView = nativeIsView;
+exports.nativeKeys = nativeKeys;
+exports.nonEnumerableProps = nonEnumerableProps;
+exports.push = push;
+exports.root = root;
+exports.slice = slice;
+exports.supportsArrayBuffer = supportsArrayBuffer;
+exports.supportsDataView = supportsDataView;
+exports.toString = toString;

package/node_modules/underscore/cjs/_shallowProperty.js

@@ -0,0 +1,8 @@
+// Internal helper to generate a function to obtain property `key` from `obj`.
+function shallowProperty(key) {
+  return function(obj) {
+    return obj == null ? void 0 : obj[key];
+  };
+}
+
+module.exports = shallowProperty;

package/node_modules/underscore/cjs/_slice.js

@@ -0,0 +1,6 @@
+var _setup = require('./_setup.js');
+var _unmethodize = require('./_unmethodize.js');
+
+var slice = _unmethodize(_setup.ArrayProto.slice);
+
+module.exports = slice;

package/node_modules/underscore/cjs/_strictEqual.js

@@ -0,0 +1,5 @@
+function strictEqual(left, right) {
+  return left === right;
+}
+
+module.exports = strictEqual;

package/node_modules/underscore/cjs/_stringTagBug.js

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _setup = require('./_setup.js');
+var _hasObjectTag = require('./_hasObjectTag.js');
+
+// In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.
+// In IE 11, the most common among them, this problem also applies to
+// `Map`, `WeakMap` and `Set`.
+var hasStringTagBug = (
+      _setup.supportsDataView && _hasObjectTag(new DataView(new ArrayBuffer(8)))
+    ),
+    isIE11 = (typeof Map !== 'undefined' && _hasObjectTag(new Map));
+
+exports.hasStringTagBug = hasStringTagBug;
+exports.isIE11 = isIE11;

package/node_modules/underscore/cjs/_tagTester.js

@@ -0,0 +1,11 @@
+var _setup = require('./_setup.js');
+
+// Internal function for creating a `toString`-based type tester.
+function tagTester(name) {
+  var tag = '[object ' + name + ']';
+  return function(obj) {
+    return _setup.toString.call(obj) === tag;
+  };
+}
+
+module.exports = tagTester;

package/node_modules/underscore/cjs/_toBufferView.js

@@ -0,0 +1,13 @@
+var _getByteLength = require('./_getByteLength.js');
+
+// Internal function to wrap or shallow-copy an ArrayBuffer,
+// typed array or DataView to a new view, reusing the buffer.
+function toBufferView(bufferSource) {
+  return new Uint8Array(
+    bufferSource.buffer || bufferSource,
+    bufferSource.byteOffset || 0,
+    _getByteLength(bufferSource)
+  );
+}
+
+module.exports = toBufferView;

package/node_modules/underscore/cjs/_toPath.js

@@ -0,0 +1,10 @@
+var underscore = require('./underscore.js');
+require('./toPath.js');
+
+// Internal wrapper for `_.toPath` to enable minification.
+// Similar to `cb` for `_.iteratee`.
+function toPath(path) {
+  return underscore.toPath(path);
+}
+
+module.exports = toPath;

package/node_modules/underscore/cjs/_unescapeMap.js

@@ -0,0 +1,7 @@
+var _escapeMap = require('./_escapeMap.js');
+var invert = require('./invert.js');
+
+// Internal list of HTML entities for unescaping.
+var unescapeMap = invert(_escapeMap);
+
+module.exports = unescapeMap;

package/node_modules/underscore/cjs/_unmethodize.js

@@ -0,0 +1,8 @@
+var _bindCb = require('./_bindCb.js');
+var _setup = require('./_setup.js');
+
+function unmethodize(method) {
+  return _bindCb(_setup.call, method);
+}
+
+module.exports = unmethodize;

package/node_modules/underscore/cjs/_wrapArrayAccessor.js

@@ -0,0 +1,14 @@
+var _setup = require('./_setup.js');
+var restArguments = require('./restArguments.js');
+
+// Internal function to wrap `Array.prototype` methods that return a
+// new value so they can be directly invoked as standalone functions.
+// Works for `concat`, `slice` and `join`.
+function wrapArrayAccessor(name) {
+  var method = _setup.ArrayProto[name];
+  return restArguments(function(array, args) {
+    return array == null ? array : method.apply(array, args);
+  });
+}
+
+module.exports = wrapArrayAccessor;

package/node_modules/underscore/cjs/_wrapArrayMutator.js

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _setup = require('./_setup.js');
+var _getLength = require('./_getLength.js');
+var identity = require('./identity.js');
+var restArguments = require('./restArguments.js');
+
+// Internal function to work around a bug in IE < 9. See
+// https://github.com/jashkenas/underscore/issues/397.
+function removeGhostHead(array) {
+  if (!_getLength(array)) delete array[0];
+  return array;
+}
+
+// Internal function to wrap `Array.prototype` methods that modify
+// the context in place so they can be directly invoked as standalone
+// functions. Works for `pop`, `push`, `reverse`, `shift`, `sort`,
+// `splice` and `unshift`.
+function wrapArrayMutator(name, fixup) {
+  var method = _setup.ArrayProto[name];
+  fixup || (fixup = identity);
+  return restArguments(function(array, args) {
+    if (array != null) method.apply(array, args);
+    return fixup(array);
+  });
+}
+
+exports.default = wrapArrayMutator;
+exports.removeGhostHead = removeGhostHead;

package/node_modules/underscore/cjs/after.js

@@ -0,0 +1,10 @@
+// Returns a function that will only be executed on and after the Nth call.
+function after(times, func) {
+  return function() {
+    if (--times < 1) {
+      return func.apply(this, arguments);
+    }
+  };
+}
+
+module.exports = after;

package/node_modules/underscore/cjs/allKeys.js

@@ -0,0 +1,15 @@
+var isObject = require('./isObject.js');
+var _setup = require('./_setup.js');
+var _collectNonEnumProps = require('./_collectNonEnumProps.js');
+
+// Retrieve all the enumerable property names of an object.
+function allKeys(obj) {
+  if (!isObject(obj)) return [];
+  var keys = [];
+  for (var key in obj) keys.push(key);
+  // Ahem, IE < 9.
+  if (_setup.hasEnumBug) _collectNonEnumProps(obj, keys);
+  return keys;
+}
+
+module.exports = allKeys;