@pinuts/bsr-uikit-relaunch 0.0.3 → 0.0.5

package/node_modules/json-logic-js/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Change Log
+
+## 2.0.2
+
+Thanks [@panzi](https://github.com/panzi) for rebuilding the test system and removing Gulp as a dev dependency.
+
+## 2.0.1
+
+The operations object could be exploited to run arbitrary code. Resolves [SNYK-JS-JSONLOGICJS-674308](https://security.snyk.io/vuln/SNYK-JS-JSONLOGICJS-674308), thanks Arel Cordero for reporting. 
+
+## 2.0.0
+
+Major version bump because we're removing the `method` operation. The [NPM advisory 1542](https://www.npmjs.com/advisories/1542) shows that an attacker can supply a JsonLogic rule that will execute arbitrary code in the client of anyone who executes that rule with any data.
+
+## 1.2.3
+
+Cleaned up JsonLogic's behavior when the `data` parameter is not an object, especially when it's falsy. Resolves PRs [88](https://github.com/jwadhams/json-logic-js/pull/88) and [89](https://github.com/jwadhams/json-logic-js/pull/89), but more importantly makes the `var` operator more resilient.

package/node_modules/json-logic-js/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jeremy Wadhams
+
+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/json-logic-js/README.md

@@ -0,0 +1,127 @@
+# json-logic-js
+
+This parser accepts [JsonLogic](http://jsonlogic.com) rules and executes them in JavaScript.
+
+The JsonLogic format is designed to allow you to share rules (logic) between front-end and back-end code (regardless of language difference), even to store logic along with a record in a database.  JsonLogic is documented extensively at [JsonLogic.com](http://jsonlogic.com), including examples of every [supported operation](http://jsonlogic.com/operations.html) and a place to [try out rules in your browser](http://jsonlogic.com/play.html).
+
+The same format can also be executed in PHP by the library [json-logic-php](https://github.com/jwadhams/json-logic-php/)
+
+## Installation
+
+We recommend that you install this library with a package manager, like [NPM](https://www.npmjs.com/) (or Yarn, etc):
+
+```bash
+npm install json-logic-js
+```
+
+Note that this project uses a [module loader](http://ricostacruz.com/cheatsheets/umdjs.html) that also makes it suitable for RequireJS projects.
+
+If that doesn't suit you, and you want to manage updates yourself, the entire library is self-contained in `logic.js` and you can download it straight into your project as you see fit.
+
+```bash
+curl -O https://raw.githubusercontent.com/jwadhams/json-logic-js/master/logic.js
+```
+
+## Examples
+
+### Simple
+```js
+jsonLogic.apply( { "==" : [1, 1] } );
+// true
+```
+
+This is a simple test, equivalent to `1 == 1`.  A few things about the format:
+
+  1. The operator is always in the "key" position. There is only one key per JsonLogic rule.
+  1. The values are typically an array.
+  1. Each value can be a string, number, boolean, array (non-associative), or null
+
+### Compound
+Here we're beginning to nest rules.
+
+```js
+jsonLogic.apply(
+  {"and" : [
+    { ">" : [3,1] },
+    { "<" : [1,3] }
+  ] }
+);
+// true
+```
+
+In an infix language (like JavaScript) this could be written as:
+
+```js
+( (3 > 1) && (1 < 3) )
+```
+
+### Data-Driven
+
+Obviously these rules aren't very interesting if they can only take static literal data. Typically `jsonLogic` will be called with a rule object and a data object. You can use the `var` operator to get attributes of the data object:
+
+```js
+jsonLogic.apply(
+  { "var" : ["a"] }, // Rule
+  { a : 1, b : 2 }   // Data
+);
+// 1
+```
+
+If you like, we support [syntactic sugar](https://en.wikipedia.org/wiki/Syntactic_sugar) on unary operators to skip the array around values:
+
+```js
+jsonLogic.apply(
+  { "var" : "a" },
+  { a : 1, b : 2 }
+);
+// 1
+```
+
+You can also use the `var` operator to access an array by numeric index:
+
+```js
+jsonLogic.apply(
+  {"var" : 1 },
+  [ "apple", "banana", "carrot" ]
+);
+// "banana"
+```
+
+Here's a complex rule that mixes literals and data. The pie isn't ready to eat unless it's cooler than 110 degrees, *and* filled with apples.
+
+```js
+var rules = { "and" : [
+  {"<" : [ { "var" : "temp" }, 110 ]},
+  {"==" : [ { "var" : "pie.filling" }, "apple" ] }
+] };
+
+var data = { "temp" : 100, "pie" : { "filling" : "apple" } };
+
+jsonLogic.apply(rules, data);
+// true
+```
+
+### Always and Never
+Sometimes the rule you want to process is "Always" or "Never."  If the first parameter passed to `jsonLogic` is a non-object, non-associative-array, it is returned immediately.
+
+```js
+//Always
+jsonLogic.apply(true, data_will_be_ignored);
+// true
+
+//Never
+jsonLogic.apply(false, i_wasnt_even_supposed_to_be_here);
+// false
+```
+
+## Compatibility
+
+This library makes use of `Array.map` and `Array.reduce`, so it's not *exactly* Internet Explorer 8 friendly.
+
+If you want to use JsonLogic *and* support deprecated browsers, you could easily use [BabelJS's polyfill](https://babeljs.io/docs/usage/polyfill/) or directly incorporate the polyfills documented on MDN for [map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) and [reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce).
+
+## Customization
+
+It's not possible to include everyone's excellent ideas without the core library bloating, bringing in a ton of outside dependencies, or occasionally causing use case conflicts (some people need to safely execute untrusted rules, some people need to change outside state).
+
+Check out the [documentation for adding custom operations](http://jsonlogic.com/add_operation.html) and be sure to stop by the [Wiki page of custom operations](https://github.com/jwadhams/json-logic-js/wiki/Custom-Operations) to see if someone has already solved your problem or to share your solution.

package/node_modules/json-logic-js/logic.js

@@ -0,0 +1,475 @@
+/* globals define,module */
+/*
+Using a Universal Module Loader that should be browser, require, and AMD friendly
+http://ricostacruz.com/cheatsheets/umdjs.html
+*/
+;(function(root, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(factory);
+  } else if (typeof exports === "object") {
+    module.exports = factory();
+  } else {
+    root.jsonLogic = factory();
+  }
+}(this, function() {
+  "use strict";
+  /* globals console:false */
+
+  if ( ! Array.isArray) {
+    Array.isArray = function(arg) {
+      return Object.prototype.toString.call(arg) === "[object Array]";
+    };
+  }
+
+  /**
+   * Return an array that contains no duplicates (original not modified)
+   * @param  {array} array   Original reference array
+   * @return {array}         New array with no duplicates
+   */
+  function arrayUnique(array) {
+    var a = [];
+    for (var i=0, l=array.length; i<l; i++) {
+      if (a.indexOf(array[i]) === -1) {
+        a.push(array[i]);
+      }
+    }
+    return a;
+  }
+
+  var jsonLogic = {};
+  var operations = {
+    "==": function(a, b) {
+      return a == b;
+    },
+    "===": function(a, b) {
+      return a === b;
+    },
+    "!=": function(a, b) {
+      return a != b;
+    },
+    "!==": function(a, b) {
+      return a !== b;
+    },
+    ">": function(a, b) {
+      return a > b;
+    },
+    ">=": function(a, b) {
+      return a >= b;
+    },
+    "<": function(a, b, c) {
+      return (c === undefined) ? a < b : (a < b) && (b < c);
+    },
+    "<=": function(a, b, c) {
+      return (c === undefined) ? a <= b : (a <= b) && (b <= c);
+    },
+    "!!": function(a) {
+      return jsonLogic.truthy(a);
+    },
+    "!": function(a) {
+      return !jsonLogic.truthy(a);
+    },
+    "%": function(a, b) {
+      return a % b;
+    },
+    "log": function(a) {
+      console.log(a); return a;
+    },
+    "in": function(a, b) {
+      if (!b || typeof b.indexOf === "undefined") return false;
+      return (b.indexOf(a) !== -1);
+    },
+    "cat": function() {
+      return Array.prototype.join.call(arguments, "");
+    },
+    "substr": function(source, start, end) {
+      if (end < 0) {
+        // JavaScript doesn't support negative end, this emulates PHP behavior
+        var temp = String(source).substr(start);
+        return temp.substr(0, temp.length + end);
+      }
+      return String(source).substr(start, end);
+    },
+    "+": function() {
+      return Array.prototype.reduce.call(arguments, function(a, b) {
+        return parseFloat(a, 10) + parseFloat(b, 10);
+      }, 0);
+    },
+    "*": function() {
+      return Array.prototype.reduce.call(arguments, function(a, b) {
+        return parseFloat(a, 10) * parseFloat(b, 10);
+      });
+    },
+    "-": function(a, b) {
+      if (b === undefined) {
+        return -a;
+      } else {
+        return a - b;
+      }
+    },
+    "/": function(a, b) {
+      return a / b;
+    },
+    "min": function() {
+      return Math.min.apply(this, arguments);
+    },
+    "max": function() {
+      return Math.max.apply(this, arguments);
+    },
+    "merge": function() {
+      return Array.prototype.reduce.call(arguments, function(a, b) {
+        return a.concat(b);
+      }, []);
+    },
+    "var": function(a, b) {
+      var not_found = (b === undefined) ? null : b;
+      var data = this;
+      if (typeof a === "undefined" || a==="" || a===null) {
+        return data;
+      }
+      var sub_props = String(a).split(".");
+      for (var i = 0; i < sub_props.length; i++) {
+        if (data === null || data === undefined) {
+          return not_found;
+        }
+        // Descending into data
+        data = data[sub_props[i]];
+        if (data === undefined) {
+          return not_found;
+        }
+      }
+      return data;
+    },
+    "missing": function() {
+      /*
+      Missing can receive many keys as many arguments, like {"missing:[1,2]}
+      Missing can also receive *one* argument that is an array of keys,
+      which typically happens if it's actually acting on the output of another command
+      (like 'if' or 'merge')
+      */
+
+      var missing = [];
+      var keys = Array.isArray(arguments[0]) ? arguments[0] : arguments;
+
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        var value = jsonLogic.apply({"var": key}, this);
+        if (value === null || value === "") {
+          missing.push(key);
+        }
+      }
+
+      return missing;
+    },
+    "missing_some": function(need_count, options) {
+      // missing_some takes two arguments, how many (minimum) items must be present, and an array of keys (just like 'missing') to check for presence.
+      var are_missing = jsonLogic.apply({"missing": options}, this);
+
+      if (options.length - are_missing.length >= need_count) {
+        return [];
+      } else {
+        return are_missing;
+      }
+    },
+  };
+
+  jsonLogic.is_logic = function(logic) {
+    return (
+      typeof logic === "object" && // An object
+      logic !== null && // but not null
+      ! Array.isArray(logic) && // and not an array
+      Object.keys(logic).length === 1 // with exactly one key
+    );
+  };
+
+  /*
+  This helper will defer to the JsonLogic spec as a tie-breaker when different language interpreters define different behavior for the truthiness of primitives.  E.g., PHP considers empty arrays to be falsy, but Javascript considers them to be truthy. JsonLogic, as an ecosystem, needs one consistent answer.
+
+  Spec and rationale here: http://jsonlogic.com/truthy
+  */
+  jsonLogic.truthy = function(value) {
+    if (Array.isArray(value) && value.length === 0) {
+      return false;
+    }
+    return !! value;
+  };
+
+
+  jsonLogic.get_operator = function(logic) {
+    return Object.keys(logic)[0];
+  };
+
+  jsonLogic.get_values = function(logic) {
+    return logic[jsonLogic.get_operator(logic)];
+  };
+
+  jsonLogic.apply = function(logic, data) {
+    // Does this array contain logic? Only one way to find out.
+    if (Array.isArray(logic)) {
+      return logic.map(function(l) {
+        return jsonLogic.apply(l, data);
+      });
+    }
+    // You've recursed to a primitive, stop!
+    if ( ! jsonLogic.is_logic(logic) ) {
+      return logic;
+    }
+
+    var op = jsonLogic.get_operator(logic);
+    var values = logic[op];
+    var i;
+    var current;
+    var scopedLogic;
+    var scopedData;
+    var initial;
+
+    // easy syntax for unary operators, like {"var" : "x"} instead of strict {"var" : ["x"]}
+    if ( ! Array.isArray(values)) {
+      values = [values];
+    }
+
+    // 'if', 'and', and 'or' violate the normal rule of depth-first calculating consequents, let each manage recursion as needed.
+    if (op === "if" || op == "?:") {
+      /* 'if' should be called with a odd number of parameters, 3 or greater
+      This works on the pattern:
+      if( 0 ){ 1 }else{ 2 };
+      if( 0 ){ 1 }else if( 2 ){ 3 }else{ 4 };
+      if( 0 ){ 1 }else if( 2 ){ 3 }else if( 4 ){ 5 }else{ 6 };
+
+      The implementation is:
+      For pairs of values (0,1 then 2,3 then 4,5 etc)
+      If the first evaluates truthy, evaluate and return the second
+      If the first evaluates falsy, jump to the next pair (e.g, 0,1 to 2,3)
+      given one parameter, evaluate and return it. (it's an Else and all the If/ElseIf were false)
+      given 0 parameters, return NULL (not great practice, but there was no Else)
+      */
+      for (i = 0; i < values.length - 1; i += 2) {
+        if ( jsonLogic.truthy( jsonLogic.apply(values[i], data) ) ) {
+          return jsonLogic.apply(values[i+1], data);
+        }
+      }
+      if (values.length === i+1) {
+        return jsonLogic.apply(values[i], data);
+      }
+      return null;
+    } else if (op === "and") { // Return first falsy, or last
+      for (i=0; i < values.length; i+=1) {
+        current = jsonLogic.apply(values[i], data);
+        if ( ! jsonLogic.truthy(current)) {
+          return current;
+        }
+      }
+      return current; // Last
+    } else if (op === "or") {// Return first truthy, or last
+      for (i=0; i < values.length; i+=1) {
+        current = jsonLogic.apply(values[i], data);
+        if ( jsonLogic.truthy(current) ) {
+          return current;
+        }
+      }
+      return current; // Last
+    } else if (op === "filter") {
+      scopedData = jsonLogic.apply(values[0], data);
+      scopedLogic = values[1];
+
+      if ( ! Array.isArray(scopedData)) {
+        return [];
+      }
+      // Return only the elements from the array in the first argument,
+      // that return truthy when passed to the logic in the second argument.
+      // For parity with JavaScript, reindex the returned array
+      return scopedData.filter(function(datum) {
+        return jsonLogic.truthy( jsonLogic.apply(scopedLogic, datum));
+      });
+    } else if (op === "map") {
+      scopedData = jsonLogic.apply(values[0], data);
+      scopedLogic = values[1];
+
+      if ( ! Array.isArray(scopedData)) {
+        return [];
+      }
+
+      return scopedData.map(function(datum) {
+        return jsonLogic.apply(scopedLogic, datum);
+      });
+    } else if (op === "reduce") {
+      scopedData = jsonLogic.apply(values[0], data);
+      scopedLogic = values[1];
+      initial = typeof values[2] !== "undefined" ? jsonLogic.apply(values[2], data) : null;
+
+      if ( ! Array.isArray(scopedData)) {
+        return initial;
+      }
+
+      return scopedData.reduce(
+        function(accumulator, current) {
+          return jsonLogic.apply(
+            scopedLogic,
+            {current: current, accumulator: accumulator}
+          );
+        },
+        initial
+      );
+    } else if (op === "all") {
+      scopedData = jsonLogic.apply(values[0], data);
+      scopedLogic = values[1];
+      // All of an empty set is false. Note, some and none have correct fallback after the for loop
+      if ( ! Array.isArray(scopedData) || ! scopedData.length) {
+        return false;
+      }
+      for (i=0; i < scopedData.length; i+=1) {
+        if ( ! jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {
+          return false; // First falsy, short circuit
+        }
+      }
+      return true; // All were truthy
+    } else if (op === "none") {
+      scopedData = jsonLogic.apply(values[0], data);
+      scopedLogic = values[1];
+
+      if ( ! Array.isArray(scopedData) || ! scopedData.length) {
+        return true;
+      }
+      for (i=0; i < scopedData.length; i+=1) {
+        if ( jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {
+          return false; // First truthy, short circuit
+        }
+      }
+      return true; // None were truthy
+    } else if (op === "some") {
+      scopedData = jsonLogic.apply(values[0], data);
+      scopedLogic = values[1];
+
+      if ( ! Array.isArray(scopedData) || ! scopedData.length) {
+        return false;
+      }
+      for (i=0; i < scopedData.length; i+=1) {
+        if ( jsonLogic.truthy( jsonLogic.apply(scopedLogic, scopedData[i]) )) {
+          return true; // First truthy, short circuit
+        }
+      }
+      return false; // None were truthy
+    }
+
+    // Everyone else gets immediate depth-first recursion
+    values = values.map(function(val) {
+      return jsonLogic.apply(val, data);
+    });
+
+
+    // The operation is called with "data" bound to its "this" and "values" passed as arguments.
+    // Structured commands like % or > can name formal arguments while flexible commands (like missing or merge) can operate on the pseudo-array arguments
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
+    if (operations.hasOwnProperty(op) && typeof operations[op] === "function") {
+      return operations[op].apply(data, values);
+    } else if (op.indexOf(".") > 0) { // Contains a dot, and not in the 0th position
+      var sub_ops = String(op).split(".");
+      var operation = operations;
+      for (i = 0; i < sub_ops.length; i++) {
+        if (!operation.hasOwnProperty(sub_ops[i])) {
+          throw new Error("Unrecognized operation " + op +
+            " (failed at " + sub_ops.slice(0, i+1).join(".") + ")");
+        }
+        // Descending into operations
+        operation = operation[sub_ops[i]];
+      }
+
+      return operation.apply(data, values);
+    }
+
+    throw new Error("Unrecognized operation " + op );
+  };
+
+  jsonLogic.uses_data = function(logic) {
+    var collection = [];
+
+    if (jsonLogic.is_logic(logic)) {
+      var op = jsonLogic.get_operator(logic);
+      var values = logic[op];
+
+      if ( ! Array.isArray(values)) {
+        values = [values];
+      }
+
+      if (op === "var") {
+        // This doesn't cover the case where the arg to var is itself a rule.
+        collection.push(values[0]);
+      } else {
+        // Recursion!
+        values.forEach(function(val) {
+          collection.push.apply(collection, jsonLogic.uses_data(val) );
+        });
+      }
+    }
+
+    return arrayUnique(collection);
+  };
+
+  jsonLogic.add_operation = function(name, code) {
+    operations[name] = code;
+  };
+
+  jsonLogic.rm_operation = function(name) {
+    delete operations[name];
+  };
+
+  jsonLogic.rule_like = function(rule, pattern) {
+    // console.log("Is ". JSON.stringify(rule) . " like " . JSON.stringify(pattern) . "?");
+    if (pattern === rule) {
+      return true;
+    } // TODO : Deep object equivalency?
+    if (pattern === "@") {
+      return true;
+    } // Wildcard!
+    if (pattern === "number") {
+      return (typeof rule === "number");
+    }
+    if (pattern === "string") {
+      return (typeof rule === "string");
+    }
+    if (pattern === "array") {
+      // !logic test might be superfluous in JavaScript
+      return Array.isArray(rule) && ! jsonLogic.is_logic(rule);
+    }
+
+    if (jsonLogic.is_logic(pattern)) {
+      if (jsonLogic.is_logic(rule)) {
+        var pattern_op = jsonLogic.get_operator(pattern);
+        var rule_op = jsonLogic.get_operator(rule);
+
+        if (pattern_op === "@" || pattern_op === rule_op) {
+          // echo "\nOperators match, go deeper\n";
+          return jsonLogic.rule_like(
+            jsonLogic.get_values(rule, false),
+            jsonLogic.get_values(pattern, false)
+          );
+        }
+      }
+      return false; // pattern is logic, rule isn't, can't be eq
+    }
+
+    if (Array.isArray(pattern)) {
+      if (Array.isArray(rule)) {
+        if (pattern.length !== rule.length) {
+          return false;
+        }
+        /*
+          Note, array order MATTERS, because we're using this array test logic to consider arguments, where order can matter. (e.g., + is commutative, but '-' or 'if' or 'var' are NOT)
+        */
+        for (var i = 0; i < pattern.length; i += 1) {
+          // If any fail, we fail
+          if ( ! jsonLogic.rule_like(rule[i], pattern[i])) {
+            return false;
+          }
+        }
+        return true; // If they *all* passed, we pass
+      } else {
+        return false; // Pattern is array, rule isn't
+      }
+    }
+
+    // Not logic, not array, not a === match for rule.
+    return false;
+  };
+
+  return jsonLogic;
+}));

package/node_modules/json-logic-js/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "json-logic-js",
+  "version": "2.0.5",
+  "description": "Build complex rules, serialize them as JSON, and execute them in JavaScript",
+  "main": "logic.js",
+  "directories": {
+    "test": "tests"
+  },
+  "devDependencies": {
+    "eslint": "^7.32.0",
+    "eslint-config-google": "^0.14.0",
+    "qunit": "^2.16.0"
+  },
+  "scripts": {
+    "test": "qunit ./tests/tests.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jwadhams/json-logic-js.git"
+  },
+  "keywords": [
+    "json",
+    "logic",
+    "jsonlogic",
+    "rules"
+  ],
+  "author": "Jeremy Wadhams <jwadhams@dealerinspire.com> (http://jsonlogic.com)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jwadhams/json-logic-js/issues"
+  },
+  "homepage": "https://github.com/jwadhams/json-logic-js#readme"
+}