@pdftron/pdfnet-node 10.3.0-beta → 10.3.1-beta

package/node_modules/underscore/amd/throttle.js

@@ -0,0 +1,51 @@
+define(['./now'], function (now) {
+
+  // Returns a function, that, when invoked, will only be triggered at most once
+  // during a given window of time. Normally, the throttled function will run
+  // as much as it can, without ever going more than once per `wait` duration;
+  // but if you'd like to disable the execution on the leading edge, pass
+  // `{leading: false}`. To disable execution on the trailing edge, ditto.
+  function throttle(func, wait, options) {
+    var timeout, context, args, result;
+    var previous = 0;
+    if (!options) options = {};
+
+    var later = function() {
+      previous = options.leading === false ? 0 : now();
+      timeout = null;
+      result = func.apply(context, args);
+      if (!timeout) context = args = null;
+    };
+
+    var throttled = function() {
+      var _now = now();
+      if (!previous && options.leading === false) previous = _now;
+      var remaining = wait - (_now - previous);
+      context = this;
+      args = arguments;
+      if (remaining <= 0 || remaining > wait) {
+        if (timeout) {
+          clearTimeout(timeout);
+          timeout = null;
+        }
+        previous = _now;
+        result = func.apply(context, args);
+        if (!timeout) context = args = null;
+      } else if (!timeout && options.trailing !== false) {
+        timeout = setTimeout(later, remaining);
+      }
+      return result;
+    };
+
+    throttled.cancel = function() {
+      clearTimeout(timeout);
+      previous = 0;
+      timeout = context = args = null;
+    };
+
+    return throttled;
+  }
+
+  return throttle;
+
+});

package/node_modules/underscore/amd/times.js

@@ -0,0 +1,13 @@
+define(['./_optimizeCb'], function (_optimizeCb) {
+
+  // Run a function **n** times.
+  function times(n, iteratee, context) {
+    var accum = Array(Math.max(0, n));
+    iteratee = _optimizeCb(iteratee, context, 1);
+    for (var i = 0; i < n; i++) accum[i] = iteratee(i);
+    return accum;
+  }
+
+  return times;
+
+});

package/node_modules/underscore/amd/toArray.js

@@ -0,0 +1,18 @@
+define(['./_setup', './identity', './isArray', './_isArrayLike', './values', './isString', './map'], function (_setup, identity, isArray, _isArrayLike, values, isString, map) {
+
+  // Safely create a real, live array from anything iterable.
+  var reStrSymbol = /[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;
+  function toArray(obj) {
+    if (!obj) return [];
+    if (isArray(obj)) return _setup.slice.call(obj);
+    if (isString(obj)) {
+      // Keep surrogate pair characters together.
+      return obj.match(reStrSymbol);
+    }
+    if (_isArrayLike(obj)) return map(obj, identity);
+    return values(obj);
+  }
+
+  return toArray;
+
+});

package/node_modules/underscore/amd/toPath.js

@@ -0,0 +1,12 @@
+define(['./isArray', './underscore'], function (isArray, underscore) {
+
+  // Normalize a (deep) property `path` to array.
+  // Like `_.iteratee`, this function can be customized.
+  function toPath(path) {
+    return isArray(path) ? path : [path];
+  }
+  underscore.toPath = toPath;
+
+  return toPath;
+
+});

package/node_modules/underscore/amd/toString.js

@@ -0,0 +1,11 @@
+define(['./value'], function (value) {
+
+  // Provide an unwrapping proxy for automatic string coercion in engine
+  // operations such as JSON stringification.
+  function toString(wrapper) {
+    return String(value(wrapper));
+  }
+
+  return toString;
+
+});

package/node_modules/underscore/amd/underscore-array-methods.js

@@ -0,0 +1,30 @@
+define(['./_setup', './underscore', './_chainResult', './each'], function (_setup, underscore, _chainResult, each) {
+
+  // Add all mutator `Array` functions to the wrapper.
+  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+    var method = _setup.ArrayProto[name];
+    underscore.prototype[name] = function() {
+      var obj = this._wrapped;
+      if (obj != null) {
+        method.apply(obj, arguments);
+        if ((name === 'shift' || name === 'splice') && obj.length === 0) {
+          delete obj[0];
+        }
+      }
+      return _chainResult(this, obj);
+    };
+  });
+
+  // Add all accessor `Array` functions to the wrapper.
+  each(['concat', 'join', 'slice'], function(name) {
+    var method = _setup.ArrayProto[name];
+    underscore.prototype[name] = function() {
+      var obj = this._wrapped;
+      if (obj != null) obj = method.apply(obj, arguments);
+      return _chainResult(this, obj);
+    };
+  });
+
+  return underscore;
+
+});

