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

package/node_modules/underscore/amd/debounce.js

@@ -0,0 +1,43 @@
+define(['./restArguments', './now'], function (restArguments, now) {
+
+  // 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;
+  }
+
+  return debounce;
+
+});

package/node_modules/underscore/amd/defaults.js

@@ -0,0 +1,8 @@
+define(['./_createAssigner', './allKeys'], function (_createAssigner, allKeys) {
+
+	// Fill in a given object with default properties.
+	var defaults = _createAssigner(allKeys, true);
+
+	return defaults;
+
+});

package/node_modules/underscore/amd/defer.js

@@ -0,0 +1,9 @@
+define(['./underscore', './partial', './delay'], function (underscore, partial, delay) {
+
+	// Defers a function, scheduling it to run after the current call stack has
+	// cleared.
+	var defer = partial(delay, underscore, 1);
+
+	return defer;
+
+});

package/node_modules/underscore/amd/delay.js

@@ -0,0 +1,13 @@
+define(['./restArguments'], function (restArguments) {
+
+  // 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);
+  });
+
+  return delay;
+
+});

package/node_modules/underscore/amd/difference.js

@@ -0,0 +1,14 @@
+define(['./_flatten', './restArguments', './filter', './contains'], function (_flatten, restArguments, filter, contains) {
+
+  // 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);
+    });
+  });
+
+  return difference;
+
+});

package/node_modules/underscore/amd/each.js

@@ -0,0 +1,25 @@
+define(['./keys', './_optimizeCb', './_isArrayLike'], function (keys, _optimizeCb, _isArrayLike) {
+
+  // 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;
+  }
+
+  return each;
+
+});

package/node_modules/underscore/amd/escape.js

@@ -0,0 +1,8 @@
+define(['./_createEscaper', './_escapeMap'], function (_createEscaper, _escapeMap) {
+
+	// Function for escaping strings to HTML interpolation.
+	var _escape = _createEscaper(_escapeMap);
+
+	return _escape;
+
+});

package/node_modules/underscore/amd/every.js

@@ -0,0 +1,17 @@
+define(['./keys', './_cb', './_isArrayLike'], function (keys, _cb, _isArrayLike) {
+
+  // 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;
+  }
+
+  return every;
+
+});

package/node_modules/underscore/amd/extend.js

@@ -0,0 +1,8 @@
+define(['./_createAssigner', './allKeys'], function (_createAssigner, allKeys) {
+
+	// Extend a given object with all the properties in passed-in object(s).
+	var extend = _createAssigner(allKeys);
+
+	return extend;
+
+});

package/node_modules/underscore/amd/extendOwn.js

@@ -0,0 +1,10 @@
+define(['./_createAssigner', './keys'], function (_createAssigner, keys) {
+
+	// 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);
+
+	return extendOwn;
+
+});

package/node_modules/underscore/amd/filter.js

@@ -0,0 +1,15 @@
+define(['./_cb', './each'], function (_cb, each) {
+
+  // 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;
+  }
+
+  return filter;
+
+});

package/node_modules/underscore/amd/find.js

@@ -0,0 +1,12 @@
+define(['./_isArrayLike', './findIndex', './findKey'], function (_isArrayLike, findIndex, findKey) {
+
+  // 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];
+  }
+
+  return find;
+
+});

package/node_modules/underscore/amd/findIndex.js

@@ -0,0 +1,8 @@
+define(['./_createPredicateIndexFinder'], function (_createPredicateIndexFinder) {
+
+	// Returns the first index on an array-like that passes a truth test.
+	var findIndex = _createPredicateIndexFinder(1);
+
+	return findIndex;
+
+});

package/node_modules/underscore/amd/findKey.js

@@ -0,0 +1,15 @@
+define(['./keys', './_cb'], function (keys, _cb) {
+
+  // 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;
+    }
+  }
+
+  return findKey;
+
+});

package/node_modules/underscore/amd/findLastIndex.js

@@ -0,0 +1,8 @@
+define(['./_createPredicateIndexFinder'], function (_createPredicateIndexFinder) {
+
+	// Returns the last index on an array-like that passes a truth test.
+	var findLastIndex = _createPredicateIndexFinder(-1);
+
+	return findLastIndex;
+
+});

package/node_modules/underscore/amd/findWhere.js

@@ -0,0 +1,11 @@
+define(['./matcher', './find'], function (matcher, find) {
+
+  // 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));
+  }
+
+  return findWhere;
+
+});

package/node_modules/underscore/amd/first.js

@@ -0,0 +1,13 @@
+define(['./initial'], function (initial) {
+
+  // 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);
+  }
+
+  return first;
+
+});

package/node_modules/underscore/amd/flatten.js

