chrome-devtools-frontend 1.0.1473514 → 1.0.1510180

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

@@ -1 +0,0 @@
-{"version":3,"file":"repeat.d.ts","sourceRoot":"","sources":["../src/directives/repeat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAC,WAAW,EAAC,MAAM,qBAAqB,CAAC;AAGhD,oBAAY,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAC3D,oBAAY,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAoDlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,6HAgW+B,CAAC"}

package/extensions/cxx_debugging/third_party/lit-html/directives/repeat.js

@@ -1,415 +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 { createMarker, directive, NodePart, removeNodes, reparentNodes } from '../lit-html.js';
-// Helper functions for manipulating parts
-// TODO(kschaaf): Refactor into Part API?
-const createAndInsertPart = (containerPart, beforePart) => {
-    const container = containerPart.startNode.parentNode;
-    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, value) => {
-    part.setValue(value);
-    part.commit();
-    return part;
-};
-const insertPartBefore = (containerPart, part, ref) => {
-    const container = containerPart.startNode.parentNode;
-    const beforeNode = ref ? ref.startNode : containerPart.endNode;
-    const endNode = part.endNode.nextSibling;
-    if (endNode !== beforeNode) {
-        reparentNodes(container, part.startNode, endNode, beforeNode);
-    }
-};
-const removePart = (part) => {
-    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, start, end) => {
-    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();
-const keyListCache = new WeakMap();
-/**
- * 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((items, keyFnOrTemplate, template) => {
-    let keyFn;
-    if (template === undefined) {
-        template = keyFnOrTemplate;
-    }
-    else if (keyFnOrTemplate !== undefined) {
-        keyFn = keyFnOrTemplate;
-    }
-    return (containerPart) => {
-        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 = [];
-        // New value list is eagerly generated from items along with a
-        // parallel array indicating its key.
-        const newValues = [];
-        const newKeys = [];
-        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;
-        let oldKeyToIndexMap;
-        // 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] = 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);
-    };
-});
-//# sourceMappingURL=repeat.js.map

package/extensions/cxx_debugging/third_party/lit-html/directives/repeat.js.map

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

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

@@ -1,36 +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 StyleInfo {
-    readonly [name: string]: 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 declare const styleMap: (styleInfo: StyleInfo) => (part: Part) => void;
-//# sourceMappingURL=style-map.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"style-map.d.ts","sourceRoot":"","sources":["../src/directives/style-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAA2B,IAAI,EAAe,MAAM,gBAAgB,CAAC;AAE5E,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAQD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,gDA4CnB,CAAC"}

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

@@ -1,78 +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, PropertyPart } from '../lit-html.js';
-/**
- * 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();
-/**
- * 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) => (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;
-    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[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[name] = styleInfo[name];
-        }
-        else {
-            style.setProperty(name, styleInfo[name]);
-        }
-    }
-});
-//# sourceMappingURL=style-map.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"style-map.js","sourceRoot":"","sources":["../src/directives/style-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAC,aAAa,EAAE,SAAS,EAAQ,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAM5E;;;GAGG;AACH,MAAM,0BAA0B,GAAG,IAAI,OAAO,EAA8B,CAAC;AAE7E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,SAAS,CAAC,CAAC,SAAoB,EAAE,EAAE,CAAC,CAAC,IAAU,EAAE,EAAE;IACzE,IAAI,CAAC,CAAC,IAAI,YAAY,aAAa,CAAC,IAAI,CAAC,IAAI,YAAY,YAAY,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;QACtE,MAAM,IAAI,KAAK,CACX,+DAA+D;YAC/D,6CAA6C,CAAC,CAAC;KACpD;IAED,MAAM,EAAC,SAAS,EAAC,GAAG,IAAI,CAAC;IACzB,MAAM,EAAC,KAAK,EAAC,GAAG,SAAS,CAAC,OAAsB,CAAC;IAEjD,IAAI,uBAAuB,GAAG,0BAA0B,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAEnE,IAAI,uBAAuB,KAAK,SAAS,EAAE;QACzC,2BAA2B;QAC3B,KAAK,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC5C,0BAA0B,CAAC,GAAG,CAAC,IAAI,EAAE,uBAAuB,GAAG,IAAI,GAAG,EAAE,CAAC,CAAC;KAC3E;IAED,0DAA0D;IAC1D,yEAAyE;IACzE,aAAa;IACb,uBAAuB,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QACvC,IAAI,CAAC,CAAC,IAAI,IAAI,SAAS,CAAC,EAAE;YACxB,uBAAwB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACtC,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE;gBAC5B,8DAA8D;gBAC7D,KAAa,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;aAC7B;iBAAM;gBACL,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;aAC5B;SACF;IACH,CAAC,CAAC,CAAC;IAEH,2BAA2B;IAC3B,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE;QAC5B,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE;YAC5B,8DAA8D;YAC7D,KAAa,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;SACxC;aAAM;YACL,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;SAC1C;KACF;AACH,CAAC,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at\n * http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at\n * http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at\n * http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at\n * http://polymer.github.io/PATENTS.txt\n */\n\nimport {AttributePart, directive, Part, PropertyPart} from '../lit-html.js';\n\nexport interface StyleInfo {\n  readonly [name: string]: string;\n}\n\n/**\n * Stores the StyleInfo object applied to a given AttributePart.\n * Used to unset existing values when a new StyleInfo object is applied.\n */\nconst previousStylePropertyCache = new WeakMap<AttributePart, Set<string>>();\n\n/**\n * A directive that applies CSS properties to an element.\n *\n * `styleMap` can only be used in the `style` attribute and must be the only\n * expression in the attribute. It takes the property names in the `styleInfo`\n * object and adds the property values as CSS properties. Property names with\n * dashes (`-`) are assumed to be valid CSS property names and set on the\n * element's style object using `setProperty()`. Names without dashes are\n * assumed to be camelCased JavaScript property names and set on the element's\n * style object using property assignment, allowing the style object to\n * translate JavaScript-style names to CSS property names.\n *\n * For example `styleMap({backgroundColor: 'red', 'border-top': '5px', '--size':\n * '0'})` sets the `background-color`, `border-top` and `--size` properties.\n *\n * @param styleInfo {StyleInfo}\n */\nexport const styleMap = directive((styleInfo: StyleInfo) => (part: Part) => {\n  if (!(part instanceof AttributePart) || (part instanceof PropertyPart) ||\n      part.committer.name !== 'style' || part.committer.parts.length > 1) {\n    throw new Error(\n        'The `styleMap` directive must be used in the style attribute ' +\n        'and must be the only part in the attribute.');\n  }\n\n  const {committer} = part;\n  const {style} = committer.element as HTMLElement;\n\n  let previousStyleProperties = previousStylePropertyCache.get(part);\n\n  if (previousStyleProperties === undefined) {\n    // Write static styles once\n    style.cssText = committer.strings.join(' ');\n    previousStylePropertyCache.set(part, previousStyleProperties = new Set());\n  }\n\n  // Remove old properties that no longer exist in styleInfo\n  // We use forEach() instead of for-of so that re don't require down-level\n  // iteration.\n  previousStyleProperties.forEach((name) => {\n    if (!(name in styleInfo)) {\n      previousStyleProperties!.delete(name);\n      if (name.indexOf('-') === -1) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (style as any)[name] = null;\n      } else {\n        style.removeProperty(name);\n      }\n    }\n  });\n\n  // Add or update properties\n  for (const name in styleInfo) {\n    previousStyleProperties.add(name);\n    if (name.indexOf('-') === -1) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (style as any)[name] = styleInfo[name];\n    } else {\n      style.setProperty(name, styleInfo[name]);\n    }\n  }\n});\n"]}