@pgarbe/cdk-ecr-sync 0.5.22 → 0.5.26

package/node_modules/jmespath/l.js

@@ -1,189 +0,0 @@
-'use strict';
-
-var Lexer = exports.Lexer = function() {
-  this.pos = 0;
-  this.buf = null;
-  this.buflen = 0;
-
-  // Operator table, mapping operator -> token name
-  this.optable = {
-    '+':  'PLUS',
-    '-':  'MINUS',
-    '*':  'MULTIPLY',
-    '.':  'PERIOD',
-    '\\': 'BACKSLASH',
-    ':':  'COLON',
-    '%':  'PERCENT',
-    '|':  'PIPE',
-    '!':  'EXCLAMATION',
-    '?':  'QUESTION',
-    '#':  'POUND',
-    '&':  'AMPERSAND',
-    ';':  'SEMI',
-    ',':  'COMMA',
-    '(':  'L_PAREN',
-    ')':  'R_PAREN',
-    '<':  'L_ANG',
-    '>':  'R_ANG',
-    '{':  'L_BRACE',
-    '}':  'R_BRACE',
-    '[':  'L_BRACKET',
-    ']':  'R_BRACKET',
-    '=':  'EQUALS'
-  };
-}
-
-// Initialize the Lexer's buffer. This resets the lexer's internal
-// state and subsequent tokens will be returned starting with the
-// beginning of the new buffer.
-Lexer.prototype.input = function(buf) {
-  this.pos = 0;
-  this.buf = buf;
-  this.buflen = buf.length;
-}
-
-// Get the next token from the current buffer. A token is an object with
-// the following properties:
-// - name: name of the pattern that this token matched (taken from rules).
-// - value: actual string value of the token.
-// - pos: offset in the current buffer where the token starts.
-//
-// If there are no more tokens in the buffer, returns null. In case of
-// an error throws Error.
-Lexer.prototype.token = function() {
-  this._skipnontokens();
-  if (this.pos >= this.buflen) {
-    return null;
-  }
-
-  // The char at this.pos is part of a real token. Figure out which.
-  var c = this.buf.charAt(this.pos);
-
-  // '/' is treated specially, because it starts a comment if followed by
-  // another '/'. If not followed by another '/', it's the DIVIDE
-  // operator.
-  if (c === '/') {
-    var next_c = this.buf.charAt(this.pos + 1);
-    if (next_c === '/') {
-      return this._process_comment();
-    } else {
-      return {name: 'DIVIDE', value: '/', pos: this.pos++};
-    }
-  } else {
-    // Look it up in the table of operators
-    var op = this.optable[c];
-    if (op !== undefined) {
-      return {name: op, value: c, pos: this.pos++};
-    } else {
-      // Not an operator - so it's the beginning of another token.
-      if (Lexer._isalpha(c)) {
-        return this._process_identifier();
-      } else if (Lexer._isdigit(c)) {
-        return this._process_number();
-      } else if (c === '"') {
-        return this._process_quote();
-      } else {
-        throw Error('Token error at ' + this.pos);
-      }
-    }
-  }
-}
-
-Lexer._isnewline = function(c) {
-  return c === '\r' || c === '\n';
-}
-
-Lexer._isdigit = function(c) {
-  return c >= '0' && c <= '9';
-}
-
-Lexer._isalpha = function(c) {
-  return (c >= 'a' && c <= 'z') ||
-         (c >= 'A' && c <= 'Z') ||
-         c === '_' || c === '$';
-}
-
-Lexer._isalphanum = function(c) {
-  return (c >= 'a' && c <= 'z') ||
-         (c >= 'A' && c <= 'Z') ||
-         (c >= '0' && c <= '9') ||
-         c === '_' || c === '$';
-}
-
-Lexer.prototype._process_number = function() {
-  var endpos = this.pos + 1;
-  while (endpos < this.buflen &&
-         Lexer._isdigit(this.buf.charAt(endpos))) {
-    endpos++;
-  }
-
-  var tok = {
-    name: 'NUMBER',
-    value: this.buf.substring(this.pos, endpos),
-    pos: this.pos
-  };
-  this.pos = endpos;
-  return tok;
-}
-
-Lexer.prototype._process_comment = function() {
-  var endpos = this.pos + 2;
-  // Skip until the end of the line
-  var c = this.buf.charAt(this.pos + 2);
-  while (endpos < this.buflen &&
-         !Lexer._isnewline(this.buf.charAt(endpos))) {
-    endpos++;
-  }
-
-  var tok = {
-    name: 'COMMENT',
-    value: this.buf.substring(this.pos, endpos),
-    pos: this.pos
-  };
-  this.pos = endpos + 1;
-  return tok;
-}
-
-Lexer.prototype._process_identifier = function() {
-  var endpos = this.pos + 1;
-  while (endpos < this.buflen &&
-         Lexer._isalphanum(this.buf.charAt(endpos))) {
-    endpos++;
-  }
-
-  var tok = {
-    name: 'IDENTIFIER',
-    value: this.buf.substring(this.pos, endpos),
-    pos: this.pos
-  };
-  this.pos = endpos;
-  return tok;
-}
-
-Lexer.prototype._process_quote = function() {
-  // this.pos points at the opening quote. Find the ending quote.
-  var end_index = this.buf.indexOf('"', this.pos + 1);
-
-  if (end_index === -1) {
-    throw Error('Unterminated quote at ' + this.pos);
-  } else {
-    var tok = {
-      name: 'QUOTE',
-      value: this.buf.substring(this.pos, end_index + 1),
-      pos: this.pos
-    };
-    this.pos = end_index + 1;
-    return tok;
-  }
-}
-
-Lexer.prototype._skipnontokens = function() {
-  while (this.pos < this.buflen) {
-    var c = this.buf.charAt(this.pos);
-    if (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
-      this.pos++;
-    } else {
-      break;
-    }
-  }
-}

