ruby2js 4.0.3 → 4.0.4

data/lib/tasks/testrails/node_modules/lit-html/directives/repeat.js.map

@@ -0,0 +1 @@
+{"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"]}

data/lib/tasks/testrails/node_modules/lit-html/directives/style-map.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @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

data/lib/tasks/testrails/node_modules/lit-html/directives/style-map.d.ts.map

@@ -0,0 +1 @@
+{"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"}

data/lib/tasks/testrails/node_modules/lit-html/directives/style-map.js

@@ -0,0 +1,78 @@
+/**
+ * @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

data/lib/tasks/testrails/node_modules/lit-html/directives/style-map.js.map

@@ -0,0 +1 @@
+{"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"]}

data/lib/tasks/testrails/node_modules/lit-html/directives/template-content.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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 { Part } from '../lit-html.js';
+/**
+ * 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 declare const templateContent: (template: HTMLTemplateElement) => (part: Part) => void;
+//# sourceMappingURL=template-content.d.ts.map

data/lib/tasks/testrails/node_modules/lit-html/directives/template-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-content.d.ts","sourceRoot":"","sources":["../src/directives/template-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAsB,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAczD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,yDAgBtB,CAAC"}

data/lib/tasks/testrails/node_modules/lit-html/directives/template-content.js

@@ -0,0 +1,41 @@
+/**
+ * @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 } from '../lit-html.js';
+// 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();
+/**
+ * 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) => (part) => {
+    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 });
+});
+//# sourceMappingURL=template-content.js.map

data/lib/tasks/testrails/node_modules/lit-html/directives/template-content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-content.js","sourceRoot":"","sources":["../src/directives/template-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAO,MAAM,gBAAgB,CAAC;AAOzD,8EAA8E;AAC9E,6EAA6E;AAC7E,2EAA2E;AAC3E,4EAA4E;AAC5E,iDAAiD;AACjD,MAAM,cAAc,GAAG,IAAI,OAAO,EAA2B,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GACxB,SAAS,CAAC,CAAC,QAA6B,EAAE,EAAE,CAAC,CAAC,IAAU,EAAQ,EAAE;IAChE,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC,EAAE;QAC/B,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;KACtE;IAED,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAE/C,IAAI,aAAa,KAAK,SAAS,IAAI,QAAQ,KAAK,aAAa,CAAC,QAAQ;QAClE,IAAI,CAAC,KAAK,KAAK,aAAa,CAAC,QAAQ,EAAE;QACzC,OAAO;KACR;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC7D,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACxB,cAAc,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,QAAQ,EAAE,QAAQ,EAAC,CAAC,CAAC;AACjD,CAAC,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright (c) 2020 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 {directive, NodePart, Part} from '../lit-html.js';\n\ninterface PreviousValue {\n  readonly template: HTMLTemplateElement;\n  readonly fragment: DocumentFragment;\n}\n\n// For each part, remember the value that was last rendered to the part by the\n// templateContent directive, and the DocumentFragment that was last set as a\n// value. The DocumentFragment is used as a unique key to check if the last\n// value rendered to the part was with templateContent. If not, we'll always\n// re-render the value passed to templateContent.\nconst previousValues = new WeakMap<NodePart, PreviousValue>();\n\n/**\n * Renders the content of a template element as HTML.\n *\n * Note, the template should be developer controlled and not user controlled.\n * Rendering a user-controlled template with this directive\n * could lead to cross-site-scripting vulnerabilities.\n */\nexport const templateContent =\n    directive((template: HTMLTemplateElement) => (part: Part): void => {\n      if (!(part instanceof NodePart)) {\n        throw new Error('templateContent can only be used in text bindings');\n      }\n\n      const previousValue = previousValues.get(part);\n\n      if (previousValue !== undefined && template === previousValue.template &&\n          part.value === previousValue.fragment) {\n        return;\n      }\n\n      const fragment = document.importNode(template.content, true);\n      part.setValue(fragment);\n      previousValues.set(part, {template, fragment});\n    });\n"]}