package/node_modules/underscore/amd/underscore.js

@@ -0,0 +1,29 @@
+define(['./_setup'], function (_setup) {
+
+  // If Underscore is called as a function, it returns a wrapped object that can
+  // be used OO-style. This wrapper holds altered versions of all functions added
+  // through `_.mixin`. Wrapped objects may be chained.
+  function _(obj) {
+    if (obj instanceof _) return obj;
+    if (!(this instanceof _)) return new _(obj);
+    this._wrapped = obj;
+  }
+
+  _.VERSION = _setup.VERSION;
+
+  // Extracts the result from a wrapped and chained object.
+  _.prototype.value = function() {
+    return this._wrapped;
+  };
+
+  // Provide unwrapping proxies for some methods used in engine operations
+  // such as arithmetic and JSON stringification.
+  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;
+
+  _.prototype.toString = function() {
+    return String(this._wrapped);
+  };
+
+  return _;
+
+});

package/node_modules/underscore/amd/unescape.js

@@ -0,0 +1,8 @@
+define(['./_createEscaper', './_unescapeMap'], function (_createEscaper, _unescapeMap) {
+
+	// Function for unescaping strings from HTML interpolation.
+	var _unescape = _createEscaper(_unescapeMap);
+
+	return _unescape;
+
+});

package/node_modules/underscore/amd/union.js

@@ -0,0 +1,11 @@
+define(['./_flatten', './restArguments', './uniq'], function (_flatten, restArguments, uniq) {
+
+  // Produce an array that contains the union: each distinct element from all of
+  // the passed-in arrays.
+  var union = restArguments(function(arrays) {
+    return uniq(_flatten(arrays, true, true));
+  });
+
+  return union;
+
+});

package/node_modules/underscore/amd/uniq.js

@@ -0,0 +1,37 @@
+define(['./_cb', './_getLength', './contains', './isBoolean'], function (_cb, _getLength, contains, isBoolean) {
+
+  // Produce a duplicate-free version of the array. If the array has already
+  // been sorted, you have the option of using a faster algorithm.
+  // The faster algorithm will not work with an iteratee if the iteratee
+  // is not a one-to-one function, so providing an iteratee will disable
+  // the faster algorithm.
+  function uniq(array, isSorted, iteratee, context) {
+    if (!isBoolean(isSorted)) {
+      context = iteratee;
+      iteratee = isSorted;
+      isSorted = false;
+    }
+    if (iteratee != null) iteratee = _cb(iteratee, context);
+    var result = [];
+    var seen = [];
+    for (var i = 0, length = _getLength(array); i < length; i++) {
+      var value = array[i],
+          computed = iteratee ? iteratee(value, i, array) : value;
+      if (isSorted && !iteratee) {
+        if (!i || seen !== computed) result.push(value);
+        seen = computed;
+      } else if (iteratee) {
+        if (!contains(seen, computed)) {
+          seen.push(computed);
+          result.push(value);
+        }
+      } else if (!contains(result, value)) {
+        result.push(value);
+      }
+    }
+    return result;
+  }
+
+  return uniq;
+
+});

package/node_modules/underscore/amd/uniqueId.js

@@ -0,0 +1,13 @@
+define(function () {
+
+  // Generate a unique integer id (unique within the entire client session).
+  // Useful for temporary DOM ids.
+  var idCounter = 0;
+  function uniqueId(prefix) {
+    var id = ++idCounter + '';
+    return prefix ? prefix + id : id;
+  }
+
+  return uniqueId;
+
+});

package/node_modules/underscore/amd/unshift.js

@@ -0,0 +1,7 @@
+define(['./_unmethodize', './_setup'], function (_unmethodize, _setup) {
+
+	var unshift = _unmethodize(_setup.ArrayProto.unshift);
+
+	return unshift;
+
+});

package/node_modules/underscore/amd/unzip.js

