@pdftron/pdfnet-node 10.1.0-beta → 10.1.1-beta

package/node_modules/underscore/cjs/before.js

@@ -0,0 +1,14 @@
+// Returns a function that will only be executed up to (but not including) the
+// Nth call.
+function before(times, func) {
+  var memo;
+  return function() {
+    if (--times > 0) {
+      memo = func.apply(this, arguments);
+    }
+    if (times <= 1) func = null;
+    return memo;
+  };
+}
+
+module.exports = before;

package/node_modules/underscore/cjs/bind.js

@@ -0,0 +1,15 @@
+var isFunction = require('./isFunction.js');
+var _executeBound = require('./_executeBound.js');
+var restArguments = require('./restArguments.js');
+
+// Create a function bound to a given object (assigning `this`, and arguments,
+// optionally).
+var bind = restArguments(function(func, context, args) {
+  if (!isFunction(func)) throw new TypeError('Bind must be called on a function');
+  var bound = restArguments(function(callArgs) {
+    return _executeBound(func, bound, context, this, args.concat(callArgs));
+  });
+  return bound;
+});
+
+module.exports = bind;

package/node_modules/underscore/cjs/bindAll.js

@@ -0,0 +1,19 @@
+var _flatten = require('./_flatten.js');
+var restArguments = require('./restArguments.js');
+var bind = require('./bind.js');
+
+// Bind a number of an object's methods to that object. Remaining arguments
+// are the method names to be bound. Useful for ensuring that all callbacks
+// defined on an object belong to it.
+var bindAll = restArguments(function(obj, keys) {
+  keys = _flatten(keys, false, false);
+  var index = keys.length;
+  if (index < 1) throw new Error('bindAll must be passed function names');
+  while (index--) {
+    var key = keys[index];
+    obj[key] = bind(obj[key], obj);
+  }
+  return obj;
+});
+
+module.exports = bindAll;

package/node_modules/underscore/cjs/chain.js

@@ -0,0 +1,10 @@
+var underscore = require('./underscore.js');
+
+// Start chaining a wrapped Underscore object.
+function chain(obj) {
+  var instance = underscore(obj);
+  instance._chain = true;
+  return instance;
+}
+
+module.exports = chain;

package/node_modules/underscore/cjs/chunk.js

@@ -0,0 +1,15 @@
+var _setup = require('./_setup.js');
+
+// Chunk a single array into multiple arrays, each containing `count` or fewer
+// items.
+function chunk(array, count) {
+  if (count == null || count < 1) return [];
+  var result = [];
+  var i = 0, length = array.length;
+  while (i < length) {
+    result.push(_setup.slice.call(array, i, i += count));
+  }
+  return result;
+}
+
+module.exports = chunk;

package/node_modules/underscore/cjs/clone.js

@@ -0,0 +1,11 @@
+var isObject = require('./isObject.js');
+var isArray = require('./isArray.js');
+var extend = require('./extend.js');
+
+// Create a (shallow-cloned) duplicate of an object.
+function clone(obj) {
+  if (!isObject(obj)) return obj;
+  return isArray(obj) ? obj.slice() : extend({}, obj);
+}
+
+module.exports = clone;

package/node_modules/underscore/cjs/compact.js

@@ -0,0 +1,8 @@
+var filter = require('./filter.js');
+
+// Trim out all falsy values from an array.
+function compact(array) {
+  return filter(array, Boolean);
+}
+
+module.exports = compact;

package/node_modules/underscore/cjs/compose.js

@@ -0,0 +1,14 @@
+// Returns a function that is the composition of a list of functions, each
+// consuming the return value of the function that follows.
+function compose() {
+  var args = arguments;
+  var start = args.length - 1;
+  return function() {
+    var i = start;
+    var result = args[start].apply(this, arguments);
+    while (i--) result = args[i].call(this, result);
+    return result;
+  };
+}
+
+module.exports = compose;

package/node_modules/underscore/cjs/concat.js

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

package/node_modules/underscore/cjs/constant.js

@@ -0,0 +1,8 @@
+// Predicate-generating function. Often useful outside of Underscore.
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+
+module.exports = constant;

package/node_modules/underscore/cjs/contains.js

