@farukada/aws-langgraph-dynamodb-ts 0.0.4 → 0.0.5

package/node_modules/underscore/amd/partial.js

@@ -0,0 +1,25 @@
+define(['./underscore', './_executeBound', './restArguments'], function (underscore, _executeBound, restArguments) {
+
+  // Partially apply a function by creating a version that has had some of its
+  // arguments pre-filled, without changing its dynamic `this` context. `_` acts
+  // as a placeholder by default, allowing any combination of arguments to be
+  // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.
+  var partial = restArguments(function(func, boundArgs) {
+    var placeholder = partial.placeholder;
+    var bound = function() {
+      var position = 0, length = boundArgs.length;
+      var args = Array(length);
+      for (var i = 0; i < length; i++) {
+        args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];
+      }
+      while (position < arguments.length) args.push(arguments[position++]);
+      return _executeBound(func, bound, this, this, args);
+    };
+    return bound;
+  });
+
+  partial.placeholder = underscore;
+
+  return partial;
+
+});

package/node_modules/underscore/amd/partition.js

@@ -0,0 +1,11 @@
+define(['./_group'], function (_group) {
+
+  // Split a collection into two arrays: one whose elements all pass the given
+  // truth test, and one whose elements all do not pass the truth test.
+  var partition = _group(function(result, value, pass) {
+    result[pass ? 0 : 1].push(value);
+  }, true);
+
+  return partition;
+
+});

package/node_modules/underscore/amd/pick.js

@@ -0,0 +1,25 @@
+define(['./isFunction', './_optimizeCb', './_flatten', './_keyInObj', './allKeys', './restArguments'], function (isFunction, _optimizeCb, _flatten, _keyInObj, allKeys, restArguments) {
+
+  // Return a copy of the object only containing the allowed properties.
+  var pick = restArguments(function(obj, keys) {
+    var result = {}, iteratee = keys[0];
+    if (obj == null) return result;
+    if (isFunction(iteratee)) {
+      if (keys.length > 1) iteratee = _optimizeCb(iteratee, keys[1]);
+      keys = allKeys(obj);
+    } else {
+      iteratee = _keyInObj;
+      keys = _flatten(keys, false, false);
+      obj = Object(obj);
+    }
+    for (var i = 0, length = keys.length; i < length; i++) {
+      var key = keys[i];
+      var value = obj[key];
+      if (iteratee(value, key, obj)) result[key] = value;
+    }
+    return result;
+  });
+
+  return pick;
+
+});

package/node_modules/underscore/amd/pluck.js

@@ -0,0 +1,10 @@
+define(['./property', './map'], function (property, map) {
+
+  // Convenience version of a common use case of `_.map`: fetching a property.
+  function pluck(obj, key) {
+    return map(obj, property(key));
+  }
+
+  return pluck;
+
+});

package/node_modules/underscore/amd/pop.js

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

package/node_modules/underscore/amd/property.js

@@ -0,0 +1,14 @@
+define(['./_deepGet', './_toPath'], function (_deepGet, _toPath) {
+
+  // Creates a function that, when passed an object, will traverse that object’s
+  // properties down the given `path`, specified as an array of keys or indices.
+  function property(path) {
+    path = _toPath(path);
+    return function(obj) {
+      return _deepGet(obj, path);
+    };
+  }
+
+  return property;
+
+});

package/node_modules/underscore/amd/propertyOf.js

@@ -0,0 +1,13 @@
+define(['./get', './noop'], function (get, noop) {
+
+  // Generates a function for a given object that returns a given property.
+  function propertyOf(obj) {
+    if (obj == null) return noop;
+    return function(path) {
+      return get(obj, path);
+    };
+  }
+
+  return propertyOf;
+
+});

package/node_modules/underscore/amd/push.js

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

package/node_modules/underscore/amd/random.js

@@ -0,0 +1,14 @@
+define(function () {
+
+  // Return a random integer between `min` and `max` (inclusive).
+  function random(min, max) {
+    if (max == null) {
+      max = min;
+      min = 0;
+    }
+    return min + Math.floor(Math.random() * (max - min + 1));
+  }
+
+  return random;
+
+});

