@pdftron/pdfnet-node 10.3.0-beta → 10.3.0

package/node_modules/underscore/amd/_keyInObj.js

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

package/node_modules/underscore/amd/_less.js

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

package/node_modules/underscore/amd/_lessEqual.js

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

package/node_modules/underscore/amd/_linearSearch.js

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

package/node_modules/underscore/amd/_mapReduce.js

@@ -0,0 +1,5 @@
+define(function () {
+
+
+
+});

package/node_modules/underscore/amd/_methodFingerprint.js

@@ -0,0 +1,44 @@
+define(['exports', './isFunction', './_getLength', './allKeys'], function (exports, isFunction, _getLength, allKeys) {
+
+  // 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;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+});

package/node_modules/underscore/amd/_optimizeCb.js

@@ -0,0 +1,27 @@
+define(function () {
+
+  // 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);
+    };
+  }
+
+  return optimizeCb;
+
+});

package/node_modules/underscore/amd/_push.js

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

package/node_modules/underscore/amd/_pusher.js

@@ -0,0 +1,13 @@
+define(function () {
+
+  // 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);
+    };
+  }
+
+  return pusher;
+
+});

package/node_modules/underscore/amd/_sequence.js

@@ -0,0 +1,18 @@
+define(function () {
+
+  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;
+  }
+
+  return sequence;
+
+});

package/node_modules/underscore/amd/_setup.js

@@ -0,0 +1,70 @@
+define(['exports'], function (exports) {
+
+  // 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;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+});

package/node_modules/underscore/amd/_shallowProperty.js

@@ -0,0 +1,12 @@
+define(function () {
+
+  // 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];
+    };
+  }
+
+  return shallowProperty;
+
+});

package/node_modules/underscore/amd/_slice.js

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

package/node_modules/underscore/amd/_strictEqual.js

@@ -0,0 +1,9 @@
+define(function () {
+
+  function strictEqual(left, right) {
+    return left === right;
+  }
+
+  return strictEqual;
+
+});

package/node_modules/underscore/amd/_stringTagBug.js

@@ -0,0 +1,16 @@
+define(['exports', './_setup', './_hasObjectTag'], function (exports, _setup, _hasObjectTag) {
+
+    // 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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+});

package/node_modules/underscore/amd/_tagTester.js

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

package/node_modules/underscore/amd/_toBufferView.js

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

package/node_modules/underscore/amd/_toPath.js

@@ -0,0 +1,11 @@
+define(['./underscore', './toPath'], function (underscore, toPath$1) {
+
+  // Internal wrapper for `_.toPath` to enable minification.
+  // Similar to `cb` for `_.iteratee`.
+  function toPath(path) {
+    return underscore.toPath(path);
+  }
+
+  return toPath;
+
+});

package/node_modules/underscore/amd/_unescapeMap.js

@@ -0,0 +1,8 @@
+define(['./_escapeMap', './invert'], function (_escapeMap, invert) {
+
+	// Internal list of HTML entities for unescaping.
+	var unescapeMap = invert(_escapeMap);
+
+	return unescapeMap;
+
+});

package/node_modules/underscore/amd/_unmethodize.js

@@ -0,0 +1,9 @@
+define(['./_bindCb', './_setup'], function (_bindCb, _setup) {
+
+  function unmethodize(method) {
+    return _bindCb(_setup.call, method);
+  }
+
+  return unmethodize;
+
+});

package/node_modules/underscore/amd/_wrapArrayAccessor.js

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

package/node_modules/underscore/amd/_wrapArrayMutator.js

@@ -0,0 +1,28 @@
+define(['exports', './_setup', './_getLength', './identity', './restArguments'], function (exports, _setup, _getLength, identity, restArguments) {
+
+  // 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;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+});

package/node_modules/underscore/amd/after.js

@@ -0,0 +1,14 @@
+define(function () {
+
+  // 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);
+      }
+    };
+  }
+
+  return after;
+
+});

package/node_modules/underscore/amd/allKeys.js

@@ -0,0 +1,15 @@
+define(['./isObject', './_setup', './_collectNonEnumProps'], function (isObject, _setup, _collectNonEnumProps) {
+
+  // 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;
+  }
+
+  return allKeys;
+
+});

package/node_modules/underscore/amd/before.js

@@ -0,0 +1,18 @@
+define(function () {
+
+  // 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;
+    };
+  }
+
+  return before;
+
+});

package/node_modules/underscore/amd/bind.js

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

package/node_modules/underscore/amd/bindAll.js

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

package/node_modules/underscore/amd/chain.js

@@ -0,0 +1,12 @@
+define(['./underscore'], function (underscore) {
+
+  // Start chaining a wrapped Underscore object.
+  function chain(obj) {
+    var instance = underscore(obj);
+    instance._chain = true;
+    return instance;
+  }
+
+  return chain;
+
+});

package/node_modules/underscore/amd/chunk.js

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

package/node_modules/underscore/amd/clone.js

@@ -0,0 +1,11 @@
+define(['./isObject', './isArray', './extend'], function (isObject, isArray, extend) {
+
+  // Create a (shallow-cloned) duplicate of an object.
+  function clone(obj) {
+    if (!isObject(obj)) return obj;
+    return isArray(obj) ? obj.slice() : extend({}, obj);
+  }
+
+  return clone;
+
+});

package/node_modules/underscore/amd/compact.js

@@ -0,0 +1,10 @@
+define(['./filter'], function (filter) {
+
+  // Trim out all falsy values from an array.
+  function compact(array) {
+    return filter(array, Boolean);
+  }
+
+  return compact;
+
+});

package/node_modules/underscore/amd/compose.js

@@ -0,0 +1,18 @@
+define(function () {
+
+  // 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;
+    };
+  }
+
+  return compose;
+
+});

package/node_modules/underscore/amd/concat.js

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

package/node_modules/underscore/amd/constant.js

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

package/node_modules/underscore/amd/contains.js

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

package/node_modules/underscore/amd/countBy.js

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

package/node_modules/underscore/amd/create.js

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