@@ -0,0 +1,11 @@
+define(['./_flatten'], function (_flatten) {
+
+  // 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);
+  }
+
+  return flatten;
+
+});

package/node_modules/underscore/amd/functions.js

@@ -0,0 +1,14 @@
+define(['./isFunction'], function (isFunction) {
+
+  // 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();
+  }
+
+  return functions;
+
+});

package/node_modules/underscore/amd/get.js

@@ -0,0 +1,14 @@
+define(['./_deepGet', './_toPath', './isUndefined'], function (_deepGet, _toPath, isUndefined) {
+
+  // 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;
+  }
+
+  return get;
+
+});

package/node_modules/underscore/amd/groupBy.js

@@ -0,0 +1,11 @@
+define(['./_has', './_group'], function (_has, _group) {
+
+  // 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];
+  });
+
+  return groupBy;
+
+});

package/node_modules/underscore/amd/has.js

@@ -0,0 +1,19 @@
+define(['./_has', './_toPath'], function (_has, _toPath) {
+
+  // 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;
+  }
+
+  return has;
+
+});

package/node_modules/underscore/amd/identity.js

@@ -0,0 +1,10 @@
+define(function () {
+
+  // Keep the identity function around for default iteratees.
+  function identity(value) {
+    return value;
+  }
+
+  return identity;
+
+});

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

@@ -0,0 +1,12 @@
+define(['./mixin', './index'], function (mixin, index) {
+
+	// Default Export
+
+	// Add all of the Underscore functions to the wrapper object.
+	var _ = mixin(index);
+	// Legacy Node.js API.
+	_._ = _;
+
+	return _;
+
+});

package/node_modules/underscore/amd/index.js