@@ -0,0 +1,17 @@
+define(['./_getLength', './pluck', './max'], function (_getLength, pluck, max) {
+
+  // Complement of zip. Unzip accepts an array of arrays and groups
+  // each array's elements on shared indices.
+  function unzip(array) {
+    var length = array && max(array, _getLength).length || 0;
+    var result = Array(length);
+
+    for (var index = 0; index < length; index++) {
+      result[index] = pluck(array, index);
+    }
+    return result;
+  }
+
+  return unzip;
+
+});

package/node_modules/underscore/amd/value.js

@@ -0,0 +1,13 @@
+define(function () {
+
+  // Extract the result from a wrapped (and possibly chained) object.
+  // This function is also aliased as `valueOf` and `toJSON`, which provide
+  // unwrapping proxies for some methods used in engine operations such as
+  // arithmetic and JSON stringification.
+  function value(wrapper) {
+    return wrapper._wrapped || wrapper;
+  }
+
+  return value;
+
+});

package/node_modules/underscore/amd/values.js

@@ -0,0 +1,16 @@
+define(['./keys'], function (keys) {
+
+  // Retrieve the values of an object's properties.
+  function values(obj) {
+    var _keys = keys(obj);
+    var length = _keys.length;
+    var values = Array(length);
+    for (var i = 0; i < length; i++) {
+      values[i] = obj[_keys[i]];
+    }
+    return values;
+  }
+
+  return values;
+
+});

package/node_modules/underscore/amd/where.js

@@ -0,0 +1,11 @@
+define(['./matcher', './filter'], function (matcher, filter) {
+
+  // Convenience version of a common use case of `_.filter`: selecting only
+  // objects containing specific `key:value` pairs.
+  function where(obj, attrs) {
+    return filter(obj, matcher(attrs));
+  }
+
+  return where;
+
+});

package/node_modules/underscore/amd/without.js

@@ -0,0 +1,10 @@
+define(['./restArguments', './difference'], function (restArguments, difference) {
+
+  // Return a version of the array that does not contain the specified value(s).
+  var without = restArguments(function(array, otherArrays) {
+    return difference(array, otherArrays);
+  });
+
+  return without;
+
+});

package/node_modules/underscore/amd/wrap.js

@@ -0,0 +1,12 @@
+define(['./partial'], function (partial) {
+
+  // Returns the first function passed as an argument to the second,
+  // allowing you to adjust arguments, run code before and after, and
+  // conditionally execute the original function.
+  function wrap(func, wrapper) {
+    return partial(wrapper, func);
+  }
+
+  return wrap;
+
+});

package/node_modules/underscore/amd/zip.js

@@ -0,0 +1,9 @@
+define(['./restArguments', './unzip'], function (restArguments, unzip) {
+
+	// Zip together multiple lists into a single array -- elements that share
+	// an index go together.
+	var zip = restArguments(unzip);
+
+	return zip;
+
+});

package/node_modules/underscore/cjs/_apply.js

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

package/node_modules/underscore/cjs/_applyProperty.js

@@ -0,0 +1,10 @@
+// Internal helper that wraps an `iteratee` to call it with the
+// property of a closed-over `object`. Useful when iterating over
+// an array of keys of `object`.
+function applyProperty(iteratee, object) {
+  return function(key) {
+    return iteratee(object[key], key, object);
+  };
+}
+
+module.exports = applyProperty;

package/node_modules/underscore/cjs/_arrayAccessors.js

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var concat = require('./concat.js');
+var join = require('./join.js');
+var slice = require('./slice.js');
+
+
+
+exports.concat = concat;
+exports.join = join;
+exports.slice = slice;

package/node_modules/underscore/cjs/_arrayMutators.js

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var pop = require('./pop.js');
+var push = require('./push.js');
+var reverse = require('./reverse.js');
+var shift = require('./shift.js');
+var sort = require('./sort.js');
+var splice = require('./splice.js');
+var unshift = require('./unshift.js');
+
+
+
+exports.pop = pop;
+exports.push = push;
+exports.reverse = reverse;
+exports.shift = shift;
+exports.sort = sort;
+exports.splice = splice;
+exports.unshift = unshift;

package/node_modules/underscore/cjs/_baseCreate.js

