@tko/build.reference 4.0.0-beta1.5 → 4.0.0-beta1.7

package/dist/browser.js

@@ -1,5 +1,5 @@
+// @tko/build.reference 🥊 4.0.0-beta1.7 IIFE
 "use strict";
-// @tko/build.reference 🥊 4.0.0-beta1.5 IIFE
 var tko = (() => {
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -478,7 +478,7 @@ var tko = (() => {
     nextKey: () => nextKey,
     set: () => set
   });
-  var datastoreTime = new Date().getTime();
+  var datastoreTime = (/* @__PURE__ */ new Date()).getTime();
   var dataStoreKeyExpandoPropertyName = `__ko__${datastoreTime}`;
   var dataStoreSymbol = Symbol("Knockout data");
   var dataStore;
@@ -2098,8 +2098,10 @@ var tko = (() => {
     return b;
   }
   var operators = {
+    // unary
     "@": unwrapOrCall,
     "#": (a, b) => () => unwrap(b),
+    // Convert to read-only.
     "=>": LAMBDA,
     "!": function not(a, b) {
       return !b;
@@ -2113,9 +2115,11 @@ var tko = (() => {
     "--": function preinc2(a, b) {
       return --b;
     },
+    // exponent
     "**": function exp(a, b) {
       return __pow(a, b);
     },
+    // mul/div
     "*": function mul(a, b) {
       return a * b;
     },
@@ -2125,6 +2129,7 @@ var tko = (() => {
     "%": function mod(a, b) {
       return a % b;
     },
+    // sub/add
     "+": function add(a, b) {
       return a + b;
     },
@@ -2134,6 +2139,8 @@ var tko = (() => {
     "&-": function neg(a, b) {
       return -1 * b;
     },
+    // unary -
+    // relational
     "<": function lt(a, b) {
       return a < b;
     },
@@ -2146,11 +2153,14 @@ var tko = (() => {
     ">=": function ge(a, b) {
       return a >= b;
     },
+    //    TODO: 'in': function (a, b) { return a in b; },
+    //    TODO: 'instanceof': function (a, b) { return a instanceof b; },
+    // equality
     "==": function equal(a, b) {
-      return a === b;
+      return a == b;
     },
     "!=": function ne(a, b) {
-      return a !== b;
+      return a != b;
     },
     "===": function sequal(a, b) {
       return a === b;
@@ -2158,6 +2168,7 @@ var tko = (() => {
     "!==": function sne(a, b) {
       return a !== b;
     },
+    // bitwise
     "&": function bitAnd(a, b) {
       return a & b;
     },
@@ -2167,6 +2178,7 @@ var tko = (() => {
     "|": function bitOr(a, b) {
       return a | b;
     },
+    // logic
     "&&": function logicAnd(a, b) {
       return a && b;
     },
@@ -2176,6 +2188,7 @@ var tko = (() => {
     "??": function nullishCoalesce(a, b) {
       return a != null ? a : b;
     },
+    // Access
     ".": function member(a, b) {
       return a == null ? void 0 : a[b];
     },
@@ -2188,6 +2201,9 @@ var tko = (() => {
     ",": function comma(a, b) {
       return b;
     },
+    // conditional/ternary
+    // '?': ternary See Node.js
+    // Function-Call
     "call": function callOp(a, b) {
       return a.apply(null, b);
     }
@@ -2252,6 +2268,15 @@ var tko = (() => {
       }
       return leaf;
     }
+    /**
+     * Return a function that calculates and returns an expression's value
+     * when called.
+     * @param  {array} ops  The operations to perform
+     * @return {function}   The function that calculates the expression.
+     *
+     * Note that for a lambda, we do not evaluate the RHS expression until
+     * the lambda is called.
+     */
     get_value(notused, context, globals, node) {
       var node = this;
       if (node.op === LAMBDA) {
@@ -2271,6 +2296,9 @@ var tko = (() => {
       const rhv = node.get_leaf_value(node.rhs, context, globals, node);
       return node.op(lhv, rhv, context, globals);
     }
+    //
+    // Class variables.
+    //
     static get isExpressionOrIdentifierSymbol() {
       return IS_EXPR_OR_IDENT;
     }
@@ -2283,6 +2311,12 @@ var tko = (() => {
       }
       return item;
     }
+    /**
+    *  Convert an array of nodes to an executable tree.
+    *  @return {object} An object with a `lhs`, `rhs` and `op` key, corresponding
+    *                      to the left hand side, right hand side, and
+    *                      operation function.
+    */
     static create_root(nodes, debug = false) {
       const out = [];
       const ops = [];
@@ -2314,6 +2348,9 @@ var tko = (() => {
       this.nodes = nodes;
       this.root = Node2.create_root(nodes);
     }
+    /**
+     * Return the value of `this` Expression instance.
+     */
     get_value(parent, context, globals, node) {
       if (!this.root) {
         this.root = Node2.create_root(this.nodes);
@@ -2352,6 +2389,27 @@ var tko = (() => {
       this.dereferences = dereferences;
       this.parser = parser;
     }
+    /**
+     * Apply all () and [] functions on the identifier to the lhs value e.g.
+     * a()[3] has deref functions that are essentially this:
+     *     [_deref_call, _deref_this where this=3]
+     *
+     * @param  {mixed} value  Should be an object.
+     * @return {mixed}        The dereferenced value.
+     *
+     * [1] We want to bind any function that is a method of an object, but not
+     *     corrupt any values (e.g. computed()s).   e.g. Running x.bind(obj) where
+     *     we're given `data-bind='binding: obj.x'` and x is a computed will
+     *     break the computed's `this` and it will stop working as expected.
+     *
+     *     The test `!last_value.hasOwnProperty(member)`
+     *     distinguishes between functions on the prototype chain (prototypal
+     *     members) and value-members added directly to the object.  This may
+     *     not be the canonical test for this relationship, but it succeeds
+     *     in the known test cases.
+     *
+     *     See: `this` tests of our dereference function.
+     */
     dereference(value2, $context, globals, node) {
       let member2;
       let refs = this.dereferences || [];
@@ -2375,6 +2433,16 @@ var tko = (() => {
       }
       return value2;
     }
+    /**
+     * Return the value as one would get it from the top-level i.e.
+     * $data.token/$context.token/globals.token; this does not return intermediate
+     * values on a chain of members i.e. $data.hello.there -- requesting the
+     * Identifier('there').value will return $data/$context/globals.there.
+     *
+     * This will dereference using () or [arg] member.
+     * @param  {object | Identifier | Expression} parent
+     * @return {mixed}  Return the primitive or an accessor.
+     */
     get_value(parent, context, globals, node) {
       const intermediate = parent && !(parent instanceof Identifier) ? Node2.value_of(parent, context, globals, node)[this.token] : context.lookup(this.token, globals, node);
       return this.dereference(intermediate, context, globals, node);
@@ -2386,6 +2454,11 @@ var tko = (() => {
         object2[property] = value2;
       }
     }
+    /**
+     * Set the value of the Identifier.
+     *
+     * @param {Mixed} new_value The value that Identifier is to be set to.
+     */
     set_value(new_value, $context, globals) {
       const $data = $context.$data || {};
       const refs = this.dereferences || [];
@@ -2421,6 +2494,21 @@ var tko = (() => {
         this.assign(root, Node2.value_of(refs[i]), new_value);
       }
     }
+    /**
+     * Determine if a character is a valid item in an identifier.
+     * Note that we do not check whether the first item is a number, nor do we
+     * support unicode identifiers here.
+     *
+     * From:  http://stackoverflow.com/a/9337047
+     * @param  {String}  ch  The character
+     * @return {Boolean}     True if this is a valid identifier
+     */
+    // function is_identifier_char(ch) {
+    //   return (ch >= 'A' && ch <= 'Z') ||
+    //          (ch >= 'a' && ch <= 'z') ||
+    //          (ch >= '0' && ch <= 9) ||
+    //           ch === '_' || ch === '$';
+    // }
     static is_valid_start_char(ch) {
       return IDStart.test(ch);
     }
@@ -2514,6 +2602,9 @@ var tko = (() => {
       }
       return this.comment(ch);
     }
+    /**
+     * Slurp any C or C++ style comments
+     */
     comment(ch) {
       if (ch !== "/") {
         return ch;
@@ -2632,6 +2723,13 @@ ${name} ${msg} of
         return number;
       }
     }
+    /**
+     * Add a property to 'object' that equals the given value.
+     * @param  {Object} object The object to add the value to.
+     * @param  {String} key    object[key] is set to the given value.
+     * @param  {mixed}  value  The value, may be a primitive or a function. If a
+     *                         function it is unwrapped as a property.
+     */
     objectAddValue(object2, key, value2) {
       if (value2 && value2[Node2.isExpressionOrIdentifierSymbol]) {
         Object.defineProperty(object2, key, {
@@ -2689,6 +2787,11 @@ ${name} ${msg} of
       }
       this.error("Bad object");
     }
+    /**
+     * Read up to delim and return the string
+     * @param  {string} delim The delimiter, either ' or "
+     * @return {string}       The string read.
+     */
     readString(delim) {
       let string = "";
       let nodes = [""];
@@ -2795,6 +2898,12 @@ ${name} ${msg} of
           return ch >= "0" && ch <= "9" ? this.number() : this.identifier();
       }
     }
+    /**
+     * Get the function for the given operator.
+     * A `.precedence` value is added to the function, with increasing
+     * precedence having a higher number.
+     * @return {function} The function that performs the infix operation
+     */
     operator(opts) {
       let op = "";
       let opFn;
@@ -2825,6 +2934,12 @@ ${name} ${msg} of
       }
       return opFn;
     }
+    /**
+     * Filters
+     * Returns what the Node interprets as an "operator".
+     * e.g.
+     *   <span data-bind="text: name | fit:20 | uppercase"></span>
+     */
     filter() {
       let ch = this.next();
       let args = [];
@@ -2850,16 +2965,32 @@ ${name} ${msg} of
         }
         ch = this.white();
       }
-      var filter = function filter2(value2, ignored, context, globals, node) {
+      function filter(value2, ignored, context, globals, node) {
         var argValues = [value2];
         for (var i = 0, j = args.length; i < j; ++i) {
           argValues.push(Node2.value_of(args[i], context, globals, node));
         }
-        return nextFilter(options_default.filters[name].apply(context, argValues));
-      };
+        return nextFilter(options_default.filters[name].apply(context, argValues), ignored, context, globals, node);
+      }
       filter.precedence = 1;
       return filter;
     }
+    /**
+     * Parse an expression – builds an operator tree, in something like
+     * Shunting-Yard.
+     *   See: http://en.wikipedia.org/wiki/Shunting-yard_algorithm
+     *
+     * @param filterable - Whether the expression can include jinga-style filters.
+     *    An argument of '|' is used only by the filter() method to parse subsequent
+     *    filters.
+     * @param allowMultipleValues - Whether multiple values separated by commas are
+     *    allowed in this expression. When true (default), this method consumes
+     *    subsequent comma-separated values.
+     * @see {@link Parser.singleValueExpression}
+     *
+     * @returns a function that computes the value of the expression
+     *    when called or a primitive.
+     */
     expression(filterable = false, allowMultipleValues = true) {
       let op;
       let nodes = [];
@@ -2929,6 +3060,13 @@ ${name} ${msg} of
       }
       return new Expression(nodes);
     }
+    /**
+     * Use this method to parse expressions that can be followed by additional markup
+     * seperated by a comma, such as in bindings strings.
+     *
+     * @returns an expression that cannot contain multiple values separated by commas.
+     * @see {@link Parser.expression}
+     */
     singleValueExpression(filterable) {
       return this.expression(filterable, false);
     }
@@ -2940,6 +3078,10 @@ ${name} ${msg} of
       nodes.push(operators["?"]);
       nodes.push(ternary2);
     }
+    /**
+     * Parse the arguments to a function, returning an Array.
+     *
+     */
     funcArguments() {
       let args = [];
       let ch = this.next("(");
@@ -2958,6 +3100,9 @@ ${name} ${msg} of
       }
       this.error("Bad arguments to function");
     }
+    /**
+     * The literal string reference `abc` in an `x.abc` expression.
+     */
     member() {
       let member2 = "";
       let ch = this.white();
@@ -2972,6 +3117,12 @@ ${name} ${msg} of
       }
       return member2;
     }
+    /**
+     * A dereference applies to an identifer, being either a function
+     * call "()" or a membership lookup with square brackets "[member]".
+     * @return {fn or undefined}  Dereference function to be applied to the
+     *                            Identifier
+     */
     dereference() {
       let member2;
       let ch = this.white();
@@ -3100,6 +3251,14 @@ ${name} ${msg} of
       }
       throw new Error("Value has cannot be converted to accessor: " + value2);
     }
+    /**
+    * Convert result[name] from a value to a function (i.e. `valueAccessor()`)
+    * @param  {object} result [Map of top-level names to values]
+    * @return {object}        [Map of top-level names to functions]
+    *
+    * Accessors may be one of (below) constAccessor, identifierAccessor,
+    * expressionAccessor, or nodeAccessor.
+    */
     convertToAccessors(result, context, globals, node) {
       objectForEach(result, (name, value2) => {
         if (value2 instanceof Identifier) {
@@ -3141,6 +3300,11 @@ ${name} ${msg} of
         options_default.onError(e);
       }
     }
+    /**
+     * Get the bindings as name: accessor()
+     * @param  {string} source The binding string to parse.
+     * @return {object}        Map of name to accessor function.
+     */
     parse(source, context = {}, globals = {}, node) {
       if (!source) {
         return () => null;
@@ -3150,6 +3314,9 @@ ${name} ${msg} of
       const bindingAccessors = this.runParse(source, parseFn);
       return this.convertToAccessors(bindingAccessors, context, globals, node);
     }
+    /**
+     * Return a function that evaluates and returns the result of the expression.
+     */
     parseExpression(source, context = {}, globals = {}, node) {
       if (!source) {
         return () => "";
@@ -3164,13 +3331,24 @@ ${name} ${msg} of
   // ../../packages/utils.parser/dist/preparse.js
   var specials = ",\"'`{}()/:[\\]";
   var bindingToken = RegExp([
+    // These match strings, either with double quotes, single quotes, or backticks
     '"(?:\\\\.|[^"])*"',
     "'(?:\\\\.|[^'])*'",
     "`(?:\\\\.|[^`])*`",
+    // Match C style comments
     "/\\*(?:[^*]|\\*+[^*/])*\\*+/",
+    // Match C++ style comments
     "//.*\n",
+    // Match a regular expression (text enclosed by slashes), but will also match sets of divisions
+    // as a regular expression (this is handled by the parsing loop below).
     "/(?:\\\\.|[^/])+/\\w*",
+    // Match text (at least two characters) that does not contain any of the above special characters,
+    // although some of the special characters are allowed to start it (all but the colon and comma).
+    // The text can contain spaces, but leading or trailing spaces are skipped.
     "[^\\s:,/][^" + specials + "]*[^\\s" + specials + "]",
+    // Match any non-space character not matched already. This will match colons and commas, since they're
+    // not matched by "everyThingElse", but will also match any other single character that wasn't already
+    // matched (for example: in "a: 1, b: 2", each of the non-space characters will be matched by oneNotSpace).
     "[^\\s]"
   ].join("|"), "g");
   var divisionLookBehind = /[\])"'A-Za-z0-9_$]+$/;
@@ -3229,6 +3407,14 @@ ${name} ${msg} of
     return result;
   }
 
+  // ../../packages/utils.parser/dist/index.js
+  function overloadOperator(op, fn, precedence) {
+    operators[op] = fn;
+    if (Number.isInteger(precedence)) {
+      operators[op].precedence = precedence;
+    }
+  }
+
   // ../../packages/computed/dist/computed.js
   var computedState = createSymbolOrString("_state");
   var DISPOSED_STATE = {
@@ -5143,6 +5329,7 @@ ${name} ${msg} of
     unwrapObservable: unwrap
   });
   var knockout = {
+    // --- Utilities ---
     cleanNode,
     dependencyDetection: dependencyDetection_exports,
     computedContext: dependencyDetection_exports,
@@ -5155,6 +5342,7 @@ ${name} ${msg} of
     tasks: tasks_exports,
     utils,
     LifeCycle,
+    // -- Observable ---
     isObservable,
     isSubscribable,
     isWriteableObservable,
@@ -5168,17 +5356,20 @@ ${name} ${msg} of
     toJS,
     toJSON,
     proxy,
+    // ... Computed ...
     computed,
     dependentObservable: computed,
     isComputed,
     isPureComputed,
     pureComputed,
     when,
+    // --- Templates ---
     nativeTemplateEngine,
     renderTemplate,
     setTemplateEngine,
     templateEngine,
     templateSources: { domElement, anonymousTemplate },
+    // --- Binding ---
     applyBindingAccessorsToNode,
     applyBindings,
     applyBindingsToDescendants,
@@ -5211,6 +5402,9 @@ ${name} ${msg} of
         bindingProvider: provider
       };
     }
+    /**
+     * @return {Object} An instance of Knockout.
+     */
     create(...additionalProperties) {
       const instance = Object.assign(
         {
@@ -5335,6 +5529,11 @@ ${name} ${msg} of
 
   // ../../packages/provider.bindingstring/dist/BindingStringProvider.js
   var BindingStringProvider = class extends Provider {
+    /** Call bindingHandler.preprocess on each respective binding string.
+     *
+     * The `preprocess` property of bindingHandler must be a static
+     * function (i.e. on the object or constructor).
+     */
     *processBinding(key, value2) {
       const [handlerName, property] = key.split(".");
       const handler2 = this.bindingHandlers.get(handlerName);
@@ -5377,6 +5576,10 @@ ${name} ${msg} of
     get FOR_NODE_TYPES() {
       return [1, 8];
     }
+    /**
+     * Convert <ko binding='...'> into <!-- ko binding: ... -->
+     * @param {HTMLElement} node
+     */
     preprocessNode(node) {
       if (node.tagName === "KO") {
         const parent = node.parentNode;
@@ -5415,6 +5618,7 @@ ${name} ${msg} of
     get FOR_NODE_TYPES() {
       return [1];
     }
+    // document.ELEMENT_NODE
     get BIND_ATTRIBUTE() {
       return "data-bind";
     }
@@ -5722,6 +5926,11 @@ ${name} ${msg} of
     get FOR_NODE_TYPES() {
       return [1];
     }
+    // document.ELEMENT_NODE
+    /**
+     * Convert <slot name='X'> to <!-- ko slot: 'X' --><!-- /ko -->
+     * @param {HTMLElement} node
+     */
     preprocessNode(node) {
       if (node.tagName === "SLOT") {
         const parent = node.parentNode;
@@ -6003,6 +6212,7 @@ ${name} ${msg} of
     get FOR_NODE_TYPES() {
       return [1];
     }
+    // document.ELEMENT_NODE
     constructor(params = {}) {
       super(params);
       this.ATTRIBUTES_TO_SKIP = new Set(params.attributesToSkip || ["data-bind"]);
@@ -6065,6 +6275,7 @@ ${name} ${msg} of
     get FOR_NODE_TYPES() {
       return [3];
     }
+    // document.TEXT_NODE
     *textToNodes(textNode) {
       const parent = textNode.parentNode;
       const isTextarea = parent && parent.nodeName === "TEXTAREA";
@@ -6091,6 +6302,17 @@ ${name} ${msg} of
       }
       return newNodes;
     }
+    /**
+     * We convert as follows:
+     *
+     *   {{# ... }} into <!-- ko ... -->
+     *   {{/ ... }} into <!-- /ko -->
+     *   {{# ... /}} into <!-- ko ... --><!-- /ko -->
+     *   {{ ... }} into <!-- ko text: ... --><!-- /ko -->
+     *   {{{ ... }}} into <!-- ko html: ... --><!-- /ko -->
+     *
+     * VirtualProvider can then pick up and do the actual binding.
+     */
     preprocessNode(node) {
       return this.textInterpolation(node);
     }
@@ -8112,6 +8334,8 @@ ${name} ${msg} of
   };
 
   // src/index.ts
+  overloadOperator("==", (a, b) => a === b);
+  overloadOperator("!=", (a, b) => a !== b);
   var builder = new Builder({
     filters,
     provider: new MultiProvider({
@@ -8134,7 +8358,7 @@ ${name} ${msg} of
       { each: bindings4.foreach }
     ]
   });
-  var version = "4.0.0-beta1.5";
+  var version = "4.0.0-beta1.7";
   var src_default = builder.create({
     jsx: {
       createElement,