@@ -0,0 +1,12 @@
+var _isArrayLike = require('./_isArrayLike.js');
+var values = require('./values.js');
+var indexOf = require('./indexOf.js');
+
+// Determine if the array or object contains a given item (using `===`).
+function contains(obj, item, fromIndex, guard) {
+  if (!_isArrayLike(obj)) obj = values(obj);
+  if (typeof fromIndex != 'number' || guard) fromIndex = 0;
+  return indexOf(obj, item, fromIndex) >= 0;
+}
+
+module.exports = contains;

package/node_modules/underscore/cjs/countBy.js

@@ -0,0 +1,11 @@
+var _has = require('./_has.js');
+var _group = require('./_group.js');
+
+// Counts instances of an object that group by a certain criterion. Pass
+// either a string attribute to count by, or a function that returns the
+// criterion.
+var countBy = _group(function(result, value, key) {
+  if (_has(result, key)) result[key]++; else result[key] = 1;
+});
+
+module.exports = countBy;

package/node_modules/underscore/cjs/create.js

@@ -0,0 +1,13 @@
+var _baseCreate = require('./_baseCreate.js');
+var extendOwn = require('./extendOwn.js');
+
+// Creates an object that inherits from the given prototype object.
+// If additional properties are provided then they will be added to the
+// created object.
+function create(prototype, props) {
+  var result = _baseCreate(prototype);
+  if (props) extendOwn(result, props);
+  return result;
+}
+
+module.exports = create;

package/node_modules/underscore/cjs/debounce.js

@@ -0,0 +1,42 @@
+var restArguments = require('./restArguments.js');
+var now = require('./now.js');
+
+// When a sequence of calls of the returned function ends, the argument
+// function is triggered. The end of a sequence is defined by the `wait`
+// parameter. If `immediate` is passed, the argument function will be
+// triggered at the beginning of the sequence instead of at the end.
+function debounce(func, wait, immediate) {
+  var timeout, previous, args, result, context;
+
+  var later = function() {
+    var passed = now() - previous;
+    if (wait > passed) {
+      timeout = setTimeout(later, wait - passed);
+    } else {
+      timeout = null;
+      if (!immediate) result = func.apply(context, args);
+      // This check is needed because `func` can recursively invoke `debounced`.
+      if (!timeout) args = context = null;
+    }
+  };
+
+  var debounced = restArguments(function(_args) {
+    context = this;
+    args = _args;
+    previous = now();
+    if (!timeout) {
+      timeout = setTimeout(later, wait);
+      if (immediate) result = func.apply(context, args);
+    }
+    return result;
+  });
+
+  debounced.cancel = function() {
+    clearTimeout(timeout);
+    timeout = args = context = null;
+  };
+
+  return debounced;
+}
+
+module.exports = debounce;

package/node_modules/underscore/cjs/defaults.js

@@ -0,0 +1,7 @@
+var _createAssigner = require('./_createAssigner.js');
+var allKeys = require('./allKeys.js');
+
+// Fill in a given object with default properties.
+var defaults = _createAssigner(allKeys, true);
+
+module.exports = defaults;

package/node_modules/underscore/cjs/defer.js

@@ -0,0 +1,9 @@
+var underscore = require('./underscore.js');
+var partial = require('./partial.js');
+var delay = require('./delay.js');
+
+// Defers a function, scheduling it to run after the current call stack has
+// cleared.
+var defer = partial(delay, underscore, 1);
+
+module.exports = defer;

package/node_modules/underscore/cjs/delay.js

@@ -0,0 +1,11 @@
+var restArguments = require('./restArguments.js');
+
+// Delays a function for the given number of milliseconds, and then calls
+// it with the arguments supplied.
+var delay = restArguments(function(func, wait, args) {
+  return setTimeout(function() {
+    return func.apply(null, args);
+  }, wait);
+});
+
+module.exports = delay;

package/node_modules/underscore/cjs/difference.js

@@ -0,0 +1,15 @@
+var _flatten = require('./_flatten.js');
+var restArguments = require('./restArguments.js');
+var filter = require('./filter.js');
+var contains = require('./contains.js');
+
+// Take the difference between one array and a number of other arrays.
+// Only the elements present in just the first array will remain.
+var difference = restArguments(function(array, rest) {
+  rest = _flatten(rest, true, true);
+  return filter(array, function(value){
+    return !contains(rest, value);
+  });
+});
+
+module.exports = difference;

package/node_modules/underscore/cjs/each.js

