chrome-devtools-frontend 1.0.1506453 → 1.0.1510180

package/extensions/cxx_debugging/third_party/lit-html/src/lib/template-result.ts

@@ -1,148 +0,0 @@
-/**
- * @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
- */
-
-/**
- * @module lit-html
- */
-
-import {reparentNodes} from './dom.js';
-import {TemplateProcessor} from './template-processor.js';
-import {boundAttributeSuffix, lastAttributeNameRegex, marker, nodeMarker} from './template.js';
-
-declare const trustedTypes: typeof window.trustedTypes;
-/**
- * Our TrustedTypePolicy for HTML which is declared using the html template
- * tag function.
- *
- * That HTML is a developer-authored constant, and is parsed with innerHTML
- * before any untrusted expressions have been mixed in. Therefor it is
- * considered safe by construction.
- */
-const policy = window.trustedTypes &&
-    trustedTypes!.createPolicy('lit-html', {createHTML: (s) => s});
-
-const commentMarker = ` ${marker} `;
-
-/**
- * The return type of `html`, which holds a Template and the values from
- * interpolated expressions.
- */
-export class TemplateResult {
-  readonly strings: TemplateStringsArray;
-  readonly values: readonly unknown[];
-  readonly type: string;
-  readonly processor: TemplateProcessor;
-
-  constructor(
-      strings: TemplateStringsArray, values: readonly unknown[], type: string,
-      processor: TemplateProcessor) {
-    this.strings = strings;
-    this.values = values;
-    this.type = type;
-    this.processor = processor;
-  }
-
-  /**
-   * Returns a string of HTML used to create a `<template>` element.
-   */
-  getHTML(): string {
-    const l = this.strings.length - 1;
-    let html = '';
-    let isCommentBinding = false;
-
-    for (let i = 0; i < l; i++) {
-      const s = this.strings[i];
-      // For each binding we want to determine the kind of marker to insert
-      // into the template source before it's parsed by the browser's HTML
-      // parser. The marker type is based on whether the expression is in an
-      // attribute, text, or comment position.
-      //   * For node-position bindings we insert a comment with the marker
-      //     sentinel as its text content, like <!--{{lit-guid}}-->.
-      //   * For attribute bindings we insert just the marker sentinel for the
-      //     first binding, so that we support unquoted attribute bindings.
-      //     Subsequent bindings can use a comment marker because multi-binding
-      //     attributes must be quoted.
-      //   * For comment bindings we insert just the marker sentinel so we don't
-      //     close the comment.
-      //
-      // The following code scans the template source, but is *not* an HTML
-      // parser. We don't need to track the tree structure of the HTML, only
-      // whether a binding is inside a comment, and if not, if it appears to be
-      // the first binding in an attribute.
-      const commentOpen = s.lastIndexOf('<!--');
-      // We're in comment position if we have a comment open with no following
-      // comment close. Because <-- can appear in an attribute value there can
-      // be false positives.
-      isCommentBinding = (commentOpen > -1 || isCommentBinding) &&
-          s.indexOf('-->', commentOpen + 1) === -1;
-      // Check to see if we have an attribute-like sequence preceding the
-      // expression. This can match "name=value" like structures in text,
-      // comments, and attribute values, so there can be false-positives.
-      const attributeMatch = lastAttributeNameRegex.exec(s);
-      if (attributeMatch === null) {
-        // We're only in this branch if we don't have a attribute-like
-        // preceding sequence. For comments, this guards against unusual
-        // attribute values like <div foo="<!--${'bar'}">. Cases like
-        // <!-- foo=${'bar'}--> are handled correctly in the attribute branch
-        // below.
-        html += s + (isCommentBinding ? commentMarker : nodeMarker);
-      } else {
-        // For attributes we use just a marker sentinel, and also append a
-        // $lit$ suffix to the name to opt-out of attribute-specific parsing
-        // that IE and Edge do for style and certain SVG attributes.
-        html += s.substr(0, attributeMatch.index) + attributeMatch[1] +
-            attributeMatch[2] + boundAttributeSuffix + attributeMatch[3] +
-            marker;
-      }
-    }
-    html += this.strings[l];
-    return html;
-  }
-
-  getTemplateElement(): HTMLTemplateElement {
-    const template = document.createElement('template');
-    let value = this.getHTML();
-    if (policy !== undefined) {
-      // this is secure because `this.strings` is a TemplateStringsArray.
-      // TODO: validate this when
-      // https://github.com/tc39/proposal-array-is-template-object is
-      // implemented.
-      value = policy.createHTML(value) as unknown as string;
-    }
-    template.innerHTML = value;
-    return template;
-  }
-}
-
-/**
- * A TemplateResult for SVG fragments.
- *
- * This class wraps HTML in an `<svg>` tag in order to parse its contents in the
- * SVG namespace, then modifies the template to remove the `<svg>` tag so that
- * clones only container the original fragment.
- */
-export class SVGTemplateResult extends TemplateResult {
-  getHTML(): string {
-    return `<svg>${super.getHTML()}</svg>`;
-  }
-
-  getTemplateElement(): HTMLTemplateElement {
-    const template = super.getTemplateElement();
-    const content = template.content;
-    const svgElement = content.firstChild!;
-    content.removeChild(svgElement);
-    reparentNodes(content, svgElement.firstChild);
-    return template;
-  }
-}