package/node_modules/jmespath/perf.js

@@ -1,33 +0,0 @@
-var jmespath = require('./jmespath')
-var Benchmark = require('benchmark');
-var suite = new Benchmark.Suite;
-
-// add tests
-suite.add('Parser#single_expr', function() {
-  jmespath.compile("foo");
-})
-.add('Parser#single_subexpr', function() {
-  jmespath.compile("foo.bar");
-})
-.add('Parser#deeply_nested_50', function() {
-  jmespath.compile("j49.j48.j47.j46.j45.j44.j43.j42.j41.j40.j39.j38.j37.j36.j35.j34.j33.j32.j31.j30.j29.j28.j27.j26.j25.j24.j23.j22.j21.j20.j19.j18.j17.j16.j15.j14.j13.j12.j11.j10.j9.j8.j7.j6.j5.j4.j3.j2.j1.j0");
-
-})
-.add('Parser#deeply_nested_50_index', function() {
-  jmespath.compile("[49][48][47][46][45][44][43][42][41][40][39][38][37][36][35][34][33][32][31][30][29][28][27][26][25][24][23][22][21][20][19][18][17][16][15][14][13][12][11][10][9][8][7][6][5][4][3][2][1][0]");
-})
-.add('Parser#basic_list_projection', function() {
-  jmespath.compile("foo[*].bar");
-})
-.on('cycle', function(event) {
-  var bench = event.target;
-  var mean = bench.stats.mean * 1000;
-  var variance = bench.stats.variance * 1000000;
-  var result = 'Mean time: ' + mean.toFixed(6) + 'msec ';
-  result += event.target.toString();
-  console.log(result);
-})
-.on('complete', function() {
-})
-// run async
-.run({ 'async': false });

package/node_modules/jmespath/reservedWords.json

@@ -1,4 +0,0 @@
-{
-  "vars": [ "define", "require", "exports"],
-  "props": ["compile", "search", "tokenize", "jmespath", "parse", "stringify", "prototype", "length"]
-}

package/node_modules/jmespath/test/compliance/basic.json