@@ -0,0 +1,154 @@
+define(['exports', './isObject', './_setup', './identity', './isFunction', './isArray', './keys', './extendOwn', './isMatch', './matcher', './toPath', './property', './iteratee', './isNumber', './isNaN', './isArguments', './each', './allKeys', './invert', './after', './before', './restArguments', './bind', './bindAll', './chain', './chunk', './extend', './clone', './filter', './compact', './compose', './constant', './values', './sortedIndex', './findIndex', './indexOf', './contains', './countBy', './create', './now', './debounce', './defaults', './partial', './delay', './defer', './difference', './escape', './every', './findKey', './find', './findLastIndex', './findWhere', './initial', './first', './flatten', './functions', './isUndefined', './get', './groupBy', './has', './isNull', './isBoolean', './isElement', './isString', './isDate', './isRegExp', './isError', './isSymbol', './isArrayBuffer', './isDataView', './isFinite', './isTypedArray', './isEmpty', './isEqual', './isMap', './isWeakMap', './isSet', './isWeakSet', './pairs', './tap', './mapObject', './noop', './propertyOf', './times', './random', './unescape', './templateSettings', './template', './result', './uniqueId', './memoize', './throttle', './wrap', './negate', './once', './lastIndexOf', './map', './reduce', './reduceRight', './reject', './some', './invoke', './pluck', './where', './max', './min', './sample', './shuffle', './sortBy', './indexBy', './partition', './toArray', './size', './pick', './omit', './rest', './last', './without', './uniq', './union', './intersection', './unzip', './zip', './object', './range', './mixin', './underscore-array-methods'], function (exports, isObject, _setup, identity, isFunction, isArray, keys, extendOwn, isMatch, matcher, toPath$1, property, iteratee, isNumber, _isNaN, isArguments, each, allKeys, invert, after, before, restArguments, bind, bindAll, chain, chunk, extend, clone, filter, compact, compose, constant, values, sortedIndex, findIndex, indexOf, contains, countBy, create, now, debounce, defaults, partial, delay, defer, difference, _escape, every, findKey, find, findLastIndex, findWhere, initial, first, flatten, functions, isUndefined, get, groupBy, has, isNull, isBoolean, isElement, isString, isDate, isRegExp, isError, isSymbol, isArrayBuffer, isDataView, _isFinite, isTypedArray, isEmpty, isEqual, isMap, isWeakMap, isSet, isWeakSet, pairs, tap, mapObject, noop, propertyOf, times, random, _unescape, templateSettings, template, result, uniqueId, memoize, throttle, wrap, negate, once, lastIndexOf, map, reduce, reduceRight, reject, some, invoke, pluck, where, max, min, sample, shuffle, sortBy, indexBy, partition, toArray, size, pick, omit, rest, last, without, uniq, union, intersection, unzip, zip, object, range, mixin, underscoreArrayMethods) {
+
+         // Named Exports
+
+         exports.isObject = isObject;
+         exports.VERSION = _setup.VERSION;
+         exports.identity = identity;
+         exports.isFunction = isFunction;
+         exports.isArray = isArray;
+         exports.keys = keys;
+         exports.assign = extendOwn;
+         exports.extendOwn = extendOwn;
+         exports.isMatch = isMatch;
+         exports.matcher = matcher;
+         exports.matches = matcher;
+         exports.toPath = toPath$1;
+         exports.property = property;
+         exports.iteratee = iteratee;
+         exports.isNumber = isNumber;
+         exports.isNaN = _isNaN;
+         exports.isArguments = isArguments;
+         exports.each = each;
+         exports.forEach = each;
+         exports.allKeys = allKeys;
+         exports.invert = invert;
+         exports.after = after;
+         exports.before = before;
+         exports.restArguments = restArguments;
+         exports.bind = bind;
+         exports.bindAll = bindAll;
+         exports.chain = chain;
+         exports.chunk = chunk;
+         exports.extend = extend;
+         exports.clone = clone;
+         exports.filter = filter;
+         exports.select = filter;
+         exports.compact = compact;
+         exports.compose = compose;
+         exports.constant = constant;
+         exports.values = values;
+         exports.sortedIndex = sortedIndex;
+         exports.findIndex = findIndex;
+         exports.indexOf = indexOf;
+         exports.contains = contains;
+         exports.include = contains;
+         exports.includes = contains;
+         exports.countBy = countBy;
+         exports.create = create;
+         exports.now = now;
+         exports.debounce = debounce;
+         exports.defaults = defaults;
+         exports.partial = partial;
+         exports.delay = delay;
+         exports.defer = defer;
+         exports.difference = difference;
+         exports.escape = _escape;
+         exports.all = every;
+         exports.every = every;
+         exports.findKey = findKey;
+         exports.detect = find;
+         exports.find = find;
+         exports.findLastIndex = findLastIndex;
+         exports.findWhere = findWhere;
+         exports.initial = initial;
+         exports.first = first;
+         exports.head = first;
+         exports.take = first;
+         exports.flatten = flatten;
+         exports.functions = functions;
+         exports.methods = functions;
+         exports.isUndefined = isUndefined;
+         exports.get = get;
+         exports.groupBy = groupBy;
+         exports.has = has;
+         exports.isNull = isNull;
+         exports.isBoolean = isBoolean;
+         exports.isElement = isElement;
+         exports.isString = isString;
+         exports.isDate = isDate;
+         exports.isRegExp = isRegExp;
+         exports.isError = isError;
+         exports.isSymbol = isSymbol;
+         exports.isArrayBuffer = isArrayBuffer;
+         exports.isDataView = isDataView;
+         exports.isFinite = _isFinite;
+         exports.isTypedArray = isTypedArray;
+         exports.isEmpty = isEmpty;
+         exports.isEqual = isEqual;
+         exports.isMap = isMap;
+         exports.isWeakMap = isWeakMap;
+         exports.isSet = isSet;
+         exports.isWeakSet = isWeakSet;
+         exports.pairs = pairs;
+         exports.tap = tap;
+         exports.mapObject = mapObject;
+         exports.noop = noop;
+         exports.propertyOf = propertyOf;
+         exports.times = times;
+         exports.random = random;
+         exports.unescape = _unescape;
+         exports.templateSettings = templateSettings;
+         exports.template = template;
+         exports.result = result;
+         exports.uniqueId = uniqueId;
+         exports.memoize = memoize;
+         exports.throttle = throttle;
+         exports.wrap = wrap;
+         exports.negate = negate;
+         exports.once = once;
+         exports.lastIndexOf = lastIndexOf;
+         exports.collect = map;
+         exports.map = map;
+         exports.foldl = reduce;
+         exports.inject = reduce;
+         exports.reduce = reduce;
+         exports.foldr = reduceRight;
+         exports.reduceRight = reduceRight;
+         exports.reject = reject;
+         exports.any = some;
+         exports.some = some;
+         exports.invoke = invoke;
+         exports.pluck = pluck;
+         exports.where = where;
+         exports.max = max;
+         exports.min = min;
+         exports.sample = sample;
+         exports.shuffle = shuffle;
+         exports.sortBy = sortBy;
+         exports.indexBy = indexBy;
+         exports.partition = partition;
+         exports.toArray = toArray;
+         exports.size = size;
+         exports.pick = pick;
+         exports.omit = omit;
+         exports.drop = rest;
+         exports.rest = rest;
+         exports.tail = rest;
+         exports.last = last;
+         exports.without = without;
+         exports.uniq = uniq;
+         exports.unique = uniq;
+         exports.union = union;
+         exports.intersection = intersection;
+         exports.transpose = unzip;
+         exports.unzip = unzip;
+         exports.zip = zip;
+         exports.object = object;
+         exports.range = range;
+         exports.mixin = mixin;
+         exports.default = underscoreArrayMethods;
+
+         Object.defineProperty(exports, '__esModule', { value: true });
+
+});

