chrome-devtools-frontend 1.0.1506453 → 1.0.1510180

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

@@ -1,442 +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 {DirectiveFn} from '../lib/directive.js';
-import {createMarker, directive, NodePart, Part, removeNodes, reparentNodes} from '../lit-html.js';
-
-export type KeyFn<T> = (item: T, index: number) => unknown;
-export type ItemTemplate<T> = (item: T, index: number) => unknown;
-
-// Helper functions for manipulating parts
-// TODO(kschaaf): Refactor into Part API?
-const createAndInsertPart =
-    (containerPart: NodePart, beforePart?: NodePart): NodePart => {
-      const container = containerPart.startNode.parentNode as Node;
-      const beforeNode = beforePart === undefined ? containerPart.endNode :
-                                                    beforePart.startNode;
-      const startNode = container.insertBefore(createMarker(), beforeNode);
-      container.insertBefore(createMarker(), beforeNode);
-      const newPart = new NodePart(containerPart.options);
-      newPart.insertAfterNode(startNode);
-      return newPart;
-    };
-
-const updatePart = (part: NodePart, value: unknown) => {
-  part.setValue(value);
-  part.commit();
-  return part;
-};
-
-const insertPartBefore =
-    (containerPart: NodePart, part: NodePart, ref?: NodePart) => {
-      const container = containerPart.startNode.parentNode as Node;
-      const beforeNode = ref ? ref.startNode : containerPart.endNode;
-      const endNode = part.endNode.nextSibling;
-      if (endNode !== beforeNode) {
-        reparentNodes(container, part.startNode, endNode, beforeNode);
-      }
-    };
-
-const removePart = (part: NodePart) => {
-  removeNodes(
-      part.startNode.parentNode!, part.startNode, part.endNode.nextSibling);
-};
-
-// Helper for generating a map of array item to its index over a subset
-// of an array (used to lazily generate `newKeyToIndexMap` and
-// `oldKeyToIndexMap`)
-const generateMap = (list: unknown[], start: number, end: number) => {
-  const map = new Map();
-  for (let i = start; i <= end; i++) {
-    map.set(list[i], i);
-  }
-  return map;
-};
-
-// Stores previous ordered list of parts and map of key to index
-const partListCache = new WeakMap<NodePart, (NodePart | null)[]>();
-const keyListCache = new WeakMap<NodePart, unknown[]>();
-
-/**
- * A directive that repeats a series of values (usually `TemplateResults`)
- * generated from an iterable, and updates those items efficiently when the
- * iterable changes based on user-provided `keys` associated with each item.
- *
- * Note that if a `keyFn` is provided, strict key-to-DOM mapping is maintained,
- * meaning previous DOM for a given key is moved into the new position if
- * needed, and DOM will never be reused with values for different keys (new DOM
- * will always be created for new keys). This is generally the most efficient
- * way to use `repeat` since it performs minimum unnecessary work for insertions
- * and removals.
- *
- * IMPORTANT: If providing a `keyFn`, keys *must* be unique for all items in a
- * given call to `repeat`. The behavior when two or more items have the same key
- * is undefined.
- *
- * If no `keyFn` is provided, this directive will perform similar to mapping
- * items to values, and DOM will be reused against potentially different items.
- */
-export const repeat =
-    directive(
-        <T>(items: Iterable<T>,
-            keyFnOrTemplate: KeyFn<T>|ItemTemplate<T>,
-            template?: ItemTemplate<T>):
-            DirectiveFn => {
-              let keyFn: KeyFn<T>;
-              if (template === undefined) {
-                template = keyFnOrTemplate;
-              } else if (keyFnOrTemplate !== undefined) {
-                keyFn = keyFnOrTemplate as KeyFn<T>;
-              }
-
-              return (containerPart: Part): void => {
-                if (!(containerPart instanceof NodePart)) {
-                  throw new Error('repeat can only be used in text bindings');
-                }
-                // Old part & key lists are retrieved from the last update
-                // (associated with the part for this instance of the directive)
-                const oldParts = partListCache.get(containerPart) || [];
-                const oldKeys = keyListCache.get(containerPart) || [];
-
-                // New part list will be built up as we go (either reused from
-                // old parts or created for new keys in this update). This is
-                // saved in the above cache at the end of the update.
-                const newParts: NodePart[] = [];
-
-                // New value list is eagerly generated from items along with a
-                // parallel array indicating its key.
-                const newValues: unknown[] = [];
-                const newKeys: unknown[] = [];
-                let index = 0;
-                for (const item of items) {
-                  newKeys[index] = keyFn ? keyFn(item, index) : index;
-                  newValues[index] = template !(item, index);
-                  index++;
-                }
-
-                // Maps from key to index for current and previous update; these
-                // are generated lazily only when needed as a performance
-                // optimization, since they are only required for multiple
-                // non-contiguous changes in the list, which are less common.
-                let newKeyToIndexMap!: Map<unknown, number>;
-                let oldKeyToIndexMap!: Map<unknown, number>;
-
-                // Head and tail pointers to old parts and new values
-                let oldHead = 0;
-                let oldTail = oldParts.length - 1;
-                let newHead = 0;
-                let newTail = newValues.length - 1;
-
-                // Overview of O(n) reconciliation algorithm (general approach
-                // based on ideas found in ivi, vue, snabbdom, etc.):
-                //
-                // * We start with the list of old parts and new values (and
-                //   arrays of their respective keys), head/tail pointers into
-                //   each, and we build up the new list of parts by updating
-                //   (and when needed, moving) old parts or creating new ones.
-                //   The initial scenario might look like this (for brevity of
-                //   the diagrams, the numbers in the array reflect keys
-                //   associated with the old parts or new values, although keys
-                //   and parts/values are actually stored in parallel arrays
-                //   indexed using the same head/tail pointers):
-                //
-                //      oldHead v                 v oldTail
-                //   oldKeys:  [0, 1, 2, 3, 4, 5, 6]
-                //   newParts: [ ,  ,  ,  ,  ,  ,  ]
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6] <- reflects the user's new
-                //                                      item order
-                //      newHead ^                 ^ newTail
-                //
-                // * Iterate old & new lists from both sides, updating,
-                //   swapping, or removing parts at the head/tail locations
-                //   until neither head nor tail can move.
-                //
-                // * Example below: keys at head pointers match, so update old
-                //   part 0 in-place (no need to move it) and record part 0 in
-                //   the `newParts` list. The last thing we do is advance the
-                //   `oldHead` and `newHead` pointers (will be reflected in the
-                //   next diagram).
-                //
-                //      oldHead v                 v oldTail
-                //   oldKeys:  [0, 1, 2, 3, 4, 5, 6]
-                //   newParts: [0,  ,  ,  ,  ,  ,  ] <- heads matched: update 0
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    and advance both oldHead
-                //                                      & newHead
-                //      newHead ^                 ^ newTail
-                //
-                // * Example below: head pointers don't match, but tail
-                //   pointers do, so update part 6 in place (no need to move
-                //   it), and record part 6 in the `newParts` list. Last,
-                //   advance the `oldTail` and `oldHead` pointers.
-                //
-                //         oldHead v              v oldTail
-                //   oldKeys:  [0, 1, 2, 3, 4, 5, 6]
-                //   newParts: [0,  ,  ,  ,  ,  , 6] <- tails matched: update 6
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    and advance both oldTail
-                //                                      & newTail
-                //         newHead ^              ^ newTail
-                //
-                // * If neither head nor tail match; next check if one of the
-                //   old head/tail items was removed. We first need to generate
-                //   the reverse map of new keys to index (`newKeyToIndexMap`),
-                //   which is done once lazily as a performance optimization,
-                //   since we only hit this case if multiple non-contiguous
-                //   changes were made. Note that for contiguous removal
-                //   anywhere in the list, the head and tails would advance
-                //   from either end and pass each other before we get to this
-                //   case and removals would be handled in the final while loop
-                //   without needing to generate the map.
-                //
-                // * Example below: The key at `oldTail` was removed (no longer
-                //   in the `newKeyToIndexMap`), so remove that part from the
-                //   DOM and advance just the `oldTail` pointer.
-                //
-                //         oldHead v           v oldTail
-                //   oldKeys:  [0, 1, 2, 3, 4, 5, 6]
-                //   newParts: [0,  ,  ,  ,  ,  , 6] <- 5 not in new map: remove
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    5 and advance oldTail
-                //         newHead ^           ^ newTail
-                //
-                // * Once head and tail cannot move, any mismatches are due to
-                //   either new or moved items; if a new key is in the previous
-                //   "old key to old index" map, move the old part to the new
-                //   location, otherwise create and insert a new part. Note
-                //   that when moving an old part we null its position in the
-                //   oldParts array if it lies between the head and tail so we
-                //   know to skip it when the pointers get there.
-                //
-                // * Example below: neither head nor tail match, and neither
-                //   were removed; so find the `newHead` key in the
-                //   `oldKeyToIndexMap`, and move that old part's DOM into the
-                //   next head position (before `oldParts[oldHead]`). Last,
-                //   null the part in the `oldPart` array since it was
-                //   somewhere in the remaining oldParts still to be scanned
-                //   (between the head and tail pointers) so that we know to
-                //   skip that old part on future iterations.
-                //
-                //         oldHead v        v oldTail
-                //   oldKeys:  [0, 1, -, 3, 4, 5, 6]
-                //   newParts: [0, 2,  ,  ,  ,  , 6] <- stuck: update & move 2
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    into place and advance
-                //                                      newHead
-                //         newHead ^           ^ newTail
-                //
-                // * Note that for moves/insertions like the one above, a part
-                //   inserted at the head pointer is inserted before the
-                //   current `oldParts[oldHead]`, and a part inserted at the
-                //   tail pointer is inserted before `newParts[newTail+1]`. The
-                //   seeming asymmetry lies in the fact that new parts are
-                //   moved into place outside in, so to the right of the head
-                //   pointer are old parts, and to the right of the tail
-                //   pointer are new parts.
-                //
-                // * We always restart back from the top of the algorithm,
-                //   allowing matching and simple updates in place to
-                //   continue...
-                //
-                // * Example below: the head pointers once again match, so
-                //   simply update part 1 and record it in the `newParts`
-                //   array.  Last, advance both head pointers.
-                //
-                //         oldHead v        v oldTail
-                //   oldKeys:  [0, 1, -, 3, 4, 5, 6]
-                //   newParts: [0, 2, 1,  ,  ,  , 6] <- heads matched: update 1
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    and advance both oldHead
-                //                                      & newHead
-                //            newHead ^        ^ newTail
-                //
-                // * As mentioned above, items that were moved as a result of
-                //   being stuck (the final else clause in the code below) are
-                //   marked with null, so we always advance old pointers over
-                //   these so we're comparing the next actual old value on
-                //   either end.
-                //
-                // * Example below: `oldHead` is null (already placed in
-                //   newParts), so advance `oldHead`.
-                //
-                //            oldHead v     v oldTail
-                //   oldKeys:  [0, 1, -, 3, 4, 5, 6] <- old head already used:
-                //   newParts: [0, 2, 1,  ,  ,  , 6]    advance oldHead
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]
-                //               newHead ^     ^ newTail
-                //
-                // * Note it's not critical to mark old parts as null when they
-                //   are moved from head to tail or tail to head, since they
-                //   will be outside the pointer range and never visited again.
-                //
-                // * Example below: Here the old tail key matches the new head
-                //   key, so the part at the `oldTail` position and move its
-                //   DOM to the new head position (before `oldParts[oldHead]`).
-                //   Last, advance `oldTail` and `newHead` pointers.
-                //
-                //               oldHead v  v oldTail
-                //   oldKeys:  [0, 1, -, 3, 4, 5, 6]
-                //   newParts: [0, 2, 1, 4,  ,  , 6] <- old tail matches new
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]   head: update & move 4,
-                //                                     advance oldTail & newHead
-                //               newHead ^     ^ newTail
-                //
-                // * Example below: Old and new head keys match, so update the
-                //   old head part in place, and advance the `oldHead` and
-                //   `newHead` pointers.
-                //
-                //               oldHead v oldTail
-                //   oldKeys:  [0, 1, -, 3, 4, 5, 6]
-                //   newParts: [0, 2, 1, 4, 3,   ,6] <- heads match: update 3
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    and advance oldHead &
-                //                                      newHead
-                //                  newHead ^  ^ newTail
-                //
-                // * Once the new or old pointers move past each other then all
-                //   we have left is additions (if old list exhausted) or
-                //   removals (if new list exhausted). Those are handled in the
-                //   final while loops at the end.
-                //
-                // * Example below: `oldHead` exceeded `oldTail`, so we're done
-                //   with the main loop.  Create the remaining part and insert
-                //   it at the new head position, and the update is complete.
-                //
-                //                   (oldHead > oldTail)
-                //   oldKeys:  [0, 1, -, 3, 4, 5, 6]
-                //   newParts: [0, 2, 1, 4, 3, 7 ,6] <- create and insert 7
-                //   newKeys:  [0, 2, 1, 4, 3, 7, 6]
-                //                     newHead ^ newTail
-                //
-                // * Note that the order of the if/else clauses is not
-                //   important to the algorithm, as long as the null checks
-                //   come first (to ensure we're always working on valid old
-                //   parts) and that the final else clause comes last (since
-                //   that's where the expensive moves occur). The order of
-                //   remaining clauses is is just a simple guess at which cases
-                //   will be most common.
-                //
-                // * TODO(kschaaf) Note, we could calculate the longest
-                //   increasing subsequence (LIS) of old items in new position,
-                //   and only move those not in the LIS set. However that costs
-                //   O(nlogn) time and adds a bit more code, and only helps
-                //   make rare types of mutations require fewer moves. The
-                //   above handles removes, adds, reversal, swaps, and single
-                //   moves of contiguous items in linear time, in the minimum
-                //   number of moves. As the number of multiple moves where LIS
-                //   might help approaches a random shuffle, the LIS
-                //   optimization becomes less helpful, so it seems not worth
-                //   the code at this point. Could reconsider if a compelling
-                //   case arises.
-
-                while (oldHead <= oldTail && newHead <= newTail) {
-                  if (oldParts[oldHead] === null) {
-                    // `null` means old part at head has already been used
-                    // below; skip
-                    oldHead++;
-                  } else if (oldParts[oldTail] === null) {
-                    // `null` means old part at tail has already been used
-                    // below; skip
-                    oldTail--;
-                  } else if (oldKeys[oldHead] === newKeys[newHead]) {
-                    // Old head matches new head; update in place
-                    newParts[newHead] =
-                        updatePart(oldParts[oldHead]!, newValues[newHead]);
-                    oldHead++;
-                    newHead++;
-                  } else if (oldKeys[oldTail] === newKeys[newTail]) {
-                    // Old tail matches new tail; update in place
-                    newParts[newTail] =
-                        updatePart(oldParts[oldTail]!, newValues[newTail]);
-                    oldTail--;
-                    newTail--;
-                  } else if (oldKeys[oldHead] === newKeys[newTail]) {
-                    // Old head matches new tail; update and move to new tail
-                    newParts[newTail] =
-                        updatePart(oldParts[oldHead]!, newValues[newTail]);
-                    insertPartBefore(
-                        containerPart,
-                        oldParts[oldHead]!,
-                        newParts[newTail + 1]);
-                    oldHead++;
-                    newTail--;
-                  } else if (oldKeys[oldTail] === newKeys[newHead]) {
-                    // Old tail matches new head; update and move to new head
-                    newParts[newHead] =
-                        updatePart(oldParts[oldTail]!, newValues[newHead]);
-                    insertPartBefore(
-                        containerPart, oldParts[oldTail]!, oldParts[oldHead]!);
-                    oldTail--;
-                    newHead++;
-                  } else {
-                    if (newKeyToIndexMap === undefined) {
-                      // Lazily generate key-to-index maps, used for removals &
-                      // moves below
-                      newKeyToIndexMap = generateMap(newKeys, newHead, newTail);
-                      oldKeyToIndexMap = generateMap(oldKeys, oldHead, oldTail);
-                    }
-                    if (!newKeyToIndexMap.has(oldKeys[oldHead])) {
-                      // Old head is no longer in new list; remove
-                      removePart(oldParts[oldHead]!);
-                      oldHead++;
-                    } else if (!newKeyToIndexMap.has(oldKeys[oldTail])) {
-                      // Old tail is no longer in new list; remove
-                      removePart(oldParts[oldTail]!);
-                      oldTail--;
-                    } else {
-                      // Any mismatches at this point are due to additions or
-                      // moves; see if we have an old part we can reuse and move
-                      // into place
-                      const oldIndex = oldKeyToIndexMap.get(newKeys[newHead]);
-                      const oldPart =
-                          oldIndex !== undefined ? oldParts[oldIndex] : null;
-                      if (oldPart === null) {
-                        // No old part for this value; create a new one and
-                        // insert it
-                        const newPart = createAndInsertPart(
-                            containerPart, oldParts[oldHead]!);
-                        updatePart(newPart, newValues[newHead]);
-                        newParts[newHead] = newPart;
-                      } else {
-                        // Reuse old part
-                        newParts[newHead] =
-                            updatePart(oldPart, newValues[newHead]);
-                        insertPartBefore(
-                            containerPart, oldPart, oldParts[oldHead]!);
-                        // This marks the old part as having been used, so that
-                        // it will be skipped in the first two checks above
-                        oldParts[oldIndex as number] = null;
-                      }
-                      newHead++;
-                    }
-                  }
-                }
-                // Add parts for any remaining new values
-                while (newHead <= newTail) {
-                  // For all remaining additions, we insert before last new
-                  // tail, since old pointers are no longer valid
-                  const newPart =
-                      createAndInsertPart(containerPart, newParts[newTail + 1]);
-                  updatePart(newPart, newValues[newHead]);
-                  newParts[newHead++] = newPart;
-                }
-                // Remove any remaining unused old parts
-                while (oldHead <= oldTail) {
-                  const oldPart = oldParts[oldHead++];
-                  if (oldPart !== null) {
-                    removePart(oldPart);
-                  }
-                }
-                // Save order of new parts for next round
-                partListCache.set(containerPart, newParts);
-                keyListCache.set(containerPart, newKeys);
-              };
-            }) as
-    <T>(items: Iterable<T>,
-        keyFnOrTemplate: KeyFn<T>|ItemTemplate<T>,
-        template?: ItemTemplate<T>) => DirectiveFn;