package/node_modules/underscore/amd/range.js

@@ -0,0 +1,27 @@
+define(function () {
+
+  // Generate an integer Array containing an arithmetic progression. A port of
+  // the native Python `range()` function. See
+  // [the Python documentation](https://docs.python.org/library/functions.html#range).
+  function range(start, stop, step) {
+    if (stop == null) {
+      stop = start || 0;
+      start = 0;
+    }
+    if (!step) {
+      step = stop < start ? -1 : 1;
+    }
+
+    var length = Math.max(Math.ceil((stop - start) / step), 0);
+    var range = Array(length);
+
+    for (var idx = 0; idx < length; idx++, start += step) {
+      range[idx] = start;
+    }
+
+    return range;
+  }
+
+  return range;
+
+});

package/node_modules/underscore/amd/reduce.js

@@ -0,0 +1,9 @@
+define(['./_createReduce'], function (_createReduce) {
+
+	// **Reduce** builds up a single result from a list of values, aka `inject`,
+	// or `foldl`.
+	var reduce = _createReduce(1);
+
+	return reduce;
+
+});

package/node_modules/underscore/amd/reduceRight.js

@@ -0,0 +1,8 @@
+define(['./_createReduce'], function (_createReduce) {
+
+	// The right-associative version of reduce, also known as `foldr`.
+	var reduceRight = _createReduce(-1);
+
+	return reduceRight;
+
+});

package/node_modules/underscore/amd/reject.js

@@ -0,0 +1,10 @@
+define(['./_cb', './filter', './negate'], function (_cb, filter, negate) {
+
+  // Return all the elements for which a truth test fails.
+  function reject(obj, predicate, context) {
+    return filter(obj, negate(_cb(predicate)), context);
+  }
+
+  return reject;
+
+});

package/node_modules/underscore/amd/rest.js

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

package/node_modules/underscore/amd/restArguments.js

@@ -0,0 +1,33 @@
+define(function () {
+
+  // Some functions take a variable number of arguments, or a few expected
+  // arguments at the beginning and then a variable number of values to operate
+  // on. This helper accumulates all remaining arguments past the function’s
+  // argument length (or an explicit `startIndex`), into an array that becomes
+  // the last argument. Similar to ES6’s "rest parameter".
+  function restArguments(func, startIndex) {
+    startIndex = startIndex == null ? func.length - 1 : +startIndex;
+    return function() {
+      var length = Math.max(arguments.length - startIndex, 0),
+          rest = Array(length),
+          index = 0;
+      for (; index < length; index++) {
+        rest[index] = arguments[index + startIndex];
+      }
+      switch (startIndex) {
+        case 0: return func.call(this, rest);
+        case 1: return func.call(this, arguments[0], rest);
+        case 2: return func.call(this, arguments[0], arguments[1], rest);
+      }
+      var args = Array(startIndex + 1);
+      for (index = 0; index < startIndex; index++) {
+        args[index] = arguments[index];
+      }
+      args[startIndex] = rest;
+      return func.apply(this, args);
+    };
+  }
+
+  return restArguments;
+
+});

package/node_modules/underscore/amd/result.js

@@ -0,0 +1,25 @@
+define(['./isFunction', './_toPath'], function (isFunction, _toPath) {
+
+  // Traverses the children of `obj` along `path`. If a child is a function, it
+  // is invoked with its parent as context. Returns the value of the final
+  // child, or `fallback` if any child is undefined.
+  function result(obj, path, fallback) {
+    path = _toPath(path);
+    var length = path.length;
+    if (!length) {
+      return isFunction(fallback) ? fallback.call(obj) : fallback;
+    }
+    for (var i = 0; i < length; i++) {
+      var prop = obj == null ? void 0 : obj[path[i]];
+      if (prop === void 0) {
+        prop = fallback;
+        i = length; // Ensure we don't continue iterating.
+      }
+      obj = isFunction(prop) ? prop.call(obj) : prop;
+    }
+    return obj;
+  }
+
+  return result;
+
+});

