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

package/node_modules/static-eval/example/vars.js

@@ -0,0 +1,11 @@
+var evaluate = require('../');
+var parse = require('esprima').parse;
+
+var src = '[1,2,3+4*10+n,foo(3+5),obj[""+"x"].y]';
+var ast = parse(src).body[0].expression;
+
+console.log(evaluate(ast, {
+    n: 6,
+    foo: function (x) { return x * 100 },
+    obj: { x: { y: 555 } }
+}));

package/node_modules/static-eval/index.js

@@ -0,0 +1,178 @@
+var unparse = require('escodegen').generate;
+
+module.exports = function (ast, vars) {
+    if (!vars) vars = {};
+    var FAIL = {};
+    
+    var result = (function walk (node, scopeVars) {
+        if (node.type === 'Literal') {
+            return node.value;
+        }
+        else if (node.type === 'UnaryExpression'){
+            var val = walk(node.argument)
+            if (node.operator === '+') return +val
+            if (node.operator === '-') return -val
+            if (node.operator === '~') return ~val
+            if (node.operator === '!') return !val
+            return FAIL
+        }
+        else if (node.type === 'ArrayExpression') {
+            var xs = [];
+            for (var i = 0, l = node.elements.length; i < l; i++) {
+                var x = walk(node.elements[i]);
+                if (x === FAIL) return FAIL;
+                xs.push(x);
+            }
+            return xs;
+        }
+        else if (node.type === 'ObjectExpression') {
+            var obj = {};
+            for (var i = 0; i < node.properties.length; i++) {
+                var prop = node.properties[i];
+                var value = prop.value === null
+                    ? prop.value
+                    : walk(prop.value)
+                ;
+                if (value === FAIL) return FAIL;
+                obj[prop.key.value || prop.key.name] = value;
+            }
+            return obj;
+        }
+        else if (node.type === 'BinaryExpression' ||
+                 node.type === 'LogicalExpression') {
+            var l = walk(node.left);
+            if (l === FAIL) return FAIL;
+            var r = walk(node.right);
+            if (r === FAIL) return FAIL;
+            
+            var op = node.operator;
+            if (op === '==') return l == r;
+            if (op === '===') return l === r;
+            if (op === '!=') return l != r;
+            if (op === '!==') return l !== r;
+            if (op === '+') return l + r;
+            if (op === '-') return l - r;
+            if (op === '*') return l * r;
+            if (op === '/') return l / r;
+            if (op === '%') return l % r;
+            if (op === '<') return l < r;
+            if (op === '<=') return l <= r;
+            if (op === '>') return l > r;
+            if (op === '>=') return l >= r;
+            if (op === '|') return l | r;
+            if (op === '&') return l & r;
+            if (op === '^') return l ^ r;
+            if (op === '&&') return l && r;
+            if (op === '||') return l || r;
+            
+            return FAIL;
+        }
+        else if (node.type === 'Identifier') {
+            if ({}.hasOwnProperty.call(vars, node.name)) {
+                return vars[node.name];
+            }
+            else return FAIL;
+        }
+        else if (node.type === 'ThisExpression') {
+            if ({}.hasOwnProperty.call(vars, 'this')) {
+                return vars['this'];
+            }
+            else return FAIL;
+        }
+        else if (node.type === 'CallExpression') {
+            var callee = walk(node.callee);
+            if (callee === FAIL) return FAIL;
+            if (typeof callee !== 'function') return FAIL;
+            
+            var ctx = node.callee.object ? walk(node.callee.object) : FAIL;
+            if (ctx === FAIL) ctx = null;
+
+            var args = [];
+            for (var i = 0, l = node.arguments.length; i < l; i++) {
+                var x = walk(node.arguments[i]);
+                if (x === FAIL) return FAIL;
+                args.push(x);
+            }
+            return callee.apply(ctx, args);
+        }
+        else if (node.type === 'MemberExpression') {
+            var obj = walk(node.object);
+            // do not allow access to methods on Function 
+            if((obj === FAIL) || (typeof obj == 'function')){
+                return FAIL;
+            }
+            if (node.property.type === 'Identifier') {
+                return obj[node.property.name];
+            }
+            var prop = walk(node.property);
+            if (prop === FAIL) return FAIL;
+            return obj[prop];
+        }
+        else if (node.type === 'ConditionalExpression') {
+            var val = walk(node.test)
+            if (val === FAIL) return FAIL;
+            return val ? walk(node.consequent) : walk(node.alternate)
+        }
+        else if (node.type === 'ExpressionStatement') {
+            var val = walk(node.expression)
+            if (val === FAIL) return FAIL;
+            return val;
+        }
+        else if (node.type === 'ReturnStatement') {
+            return walk(node.argument)
+        }
+        else if (node.type === 'FunctionExpression') {
+            
+            var bodies = node.body.body;
+            
+            // Create a "scope" for our arguments
+            var oldVars = {};
+            Object.keys(vars).forEach(function(element){
+                oldVars[element] = vars[element];
+            })
+
+            for(var i=0; i<node.params.length; i++){
+                var key = node.params[i];
+                if(key.type == 'Identifier'){
+                  vars[key.name] = null;
+                }
+                else return FAIL;
+            }
+            for(var i in bodies){
+                if(walk(bodies[i]) === FAIL){
+                    return FAIL;
+                }
+            }
+            // restore the vars and scope after we walk
+            vars = oldVars;
+            
+            var keys = Object.keys(vars);
+            var vals = keys.map(function(key) {
+                return vars[key];
+            });
+            return Function(keys.join(', '), 'return ' + unparse(node)).apply(null, vals);
+        }
+        else if (node.type === 'TemplateLiteral') {
+            var str = '';
+            for (var i = 0; i < node.expressions.length; i++) {
+                str += walk(node.quasis[i]);
+                str += walk(node.expressions[i]);
+            }
+            str += walk(node.quasis[i]);
+            return str;
+        }
+        else if (node.type === 'TaggedTemplateExpression') {
+            var tag = walk(node.tag);
+            var quasi = node.quasi;
+            var strings = quasi.quasis.map(walk);
+            var values = quasi.expressions.map(walk);
+            return tag.apply(null, [strings].concat(values));
+        }
+        else if (node.type === 'TemplateElement') {
+            return node.value.cooked;
+        }
+        else return FAIL;
+    })(ast);
+    
+    return result === FAIL ? undefined : result;
+};