package/extensions/cxx_debugging/third_party/lit-html/src/directives/style-map.ts

@@ -1,88 +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 {AttributePart, directive, Part, PropertyPart} from '../lit-html.js';
-
-export interface StyleInfo {
-  readonly [name: string]: string;
-}
-
-/**
- * Stores the StyleInfo object applied to a given AttributePart.
- * Used to unset existing values when a new StyleInfo object is applied.
- */
-const previousStylePropertyCache = new WeakMap<AttributePart, Set<string>>();
-
-/**
- * A directive that applies CSS properties to an element.
- *
- * `styleMap` can only be used in the `style` attribute and must be the only
- * expression in the attribute. It takes the property names in the `styleInfo`
- * object and adds the property values as CSS properties. Property names with
- * dashes (`-`) are assumed to be valid CSS property names and set on the
- * element's style object using `setProperty()`. Names without dashes are
- * assumed to be camelCased JavaScript property names and set on the element's
- * style object using property assignment, allowing the style object to
- * translate JavaScript-style names to CSS property names.
- *
- * For example `styleMap({backgroundColor: 'red', 'border-top': '5px', '--size':
- * '0'})` sets the `background-color`, `border-top` and `--size` properties.
- *
- * @param styleInfo {StyleInfo}
- */
-export const styleMap = directive((styleInfo: StyleInfo) => (part: Part) => {
-  if (!(part instanceof AttributePart) || (part instanceof PropertyPart) ||
-      part.committer.name !== 'style' || part.committer.parts.length > 1) {
-    throw new Error(
-        'The `styleMap` directive must be used in the style attribute ' +
-        'and must be the only part in the attribute.');
-  }
-
-  const {committer} = part;
-  const {style} = committer.element as HTMLElement;
-
-  let previousStyleProperties = previousStylePropertyCache.get(part);
-
-  if (previousStyleProperties === undefined) {
-    // Write static styles once
-    style.cssText = committer.strings.join(' ');
-    previousStylePropertyCache.set(part, previousStyleProperties = new Set());
-  }
-
-  // Remove old properties that no longer exist in styleInfo
-  // We use forEach() instead of for-of so that re don't require down-level
-  // iteration.
-  previousStyleProperties.forEach((name) => {
-    if (!(name in styleInfo)) {
-      previousStyleProperties!.delete(name);
-      if (name.indexOf('-') === -1) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (style as any)[name] = null;
-      } else {
-        style.removeProperty(name);
-      }
-    }
-  });
-
-  // Add or update properties
-  for (const name in styleInfo) {
-    previousStyleProperties.add(name);
-    if (name.indexOf('-') === -1) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      (style as any)[name] = styleInfo[name];
-    } else {
-      style.setProperty(name, styleInfo[name]);
-    }
-  }
-});

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

