text: sap.ui.define(['exports'], function (exports) { 'use strict';
  
      /**
       * @license
       * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
       * This code may only be used under the BSD style license found at
       * http://polymer.github.io/LICENSE.txt
       * The complete set of authors may be found at
       * http://polymer.github.io/AUTHORS.txt
       * The complete set of contributors may be found at
       * http://polymer.github.io/CONTRIBUTORS.txt
       * Code distributed by Google as part of the polymer project is also
       * subject to an additional IP rights grant found at
       * http://polymer.github.io/PATENTS.txt
       */
      const marker = `{{lit-${String(Math.random()).slice(2)}}}`;
      const nodeMarker = `<!--${marker}-->`;
      const markerRegex = new RegExp(`${marker}|${nodeMarker}`);
      const boundAttributeSuffix = '$lit$';
      class Template {
          constructor(result, element) {
              this.parts = [];
              this.element = element;
              const nodesToRemove = [];
              const stack = [];
              const walker = document.createTreeWalker(element.content, 133 , null, false);
              let lastPartIndex = 0;
              let index = -1;
              let partIndex = 0;
              const { strings, values: { length } } = result;
              while (partIndex < length) {
                  const node = walker.nextNode();
                  if (node === null) {
                      walker.currentNode = stack.pop();
                      continue;
                  }
                  index++;
                  if (node.nodeType === 1 ) {
                      if (node.hasAttributes()) {
                          const attributes = node.attributes;
                          const { length } = attributes;
                          let count = 0;
                          for (let i = 0; i < length; i++) {
                              if (endsWith(attributes[i].name, boundAttributeSuffix)) {
                                  count++;
                              }
                          }
                          while (count-- > 0) {
                              const stringForPart = strings[partIndex];
                              const name = lastAttributeNameRegex.exec(stringForPart)[2];
                              const attributeLookupName = name.toLowerCase() + boundAttributeSuffix;
                              const attributeValue = node.getAttribute(attributeLookupName);
                              node.removeAttribute(attributeLookupName);
                              const statics = attributeValue.split(markerRegex);
                              this.parts.push({ type: 'attribute', index, name, strings: statics });
                              partIndex += statics.length - 1;
                          }
                      }
                      if (node.tagName === 'TEMPLATE') {
                          stack.push(node);
                          walker.currentNode = node.content;
                      }
                  }
                  else if (node.nodeType === 3 ) {
                      const data = node.data;
                      if (data.indexOf(marker) >= 0) {
                          const parent = node.parentNode;
                          const strings = data.split(markerRegex);
                          const lastIndex = strings.length - 1;
                          for (let i = 0; i < lastIndex; i++) {
                              let insert;
                              let s = strings[i];
                              if (s === '') {
                                  insert = createMarker();
                              }
                              else {
                                  const match = lastAttributeNameRegex.exec(s);
                                  if (match !== null && endsWith(match[2], boundAttributeSuffix)) {
                                      s = s.slice(0, match.index) + match[1] +
                                          match[2].slice(0, -boundAttributeSuffix.length) + match[3];
                                  }
                                  insert = document.createTextNode(s);
                              }
                              parent.insertBefore(insert, node);
                              this.parts.push({ type: 'node', index: ++index });
                          }
                          if (strings[lastIndex] === '') {
                              parent.insertBefore(createMarker(), node);
                              nodesToRemove.push(node);
                          }
                          else {
                              node.data = strings[lastIndex];
                          }
                          partIndex += lastIndex;
                      }
                  }
                  else if (node.nodeType === 8 ) {
                      if (node.data === marker) {
                          const parent = node.parentNode;
                          if (node.previousSibling === null || index === lastPartIndex) {
                              index++;
                              parent.insertBefore(createMarker(), node);
                          }
                          lastPartIndex = index;
                          this.parts.push({ type: 'node', index });
                          if (node.nextSibling === null) {
                              node.data = '';
                          }
                          else {
                              nodesToRemove.push(node);
                              index--;
                          }
                          partIndex++;
                      }
                      else {
                          let i = -1;
                          while ((i = node.data.indexOf(marker, i + 1)) !== -1) {
                              this.parts.push({ type: 'node', index: -1 });
                              partIndex++;
                          }
                      }
                  }
              }
              for (const n of nodesToRemove) {
                  n.parentNode.removeChild(n);
              }
          }
      }
      const endsWith = (str, suffix) => {
          const index = str.length - suffix.length;
          return index >= 0 && str.slice(index) === suffix;
      };
      const isTemplatePartActive = (part) => part.index !== -1;
      const createMarker = () => document.createComment('');
      const lastAttributeNameRegex =
      /([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;
  
      exports.Template = Template;
      exports.boundAttributeSuffix = boundAttributeSuffix;
      exports.createMarker = createMarker;
      exports.isTemplatePartActive = isTemplatePartActive;
      exports.lastAttributeNameRegex = lastAttributeNameRegex;
      exports.marker = marker;
      exports.markerRegex = markerRegex;
      exports.nodeMarker = nodeMarker;
  
      Object.defineProperty(exports, '__esModule', { value: true });
  
  });
  