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

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;

package/node_modules/underscore/cjs/_createReduce.js

@@ -0,0 +1,30 @@
+var keys = require('./keys.js');
+var _optimizeCb = require('./_optimizeCb.js');
+var _isArrayLike = require('./_isArrayLike.js');
+
+// Internal helper to create a reducing function, iterating left or right.
+function createReduce(dir) {
+  // Wrap code that reassigns argument variables in a separate function than
+  // the one that accesses `arguments.length` to avoid a perf hit. (#1991)
+  var reducer = function(obj, iteratee, memo, initial) {
+    var _keys = !_isArrayLike(obj) && keys(obj),
+        length = (_keys || obj).length,
+        index = dir > 0 ? 0 : length - 1;
+    if (!initial) {
+      memo = obj[_keys ? _keys[index] : index];
+      index += dir;
+    }
+    for (; index >= 0 && index < length; index += dir) {
+      var currentKey = _keys ? _keys[index] : index;
+      memo = iteratee(memo, obj[currentKey], currentKey, obj);
+    }
+    return memo;
+  };
+
+  return function(obj, iteratee, memo, context) {
+    var initial = arguments.length >= 3;
+    return reducer(obj, _optimizeCb(iteratee, context, 4), memo, initial);
+  };
+}
+
+module.exports = createReduce;

package/node_modules/underscore/cjs/_createSizePropertyCheck.js

@@ -0,0 +1,11 @@
+var _setup = require('./_setup.js');
+
+// Common internal logic for `isArrayLike` and `isBufferLike`.
+function createSizePropertyCheck(getSizeProperty) {
+  return function(collection) {
+    var sizeProperty = getSizeProperty(collection);
+    return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= _setup.MAX_ARRAY_INDEX;
+  }
+}
+
+module.exports = createSizePropertyCheck;

package/node_modules/underscore/cjs/_deepGet.js

@@ -0,0 +1,11 @@
+// Internal function to obtain a nested property in `obj` along `path`.
+function deepGet(obj, path) {
+  var length = path.length;
+  for (var i = 0; i < length; i++) {
+    if (obj == null) return void 0;
+    obj = obj[path[i]];
+  }
+  return length ? obj : void 0;
+}
+
+module.exports = deepGet;

package/node_modules/underscore/cjs/_escapeMap.js

@@ -0,0 +1,11 @@
+// Internal list of HTML entities for escaping.
+var escapeMap = {
+  '&': '&',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#x27;',
+  '`': '&#x60;'
+};
+
+module.exports = escapeMap;

package/node_modules/underscore/cjs/_executeBound.js

@@ -0,0 +1,15 @@
+var isObject = require('./isObject.js');
+var _baseCreate = require('./_baseCreate.js');
+
+// Internal function to execute `sourceFunc` bound to `context` with optional
+// `args`. Determines whether to execute a function as a constructor or as a
+// normal function.
+function executeBound(sourceFunc, boundFunc, context, callingContext, args) {
+  if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
+  var self = _baseCreate(sourceFunc.prototype);
+  var result = sourceFunc.apply(self, args);
+  if (isObject(result)) return result;
+  return self;
+}
+
+module.exports = executeBound;