@@ -1,52 +0,0 @@
-/**
- * @license
- * Copyright (c) 2020 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 {directive, NodePart, Part} from '../lit-html.js';
-
-interface PreviousValue {
-  readonly template: HTMLTemplateElement;
-  readonly fragment: DocumentFragment;
-}
-
-// For each part, remember the value that was last rendered to the part by the
-// templateContent directive, and the DocumentFragment that was last set as a
-// value. The DocumentFragment is used as a unique key to check if the last
-// value rendered to the part was with templateContent. If not, we'll always
-// re-render the value passed to templateContent.
-const previousValues = new WeakMap<NodePart, PreviousValue>();
-
-/**
- * Renders the content of a template element as HTML.
- *
- * Note, the template should be developer controlled and not user controlled.
- * Rendering a user-controlled template with this directive
- * could lead to cross-site-scripting vulnerabilities.
- */
-export const templateContent =
-    directive((template: HTMLTemplateElement) => (part: Part): void => {
-      if (!(part instanceof NodePart)) {
-        throw new Error('templateContent can only be used in text bindings');
-      }
-
-      const previousValue = previousValues.get(part);
-
-      if (previousValue !== undefined && template === previousValue.template &&
-          part.value === previousValue.fragment) {
-        return;
-      }
-
-      const fragment = document.importNode(template.content, true);
-      part.setValue(fragment);
-      previousValues.set(part, {template, fragment});
-    });

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

