Function $interpolate

OpenReservation/wwwroot/Scripts/angular.js:12053–12166

* @ngdoc service * @name $interpolate * @kind function * * @requires $parse * @requires $sce * * @description * * Compiles a string with markup int

(text, mustHaveExpression, trustedContext, allOrNothing)

                 * - `context`: evaluation context for all expressions embedded in the interpolated text
                 */
                function $interpolate(text, mustHaveExpression, trustedContext, allOrNothing) {
                    // Provide a quick exit and simplified result function for text with no interpolation
                    if (!text.length || text.indexOf(startSymbol) === -1) {
                        var constantInterp;
                        if (!mustHaveExpression) {
                            var unescapedText = unescapeText(text);
                            constantInterp = valueFn(unescapedText);
                            constantInterp.exp = text;
                            constantInterp.expressions = [];
                            constantInterp.$$watchDelegate = constantWatchDelegate;
                        }
                        return constantInterp;
                    }

                    allOrNothing = !!allOrNothing;
                    var startIndex,
                        endIndex,
                        index = 0,
                        expressions = [],
                        parseFns = [],
                        textLength = text.length,
                        exp,
                        concat = [],
                        expressionPositions = [];

                    while (index < textLength) {
                        if (((startIndex = text.indexOf(startSymbol, index)) != -1) &&
                            ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1)) {
                            if (index !== startIndex) {
                                concat.push(unescapeText(text.substring(index, startIndex)));
                            }
                            exp = text.substring(startIndex + startSymbolLength, endIndex);
                            expressions.push(exp);
                            parseFns.push($parse(exp, parseStringifyInterceptor));
                            index = endIndex + endSymbolLength;
                            expressionPositions.push(concat.length);
                            concat.push('');
                        } else {
                            // we did not find an interpolation, so we have to add the remainder to the separators array
                            if (index !== textLength) {
                                concat.push(unescapeText(text.substring(index)));
                            }
                            break;
                        }
                    }

                    // Concatenating expressions makes it hard to reason about whether some combination of
                    // concatenated values are unsafe to use and could easily lead to XSS.  By requiring that a
                    // single expression be used for iframe[src], object[src], etc., we ensure that the value
                    // that's used is assigned or constructed by some JS code somewhere that is more testable or
                    // make it obvious that you bound the value to some user controlled value.  This helps reduce
                    // the load when auditing for XSS issues.
                    if (trustedContext && concat.length > 1) {
                        $interpolateMinErr.throwNoconcat(text);
                    }

                    if (!mustHaveExpression || expressions.length) {
                        var compute = function (values) {