@@ -0,0 +1,25 @@
+var keys = require('./keys.js');
+var _optimizeCb = require('./_optimizeCb.js');
+var _isArrayLike = require('./_isArrayLike.js');
+
+// The cornerstone for collection functions, an `each`
+// implementation, aka `forEach`.
+// Handles raw objects in addition to array-likes. Treats all
+// sparse array-likes as if they were dense.
+function each(obj, iteratee, context) {
+  iteratee = _optimizeCb(iteratee, context);
+  var i, length;
+  if (_isArrayLike(obj)) {
+    for (i = 0, length = obj.length; i < length; i++) {
+      iteratee(obj[i], i, obj);
+    }
+  } else {
+    var _keys = keys(obj);
+    for (i = 0, length = _keys.length; i < length; i++) {
+      iteratee(obj[_keys[i]], _keys[i], obj);
+    }
+  }
+  return obj;
+}
+
+module.exports = each;

package/node_modules/underscore/cjs/escape.js

@@ -0,0 +1,7 @@
+var _createEscaper = require('./_createEscaper.js');
+var _escapeMap = require('./_escapeMap.js');
+
+// Function for escaping strings to HTML interpolation.
+var _escape = _createEscaper(_escapeMap);
+
+module.exports = _escape;

package/node_modules/underscore/cjs/every.js

@@ -0,0 +1,17 @@
+var keys = require('./keys.js');
+var _cb = require('./_cb.js');
+var _isArrayLike = require('./_isArrayLike.js');
+
+// Determine whether all of the elements pass a truth test.
+function every(obj, predicate, context) {
+  predicate = _cb(predicate, context);
+  var _keys = !_isArrayLike(obj) && keys(obj),
+      length = (_keys || obj).length;
+  for (var index = 0; index < length; index++) {
+    var currentKey = _keys ? _keys[index] : index;
+    if (!predicate(obj[currentKey], currentKey, obj)) return false;
+  }
+  return true;
+}
+
+module.exports = every;

package/node_modules/underscore/cjs/extend.js

@@ -0,0 +1,7 @@
+var _createAssigner = require('./_createAssigner.js');
+var allKeys = require('./allKeys.js');
+
+// Extend a given object with all the properties in passed-in object(s).
+var extend = _createAssigner(allKeys);
+
+module.exports = extend;

package/node_modules/underscore/cjs/extendOwn.js

@@ -0,0 +1,9 @@
+var _createAssigner = require('./_createAssigner.js');
+var keys = require('./keys.js');
+
+// Assigns a given object with all the own properties in the passed-in
+// object(s).
+// (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
+var extendOwn = _createAssigner(keys);
+
+module.exports = extendOwn;

package/node_modules/underscore/cjs/filter.js

@@ -0,0 +1,14 @@
+var _cb = require('./_cb.js');
+var each = require('./each.js');
+
+// Return all the elements that pass a truth test.
+function filter(obj, predicate, context) {
+  var results = [];
+  predicate = _cb(predicate, context);
+  each(obj, function(value, index, list) {
+    if (predicate(value, index, list)) results.push(value);
+  });
+  return results;
+}
+
+module.exports = filter;

package/node_modules/underscore/cjs/find.js

@@ -0,0 +1,12 @@
+var _isArrayLike = require('./_isArrayLike.js');
+var findIndex = require('./findIndex.js');
+var findKey = require('./findKey.js');
+
+// Return the first value which passes a truth test.
+function find(obj, predicate, context) {
+  var keyFinder = _isArrayLike(obj) ? findIndex : findKey;
+  var key = keyFinder(obj, predicate, context);
+  if (key !== void 0 && key !== -1) return obj[key];
+}
+
+module.exports = find;

package/node_modules/underscore/cjs/findIndex.js

@@ -0,0 +1,6 @@
+var _createPredicateIndexFinder = require('./_createPredicateIndexFinder.js');
+
+// Returns the first index on an array-like that passes a truth test.
+var findIndex = _createPredicateIndexFinder(1);
+
+module.exports = findIndex;

package/node_modules/underscore/cjs/findKey.js

@@ -0,0 +1,14 @@
+var keys = require('./keys.js');
+var _cb = require('./_cb.js');
+
+// Returns the first key on an object that passes a truth test.
+function findKey(obj, predicate, context) {
+  predicate = _cb(predicate, context);
+  var _keys = keys(obj), key;
+  for (var i = 0, length = _keys.length; i < length; i++) {
+    key = _keys[i];
+    if (predicate(obj[key], key, obj)) return key;
+  }
+}
+
+module.exports = findKey;