@@ -1,96 +0,0 @@
-[{
-    "given":
-        {"foo": {"bar": {"baz": "correct"}}},
-     "cases": [
-         {
-            "expression": "foo",
-            "result": {"bar": {"baz": "correct"}}
-         },
-         {
-            "expression": "foo.bar",
-            "result": {"baz": "correct"}
-         },
-         {
-            "expression": "foo.bar.baz",
-            "result": "correct"
-         },
-         {
-            "expression": "foo\n.\nbar\n.baz",
-            "result": "correct"
-         },
-         {
-            "expression": "foo.bar.baz.bad",
-            "result": null
-         },
-         {
-            "expression": "foo.bar.bad",
-            "result": null
-         },
-         {
-            "expression": "foo.bad",
-            "result": null
-         },
-         {
-            "expression": "bad",
-            "result": null
-         },
-         {
-            "expression": "bad.morebad.morebad",
-            "result": null
-         }
-     ]
-},
-{
-    "given":
-        {"foo": {"bar": ["one", "two", "three"]}},
-    "cases": [
-         {
-            "expression": "foo",
-            "result": {"bar": ["one", "two", "three"]}
-         },
-         {
-            "expression": "foo.bar",
-            "result": ["one", "two", "three"]
-         }
-    ]
-},
-{
-    "given": ["one", "two", "three"],
-    "cases": [
-        {
-            "expression": "one",
-            "result": null
-        },
-        {
-            "expression": "two",
-            "result": null
-        },
-        {
-            "expression": "three",
-            "result": null
-        },
-        {
-            "expression": "one.two",
-            "result": null
-        }
-    ]
-},
-{
-    "given":
-        {"foo": {"1": ["one", "two", "three"], "-1": "bar"}},
-    "cases": [
-         {
-            "expression": "foo.\"1\"",
-            "result": ["one", "two", "three"]
-         },
-         {
-            "expression": "foo.\"1\"[0]",
-            "result": "one"
-         },
-         {
-            "expression": "foo.\"-1\"",
-            "result": "bar"
-         }
-    ]
-}
-]

package/node_modules/jmespath/test/compliance/boolean.json

@@ -1,257 +0,0 @@
-[
-  {
-    "given": {
-      "outer": {
-        "foo": "foo",
-        "bar": "bar",
-        "baz": "baz"
-      }
-    },
-    "cases": [
-      {
-        "expression": "outer.foo || outer.bar",
-        "result": "foo"
-      },
-      {
-        "expression": "outer.foo||outer.bar",
-        "result": "foo"
-      },
-      {
-        "expression": "outer.bar || outer.baz",
-        "result": "bar"
-      },
-      {
-        "expression": "outer.bar||outer.baz",
-        "result": "bar"
-      },
-      {
-        "expression": "outer.bad || outer.foo",
-        "result": "foo"
-      },
-      {
-        "expression": "outer.bad||outer.foo",
-        "result": "foo"
-      },
-      {
-        "expression": "outer.foo || outer.bad",
-        "result": "foo"
-      },
-      {
-        "expression": "outer.foo||outer.bad",
-        "result": "foo"
-      },
-      {
-        "expression": "outer.bad || outer.alsobad",
-        "result": null
-      },
-      {
-        "expression": "outer.bad||outer.alsobad",
-        "result": null
-      }
-    ]
-  },
-  {
-    "given": {
-      "outer": {
-        "foo": "foo",
-        "bool": false,
-        "empty_list": [],
-        "empty_string": ""
-      }
-    },
-    "cases": [
-      {
-        "expression": "outer.empty_string || outer.foo",
-        "result": "foo"
-      },
-      {
-        "expression": "outer.nokey || outer.bool || outer.empty_list || outer.empty_string || outer.foo",
-        "result": "foo"
-      }
-    ]
-  },
-  {
-    "given": {
-      "True": true,
-      "False": false,
-      "Number": 5,
-      "EmptyList": [],
-      "Zero": 0
-    },
-    "cases": [
-      {
-        "expression": "True && False",
-        "result": false
-      },
-      {
-        "expression": "False && True",
-        "result": false
-      },
-      {
-        "expression": "True && True",
-        "result": true
-      },
-      {
-        "expression": "False && False",
-        "result": false
-      },
-      {
-        "expression": "True && Number",
-        "result": 5
-      },
-      {
-        "expression": "Number && True",
-        "result": true
-      },
-      {
-        "expression": "Number && False",
-        "result": false
-      },
-      {
-        "expression": "Number && EmptyList",
-        "result": []
-      },
-      {
-        "expression": "Number && True",
-        "result": true
-      },
-      {
-        "expression": "EmptyList && True",
-        "result": []
-      },
-      {
-        "expression": "EmptyList && False",
-        "result": []
-      },
-      {
-        "expression": "True || False",
-        "result": true
-      },
-      {
-        "expression": "True || True",
-        "result": true
-      },
-      {
-        "expression": "False || True",
-        "result": true
-      },
-      {
-        "expression": "False || False",
-        "result": false
-      },
-      {
-        "expression": "Number || EmptyList",
-        "result": 5
-      },
-      {
-        "expression": "Number || True",
-        "result": 5
-      },
-      {
-        "expression": "Number || True && False",
-        "result": 5
-      },
-      {
-        "expression": "(Number || True) && False",
-        "result": false
-      },
-      {
-        "expression": "Number || (True && False)",
-        "result": 5
-      },
-      {
-        "expression": "!True",
-        "result": false
-      },
-      {
-        "expression": "!False",
-        "result": true
-      },
-      {
-        "expression": "!Number",
-        "result": false
-      },
-      {
-        "expression": "!EmptyList",
-        "result": true
-      },
-      {
-        "expression": "True && !False",
-        "result": true
-      },
-      {
-        "expression": "True && !EmptyList",
-        "result": true
-      },
-      {
-        "expression": "!False && !EmptyList",
-        "result": true
-      },
-      {
-        "expression": "!(True && False)",
-        "result": true
-      },
-      {
-        "expression": "!Zero",
-        "result": false
-      },
-      {
-        "expression": "!!Zero",
-        "result": true
-      }
-    ]
-  },
-  {
-    "given": {
-      "one": 1,
-      "two": 2,
-      "three": 3
-    },
-    "cases": [
-      {
-        "expression": "one < two",
-        "result": true
-      },
-      {
-        "expression": "one <= two",
-        "result": true
-      },
-      {
-        "expression": "one == one",
-        "result": true
-      },
-      {
-        "expression": "one == two",
-        "result": false
-      },
-      {
-        "expression": "one > two",
-        "result": false
-      },
-      {
-        "expression": "one >= two",
-        "result": false
-      },
-      {
-        "expression": "one != two",
-        "result": true
-      },
-      {
-        "expression": "one < two && three > one",
-        "result": true
-      },
-      {
-        "expression": "one < two || three > one",
-        "result": true
-      },
-      {
-        "expression": "one < two || three < one",
-        "result": true
-      },
-      {
-        "expression": "two < one || three < one",
-        "result": false
-      }
-    ]
-  }
-]