data/lib/tasks/testrails/node_modules/lit-html/directives/unsafe-html.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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';
+/**
+ * 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 declare const unsafeHTML: (value: unknown) => (part: Part) => void;
+//# sourceMappingURL=unsafe-html.d.ts.map

data/lib/tasks/testrails/node_modules/lit-html/directives/unsafe-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe-html.d.ts","sourceRoot":"","sources":["../src/directives/unsafe-html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAsB,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAczD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,0CAiBrB,CAAC"}

data/lib/tasks/testrails/node_modules/lit-html/directives/unsafe-html.js

@@ -0,0 +1,44 @@
+/**
+ * @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 } from '../lit-html.js';
+// 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();
+/**
+ * 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) => (part) => {
+    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; // innerHTML casts to string internally
+    const fragment = document.importNode(template.content, true);
+    part.setValue(fragment);
+    previousValues.set(part, { value, fragment });
+});
+//# sourceMappingURL=unsafe-html.js.map

data/lib/tasks/testrails/node_modules/lit-html/directives/unsafe-html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe-html.js","sourceRoot":"","sources":["../src/directives/unsafe-html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAO,MAAM,gBAAgB,CAAC;AAOzD,8EAA8E;AAC9E,+EAA+E;AAC/E,0EAA0E;AAC1E,+EAA+E;AAC/E,8BAA8B;AAC9B,MAAM,cAAc,GAAG,IAAI,OAAO,EAA2B,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,SAAS,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC,IAAU,EAAQ,EAAE;IAC3E,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC,EAAE;QAC/B,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;KACjE;IAED,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAE/C,IAAI,aAAa,KAAK,SAAS,IAAI,WAAW,CAAC,KAAK,CAAC;QACjD,KAAK,KAAK,aAAa,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK,aAAa,CAAC,QAAQ,EAAE;QAC1E,OAAO;KACR;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACpD,QAAQ,CAAC,SAAS,GAAG,KAAe,CAAC,CAAE,uCAAuC;IAC9E,MAAM,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC7D,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACxB,cAAc,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,CAAC,CAAC;AAC9C,CAAC,CAAC,CAAC","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 {isPrimitive} from '../lib/parts.js';\nimport {directive, NodePart, Part} from '../lit-html.js';\n\ninterface PreviousValue {\n  readonly value: unknown;\n  readonly fragment: DocumentFragment;\n}\n\n// For each part, remember the value that was last rendered to the part by the\n// unsafeHTML directive, and the DocumentFragment that was last set as a value.\n// The DocumentFragment is used as a unique key to check if the last value\n// rendered to the part was with unsafeHTML. If not, we'll always re-render the\n// value passed to unsafeHTML.\nconst previousValues = new WeakMap<NodePart, PreviousValue>();\n\n/**\n * Renders the result as HTML, rather than text.\n *\n * Note, this is unsafe to use with any user-provided input that hasn't been\n * sanitized or escaped, as it may lead to cross-site-scripting\n * vulnerabilities.\n */\nexport const unsafeHTML = directive((value: unknown) => (part: Part): void => {\n  if (!(part instanceof NodePart)) {\n    throw new Error('unsafeHTML can only be used in text bindings');\n  }\n\n  const previousValue = previousValues.get(part);\n\n  if (previousValue !== undefined && isPrimitive(value) &&\n      value === previousValue.value && part.value === previousValue.fragment) {\n    return;\n  }\n\n  const template = document.createElement('template');\n  template.innerHTML = value as string;  // innerHTML casts to string internally\n  const fragment = document.importNode(template.content, true);\n  part.setValue(fragment);\n  previousValues.set(part, {value, fragment});\n});\n"]}

data/lib/tasks/testrails/node_modules/lit-html/directives/unsafe-svg.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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';
+/**
+ * Renders the result as SVG, 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 declare const unsafeSVG: (value: unknown) => (part: Part) => void;
+//# sourceMappingURL=unsafe-svg.d.ts.map

data/lib/tasks/testrails/node_modules/lit-html/directives/unsafe-svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe-svg.d.ts","sourceRoot":"","sources":["../src/directives/unsafe-svg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,EAAsB,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAgBzD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,0CA+BpB,CAAC"}

data/lib/tasks/testrails/node_modules/lit-html/directives/unsafe-svg.js

@@ -0,0 +1,61 @@
+/**
+ * @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 { reparentNodes } from '../lib/dom.js';
+import { isPrimitive } from '../lib/parts.js';
+import { directive, NodePart } from '../lit-html.js';
+// For each part, remember the value that was last rendered to the part by the
+// unsafeSVG 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 unsafeSVG. If not, we'll always re-render the
+// value passed to unsafeSVG.
+const previousValues = new WeakMap();
+const isIe = window.navigator.userAgent.indexOf('Trident/') > 0;
+/**
+ * Renders the result as SVG, 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 unsafeSVG = directive((value) => (part) => {
+    if (!(part instanceof NodePart)) {
+        throw new Error('unsafeSVG 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');
+    const content = template.content;
+    let svgElement;
+    if (isIe) {
+        // IE can't set innerHTML of an svg element. However, it also doesn't
+        // support Trusted Types, so it's ok for us to use a string when setting
+        // innerHTML.
+        template.innerHTML = `<svg>${value}</svg>`;
+        svgElement = content.firstChild;
+    }
+    else {
+        svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+        content.appendChild(svgElement);
+        svgElement.innerHTML = value;
+    }
+    content.removeChild(svgElement);
+    reparentNodes(content, svgElement.firstChild);
+    const fragment = document.importNode(content, true);
+    part.setValue(fragment);
+    previousValues.set(part, { value, fragment });
+});
+//# sourceMappingURL=unsafe-svg.js.map

data/lib/tasks/testrails/node_modules/lit-html/directives/unsafe-svg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsafe-svg.js","sourceRoot":"","sources":["../src/directives/unsafe-svg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAO,MAAM,gBAAgB,CAAC;AAOzD,8EAA8E;AAC9E,8EAA8E;AAC9E,0EAA0E;AAC1E,8EAA8E;AAC9E,6BAA6B;AAC7B,MAAM,cAAc,GAAG,IAAI,OAAO,EAA2B,CAAC;AAE9D,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AAEhE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,SAAS,CAAC,CAAC,KAAc,EAAE,EAAE,CAAC,CAAC,IAAU,EAAQ,EAAE;IAC1E,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC,EAAE;QAC/B,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;KAChE;IAED,MAAM,aAAa,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAE/C,IAAI,aAAa,KAAK,SAAS,IAAI,WAAW,CAAC,KAAK,CAAC;QACjD,KAAK,KAAK,aAAa,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK,aAAa,CAAC,QAAQ,EAAE;QAC1E,OAAO;KACR;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACpD,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;IACjC,IAAI,UAAU,CAAC;IACf,IAAI,IAAI,EAAE;QACR,qEAAqE;QACrE,wEAAwE;QACxE,aAAa;QACb,QAAQ,CAAC,SAAS,GAAG,QAAQ,KAAK,QAAQ,CAAC;QAC3C,UAAU,GAAG,OAAO,CAAC,UAAW,CAAC;KAClC;SAAM;QACL,UAAU,GAAG,QAAQ,CAAC,eAAe,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC;QAC3E,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;QAChC,UAAU,CAAC,SAAS,GAAG,KAAe,CAAC;KACxC;IACD,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;IAChC,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;IAC9C,MAAM,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACpD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACxB,cAAc,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC,CAAC,CAAC;AAC9C,CAAC,CAAC,CAAC","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 {reparentNodes} from '../lib/dom.js';\nimport {isPrimitive} from '../lib/parts.js';\nimport {directive, NodePart, Part} from '../lit-html.js';\n\ninterface PreviousValue {\n  readonly value: unknown;\n  readonly fragment: DocumentFragment;\n}\n\n// For each part, remember the value that was last rendered to the part by the\n// unsafeSVG directive, and the DocumentFragment that was last set as a value.\n// The DocumentFragment is used as a unique key to check if the last value\n// rendered to the part was with unsafeSVG. If not, we'll always re-render the\n// value passed to unsafeSVG.\nconst previousValues = new WeakMap<NodePart, PreviousValue>();\n\nconst isIe = window.navigator.userAgent.indexOf('Trident/') > 0;\n\n/**\n * Renders the result as SVG, rather than text.\n *\n * Note, this is unsafe to use with any user-provided input that hasn't been\n * sanitized or escaped, as it may lead to cross-site-scripting\n * vulnerabilities.\n */\nexport const unsafeSVG = directive((value: unknown) => (part: Part): void => {\n  if (!(part instanceof NodePart)) {\n    throw new Error('unsafeSVG can only be used in text bindings');\n  }\n\n  const previousValue = previousValues.get(part);\n\n  if (previousValue !== undefined && isPrimitive(value) &&\n      value === previousValue.value && part.value === previousValue.fragment) {\n    return;\n  }\n\n  const template = document.createElement('template');\n  const content = template.content;\n  let svgElement;\n  if (isIe) {\n    // IE can't set innerHTML of an svg element. However, it also doesn't\n    // support Trusted Types, so it's ok for us to use a string when setting\n    // innerHTML.\n    template.innerHTML = `<svg>${value}</svg>`;\n    svgElement = content.firstChild!;\n  } else {\n    svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg');\n    content.appendChild(svgElement);\n    svgElement.innerHTML = value as string;\n  }\n  content.removeChild(svgElement);\n  reparentNodes(content, svgElement.firstChild);\n  const fragment = document.importNode(content, true);\n  part.setValue(fragment);\n  previousValues.set(part, {value, fragment});\n});\n"]}

data/lib/tasks/testrails/node_modules/lit-html/directives/until.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @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';
+/**
+ * Renders one of a series of values, including Promises, to a Part.
+ *
+ * Values are rendered in priority order, with the first argument having the
+ * highest priority and the last argument having the lowest priority. If a
+ * value is a Promise, low-priority values will be rendered until it resolves.
+ *
+ * The priority of values can be used to create placeholder content for async
+ * data. For example, a Promise with pending content can be the first,
+ * highest-priority, argument, and a non_promise loading indicator template can
+ * be used as the second, lower-priority, argument. The loading indicator will
+ * render immediately, and the primary content will render when the Promise
+ * resolves.
+ *
+ * Example:
+ *
+ *     const content = fetch('./content.txt').then(r => r.text());
+ *     html`${until(content, html`<span>Loading...</span>`)}`
+ */
+export declare const until: (...args: unknown[]) => (part: Part) => void;
+//# sourceMappingURL=until.d.ts.map

data/lib/tasks/testrails/node_modules/lit-html/directives/until.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"until.d.ts","sourceRoot":"","sources":["../src/directives/until.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAY,IAAI,EAAC,MAAM,gBAAgB,CAAC;AAgB/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,KAAK,8CAqDhB,CAAC"}

data/lib/tasks/testrails/node_modules/lit-html/directives/until.js

@@ -0,0 +1,86 @@
+/**
+ * @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 } from '../lit-html.js';
+const _state = new WeakMap();
+// Effectively infinity, but a SMI.
+const _infinity = 0x7fffffff;
+/**
+ * Renders one of a series of values, including Promises, to a Part.
+ *
+ * Values are rendered in priority order, with the first argument having the
+ * highest priority and the last argument having the lowest priority. If a
+ * value is a Promise, low-priority values will be rendered until it resolves.
+ *
+ * The priority of values can be used to create placeholder content for async
+ * data. For example, a Promise with pending content can be the first,
+ * highest-priority, argument, and a non_promise loading indicator template can
+ * be used as the second, lower-priority, argument. The loading indicator will
+ * render immediately, and the primary content will render when the Promise
+ * resolves.
+ *
+ * Example:
+ *
+ *     const content = fetch('./content.txt').then(r => r.text());
+ *     html`${until(content, html`<span>Loading...</span>`)}`
+ */
+export const until = directive((...args) => (part) => {
+    let state = _state.get(part);
+    if (state === undefined) {
+        state = {
+            lastRenderedIndex: _infinity,
+            values: [],
+        };
+        _state.set(part, state);
+    }
+    const previousValues = state.values;
+    let previousLength = previousValues.length;
+    state.values = args;
+    for (let i = 0; i < args.length; i++) {
+        // If we've rendered a higher-priority value already, stop.
+        if (i > state.lastRenderedIndex) {
+            break;
+        }
+        const value = args[i];
+        // Render non-Promise values immediately
+        if (isPrimitive(value) ||
+            typeof value.then !== 'function') {
+            part.setValue(value);
+            state.lastRenderedIndex = i;
+            // Since a lower-priority value will never overwrite a higher-priority
+            // synchronous value, we can stop processing now.
+            break;
+        }
+        // If this is a Promise we've already handled, skip it.
+        if (i < previousLength && value === previousValues[i]) {
+            continue;
+        }
+        // We have a Promise that we haven't seen before, so priorities may have
+        // changed. Forget what we rendered before.
+        state.lastRenderedIndex = _infinity;
+        previousLength = 0;
+        Promise.resolve(value).then((resolvedValue) => {
+            const index = state.values.indexOf(value);
+            // If state.values doesn't contain the value, we've re-rendered without
+            // the value, so don't render it. Then, only render if the value is
+            // higher-priority than what's already been rendered.
+            if (index > -1 && index < state.lastRenderedIndex) {
+                state.lastRenderedIndex = index;
+                part.setValue(resolvedValue);
+                part.commit();
+            }
+        });
+    }
+});
+//# sourceMappingURL=until.js.map