package/node_modules/underscore/cjs/findLastIndex.js

@@ -0,0 +1,6 @@
+var _createPredicateIndexFinder = require('./_createPredicateIndexFinder.js');
+
+// Returns the last index on an array-like that passes a truth test.
+var findLastIndex = _createPredicateIndexFinder(-1);
+
+module.exports = findLastIndex;

package/node_modules/underscore/cjs/findWhere.js

@@ -0,0 +1,10 @@
+var matcher = require('./matcher.js');
+var find = require('./find.js');
+
+// Convenience version of a common use case of `_.find`: getting the first
+// object containing specific `key:value` pairs.
+function findWhere(obj, attrs) {
+  return find(obj, matcher(attrs));
+}
+
+module.exports = findWhere;

package/node_modules/underscore/cjs/first.js

@@ -0,0 +1,11 @@
+var initial = require('./initial.js');
+
+// Get the first element of an array. Passing **n** will return the first N
+// values in the array. The **guard** check allows it to work with `_.map`.
+function first(array, n, guard) {
+  if (array == null || array.length < 1) return n == null || guard ? void 0 : [];
+  if (n == null || guard) return array[0];
+  return initial(array, array.length - n);
+}
+
+module.exports = first;

package/node_modules/underscore/cjs/flatten.js

@@ -0,0 +1,9 @@
+var _flatten = require('./_flatten.js');
+
+// Flatten out an array, either recursively (by default), or up to `depth`.
+// Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.
+function flatten(array, depth) {
+  return _flatten(array, depth, false);
+}
+
+module.exports = flatten;

package/node_modules/underscore/cjs/functions.js

@@ -0,0 +1,12 @@
+var isFunction = require('./isFunction.js');
+
+// Return a sorted list of the function names available on the object.
+function functions(obj) {
+  var names = [];
+  for (var key in obj) {
+    if (isFunction(obj[key])) names.push(key);
+  }
+  return names.sort();
+}
+
+module.exports = functions;

package/node_modules/underscore/cjs/get.js

@@ -0,0 +1,14 @@
+var _deepGet = require('./_deepGet.js');
+var _toPath = require('./_toPath.js');
+var isUndefined = require('./isUndefined.js');
+
+// Get the value of the (deep) property on `path` from `object`.
+// If any property in `path` does not exist or if the value is
+// `undefined`, return `defaultValue` instead.
+// The `path` is normalized through `_.toPath`.
+function get(object, path, defaultValue) {
+  var value = _deepGet(object, _toPath(path));
+  return isUndefined(value) ? defaultValue : value;
+}
+
+module.exports = get;

package/node_modules/underscore/cjs/groupBy.js

@@ -0,0 +1,10 @@
+var _has = require('./_has.js');
+var _group = require('./_group.js');
+
+// Groups the object's values by a criterion. Pass either a string attribute
+// to group by, or a function that returns the criterion.
+var groupBy = _group(function(result, value, key) {
+  if (_has(result, key)) result[key].push(value); else result[key] = [value];
+});
+
+module.exports = groupBy;

package/node_modules/underscore/cjs/has.js

@@ -0,0 +1,18 @@
+var _has = require('./_has.js');
+var _toPath = require('./_toPath.js');
+
+// Shortcut function for checking if an object has a given property directly on
+// itself (in other words, not on a prototype). Unlike the internal `has`
+// function, this public version can also traverse nested properties.
+function has(obj, path) {
+  path = _toPath(path);
+  var length = path.length;
+  for (var i = 0; i < length; i++) {
+    var key = path[i];
+    if (!_has(obj, key)) return false;
+    obj = obj[key];
+  }
+  return !!length;
+}
+
+module.exports = has;

package/node_modules/underscore/cjs/identity.js

@@ -0,0 +1,6 @@
+// Keep the identity function around for default iteratees.
+function identity(value) {
+  return value;
+}
+
+module.exports = identity;

package/node_modules/underscore/cjs/index-default.js

@@ -0,0 +1,11 @@
+var mixin = require('./mixin.js');
+var index = require('./index.js');
+
+// Default Export
+
+// Add all of the Underscore functions to the wrapper object.
+var _ = mixin(index);
+// Legacy Node.js API.
+_._ = _;
+
+module.exports = _;