package/node_modules/underscore/amd/reverse.js

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

package/node_modules/underscore/amd/sample.js

@@ -0,0 +1,27 @@
+define(['./_getLength', './_isArrayLike', './clone', './values', './random'], function (_getLength, _isArrayLike, clone, values, random) {
+
+  // Sample **n** random values from a collection using the modern version of the
+  // [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
+  // If **n** is not specified, returns a single random element.
+  // The internal `guard` argument allows it to work with `_.map`.
+  function sample(obj, n, guard) {
+    if (n == null || guard) {
+      if (!_isArrayLike(obj)) obj = values(obj);
+      return obj[random(obj.length - 1)];
+    }
+    var sample = _isArrayLike(obj) ? clone(obj) : values(obj);
+    var length = _getLength(sample);
+    n = Math.max(Math.min(n, length), 0);
+    var last = length - 1;
+    for (var index = 0; index < n; index++) {
+      var rand = random(index, last);
+      var temp = sample[index];
+      sample[index] = sample[rand];
+      sample[rand] = temp;
+    }
+    return sample.slice(0, n);
+  }
+
+  return sample;
+
+});

package/node_modules/underscore/amd/shift.js

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

package/node_modules/underscore/amd/shuffle.js

@@ -0,0 +1,10 @@
+define(['./sample'], function (sample) {
+
+  // Shuffle a collection.
+  function shuffle(obj) {
+    return sample(obj, Infinity);
+  }
+
+  return shuffle;
+
+});

package/node_modules/underscore/amd/size.js

@@ -0,0 +1,11 @@
+define(['./keys', './_isArrayLike'], function (keys, _isArrayLike) {
+
+  // Return the number of elements in a collection.
+  function size(obj) {
+    if (obj == null) return 0;
+    return _isArrayLike(obj) ? obj.length : keys(obj).length;
+  }
+
+  return size;
+
+});

package/node_modules/underscore/amd/slice.js

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

package/node_modules/underscore/amd/some.js

@@ -0,0 +1,17 @@
+define(['./keys', './_cb', './_isArrayLike'], function (keys, _cb, _isArrayLike) {
+
+  // Determine if at least one element in the object passes a truth test.
+  function some(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 true;
+    }
+    return false;
+  }
+
+  return some;
+
+});

package/node_modules/underscore/amd/sort.js

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

package/node_modules/underscore/amd/sortBy.js

@@ -0,0 +1,26 @@
+define(['./_cb', './map', './pluck'], function (_cb, map, pluck) {
+
+  // Sort the object's values by a criterion produced by an iteratee.
+  function sortBy(obj, iteratee, context) {
+    var index = 0;
+    iteratee = _cb(iteratee, context);
+    return pluck(map(obj, function(value, key, list) {
+      return {
+        value: value,
+        index: index++,
+        criteria: iteratee(value, key, list)
+      };
+    }).sort(function(left, right) {
+      var a = left.criteria;
+      var b = right.criteria;
+      if (a !== b) {
+        if (a > b || a === void 0) return 1;
+        if (a < b || b === void 0) return -1;
+      }
+      return left.index - right.index;
+    }), 'value');
+  }
+
+  return sortBy;
+
+});

package/node_modules/underscore/amd/sortedIndex.js

@@ -0,0 +1,18 @@
+define(['./_cb', './_getLength'], function (_cb, _getLength) {
+
+  // Use a comparator function to figure out the smallest index at which
+  // an object should be inserted so as to maintain order. Uses binary search.
+  function sortedIndex(array, obj, iteratee, context) {
+    iteratee = _cb(iteratee, context, 1);
+    var value = iteratee(obj);
+    var low = 0, high = _getLength(array);
+    while (low < high) {
+      var mid = Math.floor((low + high) / 2);
+      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
+    }
+    return low;
+  }
+
+  return sortedIndex;
+
+});

package/node_modules/underscore/amd/sortedLastIndex.js