package/extensions/cxx_debugging/third_party/lit-html/src/lib/template.ts

@@ -1,255 +0,0 @@
-/**
- * @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
- */
-
-import {TemplateResult} from './template-result.js';
-
-/**
- * An expression marker with embedded unique key to avoid collision with
- * possible text in templates.
- */
-export const marker = `{{lit-${String(Math.random()).slice(2)}}}`;
-
-/**
- * An expression marker used text-positions, multi-binding attributes, and
- * attributes with markup-like text values.
- */
-export const nodeMarker = `<!--${marker}-->`;
-
-export const markerRegex = new RegExp(`${marker}|${nodeMarker}`);
-
-/**
- * Suffix appended to all bound attribute names.
- */
-export const boundAttributeSuffix = '$lit$';
-
-/**
- * An updatable Template that tracks the location of dynamic parts.
- */
-export class Template {
-  readonly parts: TemplatePart[] = [];
-  readonly element: HTMLTemplateElement;
-
-  constructor(result: TemplateResult, element: HTMLTemplateElement) {
-    this.element = element;
-
-    const nodesToRemove: Node[] = [];
-    const stack: Node[] = [];
-    // Edge needs all 4 parameters present; IE11 needs 3rd parameter to be null
-    const walker = document.createTreeWalker(
-        element.content,
-        133 /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */,
-        null,
-        false);
-    // Keeps track of the last index associated with a part. We try to delete
-    // unnecessary nodes, but we never want to associate two different parts
-    // to the same index. They must have a constant node between.
-    let lastPartIndex = 0;
-    let index = -1;
-    let partIndex = 0;
-    const {strings, values: {length}} = result;
-    while (partIndex < length) {
-      const node = walker.nextNode() as Element | Comment | Text | null;
-      if (node === null) {
-        // We've exhausted the content inside a nested template element.
-        // Because we still have parts (the outer for-loop), we know:
-        // - There is a template in the stack
-        // - The walker will find a nextNode outside the template
-        walker.currentNode = stack.pop()!;
-        continue;
-      }
-      index++;
-
-      if (node.nodeType === 1 /* Node.ELEMENT_NODE */) {
-        if ((node as Element).hasAttributes()) {
-          const attributes = (node as Element).attributes;
-          const {length} = attributes;
-          // Per
-          // https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap,
-          // attributes are not guaranteed to be returned in document order.
-          // In particular, Edge/IE can return them out of order, so we cannot
-          // assume a correspondence between part index and attribute index.
-          let count = 0;
-          for (let i = 0; i < length; i++) {
-            if (endsWith(attributes[i].name, boundAttributeSuffix)) {
-              count++;
-            }
-          }
-          while (count-- > 0) {
-            // Get the template literal section leading up to the first
-            // expression in this attribute
-            const stringForPart = strings[partIndex];
-            // Find the attribute name
-            const name = lastAttributeNameRegex.exec(stringForPart)![2];
-            // Find the corresponding attribute
-            // All bound attributes have had a suffix added in
-            // TemplateResult#getHTML to opt out of special attribute
-            // handling. To look up the attribute value we also need to add
-            // the suffix.
-            const attributeLookupName =
-                name.toLowerCase() + boundAttributeSuffix;
-            const attributeValue =
-                (node as Element).getAttribute(attributeLookupName)!;
-            (node as Element).removeAttribute(attributeLookupName);
-            const statics = attributeValue.split(markerRegex);
-            this.parts.push({type: 'attribute', index, name, strings: statics});
-            partIndex += statics.length - 1;
-          }
-        }
-        if ((node as Element).tagName === 'TEMPLATE') {
-          stack.push(node);
-          walker.currentNode = (node as HTMLTemplateElement).content;
-        }
-      } else if (node.nodeType === 3 /* Node.TEXT_NODE */) {
-        const data = (node as Text).data;
-        if (data.indexOf(marker) >= 0) {
-          const parent = node.parentNode!;
-          const strings = data.split(markerRegex);
-          const lastIndex = strings.length - 1;
-          // Generate a new text node for each literal section
-          // These nodes are also used as the markers for node parts
-          for (let i = 0; i < lastIndex; i++) {
-            let insert: Node;
-            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 there's no text, we must insert a comment to mark our place.
-          // Else, we can trust it will stick around after cloning.
-          if (strings[lastIndex] === '') {
-            parent.insertBefore(createMarker(), node);
-            nodesToRemove.push(node);
-          } else {
-            (node as Text).data = strings[lastIndex];
-          }
-          // We have a part for each match found
-          partIndex += lastIndex;
-        }
-      } else if (node.nodeType === 8 /* Node.COMMENT_NODE */) {
-        if ((node as Comment).data === marker) {
-          const parent = node.parentNode!;
-          // Add a new marker node to be the startNode of the Part if any of
-          // the following are true:
-          //  * We don't have a previousSibling
-          //  * The previousSibling is already the start of a previous part
-          if (node.previousSibling === null || index === lastPartIndex) {
-            index++;
-            parent.insertBefore(createMarker(), node);
-          }
-          lastPartIndex = index;
-          this.parts.push({type: 'node', index});
-          // If we don't have a nextSibling, keep this node so we have an end.
-          // Else, we can remove it to save future costs.
-          if (node.nextSibling === null) {
-            (node as Comment).data = '';
-          } else {
-            nodesToRemove.push(node);
-            index--;
-          }
-          partIndex++;
-        } else {
-          let i = -1;
-          while ((i = (node as Comment).data.indexOf(marker, i + 1)) !== -1) {
-            // Comment node has a binding marker inside, make an inactive part
-            // The binding won't work, but subsequent bindings will
-            // TODO (justinfagnani): consider whether it's even worth it to
-            // make bindings in comments work
-            this.parts.push({type: 'node', index: -1});
-            partIndex++;
-          }
-        }
-      }
-    }
-
-    // Remove text binding nodes after the walk to not disturb the TreeWalker
-    for (const n of nodesToRemove) {
-      n.parentNode!.removeChild(n);
-    }
-  }
-}
-
-const endsWith = (str: string, suffix: string): boolean => {
-  const index = str.length - suffix.length;
-  return index >= 0 && str.slice(index) === suffix;
-};
-
-/**
- * A placeholder for a dynamic expression in an HTML template.
- *
- * There are two built-in part types: AttributePart and NodePart. NodeParts
- * always represent a single dynamic expression, while AttributeParts may
- * represent as many expressions are contained in the attribute.
- *
- * A Template's parts are mutable, so parts can be replaced or modified
- * (possibly to implement different template semantics). The contract is that
- * parts can only be replaced, not removed, added or reordered, and parts must
- * always consume the correct number of values in their `update()` method.
- *
- * TODO(justinfagnani): That requirement is a little fragile. A
- * TemplateInstance could instead be more careful about which values it gives
- * to Part.update().
- */
-export type TemplatePart = {
-  readonly type: 'node'; index: number;
-}|{
-  readonly type: 'attribute';
-  index: number;
-  readonly name: string;
-  readonly strings: ReadonlyArray<string>;
-};
-
-export const isTemplatePartActive = (part: TemplatePart) => part.index !== -1;
-
-// Allows `document.createComment('')` to be renamed for a
-// small manual size-savings.
-export const createMarker = () => document.createComment('');
-
-/**
- * This regex extracts the attribute name preceding an attribute-position
- * expression. It does this by matching the syntax allowed for attributes
- * against the string literal directly preceding the expression, assuming that
- * the expression is in an attribute-value position.
- *
- * See attributes in the HTML spec:
- * https://www.w3.org/TR/html5/syntax.html#elements-attributes
- *
- * " \x09\x0a\x0c\x0d" are HTML space characters:
- * https://www.w3.org/TR/html5/infrastructure.html#space-characters
- *
- * "\0-\x1F\x7F-\x9F" are Unicode control characters, which includes every
- * space character except " ".
- *
- * So an attribute is:
- *  * The name: any character except a control character, space character, ('),
- *    ("), ">", "=", or "/"
- *  * Followed by zero or more space characters
- *  * Followed by "="
- *  * Followed by zero or more space characters
- *  * Followed by:
- *    * Any character except space, ('), ("), "<", ">", "=", (`), or
- *    * (") then any non-("), or
- *    * (') then any non-(')
- */
-export const lastAttributeNameRegex =
-    // eslint-disable-next-line no-control-regex
-    /([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;

package/extensions/cxx_debugging/third_party/lit-html/src/lit-html.ts

@@ -1,74 +0,0 @@
-/**
- * @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
- */
-
-/**
- *
- * Main lit-html module.
- *
- * Main exports:
- *
- * -  [[html]]
- * -  [[svg]]
- * -  [[render]]
- *
- * @packageDocumentation
- */
-
-/**
- * Do not remove this comment; it keeps typedoc from misplacing the module
- * docs.
- */
-import {defaultTemplateProcessor} from './lib/default-template-processor.js';
-import {SVGTemplateResult, TemplateResult} from './lib/template-result.js';
-
-export {DefaultTemplateProcessor, defaultTemplateProcessor} from './lib/default-template-processor.js';
-export {directive, DirectiveFn, isDirective} from './lib/directive.js';
-// TODO(justinfagnani): remove line when we get NodePart moving methods
-export {removeNodes, reparentNodes} from './lib/dom.js';
-export {noChange, nothing, Part} from './lib/part.js';
-export {AttributeCommitter, AttributePart, BooleanAttributePart, EventPart, isIterable, isPrimitive, NodePart, PropertyCommitter, PropertyPart} from './lib/parts.js';
-export {RenderOptions} from './lib/render-options.js';
-export {parts, render} from './lib/render.js';
-export {templateCaches, templateFactory} from './lib/template-factory.js';
-export {TemplateInstance} from './lib/template-instance.js';
-export {TemplateProcessor} from './lib/template-processor.js';
-export {SVGTemplateResult, TemplateResult} from './lib/template-result.js';
-export {createMarker, isTemplatePartActive, Template} from './lib/template.js';
-
-declare global {
-  interface Window {
-    litHtmlVersions: string[];
-  }
-}
-
-// IMPORTANT: do not change the property name or the assignment expression.
-// This line will be used in regexes to search for lit-html usage.
-// TODO(justinfagnani): inject version number at build time
-if (typeof window !== 'undefined') {
-  (window['litHtmlVersions'] || (window['litHtmlVersions'] = [])).push('1.3.0');
-}
-
-/**
- * Interprets a template literal as an HTML template that can efficiently
- * render to and update a container.
- */
-export const html = (strings: TemplateStringsArray, ...values: unknown[]) =>
-    new TemplateResult(strings, values, 'html', defaultTemplateProcessor);
-
-/**
- * Interprets a template literal as an SVG template that can efficiently
- * render to and update a container.
- */
-export const svg = (strings: TemplateStringsArray, ...values: unknown[]) =>
-    new SVGTemplateResult(strings, values, 'svg', defaultTemplateProcessor);

package/extensions/cxx_debugging/third_party/lit-html/src/polyfills/template_polyfill.ts

@@ -1,70 +0,0 @@
-/**
- * @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
- */
-
-import {removeNodes, reparentNodes} from '../lib/dom.js';
-
-/**
- * A lightweight <template> polyfill that supports minimum features to cover
- * lit-html use cases. It provides an alternate route in case <template> is not
- * natively supported.
- * Please note that nested template, cloning template node and innerHTML getter
- * do NOT work with this polyfill.
- * If it can not fulfill your requirement, please consider using the full
- * polyfill: https://github.com/webcomponents/template
- */
-export const initTemplatePolyfill = (forced = false) => {
-  // Minimal polyfills (like this one) may provide only a subset of Template's
-  // functionality. So, we explicitly check that at least content is present to
-  // prevent installing patching with multiple polyfills, which might happen if
-  // multiple versions of lit-html were included on a page.
-  if (!forced && 'content' in document.createElement('template')) {
-    return;
-  }
-  const contentDoc = document.implementation.createHTMLDocument('template');
-  const body = contentDoc.body;
-  const descriptor = {
-    enumerable: true,
-    configurable: true,
-  };
-
-  const upgrade = (template: HTMLTemplateElement) => {
-    const content = contentDoc.createDocumentFragment();
-    Object.defineProperties(template, {
-      content: {
-        ...descriptor,
-        get() {
-          return content;
-        },
-      },
-      innerHTML: {
-        ...descriptor,
-        set: function(text) {
-          body.innerHTML = text;
-          removeNodes(content, content.firstChild);
-          reparentNodes(content, body.firstChild);
-        },
-      },
-    });
-  };
-
-  const capturedCreateElement = Document.prototype.createElement;
-  Document.prototype.createElement = function createElement(
-      tagName: string, options?: ElementCreationOptions) {
-    const el = capturedCreateElement.call(this, tagName, options);
-    if (el.tagName === 'TEMPLATE') {
-      upgrade(el as HTMLTemplateElement);
-    }
-    return el;
-  };
-};

package/extensions/cxx_debugging/third_party/lit-html/ts3.4/directives/async-append.d.ts

@@ -1,33 +0,0 @@
-/**
- * @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
- */
-import { Part } from '../lit-html.js';
-/**
- * A directive that renders the items of an async iterable[1], appending new
- * values after previous values, similar to the built-in support for iterables.
- *
- * Async iterables are objects with a [Symbol.asyncIterator] method, which
- * returns an iterator who's `next()` method returns a Promise. When a new
- * value is available, the Promise resolves and the value is appended to the
- * Part controlled by the directive. If another value other than this
- * directive has been set on the Part, the iterable will no longer be listened
- * to and new values won't be written to the Part.
- *
- * [1]: https://github.com/tc39/proposal-async-iteration
- *
- * @param value An async iterable
- * @param mapper An optional function that maps from (value, index) to another
- *     value. Useful for generating templates for each item in the iterable.
- */
-export declare const asyncAppend: <T>(value: AsyncIterable<T>, mapper?: ((v: T, index?: number | undefined) => unknown) | undefined) => (part: Part) => Promise<void>;
-//# sourceMappingURL=async-append.d.ts.map

package/extensions/cxx_debugging/third_party/lit-html/ts3.4/directives/async-replace.d.ts

@@ -1,34 +0,0 @@
-/**
- * @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
- */
-import { Part } from '../lit-html.js';
-/**
- * A directive that renders the items of an async iterable[1], replacing
- * previous values with new values, so that only one value is ever rendered
- * at a time.
- *
- * Async iterables are objects with a [Symbol.asyncIterator] method, which
- * returns an iterator who's `next()` method returns a Promise. When a new
- * value is available, the Promise resolves and the value is rendered to the
- * Part controlled by the directive. If another value other than this
- * directive has been set on the Part, the iterable will no longer be listened
- * to and new values won't be written to the Part.
- *
- * [1]: https://github.com/tc39/proposal-async-iteration
- *
- * @param value An async iterable
- * @param mapper An optional function that maps from (value, index) to another
- *     value. Useful for generating templates for each item in the iterable.
- */
-export declare const asyncReplace: <T>(value: AsyncIterable<T>, mapper?: ((v: T, index?: number | undefined) => unknown) | undefined) => (part: Part) => Promise<void>;
-//# sourceMappingURL=async-replace.d.ts.map

package/extensions/cxx_debugging/third_party/lit-html/ts3.4/directives/cache.d.ts

@@ -1,30 +0,0 @@
-/**
- * @license
- * Copyright (c) 2018 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
- */
-import { Part } from '../lit-html.js';
-/**
- * Enables fast switching between multiple templates by caching the DOM nodes
- * and TemplateInstances produced by the templates.
- *
- * Example:
- *
- * ```
- * let checked = false;
- *
- * html`
- *   ${cache(checked ? html`input is checked` : html`input is not checked`)}
- * `
- * ```
- */
-export declare const cache: (value: unknown) => (part: Part) => void;
-//# sourceMappingURL=cache.d.ts.map

package/extensions/cxx_debugging/third_party/lit-html/ts3.4/directives/class-map.d.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright (c) 2018 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
- */
-import { Part } from '../lit-html.js';
-export interface ClassInfo {
-    readonly [name: string]: string | boolean | number;
-}
-/**
- * A directive that applies CSS classes. This must be used in the `class`
- * attribute and must be the only part used in the attribute. It takes each
- * property in the `classInfo` argument and adds the property name to the
- * element's `class` if the property value is truthy; if the property value is
- * falsey, the property name is removed from the element's `class`. For example
- * `{foo: bar}` applies the class `foo` if the value of `bar` is truthy.
- * @param classInfo {ClassInfo}
- */
-export declare const classMap: (classInfo: ClassInfo) => (part: Part) => void;
-//# sourceMappingURL=class-map.d.ts.map