@@ -0,0 +1,20 @@
+var isObject = require('./isObject.js');
+var _setup = require('./_setup.js');
+
+// Create a naked function reference for surrogate-prototype-swapping.
+function ctor() {
+  return function(){};
+}
+
+// An internal function for creating a new object that inherits from another.
+function baseCreate(prototype) {
+  if (!isObject(prototype)) return {};
+  if (_setup.nativeCreate) return _setup.nativeCreate(prototype);
+  var Ctor = ctor();
+  Ctor.prototype = prototype;
+  var result = new Ctor;
+  Ctor.prototype = null;
+  return result;
+}
+
+module.exports = baseCreate;

package/node_modules/underscore/cjs/_baseIteratee.js

@@ -0,0 +1,19 @@
+var isObject = require('./isObject.js');
+var identity = require('./identity.js');
+var isFunction = require('./isFunction.js');
+var isArray = require('./isArray.js');
+var matcher = require('./matcher.js');
+var property = require('./property.js');
+var _optimizeCb = require('./_optimizeCb.js');
+
+// An internal function to generate callbacks that can be applied to each
+// element in a collection, returning the desired result — either `_.identity`,
+// an arbitrary callback, a property matcher, or a property accessor.
+function baseIteratee(value, context, argCount) {
+  if (value == null) return identity;
+  if (isFunction(value)) return _optimizeCb(value, context, argCount);
+  if (isObject(value) && !isArray(value)) return matcher(value);
+  return property(value);
+}
+
+module.exports = baseIteratee;

package/node_modules/underscore/cjs/_binarySearch.js

@@ -0,0 +1,15 @@
+var _getLength = require('./_getLength.js');
+
+// Iteratively cut `array` in half to figure out the index at which `obj` should
+// be inserted so as to maintain the order defined by `compare`.
+function binarySearch(array, obj, iteratee, compare) {
+  var value = iteratee(obj);
+  var low = 0, high = _getLength(array);
+  while (low < high) {
+    var mid = Math.floor((low + high) / 2);
+    if (compare(iteratee(array[mid]), value)) low = mid + 1; else high = mid;
+  }
+  return low;
+}
+
+module.exports = binarySearch;

package/node_modules/underscore/cjs/_bindCb.js

@@ -0,0 +1,10 @@
+// Internal function that returns a bound version of the passed-in callback, to
+// be repeatedly applied in other Underscore functions.
+function bindCb(func, context) {
+  if (context === void 0) return func;
+  return function() {
+    return func.apply(context, arguments);
+  };
+}
+
+module.exports = bindCb;

package/node_modules/underscore/cjs/_bindCb4.js

@@ -0,0 +1,13 @@
+// In Firefox, `Function.prototype.call` is faster than
+// `Function.prototype.apply`. In the optimized variant of
+// `bindCb` below, we exploit the fact that no Underscore
+// function passes more than four arguments to a callback.
+// **NOT general enough for use outside of Underscore.**
+function bindCb4(func, context) {
+  if (context === void 0) return func;
+  return function(a1, a2, a3, a4) {
+    return func.call(context, a1, a2, a3, a4);
+  };
+}
+
+module.exports = bindCb4;

package/node_modules/underscore/cjs/_byValue.js

@@ -0,0 +1,7 @@
+// Internal wrapper to enable match-by-value mode in `linearSearch`.
+function byValue(value) {
+  if (!(this instanceof byValue)) return new byValue(value);
+  this.value = value;
+}
+
+module.exports = byValue;

package/node_modules/underscore/cjs/_cb.js

@@ -0,0 +1,12 @@
+var underscore = require('./underscore.js');
+var _baseIteratee = require('./_baseIteratee.js');
+var iteratee = require('./iteratee.js');
+
+// The function we call internally to generate a callback. It invokes
+// `_.iteratee` if overridden, otherwise `baseIteratee`.
+function cb(value, context, argCount) {
+  if (underscore.iteratee !== iteratee) return underscore.iteratee(value, context);
+  return _baseIteratee(value, context, argCount);
+}
+
+module.exports = cb;

package/node_modules/underscore/cjs/_chainResult.js

@@ -0,0 +1,8 @@
+var underscore = require('./underscore.js');
+
+// Helper function to continue chaining intermediate results.
+function chainResult(instance, obj) {
+  return instance._chain ? underscore(obj).chain() : obj;
+}
+
+module.exports = chainResult;

package/node_modules/underscore/cjs/_collectNonEnumProps.js