package/node_modules/underscore/amd/indexBy.js

@@ -0,0 +1,11 @@
+define(['./_group'], function (_group) {
+
+  // Indexes the object's values by a criterion, similar to `_.groupBy`, but for
+  // when you know that your index values will be unique.
+  var indexBy = _group(function(result, value, key) {
+    result[key] = value;
+  });
+
+  return indexBy;
+
+});

package/node_modules/underscore/amd/indexOf.js

@@ -0,0 +1,11 @@
+define(['./_createIndexFinder', './sortedIndex', './findIndex'], function (_createIndexFinder, sortedIndex, findIndex) {
+
+	// Return the position of the first occurrence of an item in an array,
+	// or -1 if the item is not included in the array.
+	// If the array is large and already in sort order, pass `true`
+	// for **isSorted** to use binary search.
+	var indexOf = _createIndexFinder(1, findIndex, sortedIndex);
+
+	return indexOf;
+
+});

package/node_modules/underscore/amd/initial.js

@@ -0,0 +1,12 @@
+define(['./_setup'], function (_setup) {
+
+  // Returns everything but the last entry of the array. Especially useful on
+  // the arguments object. Passing **n** will return all the values in
+  // the array, excluding the last N.
+  function initial(array, n, guard) {
+    return _setup.slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
+  }
+
+  return initial;
+
+});

package/node_modules/underscore/amd/intersection.js

@@ -0,0 +1,22 @@
+define(['./_getLength', './contains'], function (_getLength, contains) {
+
+  // Produce an array that contains every item shared between all the
+  // passed-in arrays.
+  function intersection(array) {
+    var result = [];
+    var argsLength = arguments.length;
+    for (var i = 0, length = _getLength(array); i < length; i++) {
+      var item = array[i];
+      if (contains(result, item)) continue;
+      var j;
+      for (j = 1; j < argsLength; j++) {
+        if (!contains(arguments[j], item)) break;
+      }
+      if (j === argsLength) result.push(item);
+    }
+    return result;
+  }
+
+  return intersection;
+
+});

package/node_modules/underscore/amd/invert.js

@@ -0,0 +1,15 @@
+define(['./keys'], function (keys) {
+
+  // Invert the keys and values of an object. The values must be serializable.
+  function invert(obj) {
+    var result = {};
+    var _keys = keys(obj);
+    for (var i = 0, length = _keys.length; i < length; i++) {
+      result[obj[_keys[i]]] = _keys[i];
+    }
+    return result;
+  }
+
+  return invert;
+
+});

package/node_modules/underscore/amd/invoke.js

@@ -0,0 +1,28 @@
+define(['./isFunction', './_deepGet', './_toPath', './restArguments', './map'], function (isFunction, _deepGet, _toPath, restArguments, map) {
+
+  // Invoke a method (with arguments) on every item in a collection.
+  var invoke = restArguments(function(obj, path, args) {
+    var contextPath, func;
+    if (isFunction(path)) {
+      func = path;
+    } else {
+      path = _toPath(path);
+      contextPath = path.slice(0, -1);
+      path = path[path.length - 1];
+    }
+    return map(obj, function(context) {
+      var method = func;
+      if (!method) {
+        if (contextPath && contextPath.length) {
+          context = _deepGet(context, contextPath);
+        }
+        if (context == null) return void 0;
+        method = context[path];
+      }
+      return method == null ? method : method.apply(context, args);
+    });
+  });
+
+  return invoke;
+
+});

package/node_modules/underscore/amd/isArguments.js

@@ -0,0 +1,19 @@
+define(['./_tagTester', './_has'], function (_tagTester, _has) {
+
+  var isArguments = _tagTester('Arguments');
+
+  // Define a fallback version of the method in browsers (ahem, IE < 9), where
+  // there isn't any inspectable "Arguments" type.
+  (function() {
+    if (!isArguments(arguments)) {
+      isArguments = function(obj) {
+        return _has(obj, 'callee');
+      };
+    }
+  }());
+
+  var isArguments$1 = isArguments;
+
+  return isArguments$1;
+
+});

package/node_modules/underscore/amd/isArray.js

@@ -0,0 +1,9 @@
+define(['./_setup', './_tagTester'], function (_setup, _tagTester) {
+
+	// Is a given value an array?
+	// Delegates to ECMA5's native `Array.isArray`.
+	var isArray = _setup.nativeIsArray || _tagTester('Array');
+
+	return isArray;
+
+});