@@ -0,0 +1,11 @@
+define(['./_binarySearch', './_cb', './_lessEqual'], function (_binarySearch, _cb, _lessEqual) {
+
+  // Use an iteratee to figure out the greatest index at which an object should be
+  // inserted so as to maintain order. Uses binary search.
+  function sortedLastIndex(array, obj, iteratee, context) {
+    return _binarySearch(array, obj, _cb(iteratee, context), _lessEqual);
+  }
+
+  return sortedLastIndex;
+
+});

package/node_modules/underscore/amd/splice.js

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

package/node_modules/underscore/amd/tap.js

@@ -0,0 +1,13 @@
+define(function () {
+
+  // Invokes `interceptor` with the `obj` and then returns `obj`.
+  // The primary purpose of this method is to "tap into" a method chain, in
+  // order to perform operations on intermediate results within the chain.
+  function tap(obj, interceptor) {
+    interceptor(obj);
+    return obj;
+  }
+
+  return tap;
+
+});

package/node_modules/underscore/amd/template.js

@@ -0,0 +1,95 @@
+define(['./underscore', './defaults', './templateSettings'], function (underscore, defaults, templateSettings) {
+
+  // When customizing `_.templateSettings`, if you don't want to define an
+  // interpolation, evaluation or escaping regex, we need one that is
+  // guaranteed not to match.
+  var noMatch = /(.)^/;
+
+  // Certain characters need to be escaped so that they can be put into a
+  // string literal.
+  var escapes = {
+    "'": "'",
+    '\\': '\\',
+    '\r': 'r',
+    '\n': 'n',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
+  };
+
+  var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;
+
+  function escapeChar(match) {
+    return '\\' + escapes[match];
+  }
+
+  var bareIdentifier = /^\s*(\w|\$)+\s*$/;
+
+  // JavaScript micro-templating, similar to John Resig's implementation.
+  // Underscore templating handles arbitrary delimiters, preserves whitespace,
+  // and correctly escapes quotes within interpolated code.
+  // NB: `oldSettings` only exists for backwards compatibility.
+  function template(text, settings, oldSettings) {
+    if (!settings && oldSettings) settings = oldSettings;
+    settings = defaults({}, settings, underscore.templateSettings);
+
+    // Combine delimiters into one regular expression via alternation.
+    var matcher = RegExp([
+      (settings.escape || noMatch).source,
+      (settings.interpolate || noMatch).source,
+      (settings.evaluate || noMatch).source
+    ].join('|') + '|$', 'g');
+
+    // Compile the template source, escaping string literals appropriately.
+    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+      source += text.slice(index, offset).replace(escapeRegExp, escapeChar);
+      index = offset + match.length;
+
+      if (escape) {
+        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+      } else if (interpolate) {
+        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+      } else if (evaluate) {
+        source += "';\n" + evaluate + "\n__p+='";
+      }
+
+      // Adobe VMs need the match returned to produce the correct offset.
+      return match;
+    });
+    source += "';\n";
+
+    var argument = settings.variable;
+    if (argument) {
+      if (!bareIdentifier.test(argument)) throw new Error(argument);
+    } else {
+      // If a variable is not specified, place data values in local scope.
+      source = 'with(obj||{}){\n' + source + '}\n';
+      argument = 'obj';
+    }
+
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
+      source + 'return __p;\n';
+
+    var render;
+    try {
+      render = new Function(argument, '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+
+    var template = function(data) {
+      return render.call(this, data, underscore);
+    };
+
+    // Provide the compiled source as a convenience for precompilation.
+    template.source = 'function(' + argument + '){\n' + source + '}';
+
+    return template;
+  }
+
+  return template;
+
+});

package/node_modules/underscore/amd/templateSettings.js

@@ -0,0 +1,13 @@
+define(['./underscore'], function (underscore) {
+
+  // By default, Underscore uses ERB-style template delimiters. Change the
+  // following template settings to use alternative delimiters.
+  var templateSettings = underscore.templateSettings = {
+    evaluate: /<%([\s\S]+?)%>/g,
+    interpolate: /<%=([\s\S]+?)%>/g,
+    escape: /<%-([\s\S]+?)%>/g
+  };
+
+  return templateSettings;
+
+});

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;
+
+});