@@ -0,0 +1,42 @@
+var _setup = require('./_setup.js');
+var isFunction = require('./isFunction.js');
+var _has = require('./_has.js');
+
+// Internal helper to create a simple lookup structure.
+// `collectNonEnumProps` used to depend on `_.contains`, but this led to
+// circular imports. `emulatedSet` is a one-off solution that only works for
+// arrays of strings.
+function emulatedSet(keys) {
+  var hash = {};
+  for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;
+  return {
+    contains: function(key) { return hash[key]; },
+    push: function(key) {
+      hash[key] = true;
+      return keys.push(key);
+    }
+  };
+}
+
+// Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't
+// be iterated by `for key in ...` and thus missed. Extends `keys` in place if
+// needed.
+function collectNonEnumProps(obj, keys) {
+  keys = emulatedSet(keys);
+  var nonEnumIdx = _setup.nonEnumerableProps.length;
+  var constructor = obj.constructor;
+  var proto = isFunction(constructor) && constructor.prototype || _setup.ObjProto;
+
+  // Constructor is a special case.
+  var prop = 'constructor';
+  if (_has(obj, prop) && !keys.contains(prop)) keys.push(prop);
+
+  while (nonEnumIdx--) {
+    prop = _setup.nonEnumerableProps[nonEnumIdx];
+    if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {
+      keys.push(prop);
+    }
+  }
+}
+
+module.exports = collectNonEnumProps;

package/node_modules/underscore/cjs/_createAssigner.js

@@ -0,0 +1,20 @@
+// An internal function for creating assigner functions.
+function createAssigner(keysFunc, defaults) {
+  return function(obj) {
+    var length = arguments.length;
+    if (defaults) obj = Object(obj);
+    if (length < 2 || obj == null) return obj;
+    for (var index = 1; index < length; index++) {
+      var source = arguments[index],
+          keys = keysFunc(source),
+          l = keys.length;
+      for (var i = 0; i < l; i++) {
+        var key = keys[i];
+        if (!defaults || obj[key] === void 0) obj[key] = source[key];
+      }
+    }
+    return obj;
+  };
+}
+
+module.exports = createAssigner;

package/node_modules/underscore/cjs/_createEscaper.js

@@ -0,0 +1,19 @@
+var keys = require('./keys.js');
+
+// Internal helper to generate functions for escaping and unescaping strings
+// to/from HTML interpolation.
+function createEscaper(map) {
+  var escaper = function(match) {
+    return map[match];
+  };
+  // Regexes for identifying a key that needs to be escaped.
+  var source = '(?:' + keys(map).join('|') + ')';
+  var testRegexp = RegExp(source);
+  var replaceRegexp = RegExp(source, 'g');
+  return function(string) {
+    string = string == null ? '' : '' + string;
+    return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
+  };
+}
+
+module.exports = createEscaper;

package/node_modules/underscore/cjs/_createIndexFinder.js

@@ -0,0 +1,30 @@
+var _setup = require('./_setup.js');
+var _getLength = require('./_getLength.js');
+var _isNaN = require('./isNaN.js');
+
+// Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.
+function createIndexFinder(dir, predicateFind, sortedIndex) {
+  return function(array, item, idx) {
+    var i = 0, length = _getLength(array);
+    if (typeof idx == 'number') {
+      if (dir > 0) {
+        i = idx >= 0 ? idx : Math.max(idx + length, i);
+      } else {
+        length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
+      }
+    } else if (sortedIndex && idx && length) {
+      idx = sortedIndex(array, item);
+      return array[idx] === item ? idx : -1;
+    }
+    if (item !== item) {
+      idx = predicateFind(_setup.slice.call(array, i, length), _isNaN);
+      return idx >= 0 ? idx + i : -1;
+    }
+    for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
+      if (array[idx] === item) return idx;
+    }
+    return -1;
+  };
+}
+
+module.exports = createIndexFinder;

package/node_modules/underscore/cjs/_createPredicateIndexFinder.js

@@ -0,0 +1,17 @@
+var _cb = require('./_cb.js');
+var _getLength = require('./_getLength.js');
+
+// Internal function to generate `_.findIndex` and `_.findLastIndex`.
+function createPredicateIndexFinder(dir) {
+  return function(array, predicate, context) {
+    predicate = _cb(predicate, context);
+    var length = _getLength(array);
+    var index = dir > 0 ? 0 : length - 1;
+    for (; index >= 0 && index < length; index += dir) {
+      if (predicate(array[index], index, array)) return index;
+    }
+    return -1;
+  };
+}
+
+module.exports = createPredicateIndexFinder;