@@ -1,54 +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 {isPrimitive} from '../lib/parts.js';
-import {directive, NodePart, Part} from '../lit-html.js';
-
-interface PreviousValue {
-  readonly value: unknown;
-  readonly fragment: DocumentFragment;
-}
-
-// For each part, remember the value that was last rendered to the part by the
-// unsafeHTML directive, and the DocumentFragment that was last set as a value.
-// The DocumentFragment is used as a unique key to check if the last value
-// rendered to the part was with unsafeHTML. If not, we'll always re-render the
-// value passed to unsafeHTML.
-const previousValues = new WeakMap<NodePart, PreviousValue>();
-
-/**
- * Renders the result as HTML, rather than text.
- *
- * Note, this is unsafe to use with any user-provided input that hasn't been
- * sanitized or escaped, as it may lead to cross-site-scripting
- * vulnerabilities.
- */
-export const unsafeHTML = directive((value: unknown) => (part: Part): void => {
-  if (!(part instanceof NodePart)) {
-    throw new Error('unsafeHTML can only be used in text bindings');
-  }
-
-  const previousValue = previousValues.get(part);
-
-  if (previousValue !== undefined && isPrimitive(value) &&
-      value === previousValue.value && part.value === previousValue.fragment) {
-    return;
-  }
-
-  const template = document.createElement('template');
-  template.innerHTML = value as string;  // innerHTML casts to string internally
-  const fragment = document.importNode(template.content, true);
-  part.setValue(fragment);
-  previousValues.set(part, {value, fragment});
-});