package/node_modules/static-eval/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "static-eval",
+  "version": "2.0.2",
+  "description": "evaluate statically-analyzable expressions",
+  "main": "index.js",
+  "dependencies": {
+    "escodegen": "^1.8.1"
+  },
+  "devDependencies": {
+    "esprima": "^2.7.3",
+    "tape": "^4.6.0"
+  },
+  "scripts": {
+    "test": "tape test/*.js"
+  },
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/8..latest",
+      "ff/latest",
+      "chrome/latest",
+      "opera/latest",
+      "safari/latest"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/substack/static-eval.git"
+  },
+  "homepage": "https://github.com/substack/static-eval",
+  "keywords": [
+    "static",
+    "eval",
+    "expression",
+    "esprima",
+    "ast",
+    "abstract",
+    "syntax",
+    "tree",
+    "analysis"
+  ],
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "license": "MIT"
+}

package/node_modules/static-eval/readme.markdown

@@ -0,0 +1,87 @@
+# static-eval
+
+evaluate statically-analyzable expressions
+
+[![testling badge](https://ci.testling.com/substack/static-eval.png)](https://ci.testling.com/substack/static-eval)
+
+[![build status](https://secure.travis-ci.org/substack/static-eval.png)](http://travis-ci.org/substack/static-eval)
+
+# security
+
+static-eval is like `eval`. It is intended for use in build scripts and code transformations, doing some evaluation at build time—it is **NOT** suitable for handling arbitrary untrusted user input. Malicious user input _can_ execute arbitrary code.
+
+# example
+
+``` js
+var evaluate = require('static-eval');
+var parse = require('esprima').parse;
+
+var src = process.argv[2];
+var ast = parse(src).body[0].expression;
+
+console.log(evaluate(ast));
+```
+
+If you stick to simple expressions, the result is statically analyzable:
+
+```
+$ node '7*8+9'
+65
+$ node eval.js '[1,2,3+4*5-(5*11)]'
+[ 1, 2, -32 ]
+```
+
+but if you use statements, undeclared identifiers, or syntax, the result is no
+longer statically analyzable and `evaluate()` returns `undefined`:
+
+```
+$ node eval.js '1+2+3*n'
+undefined
+$ node eval.js 'x=5; x*2'
+undefined
+$ node eval.js '5-4*3'
+-7
+```
+
+You can also declare variables and functions to use in the static evaluation:
+
+``` js
+var evaluate = require('static-eval');
+var parse = require('esprima').parse;
+
+var src = '[1,2,3+4*10+n,foo(3+5),obj[""+"x"].y]';
+var ast = parse(src).body[0].expression;
+
+console.log(evaluate(ast, {
+    n: 6,
+    foo: function (x) { return x * 100 },
+    obj: { x: { y: 555 } }
+}));
+```
+
+# methods
+
+``` js
+var evaluate = require('static-eval');
+```
+
+## evaluate(ast, vars={})
+
+Evaluate the [esprima](https://npmjs.org/package/esprima)-parsed abstract syntax
+tree object `ast` with an optional collection of variables `vars` to use in the
+static expression resolution.
+
+If the expression contained in `ast` can't be statically resolved, `evaluate()`
+returns undefined.
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install static-eval
+```
+
+# license
+
+MIT

package/node_modules/static-eval/test/eval.js

@@ -0,0 +1,82 @@
+var test = require('tape');
+var evaluate = require('../');
+var parse = require('esprima').parse;
+
+test('resolved', function (t) {
+    t.plan(1);
+    
+    var src = '[1,2,3+4*10+(n||6),foo(3+5),obj[""+"x"].y]';
+    var ast = parse(src).body[0].expression;
+    var res = evaluate(ast, {
+        n: false,
+        foo: function (x) { return x * 100 },
+        obj: { x: { y: 555 } }
+    });
+    t.deepEqual(res, [ 1, 2, 49, 800, 555 ]);
+});
+
+test('unresolved', function (t) {
+    t.plan(1);
+    
+    var src = '[1,2,3+4*10*z+n,foo(3+5),obj[""+"x"].y]';
+    var ast = parse(src).body[0].expression;
+    var res = evaluate(ast, {
+        n: 6,
+        foo: function (x) { return x * 100 },
+        obj: { x: { y: 555 } }
+    });
+    t.equal(res, undefined);
+});
+
+test('boolean', function (t) {
+    t.plan(1);
+    
+    var src = '[ 1===2+3-16/4, [2]==2, [2]!==2, [2]!==[2] ]';
+    var ast = parse(src).body[0].expression;
+    t.deepEqual(evaluate(ast), [ true, true, true, true ]);
+});
+
+test('array methods', function(t) {
+    t.plan(1);
+
+    var src = '[1, 2, 3].map(function(n) { return n * 2 })';
+    var ast = parse(src).body[0].expression;
+    t.deepEqual(evaluate(ast), [2, 4, 6]);
+});
+
+test('array methods with vars', function(t) {
+    t.plan(1);
+
+    var src = '[1, 2, 3].map(function(n) { return n * x })';
+    var ast = parse(src).body[0].expression;
+    t.deepEqual(evaluate(ast, {x: 2}), [2, 4, 6]);
+});
+
+test('evaluate this', function(t) {
+    t.plan(1);
+
+    var src = 'this.x + this.y.z';
+    var ast = parse(src).body[0].expression;
+    var res = evaluate(ast, {
+        'this': { x: 1, y: { z: 100 } }
+    });
+    t.equal(res, 101);
+});
+
+test('FunctionExpression unresolved', function(t) {
+    t.plan(1);
+
+    var src = '(function(){console.log("Not Good")})';
+    var ast = parse(src).body[0].expression;
+    var res = evaluate(ast, {});
+    t.equal(res, undefined);
+});
+
+test('MemberExpressions from Functions unresolved', function(t) {
+    t.plan(1);
+
+    var src = '(function () {}).constructor';
+    var ast = parse(src).body[0].expression;
+    var res = evaluate(ast, {});
+    t.equal(res, undefined);
+});

package/node_modules/static-eval/test/prop.js

@@ -0,0 +1,16 @@
+var test = require('tape');
+var evaluate = require('../');
+var parse = require('esprima').parse;
+
+test('function property', function (t) {
+    t.plan(1);
+    
+    var src = '[1,2,3+4*10+n,beep.boop(3+5),obj[""+"x"].y]';
+    var ast = parse(src).body[0].expression;
+    var res = evaluate(ast, {
+        n: 6,
+        beep: { boop: function (x) { return x * 100 } },
+        obj: { x: { y: 555 } }
+    });
+    t.deepEqual(res, [ 1, 2, 49, 800, 555 ]);
+});

package/node_modules/static-eval/test/template-strings.js

@@ -0,0 +1,33 @@
+var test = require('tape');
+var evaluate = require('../');
+var parse = require('esprima').parse;
+
+test('untagged template strings', function (t) {
+    t.plan(1);
+    
+    var src = '`${1},${2 + n},${`4,5`}`';
+    var ast = parse(src).body[0].expression;
+    var res = evaluate(ast, {
+        n: 6
+    });
+    t.deepEqual(res, '1,8,4,5');
+});
+
+test('tagged template strings', function (t) {
+    t.plan(3);
+
+    var src = 'template`${1},${2 + n},${`4,5`}`';
+    var ast = parse(src).body[0].expression;
+    var res = evaluate(ast, {
+        template: function (strings) {
+            t.deepEqual(strings, ['', ',', ',', '']);
+
+            var values = [].slice.call(arguments, 1);
+            t.deepEqual(values, [1, 8, '4,5']);
+
+            return 'foo';
+        },
+        n: 6
+    });
+    t.deepEqual(res, 'foo');
+})

package/node_modules/underscore/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2009-2020 Jeremy Ashkenas, DocumentCloud and Investigative
+Reporters & Editors
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/underscore/README.md

@@ -0,0 +1,28 @@
+                       __
+                      /\ \                                                         __
+     __  __    ___    \_\ \     __   _ __   ____    ___    ___   _ __    __       /\_\    ____
+    /\ \/\ \ /' _ `\  /'_  \  /'__`\/\  __\/ ,__\  / ___\ / __`\/\  __\/'__`\     \/\ \  /',__\
+    \ \ \_\ \/\ \/\ \/\ \ \ \/\  __/\ \ \//\__, `\/\ \__//\ \ \ \ \ \//\  __/  __  \ \ \/\__, `\
+     \ \____/\ \_\ \_\ \___,_\ \____\\ \_\\/\____/\ \____\ \____/\ \_\\ \____\/\_\ _\ \ \/\____/
+      \/___/  \/_/\/_/\/__,_ /\/____/ \/_/ \/___/  \/____/\/___/  \/_/ \/____/\/_//\ \_\ \/___/
+                                                                                  \ \____/
+                                                                                   \/___/
+
+Underscore.js is a utility-belt library for JavaScript that provides
+support for the usual functional suspects (each, map, reduce, filter...)
+without extending any core JavaScript objects.
+
+For Docs, License, Tests, and pre-packed downloads, see:
+https://underscorejs.org
+
+For support and questions, please use
+[the gitter channel](https://gitter.im/jashkenas/underscore)
+or [stackoverflow](https://stackoverflow.com/search?q=underscore.js)
+
+Underscore is an open-sourced component of DocumentCloud:
+https://github.com/documentcloud
+
+Many thanks to our contributors:
+https://github.com/jashkenas/underscore/contributors
+
+This project adheres to a [code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.

package/node_modules/underscore/amd/_apply.js

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

package/node_modules/underscore/amd/_applyProperty.js

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

package/node_modules/underscore/amd/_arrayAccessors.js

@@ -0,0 +1,11 @@
+define(['exports', './concat', './join', './slice'], function (exports, concat, join, slice) {
+
+
+
+	exports.concat = concat;
+	exports.join = join;
+	exports.slice = slice;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+});

package/node_modules/underscore/amd/_arrayMutators.js

@@ -0,0 +1,15 @@
+define(['exports', './pop', './push', './reverse', './shift', './sort', './splice', './unshift'], function (exports, pop, push, reverse, shift, sort, splice, unshift) {
+
+
+
+	exports.pop = pop;
+	exports.push = push;
+	exports.reverse = reverse;
+	exports.shift = shift;
+	exports.sort = sort;
+	exports.splice = splice;
+	exports.unshift = unshift;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+});

package/node_modules/underscore/amd/_baseCreate.js

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

package/node_modules/underscore/amd/_baseIteratee.js

@@ -0,0 +1,15 @@
+define(['./isObject', './identity', './isFunction', './isArray', './matcher', './property', './_optimizeCb'], function (isObject, identity, isFunction, isArray, matcher, property, _optimizeCb) {
+
+  // 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);
+  }
+
+  return baseIteratee;
+
+});

package/node_modules/underscore/amd/_binarySearch.js

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

package/node_modules/underscore/amd/_bindCb.js

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

package/node_modules/underscore/amd/_bindCb4.js

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

package/node_modules/underscore/amd/_byValue.js

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

package/node_modules/underscore/amd/_cb.js

@@ -0,0 +1,12 @@
+define(['./underscore', './_baseIteratee', './iteratee'], function (underscore, _baseIteratee, iteratee) {
+
+  // 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);
+  }
+
+  return cb;
+
+});