package/node_modules/jmespath/test/compliance/current.json

@@ -1,25 +0,0 @@
-[
-    {
-        "given": {
-            "foo": [{"name": "a"}, {"name": "b"}],
-            "bar": {"baz": "qux"}
-        },
-        "cases": [
-            {
-                "expression": "@",
-                "result": {
-                    "foo": [{"name": "a"}, {"name": "b"}],
-                    "bar": {"baz": "qux"}
-                }
-            },
-            {
-                "expression": "@.bar",
-                "result": {"baz": "qux"}
-            },
-            {
-                "expression": "@.foo[0]",
-                "result": {"name": "a"}
-            }
-        ]
-    }
-]

package/node_modules/jmespath/test/compliance/escape.json

@@ -1,46 +0,0 @@
-[{
-    "given": {
-        "foo.bar": "dot",
-        "foo bar": "space",
-        "foo\nbar": "newline",
-        "foo\"bar": "doublequote",
-        "c:\\\\windows\\path": "windows",
-        "/unix/path": "unix",
-        "\"\"\"": "threequotes",
-        "bar": {"baz": "qux"}
-     },
-     "cases": [
-         {
-            "expression": "\"foo.bar\"",
-            "result": "dot"
-         },
-         {
-            "expression": "\"foo bar\"",
-            "result": "space"
-         },
-         {
-            "expression": "\"foo\\nbar\"",
-            "result": "newline"
-         },
-         {
-            "expression": "\"foo\\\"bar\"",
-            "result": "doublequote"
-         },
-         {
-            "expression": "\"c:\\\\\\\\windows\\\\path\"",
-            "result": "windows"
-         },
-         {
-            "expression": "\"/unix/path\"",
-            "result": "unix"
-         },
-         {
-            "expression": "\"\\\"\\\"\\\"\"",
-            "result": "threequotes"
-         },
-         {
-            "expression": "\"bar\".\"baz\"",
-            "result": "qux"
-         }
-     ]
-}]