17374 2008-02-15 07:53:13 -0800 Web Inspector: auto-completion for CSS property names in Styles pane 2010-06-20 15:32:22 -0700 1 1 1 Unclassified WebKit Web Inspector (Deprecated) 528+ (Nightly build) All All RESOLVED FIXED InRadar P2 Enhancement --- 1 aroben webkit-unassigned commit-queue joepeck me timothy oldest_to_newest 70763 0 aroben 2008-02-15 07:53:13 -0800 The Inspector should support tab completion while editing CSS. It could tab-complete both properties and keywords. We could even intelligently tab-complete values (e.g., when a length is needed, we could cycle through "em" "ex" "px" "%" etc.) 70764 1 aroben 2008-02-15 07:53:59 -0800 <rdar://problem/5745643> 211240 2 joepeck 2010-04-10 17:30:42 -0700 I see someone is interested in working on this (on Twitter). I'm going to put some pointers here to help them out. You don't necessarily have to follow my advice, but just so you aren't lost in the code! 1. The list of all CSS Properties that WebKit supports can be found in ".in" files spread throughout WebKit's source. You want a similar list in the inspector to use for auto-completion. Some approaches are: - You can dynamically compute this list when the inspector launches (using something like getComputedStyle(document.body). This is a very future proof approach, so as new properties are added, they may automatically be available to autocompletion. - Use an existing computed list of all properties. There is such a list available in SourceCSSTokenizer.js [1]. It appears that this list contains some differences to the getComputedStyle approach. I've attached a diff of comparatively sorted lists. - Some combination of the above two options! 2. For the autocompletion you want to be as consistent as possible. The Console already includes autocompletion, and the way it does it has already been factored out to a generic class. Minor changes may be needed. See TextPrompt.js [2] and how it is used in ConsoleView.js [3]. 3. Editing style properties happens on WebInspector.StylePropertyTreeElement in StylesSidebarPane.js [4]. It uses inspector.js' [5] generic editing. It might be useful to add a hook for an autocompletion controller/handler in this. 4. This ahead! Autocompletion is useful all over the inspector. Style Properties, style values, style selectors, element tag names / attributes! Editing of all of these is currently possible, and is all done the same way (through WebInspector.startEditing). Approach this with a solution that can be replicated for all of the above cases. [1]: http://trac.webkit.org/browser/trunk/WebCore/inspector/front-end/SourceCSSTokenizer.js#L48 [2]: http://trac.webkit.org/browser/trunk/WebCore/inspector/front-end/TextPrompt.js [3]: http://trac.webkit.org/browser/trunk/WebCore/inspector/front-end/ConsoleView.js#L334 [4]: http://trac.webkit.org/browser/trunk/WebCore/inspector/front-end/StylesSidebarPane.js#L1283 [5]: http://trac.webkit.org/browser/trunk/WebCore/inspector/front-end/inspector.js#L1816 211241 3 53063 joepeck 2010-04-10 17:32:29 -0700 Created attachment 53063 Differing Properties Between getComputedStyle and CSS Tokenizer's list Here is the differing list. Ideally we would have a list containing the best of both (red and green). 211260 4 timothy 2010-04-10 19:03:54 -0700 getComputedStyle does not return shorthands, so that is the majority of the differences. 211906 5 me 2010-04-13 02:48:37 -0700 What about CSS value keywords? I see array of them in SourceCSSTokenizer.js [1], but I don't think it's a good data structure to me. I need to know somehow, what "hidden" belongs to "overflow", "no-repeat" part of "background" and so on. Furthermore, "background" property needs something more, than just flat list of keyword. This code is borrowed from Firebug [2]: background = ["bgRepeat", "bgAttachment", "bgPosition", "color", "systemColor", "none"] "bgRepeat": [ "repeat", "repeat-x", "repeat-y", "no-repeat"] "bgAttachment": [ "scroll", "fixed"] ... [1]: http://trac.webkit.org/browser/trunk/WebCore/inspector/front-end/SourceCSSTokenizer.js#L100 [2]: http://code.google.com/p/fbug/source/browse/trunk/content/firebug/lib.js#4091 211915 6 joepeck 2010-04-13 05:41:16 -0700 I don't know the best solution or this problem. I agree something like that would be awesome to have. Its mostly just a large list of things to keep track of, and to be calculated. I thought that would be something great to do in a follow up patch (keep individual patches small and managable). But its great you're thinking ahead! If you give it a shot, we can comment on it once you put up a patch. I think a big pre-compiled hash table (which it looks like you were showing) would be acceptable. That might be a lot of duplication of strings, so maybe instead of duplicating the strings have them be the indexes into the big list of values. (Although you would need some way to keep these two in sync if you use indexes). 211988 7 timothy 2010-04-13 10:06:40 -0700 I agree you only want to complete values for the properties they make sense for. Firebug's approch is neat since the value can expand into more values. They seem to look up the edited property, then expands all the values in the array that also have value lists. If a value does not have a list it ise used as-is and not further expanding is done. Firebug's solution is obviously elegant and less duplication of lists for shorthand properties. 212421 8 joepeck 2010-04-14 10:32:18 -0700 Be aware that Bug 37582 "Web Inspector: Console: Shift-Tab does not cycle autocompletions in the reverse order" was just implemented. This may affect you slightly since that change added a new parameter (reverse) to some of the completion functions. You may want to update your checkout when that patch lands (it hasn't yet) to make merging easier and so you can take advantage of the changes! 216791 9 joepeck 2010-04-24 23:19:04 -0700 Nikita, how are things going on this? I'm pretty interested in seeing this getting added. Do you have a work in progress you could put up? 217009 10 me 2010-04-26 04:47:07 -0700 I didn't do much. I was experimenting with two different types of autocomplete suggestions http://elv1s.ru/files/web-inspector/ Right now I'm trying to hook up autocomplete to Inspector with no luck. WebInspector.StylePropertyTreeElement.prototype.editingKeyDown looks like the way to go. It even has note "// FIXME: this should cycle through known keywords for the current property name.". The problem is, it never fires for me while I'm editing CSS property. 217545 11 joepeck 2010-04-26 23:46:33 -0700 (In reply to comment #10) > I didn't do much. I was experimenting with two different types of autocomplete > suggestions http://elv1s.ru/files/web-inspector/ Neat! Great work so far. > Right now I'm trying to hook up autocomplete to Inspector with no luck. > WebInspector.StylePropertyTreeElement.prototype.editingKeyDown looks like the > way to go. It even has note "// FIXME: this should cycle through known keywords > for the current property name.". The problem is, it never fires for me while > I'm editing CSS property. Yes, I think you're in the right spot. Right now it doesn't reach that code because it returns early. Right at the start of the function it breaks unless the key was up/down/pageup/pagedown: > editingKeyDown: function(event) > { > var arrowKeyPressed = (event.keyIdentifier === "Up" || event.keyIdentifier === "Down"); > var pageKeyPressed = (event.keyIdentifier === "PageUp" || event.keyIdentifier === "PageDown"); > if (!arrowKeyPressed && !pageKeyPressed) > return; If you want to do autocompletion on key down (like your demo) you will want to call your own function here, or remove the break and handle things later. Or you could add your own keyup listener. Your demo is nice. It does a setTimeout on keydown so that when given function runs it will have access to the complete text. I don't think there are any problems with this approach, because of JavaScript's nature. The current editKeyDown code uses ranges to find the current word the cursor is in. That might be useful as well. You'll also want to know if you are before / after the initial ":" meaning you're editing the property / value and so you'll need to know more anyways. Keep up the great work! 218389 12 me 2010-04-28 07:36:30 -0700 (In reply to comment #11) > Yes, I think you're in the right spot. Right now it doesn't reach that code > because it returns early. Right at the start of the function it breaks unless > the key was up/down/pageup/pagedown: > > > editingKeyDown: function(event) > > { > > var arrowKeyPressed = (event.keyIdentifier === "Up" || event.keyIdentifier === "Down"); > > var pageKeyPressed = (event.keyIdentifier === "PageUp" || event.keyIdentifier === "PageDown"); > > if (!arrowKeyPressed && !pageKeyPressed) > > return; Actually, it returns even earlier: WebInspector.documentKeyDown = function(event) { if (WebInspector.isEditingAnyField()) return; Seems like WebInspector.StylePropertyTreeElement.prototype.editingKeyDown never fires at all, which at least strange. 218404 13 joepeck 2010-04-28 08:14:14 -0700 Hmm, it was working for me. But, that could explain why up/down have been broken sometimes. 218413 14 me 2010-04-28 08:58:33 -0700 Up/down doesn't work for me on WebKit r58391. I suppose, it was broken by http://trac.webkit.org/changeset/57909/trunk/WebCore/inspector/front-end/inspector.js#file0 219323 15 joepeck 2010-04-29 18:46:31 -0700 (In reply to comment #14) > Up/down doesn't work for me on WebKit r58391. I suppose, it was broken by > http://trac.webkit.org/changeset/57909/trunk/WebCore/inspector/front-end/inspector.js#file0 Looks like someone just opened a bug on this: https://bugs.webkit.org/show_bug.cgi?id=38325 220734 16 me 2010-05-04 13:35:38 -0700 I've made autocomplete for CSS properties. http://github.com/NV/web-inspector/commit/fdb02923ac52d . Sometimes it stops working. I've a problem with markup: <li title="font-size: 12px" class="selected"> <span class="name">font-size</span>: <span class="value">12px</span>; </li> While <li> is contentEditable, <span class="name"> might be deleted. If it happens, error occurs: StylesSidebarPane.js:1358 TypeError: Result of expression 'name' [null] is not an object. I'll keep developing in http://github.com/NV/web-inspector/tree/css_autocomplete , until I've got a solid solution. 220767 17 joepeck 2010-05-04 14:09:29 -0700 > While <li> is contentEditable, <span class="name"> might be deleted. If it > happens, error occurs: I'd have to look into this deeper if you want a good comment. I think this might be expected and you could just handle that with an if statement =) (In reply to comment #16) > I'll keep developing in > http://github.com/NV/web-inspector/tree/css_autocomplete , until I've got a > solid solution. Very Nice!! I'll put some comments here (and some in GitHub). I think you're heading in the right direction. There isn't anything particularly wrong with your patch, but I feel like I should raise some concerns so you can provide a high quality patch. WebKit is very keen on keeping a consistent style, and the Web Inspector has had an exceptional record in this regard. Here are some style issues that would should address. > properties: (function getCSSProperties(){ Space between () and {. There are a few of these in your patch. > + // Add shorthands > + // convert array-like object to array Comments should be sentences starting with a capital and ending in a period. > + var s = ... > + var j = ... > + var prop = ... Use full names except in rare cases. It really helps readability and readers like me! > + var prop = s.slice(0, j).join('-'); Unless there is a really good reason, always use double quoted strings ("-"). > + if (typeof document.documentElement.style[prop] !== 'undefined' && properties.indexOf(prop) < 0) { > + properties.push(prop); > + } Single line if statements should not have braces. There are a few of these in your patch. > + return prop.indexOf(str) === 0 Add a semicolon. I think there are few exceptions to the semicolon rule. > if (!str) return ''; Don't single line this. Make it two lines and add a blank line after it. > + for (var i=0; i<this.length; i++) { Should be => for (var i = 0; i < this.length; ++i) { > \ No newline at end of file We don't like that! > + var new_property = WebInspector.CSS.properties.firstStartsWith(property); We prefer camelCase => newProperty > if (new_property != property) { Unless there is a really good reason, always use the strict equality comparisons (=== and !==) > +Array.convert = function convert(list) > + ... > +}; Here would be an exception, I don't think we normally put the semicolon here. You extend a number of core types: KeyboardEvent.prototype.character (getter) Text.prototype.select Array.convert Array.prototype.last (getter/setter) I think some of these are nice but unnecessary. For instance the use of Array.convert in your patch is mostly just extra processing. I'll hold off on commenting on the others. I'm a fan, but we typically hold off on this. 220805 18 me 2010-05-04 15:04:13 -0700 (In reply to comment #17) > > While <li> is contentEditable, <span class="name"> might be deleted. If it > > happens, error occurs: > > I'd have to look into this deeper if you want a good comment. I think this > might be expected and you could just handle that with an if statement =) Okay, if <span> is missing I'll just add it. > > properties: (function getCSSProperties(){ > Space between () and {. There are a few of these in your patch. Line break before { isn't necessary, right? (I hate it!) > You extend a number of core types: > > KeyboardEvent.prototype.character (getter) > Text.prototype.select > Array.convert > Array.prototype.last (getter/setter) Array.* is just a syntax sugar, but KeyboardEvent.prototype.character and Text.prototype.select is really useful in my opinion. 223101 19 me 2010-05-09 15:41:03 -0700 Addition to comment #16: <div contenteditable> <span class="name">font-size</span>: </div> Firefox: I delete all text, then empty span still remains. WebKit: I delete all text, then span got deleted. I've been looking for Firefox behavior in WebKit, but I haven't found it. So, I've made dirty check via regexp http://github.com/NV/web-inspector/commit/c010093cfad 223102 20 joepeck 2010-05-09 15:54:54 -0700 > Firefox: I delete all text, then empty span still remains. > WebKit: I delete all text, then span got deleted. I can't replicate this behavior right now. Is this due to your changes? Do you think you have enough to put a patch up on Bugzilla? Also a Jing video / screenshots would be awesome! =) 223295 21 55551 me 2010-05-10 07:02:00 -0700 Created attachment 55551 Autocomplete CSS properties Patch adds completion to CSS properties. Next things I would like to do: 1) autocomplete CSS values (inside <span class="value">) 2) up/down — cycle through previous/next values 223300 22 me 2010-05-10 07:22:57 -0700 (In reply to comment #20) > > Firefox: I delete all text, then empty span still remains. > > WebKit: I delete all text, then span got deleted. > > I can't replicate this behavior right now. This is what I meant: http://elv1s.ru/files/js/contentEditable.html 225678 23 55551 joepeck 2010-05-13 23:54:12 -0700 Comment on attachment 55551 Autocomplete CSS properties I just applied the patch locally and it wasn't working. I suspect this may be an issue with the recent style panel changes. I apologize for looking at this so late. I will comment on a few things. Again, the patch looks great overall. Mostly just some style issues need fixing, and to make this work again with ToT. Also, the next patch that you put up, set the "review" flag to be "?". That marks it for review and it won't get lost =) > +++ b/WebCore/ChangeLog Use `prepare-ChangeLog --bug #####`, in this case use the number is 17374 (the bugzilla number) to generate the ChangeLog entry. I see you're using git, and probably across multiple commits and I know there are some options for that. However, your ChangeLog is fine, it would be nice to have more detail though. Examples I like are: http://trac.webkit.org/changeset/59443 (a recently landed patch) http://trac.webkit.org/changeset/59372 (shamelessly my own) > +++ b/WebCore/inspector/front-end/CSS.js I like the idea of a new file, but I think maybe we can make this a little more generic. Maybe Completion.js so that in the future we can prepare for HTML/DOM attribute completions as well (when editing DOM attributes). I think much of the code could be shared between these. > @@ -0,0 +1,37 @@ > +WebInspector.CSS = { > + properties: (function getCSSProperties() { `get`CSSProperties doesn't seem accurate. Maybe "build" or "generate" might be better. We may be looking into backend solutions for this, but I think your solution right now is great =). > + // Add shorthands. Since there is a clever trick in the code below this might want to point that out. Something like: // Add shorthands to the end of the properties list. > + if (typeof document.documentElement.style[shorthand] !== "undefined" && properties.indexOf(shorthand) < 0) { > + properties.push(shorthand); > + } Single statement if's shouldn't have braces. > +WebInspector.CSS.properties.startsWith = function startsWith(str) > +{ > + return this.filter(function(property) { > + return property.indexOf(str) === 0; > + }); > +}; It might be worth looking into sorting the list, and more quickly finding the appropriate matches. For a list of ~220 this isn't too bad but I could see this getting out of hand. For starters, using a for loop instead of a filter would let you break early. Sorting would let you do a binary search. This could be improved in the future. > + if (!str) > + return ""; Add Newline here. > + for (var i = 0; i < this.length; ++i) { > + if (this[i].indexOf(str) === 0) { > + return this[i]; > + } > + } if statement doesn't need braces. And Web Inspector code tends to go with the for loop then not needing braces either. > + if (arrowKeyPressed || pageKeyPressed && matches && matches.length) { Make this clearer so we don't have to remember our || and && ordering: if ((arrowKeyPressed || pageKeyPressed) && matches && matches.length) { > + } else { > + return; > + } No braces for the else. Also, this might read better as an early bail. It would reduce the nesting and that tends to be the Web Inspector's usual style. > + } Add newline here. > + var name = element.querySelector(".name"); > + var value = element.querySelector(".value"); I prefer nameElement and valueElement as they point out its an element. Just name and value sound too much like strings. > + if (newProperty && newProperty !== property) { > + name.textContent = newProperty; > + } > + if (n < 0) { > + name.firstChild.select(n); > + } Remove Braces. > } else { > // FIXME: this should cycle through known keywords for the current property name. > return; It looks like this could probably be removed. Or the FIXME could be updated to say we need to autocomplete the values now. > + if (start < 0) { > + start = end + start; > + } No Braces. 225680 24 joepeck 2010-05-13 23:58:38 -0700 > > I can't replicate this behavior right now. > > This is what I meant: http://elv1s.ru/files/js/contentEditable.html Oh! Interesting. I'll ask one of the contenteditable folks about this tomorrow. 225741 25 me 2010-05-14 03:53:27 -0700 (In reply to comment #23) > Single statement if's shouldn't have braces. > ... Would be nice to have a formating script like http://jsbeautifier.org/ , which does code styling properly where it possible. > I like the idea of a new file, but I think maybe we can make this > a little more generic. Maybe Completion.js so that in the future > we can prepare for HTML/DOM attribute completions as well (when editing > DOM attributes). I think much of the code could be shared between > these. I thought about Array.prototype.startsWith(str) Array.prototype.firstStartsWith(str) , but I have a feeling you guys won't like it. 225898 26 56082 me 2010-05-14 10:05:36 -0700 Created attachment 56082 Autocomplete CSS properties It should work now. I hope all minor issues, if there is any of them, will be fixed in the *next* patch, not this one. 225905 27 56082 timothy 2010-05-14 10:35:46 -0700 Comment on attachment 56082 Autocomplete CSS properties WebCore/inspector/front-end/CSS.js:13 + Remove this empty line. WebCore/inspector/front-end/CSS.js:22 + return this.filter(function(property) { What is filter? WebCore/inspector/front-end/StylesSidebarPane.js:1409 + } else if (/[A-Z-]/.test(event.character)) { Shouldn't this be /[a-zA-Z-]/ or /[a-z-]/i? WebCore/inspector/front-end/StylesSidebarPane.js:1410 + setTimeout(function() { You should name this function and not inline it in the setTimeout call since it is so long. There is another approch this could take, more like TextPrompt. TextPrompt calls autoCompleteSoon after some key events (it dosen't care if it was a character either), then autoCompleteSoon schedules a timeout that checks the text content. It is similar to what you are doing here, but you schedule a new timeout after each keydown. TextPrompt coalesces them, so if you type fast it only autocompletes once. Why can't this share code with TextPrompt or just use it? r- because you should cancel previous timeouts at a minimum, for fast typers. 225915 28 me 2010-05-14 11:22:41 -0700 (In reply to comment #27) > WebCore/inspector/front-end/CSS.js:22 > + return this.filter(function(property) { > What is filter? filter is an Array method. https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/filter > WebCore/inspector/front-end/StylesSidebarPane.js:1409 > + } else if (/[A-Z-]/.test(event.character)) { > Shouldn't this be /[a-zA-Z-]/ or /[a-z-]/i? keydown event always returns uppercase characters. http://elv1s.ru/files/js/key-code-detector.html 225982 29 me 2010-05-14 13:47:28 -0700 I've made an autocomplete, which doesn't use setTimeout at all, and, more importantly, doesn't flicker! By flickering I mean this http://screenr.com/Wpp http://elv1s.ru/files/web-inspector/fancy-autocomplete.html I would like to rewrite TextPrompt to use this approach. Guys, what do you think about it? 225995 30 joepeck 2010-05-14 14:11:50 -0700 (In reply to comment #29) > I've made an autocomplete, which doesn't use setTimeout at all, and, more importantly, doesn't flicker! > By flickering I mean this http://screenr.com/Wpp > > http://elv1s.ru/files/web-inspector/fancy-autocomplete.html > > I would like to rewrite TextPrompt to use this approach. Guys, what do you think about it? Neat. I think you should experiment with changing TextPrompt. I wonder how usable this will be for the console autocompletion, but we won't know unless we try! I think it feels great, but working with a static list of values is a lot different then asynchronously eval'ing a string and sending values across Page barriers (potentially process barriers for Chrome). 226019 31 timothy 2010-05-14 14:58:16 -0700 Yep, the reason Joe mentions are why we are not synchronous. (We use to be.) 238235 32 joepeck 2010-06-14 21:44:09 -0700 (In reply to comment #29) > I've made an autocomplete, which doesn't use setTimeout at all, > and, more importantly, doesn't flicker! > By flickering I mean this http://screenr.com/Wpp > http://elv1s.ru/files/web-inspector/fancy-autocomplete.html I just applied the most recent patch locally. I think its great, but after seeing and thinking about your non-flickering, non-setTimeout approach, I think that approach is worth taking. Further, I think it would be fine to take that approach without needing to rewrite TextPrompt. The reason I feel this is because: - the console completion must be async (results come from the inspected page) - the CSS completion is a static list of known values We can optimize TextPrompt in the future to try to perform the non-flicker autocompletion. It can do this by doing some parsing of the string (as is already done) and determining if the last set of results can be reused (no-flicker), or if a new list must be fetched (flicker). Still, its great to do small patches, so I think step 1, non-flicker CSS autocompletion would be awesome. Think you can create a new patch for this? 238969 33 58907 me 2010-06-16 11:12:45 -0700 Created attachment 58907 Input fields: two vs one What do you think about two input fields (one for CSS property name, another for value) instead of one? Firebug using two and I've found it more useful. To write "margin: auto" in Firebug I can: 1) type "m", "margin" will be suggested 2) press Tab 3) type "auto" In Web Inspector Tab jumps on next CSS property. To do the same In Web Inspector I should: 1) type "m", "margin" will be suggested (using my latest patch) 2) press Right Arrow 3) type ":" 4) type "auto" I think pressing Tab is much easier than pressing Right Arrow and writing ":" after that. 238978 34 joepeck 2010-06-16 11:25:17 -0700 (In reply to comment #33) > I think pressing Tab is much easier than pressing Right Arrow and writing ":" after that. Some thoughts I had. You can append ": " to the end of each autocompletion result. I'm trying to do something similar elsewhere. Or manually append it when the user uses the right arrow. But I agree. I tripped myself up using "tab" a few times with your autocomplete patch. Splitting into two fields sounds like a separate patch altogether, or are you suggesting doing that first? 239076 35 me 2010-06-16 14:04:11 -0700 > (In reply to comment #33) > Splitting into two fields sounds like a > separate patch altogether, or are you suggesting doing that first? No, I don't. I just looked at it, and it looks like more than a 2 hour task. 240057 36 59141 me 2010-06-18 11:30:29 -0700 Created attachment 59141 Autocomplete CSS properties and cycle through them using arrow keys 240204 37 59166 me 2010-06-18 16:10:24 -0700 Created attachment 59166 Autocomplete CSS properties and cycle through them using arrow keys Remove keypress event then editing ended. Use binary search for WebInspector.CSS.properties.firstStartsWith. 240286 38 59166 joepeck 2010-06-19 01:03:19 -0700 Comment on attachment 59166 Autocomplete CSS properties and cycle through them using arrow keys > diff --git a/WebCore/inspector/front-end/CSS.js b/WebCore/inspector/front-end/CSS.js I still don't like this file being called CSS.js. Its purpose is more about autocompletion. I still like "Completion.js" or something along those lines. Also, when you add a file you should update a number of build files. You can see the following for an example of most of them: http://trac.webkit.org/changeset/60530 - [easy] WebCore/inspector/front-end/WebKit.qrc - [easy] WebCore/WebCore.gypi - [optional, if you have Windows handy] WebCore/WebCore.vcproj/WebCore.vcproj - [optional, if you have XCode handy] WebCore/WebCore.xcodeproj/project.pbxproj > +WebInspector.CSS = { > + properties: (function buildCSSProperties() { > + var properties = Array.convert(document.defaultView.getComputedStyle(document.documentElement, "")); > + var length = properties.length; > + // Add shorthands to the end of the properties list. > + for (var i = 0; i < length; ++i) { > + var propertyWords = properties[i].split("-"); > + var j = propertyWords.length; > + while (--j) { > + var shorthand = propertyWords.slice(0, j).join("-"); > + if (typeof document.documentElement.style[shorthand] !== "undefined" && properties.indexOf(shorthand) < 0) > + properties.push(shorthand); > + } > + } > + return properties.sort(); > + })() > +} The implementation of this function is okay But it can be improved quite a bit. I played around and implemented a version twice a fast. However, this already takes ~2ms so its not really that important to improve. Some simple things I think would be worth doing that keep the readability while not going overboard are: - cache `document.documentElement.style` into a variable and remove the typeof. Resulting in: // Early on... var style = document.documentElement.style; // In the condition... style[shorthand] !== undefined - change the "slice().join()" call to a "pop(); join()" propertyWords.pop(); var shorthand = propertyWords.join("-"); These few changes along should really speed things up without affecting the readability. Other improvements are mentioned here: http://gist.github.com/444648 Ultimately I think the engine should provide this list, but that is beyond the scope of this bug. Also, after some further thought, I think this should be an unnamed anonymous function. Giving it a name makes it an unnecessary global. > +WebInspector.CSS.properties.startsWith = function startsWith(prefix) > +{ > + // FIXME: Use binary search. > + return this.filter(function(property) { > + return property.indexOf(prefix) === 0; > + }); > +} With a bit of refactoring, this could just use the binary search you implemented in firstStartsWith. And, doing so you can achieve a pretty quick ~20x speedup because of the nature of the data. Again, not something particularly necessary to speedup, but since you already have it! Make a helper function, like firstStartsWith, that returns the index of the first starting item (and -1 if not found). Then its trivial to implement firstStartsWith and startsWith on top of the binary search implementation. To see what I mean: http://gist.github.com/444674 > + var middleIndex = (maxIndex + minIndex) >> 1; // Same as Math.floor((maxIndex + minIndex) / 2), but twice faster. You can remove this comment, or just shorten it to note that this handles the flooring. > + index = (index + this.length + shift) % this.length; > + > + if (!prefix) > + return this[index]; The top statement can go inside the if block. Its not necessary otherwise. > \ No newline at end of file We want that newline! > + // Restore <span class="webkit-css-property"> if it doesn't yet exist or was actidentally deleted. Typo: actidentally => accidentally > +Array.convert = function convert(list) > +{ > + // Cast array-like object to an array. > + return Array.prototype.slice.call(list); > +} > + Again, I think this should be unnamed to prevent an extra global reference. I know this helps JSC find the function name in debugging, but I don't think its that big of a deal in this case. Also, the engine should be improved to infer the name. I think v8 does. I hope this review didn't come across as bad. I really liked the patch. I just think it could use a little more polish! Cheers! 240294 39 me 2010-06-19 01:50:28 -0700 (In reply to comment #38) > (From update of attachment 59166 [details]) > > diff --git a/WebCore/inspector/front-end/CSS.js b/WebCore/inspector/front-end/CSS.js > > I still don't like this file being called CSS.js. Its purpose > is more about autocompletion. I still like "Completion.js" > or something along those lines. This file provides WebInspector.CSS, so I called it CSS.js. It's about CSS completions, not JS completions or something else. > > +Array.convert = function convert(list) > > +{ > > + // Cast array-like object to an array. > > + return Array.prototype.slice.call(list); > > +} > > + > > Again, I think this should be unnamed to prevent an > extra global reference. I know this helps JSC find the > function name in debugging, but I don't think its > that big of a deal in this case. Also, the engine > should be improved to infer the name. I think v8 does. It isn't global for me and it shouldn't be global for you too. If it is, it's a bug. 240335 40 timothy 2010-06-19 07:13:56 -0700 I agree CSS.js is to generic. Call it CSSCompletions.js or something more specific. 240360 41 me 2010-06-19 09:53:12 -0700 (In reply to comment #40) > I agree CSS.js is to generic. Call it CSSCompletions.js or something more specific. CSSCompletions.js sounds better than Completion.js to me. Should I also rename WebInspector.CSS object to WebInspector.CSSCompletions? 240362 42 joepeck 2010-06-19 09:58:22 -0700 (In reply to comment #41) > (In reply to comment #40) > > I agree CSS.js is to generic. Call it CSSCompletions.js or something more specific. > > CSSCompletions.js sounds better than Completion.js to me. > Should I also rename WebInspector.CSS object to > WebInspector.CSSCompletions? Yes. In fact you can change WebInspector.CSS.properties to WebInspector.CSSCompletions to shorten things further. 240376 43 59191 me 2010-06-19 11:32:14 -0700 Created attachment 59191 Autocomplete CSS properties and cycle through them using arrow keys 240489 44 59191 joepeck 2010-06-20 11:40:09 -0700 Comment on attachment 59191 Autocomplete CSS properties and cycle through them using arrow keys I mentioned in IRC: > WebCore/ChangeLog > + 2010-06-19 Nikita Vasilyev <me@elv1s.ru> > + > + Reviewed by NOBODY (OOPS!). > + > + Web Inspector: added autocompletion for CSS properties. A suggestion for a property shows when you type. > + You can also cycle through known property names using arrow keys. > + https://bugs.webkit.org/show_bug.cgi?id=17374 The Bug Title & Link should be on their own. Your description should be in a paragraph after. Like so: Inspector should support tab completion while editing CSS https://bugs.webkit.org/show_bug.cgi?id=17374 Added autocompletion for CSS properties. A suggestion for a property shows when you type. You can also cycle through known property names using the Up and Down arrow keys. 240497 45 59206 me 2010-06-20 12:04:08 -0700 Created attachment 59206 Autocomplete CSS properties and cycle through them using arrow keys Do not delete last character if selection is collapsed. 240506 46 59206 joepeck 2010-06-20 12:41:45 -0700 Comment on attachment 59206 Autocomplete CSS properties and cycle through them using arrow keys Great! One thing we talked about in IRC was that this doesn't autocomplete on backspace. This acts like the autocomplete in Safari's URL bar, but not like the Inspector's JavaScript Console. This can be handled in a follow up bug. All inspector and http/tests/inspector* tests passed. 240538 47 59206 commit-queue 2010-06-20 15:32:16 -0700 Comment on attachment 59206 Autocomplete CSS properties and cycle through them using arrow keys Clearing flags on attachment: 59206 Committed r61514: <http://trac.webkit.org/changeset/61514> 240539 48 commit-queue 2010-06-20 15:32:22 -0700 All reviewed patches have been landed. Closing bug. 53063 2010-04-10 17:32:29 -0700 2010-06-11 12:31:51 -0700 Differing Properties Between getComputedStyle and CSS Tokenizer's list differing-properties.diff text/plain 2955 joepeck MGExCj4gICItd2Via2l0LWFuaW1hdGlvbiIKNGQ0CjwgICItd2Via2l0LWFuaW1hdGlvbi1maWxs LW1vZGUiCjE0YTE1Cj4gICItd2Via2l0LWJpbmRpbmciCjE3YTE5Cj4gICItd2Via2l0LWJvcmRl ci1yYWRpdXMiCjMwZDMxCjwgICItd2Via2l0LWNvbG9yLWNvcnJlY3Rpb24iCjM1YTM3Cj4gICIt d2Via2l0LWNvbHVtbi1ydWxlIgo0MGM0Miw0Mwo8ICAiLXdlYmtpdC1kYXNoYm9hcmQtcmVnaW9u IgotLS0KPiAgIi13ZWJraXQtY29sdW1ucyIKPiAgIi13ZWJraXQtZm9udC1zaXplLWRlbHRhIgo0 NWE0OSw1MAo+ICAiLXdlYmtpdC1tYXJnaW4tY29sbGFwc2UiCj4gICItd2Via2l0LW1hcmdpbi1z dGFydCIKNDZhNTIKPiAgIi13ZWJraXQtbWFycXVlZSIKNDlhNTYKPiAgIi13ZWJraXQtbWFycXVl ZS1zcGVlZCIKNTBhNTgKPiAgIi13ZWJraXQtbWFzayIKNTdhNjYsNjcKPiAgIi13ZWJraXQtbWFz ay1wb3NpdGlvbi14Igo+ICAiLXdlYmtpdC1tYXNrLXBvc2l0aW9uLXkiCjU4YTY5LDcwCj4gICIt d2Via2l0LW1hc2stcmVwZWF0LXgiCj4gICItd2Via2l0LW1hc2stcmVwZWF0LXkiCjU5YTcyCj4g ICItd2Via2l0LW1hdGNoLW5lYXJlc3QtbWFpbC1ibG9ja3F1b3RlLWNvbG9yIgo2MGE3NAo+ICAi LXdlYmtpdC1wYWRkaW5nLXN0YXJ0Igo2MmE3Nyw3OAo+ICAiLXdlYmtpdC1wZXJzcGVjdGl2ZS1v cmlnaW4teCIKPiAgIi13ZWJraXQtcGVyc3BlY3RpdmUtb3JpZ2luLXkiCjY0ZDc5CjwgICItd2Vi a2l0LXN2Zy1zaGFkb3ciCjY3YTgzLDg0Cj4gICItd2Via2l0LXRleHQtc2l6ZS1hZGp1c3QiCj4g ICItd2Via2l0LXRleHQtc3Ryb2tlIgo3MWE4OSw5MQo+ICAiLXdlYmtpdC10cmFuc2Zvcm0tb3Jp Z2luLXgiCj4gICItd2Via2l0LXRyYW5zZm9ybS1vcmlnaW4teSIKPiAgIi13ZWJraXQtdHJhbnNm b3JtLW9yaWdpbi16Igo3MmE5Mwo+ICAiLXdlYmtpdC10cmFuc2l0aW9uIgo4MGMxMDEsMTAyCjwg ICJhbGlnbm1lbnQtYmFzZWxpbmUiCi0tLQo+ICAiLXdlYmtpdC12YXJpYWJsZS1kZWNsYXJhdGlv bi1ibG9jayIKPiAgImJhY2tncm91bmQiCjg2YTEwOSwxMTAKPiAgImJhY2tncm91bmQtcG9zaXRp b24teCIKPiAgImJhY2tncm91bmQtcG9zaXRpb24teSIKODdhMTEyLDExMwo+ICAiYmFja2dyb3Vu ZC1yZXBlYXQteCIKPiAgImJhY2tncm91bmQtcmVwZWF0LXkiCjg5YzExNSwxMTYKPCAgImJhc2Vs aW5lLXNoaWZ0IgotLS0KPiAgImJvcmRlciIKPiAgImJvcmRlci1ib3R0b20iCjk1YTEyMywxMjQK PiAgImJvcmRlci1jb2xvciIKPiAgImJvcmRlci1sZWZ0Igo5OGExMjgsMTI5Cj4gICJib3JkZXIt cmFkaXVzIgo+ICAiYm9yZGVyLXJpZ2h0IgoxMDFhMTMzLDEzNQo+ICAiYm9yZGVyLXNwYWNpbmci Cj4gICJib3JkZXItc3R5bGUiCj4gICJib3JkZXItdG9wIgoxMDZhMTQxCj4gICJib3JkZXItd2lk dGgiCjExMSwxMTJkMTQ1CjwgICJjbGlwLXBhdGgiCjwgICJjbGlwLXJ1bGUiCjExNCwxMTZjMTQ3 LDE0OQo8ICAiY29sb3ItaW50ZXJwb2xhdGlvbiIKPCAgImNvbG9yLWludGVycG9sYXRpb24tZmls dGVycyIKPCAgImNvbG9yLXJlbmRlcmluZyIKLS0tCj4gICJjb250ZW50Igo+ICAiY291bnRlci1p bmNyZW1lbnQiCj4gICJjb3VudGVyLXJlc2V0IgoxMjBkMTUyCjwgICJkb21pbmFudC1iYXNlbGlu ZSIKMTIyLDEyNWQxNTMKPCAgImZpbGwiCjwgICJmaWxsLW9wYWNpdHkiCjwgICJmaWxsLXJ1bGUi CjwgICJmaWx0ZXIiCjEyNywxMjhjMTU1CjwgICJmbG9vZC1jb2xvciIKPCAgImZsb29kLW9wYWNp dHkiCi0tLQo+ICAiZm9udCIKMTMwYTE1OAo+ICAiZm9udC1zdHJldGNoIgoxMzQsMTM1ZDE2MQo8 ICAiZ2x5cGgtb3JpZW50YXRpb24taG9yaXpvbnRhbCIKPCAgImdseXBoLW9yaWVudGF0aW9uLXZl cnRpY2FsIgoxMzcsMTM4ZDE2Mgo8ICAiaW1hZ2UtcmVuZGVyaW5nIgo8ICAia2VybmluZyIKMTQx ZDE2NAo8ICAibGlnaHRpbmctY29sb3IiCjE0MmExNjYKPiAgImxpc3Qtc3R5bGUiCjE0NWExNzAK PiAgIm1hcmdpbiIKMTUwLDE1M2QxNzQKPCAgIm1hcmtlci1lbmQiCjwgICJtYXJrZXItbWlkIgo8 ICAibWFya2VyLXN0YXJ0Igo8ICAibWFzayIKMTU5YTE4MQo+ICAib3V0bGluZSIKMTYwYTE4Mwo+ ICAib3V0bGluZS1vZmZzZXQiCjE2MmExODYKPiAgIm92ZXJmbG93IgoxNjRhMTg5Cj4gICJwYWRk aW5nIgoxNjhhMTk0Cj4gICJwYWdlIgoxNzNhMjAwCj4gICJxdW90ZXMiCjE3NiwxODZjMjAzLDIw NAo8ICAic2hhcGUtcmVuZGVyaW5nIgo8ICAic3RvcC1jb2xvciIKPCAgInN0b3Atb3BhY2l0eSIK PCAgInN0cm9rZSIKPCAgInN0cm9rZS1kYXNoYXJyYXkiCjwgICJzdHJva2UtZGFzaG9mZnNldCIK PCAgInN0cm9rZS1saW5lY2FwIgo8ICAic3Ryb2tlLWxpbmVqb2luIgo8ICAic3Ryb2tlLW1pdGVy bGltaXQiCjwgICJzdHJva2Utb3BhY2l0eSIKPCAgInN0cm9rZS13aWR0aCIKLS0tCj4gICJzaXpl Igo+ICAic3JjIgoxODlkMjA2CjwgICJ0ZXh0LWFuY2hvciIKMTkxYTIwOSwyMTMKPiAgInRleHQt bGluZS10aHJvdWdoIgo+ICAidGV4dC1saW5lLXRocm91Z2gtY29sb3IiCj4gICJ0ZXh0LWxpbmUt dGhyb3VnaC1tb2RlIgo+ICAidGV4dC1saW5lLXRocm91Z2gtc3R5bGUiCj4gICJ0ZXh0LWxpbmUt dGhyb3VnaC13aWR0aCIKMTkyYTIxNSwyMTkKPiAgInRleHQtb3ZlcmxpbmUiCj4gICJ0ZXh0LW92 ZXJsaW5lLWNvbG9yIgo+ICAidGV4dC1vdmVybGluZS1tb2RlIgo+ICAidGV4dC1vdmVybGluZS1z dHlsZSIKPiAgInRleHQtb3ZlcmxpbmUtd2lkdGgiCjE5NWEyMjMsMjI3Cj4gICJ0ZXh0LXVuZGVy bGluZSIKPiAgInRleHQtdW5kZXJsaW5lLWNvbG9yIgo+ICAidGV4dC11bmRlcmxpbmUtbW9kZSIK PiAgInRleHQtdW5kZXJsaW5lLXN0eWxlIgo+ICAidGV4dC11bmRlcmxpbmUtd2lkdGgiCjE5N2Ey MzAKPiAgInVuaWNvZGUtcmFuZ2UiCjIwNmQyMzgKPCAgIndyaXRpbmctbW9kZSIK 55551 2010-05-10 07:02:00 -0700 2010-05-14 10:05:36 -0700 Autocomplete CSS properties autocomplete_css_properties.patch text/plain 7590 me ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTRiNzdiYS4uNTg3ZTVkMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAxMC0wNS0xMCAgTmlraXRhIFZhc2ls eWV2ICA8bWVAZWx2MXMucnU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgV2ViSW5zcGVjdG9yOiBBdXRvY29tcGxldGUgQ1NTIHByb3BlcnRpZXMuCisK KyAgICAgICAgSW5zcGVjdG9yIHNob3VsZCBzdXBwb3J0IHRhYiBjb21wbGV0aW9uIHdoaWxlIGVk aXRpbmcgQ1NTCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xNzM3NAorCisgICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogaW5z cGVjdG9yL2Zyb250LWVuZC9DU1MuanM6IEFkZGVkLgorICAgICAgICAoV2ViSW5zcGVjdG9yLkNT Uy5wcm9wZXJ0aWVzKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5zdGFy dHNXaXRoKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5maXJzdFN0YXJ0 c1dpdGgpOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvU3R5bGVzU2lkZWJhclBhbmUu anM6CisgICAgICAgIChXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3Rv dHlwZSk6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuaHRtbDoKKyAg ICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGllcy5qczoKKyAgICAgICAgKFRleHQu cHJvdG90eXBlLnNlbGVjdCk6CisgICAgICAgICgpOgorCiAyMDEwLTA1LTEwICBJbHlhIFRpa2hv bm92c2t5ICA8bG9pc2xvQGNocm9taXVtLm9yZz4KIAogICAgICAgICBOb3QgcmV2aWV3ZWQ6IHJv bGxiYWNrIHRoZSBjb21taXQgcjU5MDYyCmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9m cm9udC1lbmQvQ1NTLmpzIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0NTUy5qcwpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMTA5ODI4Ci0tLSAvZGV2L251bGwKKysr IGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0NTUy5qcwpAQCAtMCwwICsxLDM3IEBACitX ZWJJbnNwZWN0b3IuQ1NTID0geworICAgIHByb3BlcnRpZXM6IChmdW5jdGlvbiBnZXRDU1NQcm9w ZXJ0aWVzKCkgeworICAgICAgICB2YXIgcHJvcGVydGllcyA9IEFycmF5LmNvbnZlcnQoZG9jdW1l bnQuZGVmYXVsdFZpZXcuZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5kb2N1bWVudEVsZW1lbnQs ICIiKSk7CisgICAgICAgIHZhciBsZW5ndGggPSBwcm9wZXJ0aWVzLmxlbmd0aDsKKyAgICAgICAg Ly8gQWRkIHNob3J0aGFuZHMuCisgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgbGVuZ3RoOyAr K2kpIHsKKyAgICAgICAgICAgIHZhciBwcm9wZXJ0eVdvcmRzID0gcHJvcGVydGllc1tpXS5zcGxp dCgiLSIpOworICAgICAgICAgICAgdmFyIGogPSBwcm9wZXJ0eVdvcmRzLmxlbmd0aDsKKyAgICAg ICAgICAgIHdoaWxlICgtLWopIHsKKyAgICAgICAgICAgICAgICB2YXIgc2hvcnRoYW5kID0gcHJv cGVydHlXb3Jkcy5zbGljZSgwLCBqKS5qb2luKCItIik7CisgICAgICAgICAgICAgICAgaWYgKHR5 cGVvZiBkb2N1bWVudC5kb2N1bWVudEVsZW1lbnQuc3R5bGVbc2hvcnRoYW5kXSAhPT0gInVuZGVm aW5lZCIgJiYgcHJvcGVydGllcy5pbmRleE9mKHNob3J0aGFuZCkgPCAwKSB7CisgICAgICAgICAg ICAgICAgICAgIHByb3BlcnRpZXMucHVzaChzaG9ydGhhbmQpOworICAgICAgICAgICAgICAgIH0K KyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICByZXR1cm4gcHJvcGVydGllczsKKyAg ICB9KSgpCit9CisKK1dlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5zdGFydHNXaXRoID0gZnVu Y3Rpb24gc3RhcnRzV2l0aChzdHIpCit7CisgICAgcmV0dXJuIHRoaXMuZmlsdGVyKGZ1bmN0aW9u KHByb3BlcnR5KSB7CisgICAgICAgIHJldHVybiBwcm9wZXJ0eS5pbmRleE9mKHN0cikgPT09IDA7 CisgICAgfSk7Cit9OworCitXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMuZmlyc3RTdGFydHNX aXRoID0gZnVuY3Rpb24gZmlyc3RTdGFydHNXaXRoKHN0cikKK3sKKyAgICBpZiAoIXN0cikKKyAg ICAgICAgcmV0dXJuICIiOworICAgIGZvciAodmFyIGkgPSAwOyBpIDwgdGhpcy5sZW5ndGg7ICsr aSkgeworICAgICAgICBpZiAodGhpc1tpXS5pbmRleE9mKHN0cikgPT09IDApIHsKKyAgICAgICAg ICAgIHJldHVybiB0aGlzW2ldOworICAgICAgICB9CisgICAgfQorICAgIHJldHVybiAiIjsKK307 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvU3R5bGVzU2lkZWJhclBh bmUuanMgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvU3R5bGVzU2lkZWJhclBhbmUuanMK aW5kZXggYzI4MGZiYi4uMmZmYjRjZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJv bnQtZW5kL1N0eWxlc1NpZGViYXJQYW5lLmpzCisrKyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250 LWVuZC9TdHlsZXNTaWRlYmFyUGFuZS5qcwpAQCAtMTI5OCw4ICsxMjk4LDYgQEAgV2ViSW5zcGVj dG9yLlN0eWxlUHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUgPSB7CiAgICAgewogICAgICAg ICB2YXIgYXJyb3dLZXlQcmVzc2VkID0gKGV2ZW50LmtleUlkZW50aWZpZXIgPT09ICJVcCIgfHwg ZXZlbnQua2V5SWRlbnRpZmllciA9PT0gIkRvd24iKTsKICAgICAgICAgdmFyIHBhZ2VLZXlQcmVz c2VkID0gKGV2ZW50LmtleUlkZW50aWZpZXIgPT09ICJQYWdlVXAiIHx8IGV2ZW50LmtleUlkZW50 aWZpZXIgPT09ICJQYWdlRG93biIpOwotICAgICAgICBpZiAoIWFycm93S2V5UHJlc3NlZCAmJiAh cGFnZUtleVByZXNzZWQpCi0gICAgICAgICAgICByZXR1cm47CiAKICAgICAgICAgdmFyIHNlbGVj dGlvbiA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKTsKICAgICAgICAgaWYgKCFzZWxlY3Rpb24ucmFu Z2VDb3VudCkKQEAgLTEzMTUsNyArMTMxMyw3IEBAIFdlYkluc3BlY3Rvci5TdHlsZVByb3BlcnR5 VHJlZUVsZW1lbnQucHJvdG90eXBlID0gewogICAgICAgICB2YXIgcmVwbGFjZW1lbnRTdHJpbmcg PSB3b3JkU3RyaW5nOwogCiAgICAgICAgIHZhciBtYXRjaGVzID0gLyguKj8pKC0/XGQrKD86XC5c ZCspPykoLiopLy5leGVjKHdvcmRTdHJpbmcpOwotICAgICAgICBpZiAobWF0Y2hlcyAmJiBtYXRj aGVzLmxlbmd0aCkgeworICAgICAgICBpZiAoYXJyb3dLZXlQcmVzc2VkIHx8IHBhZ2VLZXlQcmVz c2VkICYmIG1hdGNoZXMgJiYgbWF0Y2hlcy5sZW5ndGgpIHsKICAgICAgICAgICAgIHZhciBwcmVm aXggPSBtYXRjaGVzWzFdOwogICAgICAgICAgICAgdmFyIG51bWJlciA9IHBhcnNlRmxvYXQobWF0 Y2hlc1syXSk7CiAgICAgICAgICAgICB2YXIgc3VmZml4ID0gbWF0Y2hlc1szXTsKQEAgLTEzNTIs NiArMTM1MCwzOCBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3Rv dHlwZSA9IHsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgcmVwbGFjZW1lbnRTdHJpbmcg PSBwcmVmaXggKyBudW1iZXIgKyBzdWZmaXg7CisgICAgICAgIH0gZWxzZSBpZiAoL1tBLVotXS8u dGVzdChldmVudC5jaGFyYWN0ZXIpKSB7CisgICAgICAgICAgICBzZXRUaW1lb3V0KGZ1bmN0aW9u KCkgeworICAgICAgICAgICAgICAgIHZhciBlbGVtZW50ID0gZXZlbnQudGFyZ2V0OworICAgICAg ICAgICAgICAgIHZhciBuYW1lID0gZWxlbWVudC5xdWVyeVNlbGVjdG9yKCIubmFtZSIpOworICAg ICAgICAgICAgICAgIGlmICghbmFtZSkgeworICAgICAgICAgICAgICAgICAgICB2YXIgaW5kZXgg PSBlbGVtZW50LnRleHRDb250ZW50LmluZGV4T2YoJzonKTsKKyAgICAgICAgICAgICAgICAgICAg aWYgKGluZGV4ID49IDApIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHZhciBwcm9wZXJ0eSA9 IGVsZW1lbnQudGV4dENvbnRlbnQuc3Vic3RyaW5nKDAsIGluZGV4KTsKKyAgICAgICAgICAgICAg ICAgICAgICAgIGlmIChwcm9wZXJ0eSkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8v IEEgc3Bhbi5uYW1lIGRvZXNuJ3QgeWV0IGV4aXN0LCBzbyBsZXRzIGNyZWF0ZSBvbmUuCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgbmFtZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInNw YW4iKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBuYW1lLmNsYXNzTmFtZSA9ICJuYW1l IjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBuYW1lLnRleHRDb250ZW50ID0gcHJvcGVy dHk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgZWxlbWVudC50ZXh0Q29udGVudCA9IGVs ZW1lbnQudGV4dENvbnRlbnQucmVwbGFjZShwcm9wZXJ0eSwgIiIpOworICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGVsZW1lbnQuaW5zZXJ0QmVmb3JlKG5hbWUsIGVsZW1lbnQuZmlyc3RDaGls ZCk7CisgICAgICAgICAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAg ICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICB2YXIgdmFsdWUg PSBlbGVtZW50LnF1ZXJ5U2VsZWN0b3IoIi52YWx1ZSIpOworICAgICAgICAgICAgICAgIHZhciBw cm9wZXJ0eSA9IG5hbWUudGV4dENvbnRlbnQ7CisgICAgICAgICAgICAgICAgdmFyIG5ld1Byb3Bl cnR5ID0gV2ViSW5zcGVjdG9yLkNTUy5wcm9wZXJ0aWVzLmZpcnN0U3RhcnRzV2l0aChwcm9wZXJ0 eSk7CisgICAgICAgICAgICAgICAgaWYgKG5ld1Byb3BlcnR5ICYmIG5ld1Byb3BlcnR5ICE9PSBw cm9wZXJ0eSkgeworICAgICAgICAgICAgICAgICAgICBuYW1lLnRleHRDb250ZW50ID0gbmV3UHJv cGVydHk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIHZhciBuID0gcHJvcGVy dHkubGVuZ3RoIC0gbmV3UHJvcGVydHkubGVuZ3RoOworICAgICAgICAgICAgICAgIGlmIChuIDwg MCkgeworICAgICAgICAgICAgICAgICAgICBuYW1lLmZpcnN0Q2hpbGQuc2VsZWN0KG4pOworICAg ICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0sIDApOworICAgICAgICAgICAgcmV0dXJuOwog ICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgLy8gRklYTUU6IHRoaXMgc2hvdWxkIGN5Y2xl IHRocm91Z2gga25vd24ga2V5d29yZHMgZm9yIHRoZSBjdXJyZW50IHByb3BlcnR5IG5hbWUuCiAg ICAgICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1l bmQvaW5zcGVjdG9yLmh0bWwgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9y Lmh0bWwKaW5kZXggNGZhOGRkYy4uN2IzMGUwMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0 b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sCisrKyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250 LWVuZC9pbnNwZWN0b3IuaHRtbApAQCAtODAsNiArODAsNyBAQCBUSElTIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICAgIDxzY3Jp cHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlByb3BlcnRpZXNTaWRlYmFyUGFuZS5qcyI+ PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iRXZlbnRM aXN0ZW5lcnNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0 L2phdmFzY3JpcHQiIHNyYz0iQ29sb3IuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQgdHlwZT0i dGV4dC9qYXZhc2NyaXB0IiBzcmM9IkNTUy5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBl PSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iU3R5bGVzU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0Pgog ICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlBhbmVsRW5hYmxlclZpZXcu anMiPjwvc2NyaXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Ildl bGNvbWVWaWV3LmpzIj48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC91dGlsaXRpZXMuanMgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvdXRpbGl0 aWVzLmpzCmluZGV4IDk4ZjM0YjkuLmE1NmVlY2UgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVj dG9yL2Zyb250LWVuZC91dGlsaXRpZXMuanMKKysrIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQt ZW5kL3V0aWxpdGllcy5qcwpAQCAtMzEyLDYgKzMxMiwyNyBAQCBFbGVtZW50LnByb3RvdHlwZS5v ZmZzZXRSZWxhdGl2ZVRvV2luZG93ID0gZnVuY3Rpb24odGFyZ2V0V2luZG93KQogICAgIHJldHVy biBlbGVtZW50T2Zmc2V0OwogfQogCitLZXlib2FyZEV2ZW50LnByb3RvdHlwZS5fX2RlZmluZUdl dHRlcl9fKCJjaGFyYWN0ZXIiLCBmdW5jdGlvbiBnZXRDaGFyYWN0ZXIoKQoreworICAgIHZhciBj b2RlID0gcGFyc2VJbnQodGhpcy5rZXlJZGVudGlmaWVyLnNsaWNlKDIpLCAxNik7CisgICAgcmV0 dXJuIFN0cmluZy5mcm9tQ2hhckNvZGUoY29kZSk7Cit9KTsKKworVGV4dC5wcm90b3R5cGUuc2Vs ZWN0ID0gZnVuY3Rpb24gc2VsZWN0KHN0YXJ0LCBlbmQpCit7CisgICAgZW5kID0gZW5kIHx8IHRo aXMudGV4dENvbnRlbnQubGVuZ3RoOworICAgIGlmIChzdGFydCA8IDApIHsKKyAgICAgICAgc3Rh cnQgPSBlbmQgKyBzdGFydDsKKyAgICB9CisgICAgdmFyIHNlbGVjdGlvbiA9IHdpbmRvdy5nZXRT ZWxlY3Rpb24oKTsKKyAgICBzZWxlY3Rpb24ucmVtb3ZlQWxsUmFuZ2VzKCk7CisgICAgdmFyIHJh bmdlID0gZG9jdW1lbnQuY3JlYXRlUmFuZ2UoKTsKKyAgICByYW5nZS5zZXRTdGFydCh0aGlzLCBz dGFydCk7CisgICAgcmFuZ2Uuc2V0RW5kKHRoaXMsIGVuZCk7CisgICAgc2VsZWN0aW9uLmFkZFJh bmdlKHJhbmdlKTsKKyAgICByZXR1cm4gdGhpczsKK307CisKIE5vZGUucHJvdG90eXBlLmlzV2hp dGVzcGFjZSA9IGlzTm9kZVdoaXRlc3BhY2U7CiBOb2RlLnByb3RvdHlwZS5kaXNwbGF5TmFtZSA9 IG5vZGVEaXNwbGF5TmFtZTsKIE5vZGUucHJvdG90eXBlLmlzQW5jZXN0b3IgPSBmdW5jdGlvbihu b2RlKQpAQCAtNjMyLDYgKzY1MywxMiBAQCBIVE1MVGV4dEFyZWFFbGVtZW50LnByb3RvdHlwZS5t b3ZlQ3Vyc29yVG9FbmQgPSBmdW5jdGlvbigpCiAgICAgdGhpcy5zZXRTZWxlY3Rpb25SYW5nZShs ZW5ndGgsIGxlbmd0aCk7CiB9CiAKK0FycmF5LmNvbnZlcnQgPSBmdW5jdGlvbiBjb252ZXJ0KGxp c3QpCit7CisgICAgLy8gQ29udmVydCBhcnJheS1saWtlIG9iamVjdCB0byBhcnJheS4KKyAgICBy ZXR1cm4gQXJyYXkucHJvdG90eXBlLnNsaWNlLmNhbGwobGlzdCk7Cit9CisKIEFycmF5LnByb3Rv dHlwZS5yZW1vdmUgPSBmdW5jdGlvbih2YWx1ZSwgb25seUZpcnN0KQogewogICAgIGlmIChvbmx5 Rmlyc3QpIHsK 56082 2010-05-14 10:05:36 -0700 2010-06-18 11:30:29 -0700 Autocomplete CSS properties css.patch text/plain 8024 me ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTVhNmZhMC4uZjVlYmYwOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0wNS0xNCAgTmlraXRhIFZhc2ls eWV2ICA8bWVAZWx2MXMucnU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgV2ViSW5zcGVjdG9yOiBJbnNwZWN0b3Igc2hvdWxkIHN1cHBvcnQgdGFiIGNv bXBsZXRpb24gd2hpbGUgZWRpdGluZyBDU1MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTE3Mzc0CisKKyAgICAgICAgQWRkZWQgYXV0b2NvbXBsZXRpb24g Zm9yIENTUyBwcm9wZXJ0aWVzLiBBIHN1Z2dlc3Rpb24gZm9yIGEgcHJvcGVydHkKKyAgICAgICAg c2hvd3Mgd2hlbiB5b3UgdHlwZS4KKworICAgICAgICBObyBuZXcgdGVzdHMuIChPT1BTISkKKwor ICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvQ1NTLmpzOiBBZGRlZC4KKyAgICAgICAgKFdl Ykluc3BlY3Rvci5DU1MucHJvcGVydGllcyk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTLnBy b3BlcnRpZXMuc3RhcnRzV2l0aCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRp ZXMuZmlyc3RTdGFydHNXaXRoKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxl c1NpZGViYXJQYW5lLmpzOgorICAgICAgICAoV2ViSW5zcGVjdG9yLlN0eWxlUHJvcGVydHlUcmVl RWxlbWVudC5wcm90b3R5cGUpOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVj dG9yLmh0bWw6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC91dGlsaXRpZXMuanM6Cisg ICAgICAgIChUZXh0LnByb3RvdHlwZS5zZWxlY3QpOgorICAgICAgICAoKToKKwogMjAxMC0wNS0x NCAgWmhlbnlhbyBNbyAgPHptb0Bnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERp bWl0cmkgR2xhemtvdi4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9D U1MuanMgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvQ1NTLmpzCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAuLmYyMjMyNWIKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3Jl L2luc3BlY3Rvci9mcm9udC1lbmQvQ1NTLmpzCkBAIC0wLDAgKzEsMzcgQEAKK1dlYkluc3BlY3Rv ci5DU1MgPSB7CisgICAgcHJvcGVydGllczogKGZ1bmN0aW9uIGJ1aWxkQ1NTUHJvcGVydGllcygp IHsKKyAgICAgICAgdmFyIHByb3BlcnRpZXMgPSBBcnJheS5jb252ZXJ0KGRvY3VtZW50LmRlZmF1 bHRWaWV3LmdldENvbXB1dGVkU3R5bGUoZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50LCAiIikpOwor ICAgICAgICB2YXIgbGVuZ3RoID0gcHJvcGVydGllcy5sZW5ndGg7CisgICAgICAgIC8vIEFkZCBz aG9ydGhhbmRzIHRvIHRoZSBlbmQgb2YgdGhlIHByb3BlcnRpZXMgbGlzdC4KKyAgICAgICAgZm9y ICh2YXIgaSA9IDA7IGkgPCBsZW5ndGg7ICsraSkgeworICAgICAgICAgICAgdmFyIHByb3BlcnR5 V29yZHMgPSBwcm9wZXJ0aWVzW2ldLnNwbGl0KCItIik7CisgICAgICAgICAgICB2YXIgaiA9IHBy b3BlcnR5V29yZHMubGVuZ3RoOworICAgICAgICAgICAgd2hpbGUgKC0taikgeworICAgICAgICAg ICAgICAgIHZhciBzaG9ydGhhbmQgPSBwcm9wZXJ0eVdvcmRzLnNsaWNlKDAsIGopLmpvaW4oIi0i KTsKKyAgICAgICAgICAgICAgICBpZiAodHlwZW9mIGRvY3VtZW50LmRvY3VtZW50RWxlbWVudC5z dHlsZVtzaG9ydGhhbmRdICE9PSAidW5kZWZpbmVkIiAmJiBwcm9wZXJ0aWVzLmluZGV4T2Yoc2hv cnRoYW5kKSA8IDApCisgICAgICAgICAgICAgICAgICAgIHByb3BlcnRpZXMucHVzaChzaG9ydGhh bmQpOworICAgICAgICAgICAgICAgIAorICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAg IHJldHVybiBwcm9wZXJ0aWVzOworICAgIH0pKCkKK30KKworV2ViSW5zcGVjdG9yLkNTUy5wcm9w ZXJ0aWVzLnN0YXJ0c1dpdGggPSBmdW5jdGlvbiBzdGFydHNXaXRoKHN0cikKK3sKKyAgICByZXR1 cm4gdGhpcy5maWx0ZXIoZnVuY3Rpb24ocHJvcGVydHkpIHsKKyAgICAgICAgcmV0dXJuIHByb3Bl cnR5LmluZGV4T2Yoc3RyKSA9PT0gMDsKKyAgICB9KTsKK307CisKK1dlYkluc3BlY3Rvci5DU1Mu cHJvcGVydGllcy5maXJzdFN0YXJ0c1dpdGggPSBmdW5jdGlvbiBmaXJzdFN0YXJ0c1dpdGgoc3Ry KQoreworICAgIGlmICghc3RyKQorICAgICAgICByZXR1cm4gIiI7CisgICAgCisgICAgZm9yICh2 YXIgaSA9IDA7IGkgPCB0aGlzLmxlbmd0aDsgKytpKQorICAgICAgICBpZiAodGhpc1tpXS5pbmRl eE9mKHN0cikgPT09IDApCisgICAgICAgICAgICByZXR1cm4gdGhpc1tpXTsKKyAgICAKKyAgICBy ZXR1cm4gIiI7Cit9OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1N0 eWxlc1NpZGViYXJQYW5lLmpzIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxlc1Np ZGViYXJQYW5lLmpzCmluZGV4IDM1ZDI1ZDQuLjQwNTVjYjggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv aW5zcGVjdG9yL2Zyb250LWVuZC9TdHlsZXNTaWRlYmFyUGFuZS5qcworKysgYi9XZWJDb3JlL2lu c3BlY3Rvci9mcm9udC1lbmQvU3R5bGVzU2lkZWJhclBhbmUuanMKQEAgLTEzNTQsOCArMTM1NCw2 IEBAIFdlYkluc3BlY3Rvci5TdHlsZVByb3BlcnR5VHJlZUVsZW1lbnQucHJvdG90eXBlID0gewog ICAgIHsKICAgICAgICAgdmFyIGFycm93S2V5UHJlc3NlZCA9IChldmVudC5rZXlJZGVudGlmaWVy ID09PSAiVXAiIHx8IGV2ZW50LmtleUlkZW50aWZpZXIgPT09ICJEb3duIik7CiAgICAgICAgIHZh ciBwYWdlS2V5UHJlc3NlZCA9IChldmVudC5rZXlJZGVudGlmaWVyID09PSAiUGFnZVVwIiB8fCBl dmVudC5rZXlJZGVudGlmaWVyID09PSAiUGFnZURvd24iKTsKLSAgICAgICAgaWYgKCFhcnJvd0tl eVByZXNzZWQgJiYgIXBhZ2VLZXlQcmVzc2VkKQotICAgICAgICAgICAgcmV0dXJuOwogCiAgICAg ICAgIHZhciBzZWxlY3Rpb24gPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CiAgICAgICAgIGlmICgh c2VsZWN0aW9uLnJhbmdlQ291bnQpCkBAIC0xMzcxLDcgKzEzNjksNyBAQCBXZWJJbnNwZWN0b3Iu U3R5bGVQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKICAgICAgICAgdmFyIHJlcGxh Y2VtZW50U3RyaW5nID0gd29yZFN0cmluZzsKIAogICAgICAgICB2YXIgbWF0Y2hlcyA9IC8oLio/ KSgtP1xkKyg/OlwuXGQrKT8pKC4qKS8uZXhlYyh3b3JkU3RyaW5nKTsKLSAgICAgICAgaWYgKG1h dGNoZXMgJiYgbWF0Y2hlcy5sZW5ndGgpIHsKKyAgICAgICAgaWYgKChhcnJvd0tleVByZXNzZWQg fHwgcGFnZUtleVByZXNzZWQpICYmIG1hdGNoZXMgJiYgbWF0Y2hlcy5sZW5ndGgpIHsKICAgICAg ICAgICAgIHZhciBwcmVmaXggPSBtYXRjaGVzWzFdOwogICAgICAgICAgICAgdmFyIG51bWJlciA9 IHBhcnNlRmxvYXQobWF0Y2hlc1syXSk7CiAgICAgICAgICAgICB2YXIgc3VmZml4ID0gbWF0Y2hl c1szXTsKQEAgLTE0MDgsOCArMTQwNiw0NCBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRy ZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgcmVw bGFjZW1lbnRTdHJpbmcgPSBwcmVmaXggKyBudW1iZXIgKyBzdWZmaXg7CisgICAgICAgIH0gZWxz ZSBpZiAoL1tBLVotXS8udGVzdChldmVudC5jaGFyYWN0ZXIpKSB7CisgICAgICAgICAgICBzZXRU aW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgICAgIHZhciBlbGVtZW50ID0gZXZlbnQu dGFyZ2V0OworICAgICAgICAgICAgICAgIHZhciBwcm9wZXJ0eUVsZW1lbnQgPSBlbGVtZW50LnF1 ZXJ5U2VsZWN0b3IoIi53ZWJraXQtY3NzLXByb3BlcnR5Iik7CisgICAgICAgICAgICAgICAgaWYg KCFwcm9wZXJ0eUVsZW1lbnQpIHsKKyAgICAgICAgICAgICAgICAgICAgdmFyIGluZGV4ID0gZWxl bWVudC50ZXh0Q29udGVudC5pbmRleE9mKCc6Jyk7CisgICAgICAgICAgICAgICAgICAgIHZhciBw cm9wZXJ0eTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKGluZGV4IDwgMCkgeworICAgICAgICAg ICAgICAgICAgICAgICAgLy8gVGhpcyBoYXBwZW5zIHRoZW4gd2UgYXJlIGFkZGluZyBhIG5ldyBD U1MgcHJvcGVydHkuCisgICAgICAgICAgICAgICAgICAgICAgICBwcm9wZXJ0eSA9IGVsZW1lbnQu dGV4dENvbnRlbnQ7CisgICAgICAgICAgICAgICAgICAgICAgICBlbGVtZW50LmFwcGVuZENoaWxk KGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKCc6JykpOworICAgICAgICAgICAgICAgICAgICB9IGVs c2UgaWYgKGluZGV4ID4gMCkKKyAgICAgICAgICAgICAgICAgICAgICAgIHByb3BlcnR5ID0gZWxl bWVudC50ZXh0Q29udGVudC5zdWJzdHJpbmcoMCwgaW5kZXgpOworICAgICAgICAgICAgICAgICAg ICAKKyAgICAgICAgICAgICAgICAgICAgaWYgKCFwcm9wZXJ0eSkgCisgICAgICAgICAgICAgICAg ICAgICAgICByZXR1cm47CisgICAgICAgICAgICAgICAgICAgIAorICAgICAgICAgICAgICAgICAg ICAvLyBBIHNwYW4ud2Via2l0LWNzcy1wcm9wZXJ0eSBkb2Vzbid0IHlldCBleGlzdCwgc28gbGV0 cyBjcmVhdGUgb25lLgorICAgICAgICAgICAgICAgICAgICBwcm9wZXJ0eUVsZW1lbnQgPSBkb2N1 bWVudC5jcmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICAgICAgICAgIHByb3BlcnR5 RWxlbWVudC5jbGFzc05hbWUgPSAid2Via2l0LWNzcy1wcm9wZXJ0eSI7CisgICAgICAgICAgICAg ICAgICAgIHByb3BlcnR5RWxlbWVudC50ZXh0Q29udGVudCA9IHByb3BlcnR5OworICAgICAgICAg ICAgICAgICAgICBlbGVtZW50LnRleHRDb250ZW50ID0gZWxlbWVudC50ZXh0Q29udGVudC5yZXBs YWNlKHByb3BlcnR5LCAiIik7CisgICAgICAgICAgICAgICAgICAgIGVsZW1lbnQuaW5zZXJ0QmVm b3JlKHByb3BlcnR5RWxlbWVudCwgZWxlbWVudC5maXJzdENoaWxkKTsKKyAgICAgICAgICAgICAg ICB9CisgICAgICAgICAgICAgICAgCisgICAgICAgICAgICAgICAgdmFyIHByb3BlcnR5ID0gcHJv cGVydHlFbGVtZW50LnRleHRDb250ZW50OworICAgICAgICAgICAgICAgIHZhciBuZXdQcm9wZXJ0 eSA9IFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5maXJzdFN0YXJ0c1dpdGgocHJvcGVydHkp OworICAgICAgICAgICAgICAgIGlmIChuZXdQcm9wZXJ0eSAmJiBuZXdQcm9wZXJ0eSAhPT0gcHJv cGVydHkpCisgICAgICAgICAgICAgICAgICAgIHByb3BlcnR5RWxlbWVudC50ZXh0Q29udGVudCA9 IG5ld1Byb3BlcnR5OworICAgICAgICAgICAgICAgIAorICAgICAgICAgICAgICAgIHZhciBuID0g cHJvcGVydHkubGVuZ3RoIC0gbmV3UHJvcGVydHkubGVuZ3RoOworICAgICAgICAgICAgICAgIGlm IChuIDwgMCkKKyAgICAgICAgICAgICAgICAgICAgcHJvcGVydHlFbGVtZW50LmZpcnN0Q2hpbGQu c2VsZWN0KG4pOworICAgICAgICAgICAgICAgIAorICAgICAgICAgICAgfSwgMCk7CisgICAgICAg ICAgICByZXR1cm47CiAgICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogdGhp cyBzaG91bGQgY3ljbGUgdGhyb3VnaCBrbm93biBrZXl3b3JkcyBmb3IgdGhlIGN1cnJlbnQgcHJv cGVydHkgbmFtZS4KKyAgICAgICAgICAgIC8vIEZJWE1FOiB0aGlzIHNob3VsZCBhbHNvIGN5Y2xl IHRocm91Z2gga25vd24gdmFsdWVzLgogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuaHRtbCBi L1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuaHRtbAppbmRleCA3NGJkZGFm Li4yNDZkMTc3IDEwMDY0NAotLS0gYS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVj dG9yLmh0bWwKKysrIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1s CkBAIC04MCw2ICs4MCw3IEBAIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFz Y3JpcHQiIHNyYz0iUHJvcGVydGllc1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2Ny aXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJFdmVudExpc3RlbmVyc1NpZGViYXJQYW5l LmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJD b2xvci5qcyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNy Yz0iQ1NTLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIg c3JjPSJTdHlsZXNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0 ZXh0L2phdmFzY3JpcHQiIHNyYz0iUGFuZWxFbmFibGVyVmlldy5qcyI+PC9zY3JpcHQ+CiAgICAg PHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iV2VsY29tZVZpZXcuanMiPjwvc2Ny aXB0PgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGllcy5q cyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC91dGlsaXRpZXMuanMKaW5kZXggZjg3YjUz ZC4uZGM0MjdkYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxp dGllcy5qcworKysgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvdXRpbGl0aWVzLmpzCkBA IC0zMjEsNiArMzIxLDI3IEBAIEVsZW1lbnQucHJvdG90eXBlLm9mZnNldFJlbGF0aXZlVG9XaW5k b3cgPSBmdW5jdGlvbih0YXJnZXRXaW5kb3cpCiAgICAgcmV0dXJuIGVsZW1lbnRPZmZzZXQ7CiB9 CiAKK0tleWJvYXJkRXZlbnQucHJvdG90eXBlLl9fZGVmaW5lR2V0dGVyX18oImNoYXJhY3RlciIs IGZ1bmN0aW9uIGdldENoYXJhY3RlcigpCit7CisgICAgdmFyIGNvZGUgPSBwYXJzZUludCh0aGlz LmtleUlkZW50aWZpZXIuc2xpY2UoMiksIDE2KTsKKyAgICByZXR1cm4gU3RyaW5nLmZyb21DaGFy Q29kZShjb2RlKTsKK30pOworCitUZXh0LnByb3RvdHlwZS5zZWxlY3QgPSBmdW5jdGlvbiBzZWxl Y3Qoc3RhcnQsIGVuZCkKK3sKKyAgICBlbmQgPSBlbmQgfHwgdGhpcy50ZXh0Q29udGVudC5sZW5n dGg7CisgICAgaWYgKHN0YXJ0IDwgMCkKKyAgICAgICAgc3RhcnQgPSBlbmQgKyBzdGFydDsKKyAg ICAKKyAgICB2YXIgc2VsZWN0aW9uID0gd2luZG93LmdldFNlbGVjdGlvbigpOworICAgIHNlbGVj dGlvbi5yZW1vdmVBbGxSYW5nZXMoKTsKKyAgICB2YXIgcmFuZ2UgPSBkb2N1bWVudC5jcmVhdGVS YW5nZSgpOworICAgIHJhbmdlLnNldFN0YXJ0KHRoaXMsIHN0YXJ0KTsKKyAgICByYW5nZS5zZXRF bmQodGhpcywgZW5kKTsKKyAgICBzZWxlY3Rpb24uYWRkUmFuZ2UocmFuZ2UpOworICAgIHJldHVy biB0aGlzOworfTsKKwogTm9kZS5wcm90b3R5cGUuaXNXaGl0ZXNwYWNlID0gaXNOb2RlV2hpdGVz cGFjZTsKIE5vZGUucHJvdG90eXBlLmRpc3BsYXlOYW1lID0gbm9kZURpc3BsYXlOYW1lOwogTm9k ZS5wcm90b3R5cGUuaXNBbmNlc3RvciA9IGZ1bmN0aW9uKG5vZGUpCkBAIC02NDEsNiArNjYyLDEy IEBAIEhUTUxUZXh0QXJlYUVsZW1lbnQucHJvdG90eXBlLm1vdmVDdXJzb3JUb0VuZCA9IGZ1bmN0 aW9uKCkKICAgICB0aGlzLnNldFNlbGVjdGlvblJhbmdlKGxlbmd0aCwgbGVuZ3RoKTsKIH0KIAor QXJyYXkuY29udmVydCA9IGZ1bmN0aW9uIGNvbnZlcnQobGlzdCkKK3sKKyAgICAvLyBDb252ZXJ0 IGFycmF5LWxpa2Ugb2JqZWN0IHRvIGFycmF5LgorICAgIHJldHVybiBBcnJheS5wcm90b3R5cGUu c2xpY2UuY2FsbChsaXN0KTsKK30KKwogQXJyYXkucHJvdG90eXBlLnJlbW92ZSA9IGZ1bmN0aW9u KHZhbHVlLCBvbmx5Rmlyc3QpCiB7CiAgICAgaWYgKG9ubHlGaXJzdCkgewo= 58907 2010-06-16 11:12:45 -0700 2010-06-16 11:12:45 -0700 Input fields: two vs one 2-fields-vs-1-field.png image/png 8218 me iVBORw0KGgoAAAANSUhEUgAAAZAAAADICAIAAABJdyC1AAAf4UlEQVR42uybsU4jMRgG8/5vcBVV Oio6Kqp0VHRUVOnQFekQxd7ovuNnZS/riAMpK2aKaNfrJGv7y9hxYDeJiGwEhSUiCktERGGJiMIS EVFYIiIKS0QUloiIwhIRUVgiorBERBSWiIjCEhGFJSKyNWHdLPH4+Mill5cXjp+enlLz/v6e0/kT n5+f6/R0Ot3e3v76y36/p/I0gne5mXE4HOaXclpwWjXrresSDFtHnePx2FSghNvOPVNhko4afboo 43t3d8dwTzMYjopKDQqDuJK0M2PZD3fy2bx1n6K6xON69ggArSPtk1y+sI5vJIg5rjiSUQpzfH19 TZ0Mf+rXGHNwdXWVVyC1hIBjojP8DFCtbqCC1csxMeUGqvI8XisfgNzSw8MDL5j7b0xKYV42dSZZ gj6k66IkjuP3GoLKAxmoQio3/VkBC9MqVbkf7gxi89YMX5+iXOLxo+zRHA4IalpE7Ce5cGE1OeiT ykBGSVRIMjJ/8jlvhp+sNCUkYCispnBFWLAyG5/TKObSuqtqlJ5ah2HtHbFYAvTwirAo+WQa+0tj K42F1bSRtE+yaWExBcVEHDB/IqkkkgMqN8ufPuXY7aKEVbPxfIWls9ahu5KBZmVKn/cKy7JlW8Kq FJHwSTYtrKxBiCxLKlTFFJSVcxK8qoxxQBOaYiisqsnx54TVl9DAvDKfQL8RnD+v3EAnrOwh5Ivh orDCMBh95aGwCk4/I6wqkU0LC7Kq4hFtsVWZaoRyXRmRGjXP38P6vhXWcN1HCS1ygm3ovt2PhVWb of+5wmp3VL9/hUXIDcDmhZXtKgYyS6poiFNGt9+Une+MorZk5aK+EvZ7bQs3LEvbAvRPs+5m0Hth JTAJyYa+EtKif6mWrQsrea3Jh4PEt9+xwhr5QSdLsOxqXYKwksjsxcxDiX9pSCbw3LO/bS/CUNI5 dCD9wxDX78WLwqJO/gBiK8KiIe8tkq0Li/xFRs0Pbf0KJS6D2hL6WmF1+xrjS1UY5zL59z/G11W3 3nuaj3T1FcPdq6E57YVVxCNfKKw5w0uVvXlcXVz/uL90z/QLG5qpcs+G9RyOb7gOFf81R0QUloiI whIRUVgiorBERBSWiIjCEhGFJSKisEREFJaIKCwREYUlIqKwRERhiYgoLBERhSUiCktERGGJiCgs EVFYIiIKS0REYYmIwhIRUVgiIgpLRBSW/GB2u9131s9TwNwqrMvi9fQbTq+TKKx3VNU0Kaw/7J39 cxNHmseff+R+SFVCqrKHfkktl7q9XaL8cuc6EmWrFtgtBLkQELkrZ9fER7KispAovETWEqxdbCbB oDocBRN5Y2RiFMDKcuJNxB47EXG08QtRAgIsGyWMMIoZ5+a+mkZao4lsydjIIs+npkTPMz0zDTN8 1N3q6SkOJeImk1vRSiAdkcQupZGO2k2kY5EVjak4YZHO5GChiAjmbWJhMbMkLCrNPoosdinVVx4i W4RVVWnkqcooI2OEhcXMrbDSelotUj0GxxV9oppBbg1WHjPXU24TNwmZWWwSOsNByUTA5JETupMG 3VYT6dh9kWzWqFRjIYFZUtSY02x2hxO5GlSN2RpMqIU9J5vJFEpqDAuL+9qZGQtLogw14Vg8JFmJ bFFV8VjwpyeeVpODATORIxjX1EE7ZYKDSWUwYBd9WNFMPntcyzDotZJJQrAgyRAU6I9xFes+F5ax Y4s73ZnZbRJaZUVUkiAvczghQ1LebONNdpqoJqBnsw3mNQnVqA1RP5QVryFyhpOFTuK1mQjYgxpT gZCguE53JFhYzJw2CSXl7yayRr/JCMuXrQpF3GY4KYoKlNmT1iOJoKhhZYj5bQSf+R1EjsQUZ0km IsHMwbnTncdDsLCYu6xhOeOwVUK2E5kcIRjJSWR2BjN6SspWgq9i+i+DllBcSUS8BMxwnCCGvYA9 ENemRo1a4EFuErKtWFjMXfZhCSwOX1JEE2FbLugMpDUQl6wiYJWkGiEsQTxQA6dN+/NfetCLbPwr IcO978xdjnRX1XQ6rf7QqHQlPTmESNrQly6ZyeKJFjd6yxqKJRWFR7ozDHNPHs35P53vwVjf9jVr nlxItHDbl+MZvpuaGxferl5MGZacHfludhnXUXUmJia+1xFF1RiG+TELS+hg4rsr0m5pHi63bt3K OYuFVV5aGKalJff/sQzCEidGRQY1GthBgxDm04IioXUraluiqBpTVmGJxK6//VgWxngPjI2N4X8l ahLlERZ8CSPcvHlTCAt09JVnMYIiKYqCsqGEKCcLi4XFwir7PTA8PIz+8Bs3bpRBWLAATAlfwgtz LCy1rUedgbBGR0dRNmF0lJZbhfefsIjo3tiHiFhYd38PRKPRWCyWSCTKICw0tdDJDVleu3ZtToXV tNNKZG7oKVlYly5dQtlQQpRzJsJKp+LxlMZwDYuFNUv3QCgU+uSTT+Cs8ggLlZfr169fvXp1ToXV flJeXxduK72GNTQ0hLKhhCgnSltqq1CRO4g6+Bnt2RUW6eQpgLKIoDFhzJO3Vawag4aIYTEcudAx jacrdC4WVqF74NChQ3AW6lllEBaqLWhwoVGKisz87MPCvwvKhjYzerJmIKx05CjR0bTGzLKwciIw CqKQjIpMg0LxaatO05Znir1YWEXeA++8887Ro0dRySqPsFKpFISFCl5WWOlNa23r6jyPEZnt/o3V ZiLLm2chFLVhl9NEGUyLrBsOKx196Y2rbOsPyBtWmQk84WnVvdN6OPD0okzGBxaYl+2MdvREly0y mZ4wm9f6RAYsbQGfeZXXvd/zAGVYtz9WSFiRSARlQ08WWoXoxsoKayLi7zCTi8hlNnu80Zvp6CmL 7ZSib8umJ2LRWNDbQtQSlGNyuD8au5nZGjtv03cketsb+VbLEnZbiGwRdtvsCcsoiBmnxTKnwuIm YZH3wN69ez/44ANZlssprAsXLmSFpVQvIshqw05nRjq1XusCWn0gKdXZENzoi7WejS4jWu1LdvQp 1U8QMG8NS2/ZiZwHYaLjfkSqtoYO9iQda7G7DNO9ezKhZ3DnhNXaJlEG27ZA/M2tVmw6WEBYPT09 KNvIyAjKmRNW1NtM1OCTE0ryop1cTjmlyJmalBBWNj0ecLZYLfXIaatpqbE1O/1XNGXIQi6bpz+t TgwGDhHVBxMTmo4s2chkj7KwWFgsrCnvgT179rS3t3d1dZVTWOgqmiysqrcS7QEPUc27fep6CMvX D6ks25fQdZOuRkQXFnKaakOZ4Mexbfuj7X1ag91ES3ztiCC92Qxh3a5StbkNwkLFbdKmAsLq7u5G 2fCTBMqJwQ26sL51kMseFJWjccmkCyvyd2GlJ6XVKNKdwkJZl3kGNcFNN7lqAtc0ZvaEZWzTzXpT 0bgYj2yM5AW5SXj/CGvdAlrXprYfdtMCqV3oqfmYiai6TdF1E8vWsEROERRLesMTZNocEavbVlFO WK35wsocvFWkSxWW0o/GoBRB+w4k7JQVlumoIkLB1lxakRHvVO4QVkssKyzIzuZPaMzdCcsoi2n7 s42CmLmwjEcufC7udL8/hbW6LQ1hwSNtQlgtchVRVZ3c1hNfv4SALi/kFObScovbbqZFbk9PumFn DRHkNVlYzuaI2h7RV31CUiJdorDUKzY067xD6fQ1j9VFurz0XwM9keREQj6BCJlvSwoiQ1xOTqAu lkjc1JKfmyC4YEZSST2nP4ZNGQb9TqvNGeEfFO/JsAZhhHm7sLAqSVjrF2WE1RGQUAlq61OxCis1 73OSTtVmX/UyemxzRDQJ84TVcTZcRTpLnNWrTKZa+c5OK+wo315dIIQl0iUIC/F4EHpyYbFJYcnm skgxWMxpRgRLs9fTmhUWSHlt9SKz2T2kz7WT8ZRYnIEr2m1Ufw0BZ5iNNYfCIsG8txX3YVWQsAqP pfo4efDjaUart55MwnFtPUinNy6hB+wygkUtpQgLqEoqqUzkjdtPJlOq9gOkM5nHtRzqOHIq+f3r MSjLyS9Z5EdzuNO9UoVV+uKuNRGZn15rf4yApe6kNvvCmhPSXiuR1cP1q2mExfzo74H7SlgdkaR0 ILhpp8+xX363B5HKEBZIxOI8pIGFxVTAOCzoICesebUYhcUTNvB8WEx5Kf9IdwzLFANH59tiHDjK wppTent78YT5FHN7YC4k1MfxvBSeJsMzZV6vd9++fXsKoxEVjIj0HEBZ9jCzCq41rng5nyVEnQWP vODBFzz+godgUA60TmFQSZLq6+vr6uq2zw5bHK9vKSYfzojz4uwoA0qC8kx+NIeFNde88soruAr9 /f0/+O+MIB5Bx3OduCL4gsXVwTctWgfthYGSCkTmCiK6I83MHrjWuOLlnK1BTN2HWxAPGEOZ586d O378+Pvvvw9fQKi7d+9uKIL6Tb+mxb/acWdw4xrTQ6teFulXX/gp/fNDG+sbpgVnbGpqwtlRBpQE 5Sn+4edYqFN/urDe4YtpzEyFJdixYwfuSKOwoBt8c+ATCy7Np59+Kssy0rmlW6f4CBK5VWPQuBcg gNUCYFNettwnyMsDyHhkpgC41rjiufmwyjy9DLqKUJrTp0/DFLBpa2sr2qveImhyrqTHVzbdGdxS /cg/PL9FpPe/tcW24TWPd3pwRpwXZ0cZUBKUp8jpZZJyJ5GrxjcUDekJHr9+d8ISNDY2Tr4vM5OR EQln4SsEicuXL+PzYhaRniZSOI2lmL0IYLUA2GT8BLmtxmz5R2YKgKoDrnhuxtEyT+CH0gwMDMAR qNeg1hcMBo8dOxYoAv+e5+lfn//LncHGl00P1P45UCI4I86Ls6MMKAnKU+QEfmFHPVlOpJFS+i3k IuspHk9198LaunXrmTNn8oSVm6U2V9tKZRHpKSIlpI2R4iCdXDr7KTCkmRLBFc/N6V7mKZLRTwQ7 fH5i55N2V8s7f3jol0RPP7jp4LGuDGcPSC88aiGy0KPWqtcPnegCIZ/9xV+QHiSrHSFw4pD7N9YH RfAXW5q7Tvv+w/rgo6sfrXr5DWQQnDr8RtWLrzc3b3pQz1bb3C7ivib74qeJfkk/febfXZ2ZHwdR njPSKqJ/CQylppgiWTwVaPVewV/IZ3OJR3PEiKrhkJOIPFGedLQ0YTkcDnxzoBmu5UGUe9MS0qqq ik/BtJES0sZIcRBRXhqfBbcypZN7a06ZX0IBZ6EuM3i6jn5DtHz1+2fPtjRYaOnyD6MDHzYtp6X/ 9KcjJ3p7Ply3lDYc6R6IdiJBG97o7OntbFlHK1/pHRj47JRES2m59G73Z917X3344bpDAwPRcFf4 Q2RYigy36T3mQDYcef//nvJJFmzqHhg4kcnzsNP/UeSzv764nDZ+9BlagihP74EXiX4dvDg25Uso Um5yuaMTSvgQ7OTz47NBVnRhnd1NtNDHs8YULaxNmzYdPny4YIWfKD+dixAVH8mtFn/kIl8rTXfm NEbyNvELq2dMmV/zhXoWbtNLspNWLg1+NYqRBF93uWjFz45c6HtpBf32SN9whq/qnqM/hL4YOrOF Vqw8J0KZ9Jah4eG/So/Qy01xhJDe+7NH/nx8+M4MgqEzdbTi344MTt40hMP+6r1z6DEZGbn4xzW0 +cwF9FuhPMW95ivlNLncwfM15LKHUmq0E8IKc5uwdPBbxzfffKMVRrjD6J1S5ZUXNMaNexWvFcqS twp+UGosrMp7kapoG0INicgf6T//dOVGhpGeOnpmeffXH/38GarvuZzK0Ff7DDk+/rr7L8vpt7tH 9NCFj2ppXd3l1Mjel+jnzeGUzgdO+slbJ0X6cuY4yACyq+vqL0/eNNq9HKc4P6I3kgdwii1yXKiq uBep3vRY9JZgTbeqaUq4g6hlkN+gPxcQVdx5S3IQC6syXlWf01ay701avS1265ZyNfzSs/SPUnB8 7PPnnqXn/OHrypd7NhM9S7vOj4727qBnnwxeHL10/n8QofW7RsfHw82Laf2OfuW6fOQFBBcfCI/r jJ5H5q1fjoFxoO+7A/knpa/u+C9a3By8PnbpwA6i1dTwaVK0lq90Nf/u9w1fjE39qnoxB6lLH89w zQFzOT4X8dSA3/aUzcezxlSmsAy1uRkKi21V8cIymkvwbbSRniOxPPX2wVFdZBfPbBeRte8dbNxO T733CWKNr4lsKxrf+x3VNn77/ffjI2dWiH1fe7Vx18LHvV3Cg9ljYkdE9NXqncg/OX31/F6RZ4Vn 7++rafv5UVGl6t65mIg8U3RCGaaRIXNHTNUEX+mzxjzuPKsxDFPpwjKifOGmNc6EqqnqHXH1BoZe qPmZrycNIkknrytayaiJawo+0yo+orY15O5TslvwbHZKK45EPBGLXcsrUsBGC52yxjDMfSisPgeE dc9bUEnnGqL/ttkbbZRJuBPa7DCgzxoj86gGhrkvhaXeiEcuxFXtXqNej8vhgO+4P9Q3mNZmjfRw fJiHNDDMPYQ7Apm7hUcbMSwsZt7Bv98zFSUsNTP7h6LwGCSGhcXMe2Epspt0rO4QS4thYTEV0CSM B+1ETh4rybCwmAoQliI7idwsLIZ735kKEFZEMpPNz01ChmtYTIUIqybAwmJYWEwlDGtIR8yUweaJ aAzDwmLms7Bi/8/eGbzGjWRx+P0rc8lRx7BX7W1goOfkU7OH0NFcYpAZXzTk1GF2kQ8zFkyyCpgV mUnHGDWYNkwa1jSB3oE0JjJEYISXjlEggkSJtbhiIm8qG+2TCnccrzOO21ljx78PgUuvS3o+fbwq PXV3LNKswTDJ0N8AICxwyoUV2BrhdV+AvXZwJoSV9Zt4SggAOAOd7kKI0DfRhwUAOCud7prdiQoA AMDLzwAAAGEBACAsAACAsAAAAMICAEBYAAAAYQEAAIQFAICwAAAAwgIAFBAWAABAWAAAAGEBACAs AACAsAAA4HMWlhRZluF74wEA4wlLhA5pjjjaL+y46pKjkUeWRhW1QBQAADCWsOho9hGBuuSovvKI jBCqAgAcU1h5NZYfqZ4jO26UyBxiNQgAON6S0B70XI0YzQvSyklDp65RheWHu1Mj16yRQneFjG1d dwbpqIIy9XovlR/2XKCT1scPXQAAjiEsl0rMQZz03TqREUnh1fivl+QyG3Z1omYvKeTQojI4zMSw a6k9rKicZyVFybBVJ80Vv/tTYhpRJ0aJBQA41pKwHghVJLlE+iANdKLWUL77jVWzW00zhvuWhDIy ONphZSUmkT3IPpSkZWjEWL0CAACOtyR0xTsT1aN/lcLyd0uh0NHZSREXULqXV5G0pyqskrhjEPus 0yRqpr+TJUvDXnlzbLoDAI5ZYdkJ2yoNLCKt2Wcj2US63Sv1lAV1Yl/F1ZPBWj8RadgiRh+t/mKL SqxuckgmGdWIfCwJAQDH3MNS1Jp+pqLpwBgF7W5eMIlbV4G665pKWIqkaxIZhz7+y4ctnoanhACA Y3a6S5nnuTyoK13ke0McyYt9ZK5ONS/6uO6tej/OhECnOwDghF/NySPbMGoakWYnH2XFxDP1E+h0 f1vxn4o3b97Iin9X7Hxq1G1lBedSSd9WFACAUyQsmfb8VqcXZMXpYq+t3L+6J3a8fv165CwICwB8 W8NHoZShqir2SPG2OIGDE+V5rqot9Q8UAAAI61BUbcXuePXqlRIW8+vapzz+F04khOCMnJezQ1gA nCthyXxHFmPBvuDVGdc7bJCTFNaLFy84I+dVa0OsCgE4L8IaLtepoYc7Y6lOSt4O397e3tzcHEtY +Z17yeLRhfXkyRPOyHk5O4QFwDkSltwMvLuDfLxrqyaNra2tp0+fjiOslQERzawcWViPHj3ijJyX s0spsSoEAHtYh8MFjhDi2bNnXPKMI6ww1Eh3Vo8srCiKOGOWZbyTBWEBcDqFlXduGM5dr9ag+nzH n9OpURtscVyG92y9QdQgfbre2hA80581vIdBa1Ynjl/1OMSIja45rXFEm9St5ajYiaxpTb+q12/4 YpTjsV+fbQWBp1U3dIK4UMjIJNKbPfm+sF6+fMnCiuN4r7CW/hFemtCJuaDpl/32mvhuoja1KEoH 7Y7by5HzN+8L0qZ+Dq77A2cxWao+/bNlUIV22b/zAWGFYcgZeSeLV4W8jQVhAXAKhSXcaZaI3lq2 S+ncajUnyX6YRXcNDvprsdiKrAbZa1k58yoRe60ziH6zqGFzKE86HDE6/Wwn697gywOWULqZVhMc Mcqx7lKpKqP3OBl06vxRVlTIoaVR3ekfKKyNjY13wloNvyT64rLv3RdzNy0iZ2FNfHOBLvmZEpYa z/3kfPlVjYj0CfPrPxlff9vlzazr33PE/OGeWFqJLl0gutI7UFirq6uc8fnz55wdwgLg9ArL+C2V jz1qmGkhvUnW0z+bDbIGqSqP3DKSqZn6rX7BbMe9IGLLhPMaXfOVbsK2XgqrIl939glLFW77Pxpx kLB4U2kkrDs/W0TNO9WCbnHRIXLa7wvryrtxtSQMy5kjl/1hZqhO275NZCUHCevBgwecMU1Tzs7N DRAWAKdRWM4kOetSbjg06Uqlp+DveoPcdWWVWFVYuzNVUJG3rpLeDtVJb5ZGwhL7hVXeXKjxWMJy LJ0uuurZ3y83TbqghEXf+GpJmEzQrrBWA7WHtVdY+o9xNVayM2MJYQFwZoVlr+dyo/RIroQVBkaD jLtBvpN414iUvNRMNtcegnmdpp14Jw+XTWqwvPYKy04kU52uKUntGzNpq2m5veGhwpr70SAynPv5 L/MeMRc9JSz9+3ApTKYmiLnii11h0ZSf8njhXsp7WD98q9EF2ysVlk59RTTRkaiwADijwvKmS2EV j10ugvJC8ilbKRnYLCA+jLbv2lRrh2pJuE9YxdbAqKbRNdud1fRbwfubVnxhoE5pUklqNFYnA42I aq38MGH9GsaXLlKF8d1PLlGdayjvpq1CuuVNlNVWpsqo6zMmKS667TKSlkZT/NGeWy0KCAuAz6yt QW5n2bY8xHabWV42tfMw96+RNh8c2ZdpKuThS8LKRHLhfrb0foPC0kq2sCLL8b74qli4L/ZOXlzJ OFKNISwAzmUfVnBLo4Zu3rBqZT1V628WY3K4sD7NAWEBcI4bR2UWPex1lv1uEKRlnQVhAQBhnSeU sFgcI2H9/w8ICwAI6xjC4gZO1Th6MgcaRwHA18uMA1c3/HIMvyITx3EYhv1+f2lp6fbt267rzs7O zszM/OVTwPfhu/E9+c58f86CV3MA+DyFlY9aE/YQtv/b3v29tlXGcRz//jHqhWBuvNmVrl4pE8rA GyVeFSMI66oMXGA/sC10QXHtoG1YC3HMrsNknUVY5kpFYwspNXQtC2lNFgtydD3QIz3NONZDPX5z DoGSlm2hZfTU94sQDiH9Pr368Dwnz/k+7bqtYf/tZYLWfZZl6aPIpVJpbm5uampqYmJCk2VkZGR4 eHiwofvjUy/KSZF3TnR0D7ZI64yOjmpNraz1dRQefgaOYGDt3PzZtIlUd7ofbHsZvam0uLg4Ozur maLzoEwmc/PmzTHf1d64yLtvdl7+/Lx/8cnwWCu0jlbTmlpZ6+sotJcBjuoMa4/AWgoCq8n+Gvjp lKdcLmua6AxIV23T09P37t3L+i6//6EcS0zq1a3RY9Ihb3xxK9sCraPVtKZW1vo6Cg38gBAEllMd q/d+ySf93i+RVNH01O72MqpWSva3i/+hnEk2tZfRV/t4oaX2MqWZZPvOIXwPrutHr2Ufbtq2rXeU NEd07rO8vKz3mBYWFvS3vPm6n+MvdL7Vk52fz1862SnSKa8OTs/XfX/1lIhcSP80/0RaR6tpTa2s 9XUUWiQDIQisxmM0XXnDyGWi2gSm5Hp7tJdxK3ohiVRlw67MxP17WE3tZSIttZdZ1e9oPhYqdq3S HQzhW7l9VuS96d8f670kTRCd9ehKTQNF74hXq1UNl3Ld/XPy6bm7ywvpYZFLV5L6fvHbhbLKf/OZ yEtX7j4oP5HW0WpaUytrfR2FQyiAUASWru+ihVow20pqTuVr5u72Mv7XYpWdS8J9tZextWx0qrJz iN3HfDmOo2s0va9kWZbOgHTPgWmaa3XV8y9f7M38GJOLnZNVYyatsXXn4dqz0zpaTWtqZa2vo3DM FxCSwGr0fnH88CpZ+d3tZUp3onIm5Xh1Zt6fYe2nvczfpagOUQ3qGcEQuw9S1dVZEFs696n5NlWd OXyiV6RXPsr9tbn5xw8Zka8W9aoVNZ9WDqKKg1SBsMywEoam1XpBgyMymtPV3+72Mv4vg+25Ndtc GWvcw9pPexlLm9W0jecc10z3+0MUbc/36JevT58dWnm83XRa/T++rYbFaymRvhu/6uWfF6RPLtzf 8q0XMx1vd9woPNp6mqDgznPqOaoeCMc9rODVPpq2vLq92ssYyZ7ga9FkpisILHc9Hw3+tqc7ORRp G2+hvYxZTAXfiV5LxXcsCQv9x0UkVXL+bdje28b1D74USdRfx7+rbm0Hfrt9WkRe75vdboWOQk4B oZlhma7nuk9vL2NvWI7XxLE2bK9lrrlu67vj6ltJJ3QDxUYRV5983vSejWmYq6vrTf9SNiavJAoe gCMYWMVu/0SJ58xK1NeVsfhQTOoXA6Z3MMpjUZFoYdMDcAQDy60ZS1XD9Z43d8Mo5LPpqclcseJ4 B8ZZM9YcDwA73QGAwALwvwgs17Esy7ZdDwAOeWDZhQHx6fnJhBaAECwJjem4SMLyAODQB5ZdSIgM EFgAQhBYS8k2iU2yJAQQksDqyhJYAMKwrcFZapO6WGrJA4DDHFirk3GJxPMVw2J/A4BDHliFRER4 3BdAKALLynXzKyGAEOx0t217Kd3FPiwAYdnpHklMljwA4OFnACCwABBYAEBgAQCBBYDAAgACCwAI LAAEFgAQWAA8AgsACCwAILAAEFgAQGABAIEFgMACAAILAAgsAAQWABBYANCy/wAQdIcoAUXYogAA AABJRU5ErkJggg== 59141 2010-06-18 11:30:29 -0700 2010-06-18 16:10:24 -0700 Autocomplete CSS properties and cycle through them using arrow keys css_properties_autocomplete.patch text/plain 10940 me ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZjI4OTM0Yi4uMmQzMGVjNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAxMC0wNi0xOCAgTmlraXRhIFZhc2ls eWV2ICA8bWVAZWx2MXMucnU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgSW5zcGVjdG9yIHNob3VsZCBzdXBwb3J0IHRhYiBjb21wbGV0aW9uIHdoaWxl IGVkaXRpbmcgQ1NTCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNzM3NAorICAgICAgICAKKyAgICAgICAgQWRkZWQgYXV0b2NvbXBsZXRpb24gZm9yIENT UyBwcm9wZXJ0aWVzLiBBIHN1Z2dlc3Rpb24gZm9yIGEgcHJvcGVydHkgc2hvd3Mgd2hlbiB5b3Ug dHlwZS4KKyAgICAgICAgWW91IGNhbiBhbHNvIGN5Y2xlIHRocm91Z2gga25vd24gcHJvcGVydHkg bmFtZXMgdXNpbmcgYXJyb3cga2V5cy4KKworICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQv Q1NTLmpzOiBBZGRlZC4KKyAgICAgICAgKFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcyk6Cisg ICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMuc3RhcnRzV2l0aCk6CisgICAgICAg IChXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMuZmlyc3RTdGFydHNXaXRoKToKKyAgICAgICAg KFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5fY2xvc2VzdCk6CisgICAgICAgIChXZWJJbnNw ZWN0b3IuQ1NTLnByb3BlcnRpZXMubmV4dCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTLnBy b3BlcnRpZXMucHJldmlvdXMpOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvU3R5bGVz U2lkZWJhclBhbmUuanM6CisgICAgICAgIChXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVF bGVtZW50LnByb3RvdHlwZSk6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0 b3IuaHRtbDoKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGllcy5qczoKKyAg ICAgICAgKFRleHQucHJvdG90eXBlLnNlbGVjdCk6CisgICAgICAgICgpOgorCiAyMDEwLTA2LTE3 ICBTdGVwaGVuIFdoaXRlICA8c2Vub3JibGFuY29AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IERhdmlkIExldmluLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJv bnQtZW5kL0NTUy5qcyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9DU1MuanMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmI5NWJlYwotLS0gL2Rldi9udWxsCisrKyBi L1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9DU1MuanMKQEAgLTAsMCArMSw2NiBAQAorV2Vi SW5zcGVjdG9yLkNTUyA9IHsKKyAgICBwcm9wZXJ0aWVzOiAoZnVuY3Rpb24gYnVpbGRDU1NQcm9w ZXJ0aWVzKCkgeworICAgICAgICB2YXIgcHJvcGVydGllcyA9IEFycmF5LmNvbnZlcnQoZG9jdW1l bnQuZGVmYXVsdFZpZXcuZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5kb2N1bWVudEVsZW1lbnQs ICIiKSk7CisgICAgICAgIHZhciBsZW5ndGggPSBwcm9wZXJ0aWVzLmxlbmd0aDsKKyAgICAgICAg Ly8gQWRkIHNob3J0aGFuZHMgdG8gdGhlIGVuZCBvZiB0aGUgcHJvcGVydGllcyBsaXN0LgorICAg ICAgICBmb3IgKHZhciBpID0gMDsgaSA8IGxlbmd0aDsgKytpKSB7CisgICAgICAgICAgICB2YXIg cHJvcGVydHlXb3JkcyA9IHByb3BlcnRpZXNbaV0uc3BsaXQoIi0iKTsKKyAgICAgICAgICAgIHZh ciBqID0gcHJvcGVydHlXb3Jkcy5sZW5ndGg7CisgICAgICAgICAgICB3aGlsZSAoLS1qKSB7Cisg ICAgICAgICAgICAgICAgdmFyIHNob3J0aGFuZCA9IHByb3BlcnR5V29yZHMuc2xpY2UoMCwgaiku am9pbigiLSIpOworICAgICAgICAgICAgICAgIGlmICh0eXBlb2YgZG9jdW1lbnQuZG9jdW1lbnRF bGVtZW50LnN0eWxlW3Nob3J0aGFuZF0gIT09ICJ1bmRlZmluZWQiICYmIHByb3BlcnRpZXMuaW5k ZXhPZihzaG9ydGhhbmQpIDwgMCkKKyAgICAgICAgICAgICAgICAgICAgcHJvcGVydGllcy5wdXNo KHNob3J0aGFuZCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIHBy b3BlcnRpZXM7CisgICAgfSkoKQorfQorCitXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMuc3Rh cnRzV2l0aCA9IGZ1bmN0aW9uIHN0YXJ0c1dpdGgocHJlZml4KQoreworICAgIHJldHVybiB0aGlz LmZpbHRlcihmdW5jdGlvbihwcm9wZXJ0eSkgeworICAgICAgICByZXR1cm4gcHJvcGVydHkuaW5k ZXhPZihwcmVmaXgpID09PSAwOworICAgIH0pOworfQorCitXZWJJbnNwZWN0b3IuQ1NTLnByb3Bl cnRpZXMuZmlyc3RTdGFydHNXaXRoID0gZnVuY3Rpb24gZmlyc3RTdGFydHNXaXRoKHByZWZpeCkK K3sKKyAgICBpZiAoIXByZWZpeCkKKyAgICAgICAgcmV0dXJuICIiOworCisgICAgZm9yICh2YXIg aSA9IDA7IGkgPCB0aGlzLmxlbmd0aDsgKytpKQorICAgICAgICBpZiAodGhpc1tpXS5pbmRleE9m KHByZWZpeCkgPT09IDApCisgICAgICAgICAgICByZXR1cm4gdGhpc1tpXTsKKworICAgIHJldHVy biAiIjsKK30KKworV2ViSW5zcGVjdG9yLkNTUy5wcm9wZXJ0aWVzLl9jbG9zZXN0ID0gZnVuY3Rp b24gX2Nsb3Nlc3Qoc3RyLCBwcmVmaXgsIHNoaWZ0KQoreworICAgIGlmICghc3RyKQorICAgICAg ICByZXR1cm4gIiI7CisKKyAgICB2YXIgaW5kZXggPSB0aGlzLmluZGV4T2Yoc3RyKTsKKyAgICBp ZiAoaW5kZXggPT09IC0xKQorICAgICAgICByZXR1cm4gIiI7CisKKyAgICBpbmRleCA9IChpbmRl eCArIHRoaXMubGVuZ3RoICsgc2hpZnQpICUgdGhpcy5sZW5ndGg7CisKKyAgICBpZiAoIXByZWZp eCkKKyAgICAgICAgcmV0dXJuIHRoaXNbaW5kZXhdOworCisgICAgdmFyIHByb3BlcnRpZXNXaXRo UHJlZml4ID0gdGhpcy5zdGFydHNXaXRoKHByZWZpeCk7CisgICAgdmFyIGogPSBwcm9wZXJ0aWVz V2l0aFByZWZpeC5pbmRleE9mKHN0cik7CisgICAgaiA9IChqICsgcHJvcGVydGllc1dpdGhQcmVm aXgubGVuZ3RoICsgc2hpZnQpICUgcHJvcGVydGllc1dpdGhQcmVmaXgubGVuZ3RoOworICAgIHJl dHVybiBwcm9wZXJ0aWVzV2l0aFByZWZpeFtqXTsKK30KKworV2ViSW5zcGVjdG9yLkNTUy5wcm9w ZXJ0aWVzLm5leHQgPSBmdW5jdGlvbiBuZXh0KHN0ciwgcHJlZml4KQoreworICAgIHJldHVybiBX ZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMuX2Nsb3Nlc3Qoc3RyLCBwcmVmaXgsIDEpOworfQor CitXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMucHJldmlvdXMgPSBmdW5jdGlvbiBwcmV2aW91 cyhzdHIsIHByZWZpeCkKK3sKKyAgICByZXR1cm4gV2ViSW5zcGVjdG9yLkNTUy5wcm9wZXJ0aWVz Ll9jbG9zZXN0KHN0ciwgcHJlZml4LCAtMSk7Cit9ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmls ZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxlc1NpZGViYXJQ YW5lLmpzIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxlc1NpZGViYXJQYW5lLmpz CmluZGV4IDE4YjdmMGYuLmI5NTQ2YmEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9TdHlsZXNTaWRlYmFyUGFuZS5qcworKysgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9u dC1lbmQvU3R5bGVzU2lkZWJhclBhbmUuanMKQEAgLTEzMTUsNiArMTMxNSwxOCBAQCBXZWJJbnNw ZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKICAgICAgICAgZXZl bnQuc3RvcFByb3BhZ2F0aW9uKCk7CiAgICAgfSwKIAorICAgIHJlc3RvcmVOYW1lRWxlbWVudDog ZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgLy8gUmVzdG9yZSA8c3BhbiBjbGFzcz0id2Via2l0 LWNzcy1wcm9wZXJ0eSI+IGlmIGl0IGRvZXNuJ3QgeWV0IGV4aXN0IG9yIHdhcyBhY3RpZGVudGFs bHkgZGVsZXRlZC4KKyAgICAgICAgaWYgKHRoaXMubmFtZUVsZW1lbnQgPT09IHRoaXMubGlzdEl0 ZW1FbGVtZW50LnF1ZXJ5U2VsZWN0b3IoIi53ZWJraXQtY3NzLXByb3BlcnR5IikpCisgICAgICAg ICAgICByZXR1cm47CisKKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0 ZUVsZW1lbnQoInNwYW4iKTsKKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5jbGFzc05hbWUgPSAi d2Via2l0LWNzcy1wcm9wZXJ0eSI7CisgICAgICAgIHRoaXMubmFtZUVsZW1lbnQudGV4dENvbnRl bnQgPSAiIjsKKyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuaW5zZXJ0QmVmb3JlKHRoaXMu bmFtZUVsZW1lbnQsIHRoaXMubGlzdEl0ZW1FbGVtZW50LmZpcnN0Q2hpbGQpOworICAgIH0sCisK ICAgICBzdGFydEVkaXRpbmc6IGZ1bmN0aW9uKHNlbGVjdEVsZW1lbnQpCiAgICAgewogICAgICAg ICAvLyBGSVhNRTogd2UgZG9uJ3QgYWxsb3cgZWRpdGluZyBvZiBsb25naGFuZCBwcm9wZXJ0aWVz IHVuZGVyIGEgc2hvcnRoYW5kIHJpZ2h0IG5vdy4KQEAgLTEzMzMsMTEgKzEzNDUsNDEgQEAgV2Vi SW5zcGVjdG9yLlN0eWxlUHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUgPSB7CiAgICAgICAg ICAgICBzZWxlY3RFbGVtZW50ID0gdGhpcy5saXN0SXRlbUVsZW1lbnQ7CiAKICAgICAgICAgdGhp cy5saXN0SXRlbUVsZW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigia2V5ZG93biIsIGNvbnRleHQua2V5 RG93bkxpc3RlbmVyLCBmYWxzZSk7CisgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LmFkZEV2 ZW50TGlzdGVuZXIoImtleXByZXNzIiwgdGhpcy5lZGl0aW5nS2V5UHJlc3MuYmluZCh0aGlzKSwg ZmFsc2UpOwogCiAgICAgICAgIFdlYkluc3BlY3Rvci5zdGFydEVkaXRpbmcodGhpcy5saXN0SXRl bUVsZW1lbnQsIHRoaXMuZWRpdGluZ0NvbW1pdHRlZC5iaW5kKHRoaXMpLCB0aGlzLmVkaXRpbmdD YW5jZWxsZWQuYmluZCh0aGlzKSwgY29udGV4dCk7CiAgICAgICAgIHdpbmRvdy5nZXRTZWxlY3Rp b24oKS5zZXRCYXNlQW5kRXh0ZW50KHNlbGVjdEVsZW1lbnQsIDAsIHNlbGVjdEVsZW1lbnQsIDEp OwogICAgIH0sCiAKKyAgICBlZGl0aW5nS2V5UHJlc3M6IGZ1bmN0aW9uKGV2ZW50KQorICAgIHsK KyAgICAgICAgdmFyIHNlbGVjdGlvbiA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKTsKKyAgICAgICAg aWYgKCFzZWxlY3Rpb24ucmFuZ2VDb3VudCkKKyAgICAgICAgICAgIHJldHVybjsKKworICAgICAg ICB2YXIgZWxlbWVudCA9IGV2ZW50LnRhcmdldDsKKyAgICAgICAgdmFyIHNlbGVjdGlvblJhbmdl ID0gc2VsZWN0aW9uLmdldFJhbmdlQXQoMCk7CisgICAgICAgIHZhciBjb2xvbkluZGV4ID0gdGhp cy5saXN0SXRlbUVsZW1lbnQudGV4dENvbnRlbnQuaW5kZXhPZigiOiIpOworICAgICAgICB2YXIg c2VsZWN0aW9uTGVmdE9mZnNldCA9IGVsZW1lbnQuc2VsZWN0aW9uTGVmdE9mZnNldDsKKworICAg ICAgICBpZiAoY29sb25JbmRleCA8IDAgfHwgc2VsZWN0aW9uTGVmdE9mZnNldCA8PSBjb2xvbklu ZGV4KSB7CisgICAgICAgICAgICAvLyBDb21wbGV0ZSBwcm9wZXJ0eSBuYW1lcy4KKyAgICAgICAg ICAgIHZhciBwcmVmaXggPSBzZWxlY3Rpb25SYW5nZS5zdGFydENvbnRhaW5lci50ZXh0Q29udGVu dC5zdWJzdHJpbmcoMCwgc2VsZWN0aW9uUmFuZ2Uuc3RhcnRPZmZzZXQpOworICAgICAgICAgICAg dmFyIHByb3BlcnR5ID0gV2ViSW5zcGVjdG9yLkNTUy5wcm9wZXJ0aWVzLmZpcnN0U3RhcnRzV2l0 aChwcmVmaXggKyBldmVudC5kYXRhKTsKKworICAgICAgICAgICAgdGhpcy5yZXN0b3JlTmFtZUVs ZW1lbnQoKTsKKyAgICAgICAgICAgIAorICAgICAgICAgICAgaWYgKHByb3BlcnR5KSB7CisgICAg ICAgICAgICAgICAgaWYgKHByb3BlcnR5ICE9PSB0aGlzLm5hbWVFbGVtZW50LnRleHRDb250ZW50 KQorICAgICAgICAgICAgICAgICAgICB0aGlzLm5hbWVFbGVtZW50LnRleHRDb250ZW50ID0gcHJv cGVydHk7CisgICAgICAgICAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5maXJzdENoaWxkLnNlbGVj dChwcmVmaXgubGVuZ3RoICsgZXZlbnQuZGF0YS5sZW5ndGgpOworICAgICAgICAgICAgICAgIGV2 ZW50LnByZXZlbnREZWZhdWx0KCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7Cisg ICAgICAgICAgICAvLyBGSVhNRTogVGhpcyBzaG91bGQgY29tcGxldGUgcHJvcGVydHkgdmFsdWVz LgorICAgICAgICB9CisgICAgfSwKKwogICAgIGVkaXRpbmdLZXlEb3duOiBmdW5jdGlvbihldmVu dCkKICAgICB7CiAgICAgICAgIHZhciBhcnJvd0tleVByZXNzZWQgPSAoZXZlbnQua2V5SWRlbnRp ZmllciA9PT0gIlVwIiB8fCBldmVudC5rZXlJZGVudGlmaWVyID09PSAiRG93biIpOwpAQCAtMTM5 Niw5ICsxNDM4LDI0IEBAIFdlYkluc3BlY3Rvci5TdHlsZVByb3BlcnR5VHJlZUVsZW1lbnQucHJv dG90eXBlID0gewogICAgICAgICAgICAgfQogCiAgICAgICAgICAgICByZXBsYWNlbWVudFN0cmlu ZyA9IHByZWZpeCArIG51bWJlciArIHN1ZmZpeDsKLSAgICAgICAgfSBlbHNlIHsKLSAgICAgICAg ICAgIC8vIEZJWE1FOiB0aGlzIHNob3VsZCBjeWNsZSB0aHJvdWdoIGtub3duIGtleXdvcmRzIGZv ciB0aGUgY3VycmVudCBwcm9wZXJ0eSBuYW1lLgorICAgICAgICB9IGVsc2UgaWYgKHNlbGVjdGlv bi5jb250YWluc05vZGUodGhpcy5uYW1lRWxlbWVudCwgdHJ1ZSkpIHsKKyAgICAgICAgICAgIHZh ciBwcmVmaXggPSBzZWxlY3Rpb25SYW5nZS5zdGFydENvbnRhaW5lci50ZXh0Q29udGVudC5zdWJz dHJpbmcoMCwgc2VsZWN0aW9uUmFuZ2Uuc3RhcnRPZmZzZXQpOworICAgICAgICAgICAgdmFyIHBy b3BlcnR5OworCisgICAgICAgICAgICBpZiAoZXZlbnQua2V5SWRlbnRpZmllciA9PT0gIlVwIikK KyAgICAgICAgICAgICAgICBwcm9wZXJ0eSA9IFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5w cmV2aW91cyh3b3JkU3RyaW5nLCBwcmVmaXgpOworICAgICAgICAgICAgZWxzZSBpZiAoZXZlbnQu a2V5SWRlbnRpZmllciA9PT0gIkRvd24iKQorICAgICAgICAgICAgICAgIHByb3BlcnR5ID0gV2Vi SW5zcGVjdG9yLkNTUy5wcm9wZXJ0aWVzLm5leHQod29yZFN0cmluZywgcHJlZml4KTsKKworICAg ICAgICAgICAgdmFyIHN0YXJ0T2Zmc2V0ID0gc2VsZWN0aW9uUmFuZ2Uuc3RhcnRPZmZzZXQ7Cisg ICAgICAgICAgICBpZiAocHJvcGVydHkpIHsKKyAgICAgICAgICAgICAgICB0aGlzLm5hbWVFbGVt ZW50LnRleHRDb250ZW50ID0gcHJvcGVydHk7CisgICAgICAgICAgICAgICAgdGhpcy5uYW1lRWxl bWVudC5maXJzdENoaWxkLnNlbGVjdChzdGFydE9mZnNldCk7CisgICAgICAgICAgICB9CisgICAg ICAgICAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpOwogICAgICAgICAgICAgcmV0dXJuOworICAg ICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gRklYTUU6IHRoaXMgc2hvdWxkIGN5Y2xlIHRo cm91Z2gga25vd24ga2V5d29yZHMgZm9yIHRoZSBjdXJyZW50IHByb3BlcnR5IHZhbHVlLgogICAg ICAgICB9CiAKICAgICAgICAgdmFyIHJlcGxhY2VtZW50VGV4dE5vZGUgPSBkb2N1bWVudC5jcmVh dGVUZXh0Tm9kZShyZXBsYWNlbWVudFN0cmluZyk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3Bl Y3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0bWwgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1l bmQvaW5zcGVjdG9yLmh0bWwKaW5kZXggNGM1MTYzNC4uNDYxNmU2YyAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sCisrKyBiL1dlYkNvcmUvaW5z cGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuaHRtbApAQCAtODIsNiArODIsNyBAQCBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlByb3BlcnRpZXNTaWRl YmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQi IHNyYz0iRXZlbnRMaXN0ZW5lcnNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlw dCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iQ29sb3IuanMiPjwvc2NyaXB0PgorICAgIDxz Y3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IkNTUy5qcyI+PC9zY3JpcHQ+CiAgICAg PHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iU3R5bGVzU2lkZWJhclBhbmUuanMi Pjwvc2NyaXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlBhbmVs RW5hYmxlclZpZXcuanMiPjwvc2NyaXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2Ny aXB0IiBzcmM9IldlbGNvbWVWaWV3LmpzIj48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUv aW5zcGVjdG9yL2Zyb250LWVuZC91dGlsaXRpZXMuanMgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9u dC1lbmQvdXRpbGl0aWVzLmpzCmluZGV4IGJiMTlkYmQuLmZlZmFiZmIgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC91dGlsaXRpZXMuanMKKysrIGIvV2ViQ29yZS9pbnNw ZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGllcy5qcwpAQCAtMzI4LDYgKzMyOCw2MiBAQCBFbGVtZW50 LnByb3RvdHlwZS5vZmZzZXRSZWxhdGl2ZVRvV2luZG93ID0gZnVuY3Rpb24odGFyZ2V0V2luZG93 KQogICAgIHJldHVybiBlbGVtZW50T2Zmc2V0OwogfQogCitLZXlib2FyZEV2ZW50LnByb3RvdHlw ZS5fX2RlZmluZUdldHRlcl9fKCJkYXRhIiwgZnVuY3Rpb24gZ2V0Q2hhcmFjdGVyRGF0YSgpCit7 CisgICAgLy8gRW11bGF0ZSAiZGF0YSIgYXR0cmlidXRlIGZyb20gRE9NIDMgVGV4dElucHV0IGV2 ZW50LgorICAgIC8vIFNlZSBodHRwOi8vd3d3LnczLm9yZy9UUi9ET00tTGV2ZWwtMy1FdmVudHMv I2V2ZW50cy1FdmVudHMtVGV4dEV2ZW50LWRhdGEKKyAgICBzd2l0Y2ggKHRoaXMudHlwZSkgewor ICAgICAgICBjYXNlICJrZXlwcmVzcyI6CisgICAgICAgICAgICByZXR1cm4gU3RyaW5nLmZyb21D aGFyQ29kZSh0aGlzLmNoYXJDb2RlKTsKKyAgICAgICAgY2FzZSAia2V5ZG93biI6CisgICAgICAg IGNhc2UgImtleXVwIjoKKyAgICAgICAgICAgIGlmICghdGhpcy5jdHJsS2V5ICYmICF0aGlzLm1l dGFLZXkgJiYgIXRoaXMuYWx0S2V5KQorICAgICAgICAgICAgICAgIHJldHVybiBTdHJpbmcuZnJv bUNoYXJDb2RlKHRoaXMud2hpY2gpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAg IHJldHVybiAiIjsKKyAgICB9Cit9KTsKKworVGV4dC5wcm90b3R5cGUuc2VsZWN0ID0gZnVuY3Rp b24gc2VsZWN0KHN0YXJ0LCBlbmQpCit7CisgICAgc3RhcnQgPSBzdGFydCB8fCAwOworICAgIGVu ZCA9IGVuZCB8fCB0aGlzLnRleHRDb250ZW50Lmxlbmd0aDsKKworICAgIGlmIChzdGFydCA8IDAp CisgICAgICAgIHN0YXJ0ID0gZW5kICsgc3RhcnQ7CisKKyAgICB2YXIgc2VsZWN0aW9uID0gd2lu ZG93LmdldFNlbGVjdGlvbigpOworICAgIHNlbGVjdGlvbi5yZW1vdmVBbGxSYW5nZXMoKTsKKyAg ICB2YXIgcmFuZ2UgPSBkb2N1bWVudC5jcmVhdGVSYW5nZSgpOworICAgIHJhbmdlLnNldFN0YXJ0 KHRoaXMsIHN0YXJ0KTsKKyAgICByYW5nZS5zZXRFbmQodGhpcywgZW5kKTsKKyAgICBzZWxlY3Rp b24uYWRkUmFuZ2UocmFuZ2UpOworICAgIHJldHVybiB0aGlzOworfTsKKworRWxlbWVudC5wcm90 b3R5cGUuX19kZWZpbmVHZXR0ZXJfXygic2VsZWN0aW9uTGVmdE9mZnNldCIsIGZ1bmN0aW9uIGdl dFNlbGVjdGlvbk9mZnNldCgpIHsKKyAgICAvLyBDYWxjdWxhdGUgc2VsZWN0aW9uIG9mZnNldCBy ZWxhdGl2ZSB0byB0aGUgY3VycmVudCBlbGVtZW50LgorCisgICAgdmFyIHNlbGVjdGlvbiA9IHdp bmRvdy5nZXRTZWxlY3Rpb24oKTsKKyAgICBpZiAoIXNlbGVjdGlvbi5jb250YWluc05vZGUodGhp cywgdHJ1ZSkgfHwgIXNlbGVjdGlvbi5yYW5nZUNvdW50KQorICAgICAgICByZXR1cm4gbnVsbDsK KworICAgIHZhciByYW5nZSA9IHNlbGVjdGlvbi5nZXRSYW5nZUF0KDApOworCisgICAgdmFyIGxl ZnRPZmZzZXQgPSByYW5nZS5zdGFydE9mZnNldDsKKyAgICB2YXIgbm9kZSA9IHJhbmdlLnN0YXJ0 Q29udGFpbmVyOworCisgICAgd2hpbGUgKG5vZGUgIT09IHRoaXMpIHsKKyAgICAgICAgd2hpbGUg KG5vZGUucHJldmlvdXNTaWJsaW5nKSB7CisgICAgICAgICAgICBub2RlID0gbm9kZS5wcmV2aW91 c1NpYmxpbmc7CisgICAgICAgICAgICBsZWZ0T2Zmc2V0ICs9IG5vZGUudGV4dENvbnRlbnQubGVu Z3RoOworICAgICAgICB9CisgICAgICAgIG5vZGUgPSBub2RlLnBhcmVudE5vZGU7CisgICAgfQor CisgICAgcmV0dXJuIGxlZnRPZmZzZXQ7Cit9KTsKKwogTm9kZS5wcm90b3R5cGUuaXNXaGl0ZXNw YWNlID0gaXNOb2RlV2hpdGVzcGFjZTsKIE5vZGUucHJvdG90eXBlLmRpc3BsYXlOYW1lID0gbm9k ZURpc3BsYXlOYW1lOwogTm9kZS5wcm90b3R5cGUuaXNBbmNlc3RvciA9IGZ1bmN0aW9uKG5vZGUp CkBAIC02NzIsNiArNzI4LDEyIEBAIEFycmF5LnByb3RvdHlwZS5rZXlTZXQgPSBmdW5jdGlvbigp CiAgICAgcmV0dXJuIGtleXM7CiB9CiAKK0FycmF5LmNvbnZlcnQgPSBmdW5jdGlvbiBjb252ZXJ0 KGxpc3QpCit7CisgICAgLy8gQ2FzdCBhcnJheS1saWtlIG9iamVjdCB0byBhbiBhcnJheS4KKyAg ICByZXR1cm4gQXJyYXkucHJvdG90eXBlLnNsaWNlLmNhbGwobGlzdCk7Cit9CisKIGZ1bmN0aW9u IGluc2VydGlvbkluZGV4Rm9yT2JqZWN0SW5MaXN0U29ydGVkQnlGdW5jdGlvbihhbk9iamVjdCwg YUxpc3QsIGFGdW5jdGlvbikKIHsKICAgICAvLyBpbmRleE9mIHJldHVybnMgKC1sb3dlckJvdW5k IC0gMSkuIFRha2luZyAoLXJlc3VsdCAtIDEpIHdvcmtzIG91dCB0byBsb3dlckJvdW5kLgo= 59166 2010-06-18 16:10:24 -0700 2010-06-19 11:32:14 -0700 Autocomplete CSS properties and cycle through them using arrow keys css_properties_autocomplete.patch text/plain 12782 me ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZjI4OTM0Yi4uMjgwZDVkMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNyBAQAorMjAxMC0wNi0xOCAgTmlraXRhIFZhc2ls eWV2ICA8bWVAZWx2MXMucnU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgV2ViSW5zcGVjdG9yOiBJbnNwZWN0b3Igc2hvdWxkIHN1cHBvcnQgdGFiIGNv bXBsZXRpb24gd2hpbGUgZWRpdGluZyBDU1MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTE3Mzc0CisKKyAgICAgICAgQWRkZWQgYXV0b2NvbXBsZXRpb24g Zm9yIENTUyBwcm9wZXJ0aWVzLiBBIHN1Z2dlc3Rpb24gZm9yIGEgcHJvcGVydHkgc2hvd3Mgd2hl biB5b3UgdHlwZS4KKyAgICAgICAgWW91IGNhbiBhbHNvIGN5Y2xlIHRocm91Z2gga25vd24gcHJv cGVydHkgbmFtZXMgdXNpbmcgYXJyb3cga2V5cy4KKworICAgICAgICAqIGluc3BlY3Rvci9mcm9u dC1lbmQvQ1NTLmpzOiBBZGRlZC4KKyAgICAgICAgKFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGll cyk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMuc3RhcnRzV2l0aCk6Cisg ICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMuZmlyc3RTdGFydHNXaXRoKToKKyAg ICAgICAgKFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5fY2xvc2VzdCk6CisgICAgICAgIChX ZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRpZXMubmV4dCk6CisgICAgICAgIChXZWJJbnNwZWN0b3Iu Q1NTLnByb3BlcnRpZXMucHJldmlvdXMpOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQv U3R5bGVzU2lkZWJhclBhbmUuanM6CisgICAgICAgIChXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0 eVRyZWVFbGVtZW50LnByb3RvdHlwZSk6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9p bnNwZWN0b3IuaHRtbDoKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGllcy5q czoKKyAgICAgICAgKFRleHQucHJvdG90eXBlLnNlbGVjdCk6CisgICAgICAgICgpOgorCiAyMDEw LTA2LTE3ICBTdGVwaGVuIFdoaXRlICA8c2Vub3JibGFuY29AY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IERhdmlkIExldmluLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNwZWN0 b3IvZnJvbnQtZW5kL0NTUy5qcyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9DU1MuanMK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTNmNTE3MgotLS0gL2Rldi9udWxs CisrKyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9DU1MuanMKQEAgLTAsMCArMSw4NyBA QAorV2ViSW5zcGVjdG9yLkNTUyA9IHsKKyAgICBwcm9wZXJ0aWVzOiAoZnVuY3Rpb24gYnVpbGRD U1NQcm9wZXJ0aWVzKCkgeworICAgICAgICB2YXIgcHJvcGVydGllcyA9IEFycmF5LmNvbnZlcnQo ZG9jdW1lbnQuZGVmYXVsdFZpZXcuZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5kb2N1bWVudEVs ZW1lbnQsICIiKSk7CisgICAgICAgIHZhciBsZW5ndGggPSBwcm9wZXJ0aWVzLmxlbmd0aDsKKyAg ICAgICAgLy8gQWRkIHNob3J0aGFuZHMgdG8gdGhlIGVuZCBvZiB0aGUgcHJvcGVydGllcyBsaXN0 LgorICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IGxlbmd0aDsgKytpKSB7CisgICAgICAgICAg ICB2YXIgcHJvcGVydHlXb3JkcyA9IHByb3BlcnRpZXNbaV0uc3BsaXQoIi0iKTsKKyAgICAgICAg ICAgIHZhciBqID0gcHJvcGVydHlXb3Jkcy5sZW5ndGg7CisgICAgICAgICAgICB3aGlsZSAoLS1q KSB7CisgICAgICAgICAgICAgICAgdmFyIHNob3J0aGFuZCA9IHByb3BlcnR5V29yZHMuc2xpY2Uo MCwgaikuam9pbigiLSIpOworICAgICAgICAgICAgICAgIGlmICh0eXBlb2YgZG9jdW1lbnQuZG9j dW1lbnRFbGVtZW50LnN0eWxlW3Nob3J0aGFuZF0gIT09ICJ1bmRlZmluZWQiICYmIHByb3BlcnRp ZXMuaW5kZXhPZihzaG9ydGhhbmQpIDwgMCkKKyAgICAgICAgICAgICAgICAgICAgcHJvcGVydGll cy5wdXNoKHNob3J0aGFuZCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgcmV0 dXJuIHByb3BlcnRpZXMuc29ydCgpOworICAgIH0pKCkKK30KKworV2ViSW5zcGVjdG9yLkNTUy5w cm9wZXJ0aWVzLnN0YXJ0c1dpdGggPSBmdW5jdGlvbiBzdGFydHNXaXRoKHByZWZpeCkKK3sKKyAg ICAvLyBGSVhNRTogVXNlIGJpbmFyeSBzZWFyY2guCisgICAgcmV0dXJuIHRoaXMuZmlsdGVyKGZ1 bmN0aW9uKHByb3BlcnR5KSB7CisgICAgICAgIHJldHVybiBwcm9wZXJ0eS5pbmRleE9mKHByZWZp eCkgPT09IDA7CisgICAgfSk7Cit9CisKK1dlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5maXJz dFN0YXJ0c1dpdGggPSBmdW5jdGlvbiBmaXJzdFN0YXJ0c1dpdGgocHJlZml4KQoreworICAgIGlm ICghcHJlZml4KQorICAgICAgICByZXR1cm4gIiI7CisKKyAgICB2YXIgbWF4SW5kZXggPSB0aGlz Lmxlbmd0aCAtIDE7CisgICAgdmFyIG1pbkluZGV4ID0gMDsKKyAgICB2YXIgZm91bmRJbmRleDsK KworICAgIGRvIHsKKyAgICAgICAgdmFyIG1pZGRsZUluZGV4ID0gKG1heEluZGV4ICsgbWluSW5k ZXgpID4+IDE7IC8vIFNhbWUgYXMgTWF0aC5mbG9vcigobWF4SW5kZXggKyBtaW5JbmRleCkgLyAy KSwgYnV0IHR3aWNlIGZhc3Rlci4KKworICAgICAgICBpZiAodGhpc1ttaWRkbGVJbmRleF0uaW5k ZXhPZihwcmVmaXgpID09PSAwKSB7CisgICAgICAgICAgICBmb3VuZEluZGV4ID0gbWlkZGxlSW5k ZXg7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorICAgICAgICBpZiAodGhpc1ttaWRk bGVJbmRleF0gPCBwcmVmaXgpCisgICAgICAgICAgICBtaW5JbmRleCA9IG1pZGRsZUluZGV4ICsg MTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgbWF4SW5kZXggPSBtaWRkbGVJbmRleCAtIDE7 CisgICAgICAgIAorICAgIH0gd2hpbGUgKG1pbkluZGV4IDw9IG1heEluZGV4KTsKKworICAgIGlm ICghZm91bmRJbmRleCkKKyAgICAgICAgcmV0dXJuICIiOworCisgICAgd2hpbGUgKGZvdW5kSW5k ZXggJiYgdGhpc1tmb3VuZEluZGV4IC0gMV0uaW5kZXhPZihwcmVmaXgpID09PSAwKQorICAgICAg ICBmb3VuZEluZGV4LS07CisKKyAgICByZXR1cm4gdGhpc1tmb3VuZEluZGV4XTsKK30KKworV2Vi SW5zcGVjdG9yLkNTUy5wcm9wZXJ0aWVzLl9jbG9zZXN0ID0gZnVuY3Rpb24gX2Nsb3Nlc3Qoc3Ry LCBwcmVmaXgsIHNoaWZ0KQoreworICAgIGlmICghc3RyKQorICAgICAgICByZXR1cm4gIiI7CisK KyAgICB2YXIgaW5kZXggPSB0aGlzLmluZGV4T2Yoc3RyKTsKKyAgICBpZiAoaW5kZXggPT09IC0x KQorICAgICAgICByZXR1cm4gIiI7CisKKyAgICBpbmRleCA9IChpbmRleCArIHRoaXMubGVuZ3Ro ICsgc2hpZnQpICUgdGhpcy5sZW5ndGg7CisKKyAgICBpZiAoIXByZWZpeCkKKyAgICAgICAgcmV0 dXJuIHRoaXNbaW5kZXhdOworCisgICAgdmFyIHByb3BlcnRpZXNXaXRoUHJlZml4ID0gdGhpcy5z dGFydHNXaXRoKHByZWZpeCk7CisgICAgdmFyIGogPSBwcm9wZXJ0aWVzV2l0aFByZWZpeC5pbmRl eE9mKHN0cik7CisgICAgaiA9IChqICsgcHJvcGVydGllc1dpdGhQcmVmaXgubGVuZ3RoICsgc2hp ZnQpICUgcHJvcGVydGllc1dpdGhQcmVmaXgubGVuZ3RoOworICAgIHJldHVybiBwcm9wZXJ0aWVz V2l0aFByZWZpeFtqXTsKK30KKworV2ViSW5zcGVjdG9yLkNTUy5wcm9wZXJ0aWVzLm5leHQgPSBm dW5jdGlvbiBuZXh0KHN0ciwgcHJlZml4KQoreworICAgIHJldHVybiBXZWJJbnNwZWN0b3IuQ1NT LnByb3BlcnRpZXMuX2Nsb3Nlc3Qoc3RyLCBwcmVmaXgsIDEpOworfQorCitXZWJJbnNwZWN0b3Iu Q1NTLnByb3BlcnRpZXMucHJldmlvdXMgPSBmdW5jdGlvbiBwcmV2aW91cyhzdHIsIHByZWZpeCkK K3sKKyAgICByZXR1cm4gV2ViSW5zcGVjdG9yLkNTUy5wcm9wZXJ0aWVzLl9jbG9zZXN0KHN0ciwg cHJlZml4LCAtMSk7Cit9ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxlc1NpZGViYXJQYW5lLmpzIGIvV2ViQ29y ZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxlc1NpZGViYXJQYW5lLmpzCmluZGV4IDE4YjdmMGYu LmFkMTJjZmQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9TdHlsZXNT aWRlYmFyUGFuZS5qcworKysgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvU3R5bGVzU2lk ZWJhclBhbmUuanMKQEAgLTEzMTUsNiArMTMxNSwxOCBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9w ZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKICAgICAgICAgZXZlbnQuc3RvcFByb3BhZ2F0 aW9uKCk7CiAgICAgfSwKIAorICAgIHJlc3RvcmVOYW1lRWxlbWVudDogZnVuY3Rpb24oKQorICAg IHsKKyAgICAgICAgLy8gUmVzdG9yZSA8c3BhbiBjbGFzcz0id2Via2l0LWNzcy1wcm9wZXJ0eSI+ IGlmIGl0IGRvZXNuJ3QgeWV0IGV4aXN0IG9yIHdhcyBhY3RpZGVudGFsbHkgZGVsZXRlZC4KKyAg ICAgICAgaWYgKHRoaXMubmFtZUVsZW1lbnQgPT09IHRoaXMubGlzdEl0ZW1FbGVtZW50LnF1ZXJ5 U2VsZWN0b3IoIi53ZWJraXQtY3NzLXByb3BlcnR5IikpCisgICAgICAgICAgICByZXR1cm47CisK KyAgICAgICAgdGhpcy5uYW1lRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInNwYW4i KTsKKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5jbGFzc05hbWUgPSAid2Via2l0LWNzcy1wcm9w ZXJ0eSI7CisgICAgICAgIHRoaXMubmFtZUVsZW1lbnQudGV4dENvbnRlbnQgPSAiIjsKKyAgICAg ICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuaW5zZXJ0QmVmb3JlKHRoaXMubmFtZUVsZW1lbnQsIHRo aXMubGlzdEl0ZW1FbGVtZW50LmZpcnN0Q2hpbGQpOworICAgIH0sCisKICAgICBzdGFydEVkaXRp bmc6IGZ1bmN0aW9uKHNlbGVjdEVsZW1lbnQpCiAgICAgewogICAgICAgICAvLyBGSVhNRTogd2Ug ZG9uJ3QgYWxsb3cgZWRpdGluZyBvZiBsb25naGFuZCBwcm9wZXJ0aWVzIHVuZGVyIGEgc2hvcnRo YW5kIHJpZ2h0IG5vdy4KQEAgLTEzMjQsNyArMTMzNiwxMiBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQ cm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKICAgICAgICAgaWYgKFdlYkluc3BlY3Rv ci5pc0JlaW5nRWRpdGVkKHRoaXMubGlzdEl0ZW1FbGVtZW50KSB8fCAodGhpcy50cmVlT3V0bGlu ZS5zZWN0aW9uICYmICF0aGlzLnRyZWVPdXRsaW5lLnNlY3Rpb24uZWRpdGFibGUpKQogICAgICAg ICAgICAgcmV0dXJuOwogCi0gICAgICAgIHZhciBjb250ZXh0ID0geyBleHBhbmRlZDogdGhpcy5l eHBhbmRlZCwgaGFzQ2hpbGRyZW46IHRoaXMuaGFzQ2hpbGRyZW4sIGtleURvd25MaXN0ZW5lcjog dGhpcy5lZGl0aW5nS2V5RG93bi5iaW5kKHRoaXMpIH07CisgICAgICAgIHZhciBjb250ZXh0ID0g eworICAgICAgICAgICAgZXhwYW5kZWQ6IHRoaXMuZXhwYW5kZWQsCisgICAgICAgICAgICBoYXND aGlsZHJlbjogdGhpcy5oYXNDaGlsZHJlbiwKKyAgICAgICAgICAgIGtleURvd25MaXN0ZW5lcjog dGhpcy5lZGl0aW5nS2V5RG93bi5iaW5kKHRoaXMpLAorICAgICAgICAgICAga2V5UHJlc3NMaXN0 ZW5lcjogdGhpcy5lZGl0aW5nS2V5UHJlc3MuYmluZCh0aGlzKQorICAgICAgICB9OwogCiAgICAg ICAgIC8vIExpZSBhYm91dCBvdXIgY2hpbGRyZW4gdG8gcHJldmVudCBleHBhbmRpbmcgb24gZG91 YmxlIGNsaWNrIGFuZCB0byBjb2xsYXBzZSBzaG9ydGhhbmRzLgogICAgICAgICB0aGlzLmhhc0No aWxkcmVuID0gZmFsc2U7CkBAIC0xMzMzLDExICsxMzUwLDQwIEBAIFdlYkluc3BlY3Rvci5TdHls ZVByb3BlcnR5VHJlZUVsZW1lbnQucHJvdG90eXBlID0gewogICAgICAgICAgICAgc2VsZWN0RWxl bWVudCA9IHRoaXMubGlzdEl0ZW1FbGVtZW50OwogCiAgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVt ZW50LmFkZEV2ZW50TGlzdGVuZXIoImtleWRvd24iLCBjb250ZXh0LmtleURvd25MaXN0ZW5lciwg ZmFsc2UpOworICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hZGRFdmVudExpc3RlbmVyKCJr ZXlwcmVzcyIsIGNvbnRleHQua2V5UHJlc3NMaXN0ZW5lciwgZmFsc2UpOwogCiAgICAgICAgIFdl Ykluc3BlY3Rvci5zdGFydEVkaXRpbmcodGhpcy5saXN0SXRlbUVsZW1lbnQsIHRoaXMuZWRpdGlu Z0NvbW1pdHRlZC5iaW5kKHRoaXMpLCB0aGlzLmVkaXRpbmdDYW5jZWxsZWQuYmluZCh0aGlzKSwg Y29udGV4dCk7CiAgICAgICAgIHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRCYXNlQW5kRXh0ZW50 KHNlbGVjdEVsZW1lbnQsIDAsIHNlbGVjdEVsZW1lbnQsIDEpOwogICAgIH0sCiAKKyAgICBlZGl0 aW5nS2V5UHJlc3M6IGZ1bmN0aW9uKGV2ZW50KQorICAgIHsKKyAgICAgICAgdmFyIHNlbGVjdGlv biA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKTsKKyAgICAgICAgdmFyIGNvbG9uSW5kZXggPSB0aGlz Lmxpc3RJdGVtRWxlbWVudC50ZXh0Q29udGVudC5pbmRleE9mKCI6Iik7CisgICAgICAgIHZhciBz ZWxlY3Rpb25MZWZ0T2Zmc2V0ID0gZXZlbnQudGFyZ2V0LnNlbGVjdGlvbkxlZnRPZmZzZXQ7CisK KyAgICAgICAgaWYgKGNvbG9uSW5kZXggPCAwIHx8IHNlbGVjdGlvbkxlZnRPZmZzZXQgPD0gY29s b25JbmRleCkgeworICAgICAgICAgICAgLy8gQ29tcGxldGUgcHJvcGVydHkgbmFtZXMuCisgICAg ICAgICAgICB2YXIgY2hhcmFjdGVyID0gZXZlbnQuZGF0YS50b0xvd2VyQ2FzZSgpOworICAgICAg ICAgICAgaWYgKGNoYXJhY3RlciAmJiAvW2Etei1dLy50ZXN0KGNoYXJhY3RlcikpIHsKKyAgICAg ICAgICAgICAgICB2YXIgcHJlZml4ID0gc2VsZWN0aW9uLmFuY2hvck5vZGUudGV4dENvbnRlbnQu c3Vic3RyaW5nKDAsIHNlbGVjdGlvbi5hbmNob3JPZmZzZXQpOworICAgICAgICAgICAgICAgIHZh ciBwcm9wZXJ0eSA9IFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5maXJzdFN0YXJ0c1dpdGgo cHJlZml4ICsgY2hhcmFjdGVyKTsKKworICAgICAgICAgICAgICAgIHNlbGVjdGlvbi5kZWxldGVG cm9tRG9jdW1lbnQoKTsKKyAgICAgICAgICAgICAgICB0aGlzLnJlc3RvcmVOYW1lRWxlbWVudCgp OworCisgICAgICAgICAgICAgICAgaWYgKHByb3BlcnR5KSB7CisgICAgICAgICAgICAgICAgICAg IGlmIChwcm9wZXJ0eSAhPT0gdGhpcy5uYW1lRWxlbWVudC50ZXh0Q29udGVudCkKKyAgICAgICAg ICAgICAgICAgICAgICAgIHRoaXMubmFtZUVsZW1lbnQudGV4dENvbnRlbnQgPSBwcm9wZXJ0eTsK KyAgICAgICAgICAgICAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5maXJzdENoaWxkLnNlbGVjdChw cmVmaXgubGVuZ3RoICsgMSk7CisgICAgICAgICAgICAgICAgICAgIGV2ZW50LnByZXZlbnREZWZh dWx0KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2Ug eworICAgICAgICAgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIGNvbXBsZXRlIHByb3BlcnR5IHZh bHVlcy4KKyAgICAgICAgfQorICAgIH0sCisKICAgICBlZGl0aW5nS2V5RG93bjogZnVuY3Rpb24o ZXZlbnQpCiAgICAgewogICAgICAgICB2YXIgYXJyb3dLZXlQcmVzc2VkID0gKGV2ZW50LmtleUlk ZW50aWZpZXIgPT09ICJVcCIgfHwgZXZlbnQua2V5SWRlbnRpZmllciA9PT0gIkRvd24iKTsKQEAg LTEzOTYsOSArMTQ0MiwyNCBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVFbGVtZW50 LnByb3RvdHlwZSA9IHsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgcmVwbGFjZW1lbnRT dHJpbmcgPSBwcmVmaXggKyBudW1iZXIgKyBzdWZmaXg7Ci0gICAgICAgIH0gZWxzZSB7Ci0gICAg ICAgICAgICAvLyBGSVhNRTogdGhpcyBzaG91bGQgY3ljbGUgdGhyb3VnaCBrbm93biBrZXl3b3Jk cyBmb3IgdGhlIGN1cnJlbnQgcHJvcGVydHkgbmFtZS4KKyAgICAgICAgfSBlbHNlIGlmIChzZWxl Y3Rpb24uY29udGFpbnNOb2RlKHRoaXMubmFtZUVsZW1lbnQsIHRydWUpKSB7CisgICAgICAgICAg ICB2YXIgcHJlZml4ID0gc2VsZWN0aW9uUmFuZ2Uuc3RhcnRDb250YWluZXIudGV4dENvbnRlbnQu c3Vic3RyaW5nKDAsIHNlbGVjdGlvblJhbmdlLnN0YXJ0T2Zmc2V0KTsKKyAgICAgICAgICAgIHZh ciBwcm9wZXJ0eTsKKworICAgICAgICAgICAgaWYgKGV2ZW50LmtleUlkZW50aWZpZXIgPT09ICJV cCIpCisgICAgICAgICAgICAgICAgcHJvcGVydHkgPSBXZWJJbnNwZWN0b3IuQ1NTLnByb3BlcnRp ZXMucHJldmlvdXMod29yZFN0cmluZywgcHJlZml4KTsKKyAgICAgICAgICAgIGVsc2UgaWYgKGV2 ZW50LmtleUlkZW50aWZpZXIgPT09ICJEb3duIikKKyAgICAgICAgICAgICAgICBwcm9wZXJ0eSA9 IFdlYkluc3BlY3Rvci5DU1MucHJvcGVydGllcy5uZXh0KHdvcmRTdHJpbmcsIHByZWZpeCk7CisK KyAgICAgICAgICAgIHZhciBzdGFydE9mZnNldCA9IHNlbGVjdGlvblJhbmdlLnN0YXJ0T2Zmc2V0 OworICAgICAgICAgICAgaWYgKHByb3BlcnR5KSB7CisgICAgICAgICAgICAgICAgdGhpcy5uYW1l RWxlbWVudC50ZXh0Q29udGVudCA9IHByb3BlcnR5OworICAgICAgICAgICAgICAgIHRoaXMubmFt ZUVsZW1lbnQuZmlyc3RDaGlsZC5zZWxlY3Qoc3RhcnRPZmZzZXQpOworICAgICAgICAgICAgfQor ICAgICAgICAgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTsKICAgICAgICAgICAgIHJldHVybjsK KyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIEZJWE1FOiB0aGlzIHNob3VsZCBjeWNs ZSB0aHJvdWdoIGtub3duIGtleXdvcmRzIGZvciB0aGUgY3VycmVudCBwcm9wZXJ0eSB2YWx1ZS4K ICAgICAgICAgfQogCiAgICAgICAgIHZhciByZXBsYWNlbWVudFRleHROb2RlID0gZG9jdW1lbnQu Y3JlYXRlVGV4dE5vZGUocmVwbGFjZW1lbnRTdHJpbmcpOwpAQCAtMTQzNCw2ICsxNDk1LDcgQEAg V2ViSW5zcGVjdG9yLlN0eWxlUHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUgPSB7CiAgICAg ICAgIGlmIChjb250ZXh0LmV4cGFuZGVkKQogICAgICAgICAgICAgdGhpcy5leHBhbmQoKTsKICAg ICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQucmVtb3ZlRXZlbnRMaXN0ZW5lcigia2V5ZG93biIs IGNvbnRleHQua2V5RG93bkxpc3RlbmVyLCBmYWxzZSk7CisgICAgICAgIHRoaXMubGlzdEl0ZW1F bGVtZW50LnJlbW92ZUV2ZW50TGlzdGVuZXIoImtleXByZXNzIiwgY29udGV4dC5rZXlQcmVzc0xp c3RlbmVyLCBmYWxzZSk7CiAgICAgICAgIGRlbGV0ZSB0aGlzLm9yaWdpbmFsQ1NTVGV4dDsKICAg ICB9LAogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9y Lmh0bWwgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0bWwKaW5kZXgg NGM1MTYzNC4uNDYxNmU2YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5k L2luc3BlY3Rvci5odG1sCisrKyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0 b3IuaHRtbApAQCAtODIsNiArODIsNyBAQCBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICAgIDxzY3JpcHQgdHlwZT0idGV4 dC9qYXZhc2NyaXB0IiBzcmM9IlByb3BlcnRpZXNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAg ICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iRXZlbnRMaXN0ZW5lcnNTaWRl YmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQi IHNyYz0iQ29sb3IuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2Ny aXB0IiBzcmM9IkNTUy5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFz Y3JpcHQiIHNyYz0iU3R5bGVzU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0PgogICAgIDxzY3JpcHQg dHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlBhbmVsRW5hYmxlclZpZXcuanMiPjwvc2NyaXB0 PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IldlbGNvbWVWaWV3Lmpz Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC91dGls aXRpZXMuanMgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvdXRpbGl0aWVzLmpzCmluZGV4 IGJiMTlkYmQuLmI2ODUzNTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC91dGlsaXRpZXMuanMKKysrIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGll cy5qcwpAQCAtMzI4LDYgKzMyOCw2NSBAQCBFbGVtZW50LnByb3RvdHlwZS5vZmZzZXRSZWxhdGl2 ZVRvV2luZG93ID0gZnVuY3Rpb24odGFyZ2V0V2luZG93KQogICAgIHJldHVybiBlbGVtZW50T2Zm c2V0OwogfQogCitLZXlib2FyZEV2ZW50LnByb3RvdHlwZS5fX2RlZmluZUdldHRlcl9fKCJkYXRh IiwgZnVuY3Rpb24gZ2V0Q2hhcmFjdGVyRGF0YSgpCit7CisgICAgLy8gRW11bGF0ZSAiZGF0YSIg YXR0cmlidXRlIGZyb20gRE9NIDMgVGV4dElucHV0IGV2ZW50LgorICAgIC8vIFNlZSBodHRwOi8v d3d3LnczLm9yZy9UUi9ET00tTGV2ZWwtMy1FdmVudHMvI2V2ZW50cy1FdmVudHMtVGV4dEV2ZW50 LWRhdGEKKyAgICBzd2l0Y2ggKHRoaXMudHlwZSkgeworICAgICAgICBjYXNlICJrZXlwcmVzcyI6 CisgICAgICAgICAgICBpZiAoIXRoaXMuY3RybEtleSAmJiAhdGhpcy5tZXRhS2V5KQorICAgICAg ICAgICAgICAgIHJldHVybiBTdHJpbmcuZnJvbUNoYXJDb2RlKHRoaXMuY2hhckNvZGUpOworICAg ICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHJldHVybiAiIjsKKyAgICAgICAgY2FzZSAi a2V5ZG93biI6CisgICAgICAgIGNhc2UgImtleXVwIjoKKyAgICAgICAgICAgIGlmICghdGhpcy5j dHJsS2V5ICYmICF0aGlzLm1ldGFLZXkgJiYgIXRoaXMuYWx0S2V5KQorICAgICAgICAgICAgICAg IHJldHVybiBTdHJpbmcuZnJvbUNoYXJDb2RlKHRoaXMud2hpY2gpOworICAgICAgICAgICAgZWxz ZQorICAgICAgICAgICAgICAgIHJldHVybiAiIjsKKyAgICB9Cit9KTsKKworVGV4dC5wcm90b3R5 cGUuc2VsZWN0ID0gZnVuY3Rpb24gc2VsZWN0KHN0YXJ0LCBlbmQpCit7CisgICAgc3RhcnQgPSBz dGFydCB8fCAwOworICAgIGVuZCA9IGVuZCB8fCB0aGlzLnRleHRDb250ZW50Lmxlbmd0aDsKKwor ICAgIGlmIChzdGFydCA8IDApCisgICAgICAgIHN0YXJ0ID0gZW5kICsgc3RhcnQ7CisKKyAgICB2 YXIgc2VsZWN0aW9uID0gd2luZG93LmdldFNlbGVjdGlvbigpOworICAgIHNlbGVjdGlvbi5yZW1v dmVBbGxSYW5nZXMoKTsKKyAgICB2YXIgcmFuZ2UgPSBkb2N1bWVudC5jcmVhdGVSYW5nZSgpOwor ICAgIHJhbmdlLnNldFN0YXJ0KHRoaXMsIHN0YXJ0KTsKKyAgICByYW5nZS5zZXRFbmQodGhpcywg ZW5kKTsKKyAgICBzZWxlY3Rpb24uYWRkUmFuZ2UocmFuZ2UpOworICAgIHJldHVybiB0aGlzOwor fTsKKworRWxlbWVudC5wcm90b3R5cGUuX19kZWZpbmVHZXR0ZXJfXygic2VsZWN0aW9uTGVmdE9m ZnNldCIsIGZ1bmN0aW9uIGdldFNlbGVjdGlvbk9mZnNldCgpIHsKKyAgICAvLyBDYWxjdWxhdGUg c2VsZWN0aW9uIG9mZnNldCByZWxhdGl2ZSB0byB0aGUgY3VycmVudCBlbGVtZW50LgorCisgICAg dmFyIHNlbGVjdGlvbiA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKTsKKyAgICBpZiAoIXNlbGVjdGlv bi5jb250YWluc05vZGUodGhpcywgdHJ1ZSkgfHwgIXNlbGVjdGlvbi5yYW5nZUNvdW50KQorICAg ICAgICByZXR1cm4gbnVsbDsKKworICAgIHZhciByYW5nZSA9IHNlbGVjdGlvbi5nZXRSYW5nZUF0 KDApOworCisgICAgdmFyIGxlZnRPZmZzZXQgPSByYW5nZS5zdGFydE9mZnNldDsKKyAgICB2YXIg bm9kZSA9IHJhbmdlLnN0YXJ0Q29udGFpbmVyOworCisgICAgd2hpbGUgKG5vZGUgIT09IHRoaXMp IHsKKyAgICAgICAgd2hpbGUgKG5vZGUucHJldmlvdXNTaWJsaW5nKSB7CisgICAgICAgICAgICBu b2RlID0gbm9kZS5wcmV2aW91c1NpYmxpbmc7CisgICAgICAgICAgICBsZWZ0T2Zmc2V0ICs9IG5v ZGUudGV4dENvbnRlbnQubGVuZ3RoOworICAgICAgICB9CisgICAgICAgIG5vZGUgPSBub2RlLnBh cmVudE5vZGU7CisgICAgfQorCisgICAgcmV0dXJuIGxlZnRPZmZzZXQ7Cit9KTsKKwogTm9kZS5w cm90b3R5cGUuaXNXaGl0ZXNwYWNlID0gaXNOb2RlV2hpdGVzcGFjZTsKIE5vZGUucHJvdG90eXBl LmRpc3BsYXlOYW1lID0gbm9kZURpc3BsYXlOYW1lOwogTm9kZS5wcm90b3R5cGUuaXNBbmNlc3Rv ciA9IGZ1bmN0aW9uKG5vZGUpCkBAIC02NzIsNiArNzMxLDEyIEBAIEFycmF5LnByb3RvdHlwZS5r ZXlTZXQgPSBmdW5jdGlvbigpCiAgICAgcmV0dXJuIGtleXM7CiB9CiAKK0FycmF5LmNvbnZlcnQg PSBmdW5jdGlvbiBjb252ZXJ0KGxpc3QpCit7CisgICAgLy8gQ2FzdCBhcnJheS1saWtlIG9iamVj dCB0byBhbiBhcnJheS4KKyAgICByZXR1cm4gQXJyYXkucHJvdG90eXBlLnNsaWNlLmNhbGwobGlz dCk7Cit9CisKIGZ1bmN0aW9uIGluc2VydGlvbkluZGV4Rm9yT2JqZWN0SW5MaXN0U29ydGVkQnlG dW5jdGlvbihhbk9iamVjdCwgYUxpc3QsIGFGdW5jdGlvbikKIHsKICAgICAvLyBpbmRleE9mIHJl dHVybnMgKC1sb3dlckJvdW5kIC0gMSkuIFRha2luZyAoLXJlc3VsdCAtIDEpIHdvcmtzIG91dCB0 byBsb3dlckJvdW5kLgo= 59191 2010-06-19 11:32:14 -0700 2010-06-20 12:04:08 -0700 Autocomplete CSS properties and cycle through them using arrow keys css_properties_autocomplete.patch text/plain 13997 me ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZjI4OTM0Yi4uZmY5ZDA4ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyOCBAQAorMjAxMC0wNi0xOSAgTmlraXRhIFZhc2ls eWV2ICA8bWVAZWx2MXMucnU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgV2ViIEluc3BlY3RvcjogYWRkZWQgYXV0b2NvbXBsZXRpb24gZm9yIENTUyBw cm9wZXJ0aWVzLiBBIHN1Z2dlc3Rpb24gZm9yIGEgcHJvcGVydHkgc2hvd3Mgd2hlbiB5b3UgdHlw ZS4KKyAgICAgICAgWW91IGNhbiBhbHNvIGN5Y2xlIHRocm91Z2gga25vd24gcHJvcGVydHkgbmFt ZXMgdXNpbmcgYXJyb3cga2V5cy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTE3Mzc0CisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICog aW5zcGVjdG9yL2Zyb250LWVuZC9DU1NDb21wbGV0aW9ucy5qczogQWRkZWQuCisgICAgICAgIChX ZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkNTU0Nv bXBsZXRpb25zLnN0YXJ0c1dpdGgpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkNTU0NvbXBsZXRp b25zLmZpcnN0U3RhcnRzV2l0aCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlv bnMuX2ZpcnN0SW5kZXhPZlByZWZpeCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTQ29tcGxl dGlvbnMubmV4dCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMucHJldmlv dXMpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkNTU0NvbXBsZXRpb25zLl9jbG9zZXN0KToKKyAg ICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxlc1NpZGViYXJQYW5lLmpzOgorICAgICAg ICAoV2ViSW5zcGVjdG9yLlN0eWxlUHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUpOgorICAg ICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvV2ViS2l0LnFyYzoKKyAgICAgICAgKiBpbnNwZWN0 b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1l bmQvdXRpbGl0aWVzLmpzOgorICAgICAgICAoVGV4dC5wcm90b3R5cGUuc2VsZWN0KToKKyAgICAg ICAgKCk6CisKIDIwMTAtMDYtMTcgIFN0ZXBoZW4gV2hpdGUgIDxzZW5vcmJsYW5jb0BjaHJvbWl1 bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCmRpZmYgLS1naXQgYS9X ZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDBjMGY1ODAu LjkyNzg2YTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1dlYkNvcmUv V2ViQ29yZS5neXBpCkBAIC0zODk3LDYgKzM4OTcsNyBAQAogICAgICAgICAgICAgJ2luc3BlY3Rv ci9mcm9udC1lbmQvQ29uc29sZVZpZXcuanMnLAogICAgICAgICAgICAgJ2luc3BlY3Rvci9mcm9u dC1lbmQvQ29udGV4dE1lbnUuanMnLAogICAgICAgICAgICAgJ2luc3BlY3Rvci9mcm9udC1lbmQv Q29va2llSXRlbXNWaWV3LmpzJywKKyAgICAgICAgICAgICdpbnNwZWN0b3IvZnJvbnQtZW5kL0NT U0NvbXBsZXRpb25zLmpzJywKICAgICAgICAgICAgICdpbnNwZWN0b3IvZnJvbnQtZW5kL0NTU1N0 eWxlTW9kZWwuanMnLAogICAgICAgICAgICAgJ2luc3BlY3Rvci9mcm9udC1lbmQvRGF0YWJhc2Uu anMnLAogICAgICAgICAgICAgJ2luc3BlY3Rvci9mcm9udC1lbmQvRGF0YWJhc2VRdWVyeVZpZXcu anMnLApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0NTU0NvbXBsZXRp b25zLmpzIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0NTU0NvbXBsZXRpb25zLmpzCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU0ODU0NjQKLS0tIC9kZXYvbnVsbAor KysgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvQ1NTQ29tcGxldGlvbnMuanMKQEAgLTAs MCArMSwxMDIgQEAKK1dlYkluc3BlY3Rvci5DU1NDb21wbGV0aW9ucyA9IChmdW5jdGlvbigpIHsK KyAgICB2YXIgdXNlZCA9IHt9OworICAgIHZhciBwcm9wZXJ0aWVzID0gW107CisgICAgdmFyIHN0 eWxlID0gZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50LnN0eWxlOworICAgIHZhciBsaXN0ID0gZG9j dW1lbnQuZGVmYXVsdFZpZXcuZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5kb2N1bWVudEVsZW1l bnQsICIiKTsKKyAgICB2YXIgbGVuZ3RoID0gbGlzdC5sZW5ndGg7CisgICAgZm9yICh2YXIgaSA9 IDA7IGkgPCBsZW5ndGg7ICsraSkKKyAgICAgICAgdXNlZFtwcm9wZXJ0aWVzW2ldID0gbGlzdFtp XV0gPSB0cnVlOworCisgICAgZm9yICh2YXIgaSA9IDAsIGVuZCA9IGxlbmd0aDsgaSA8IGxlbmd0 aDsgKytpKSB7CisgICAgICAgIHZhciBwcm9wZXJ0eVdvcmRzID0gcHJvcGVydGllc1tpXS5zcGxp dCgiLSIpOworICAgICAgICB2YXIgaiA9IHByb3BlcnR5V29yZHMubGVuZ3RoOworICAgICAgICB3 aGlsZSAoLS1qKSB7CisgICAgICAgICAgICBwcm9wZXJ0eVdvcmRzLnBvcCgpOworICAgICAgICAg ICAgdmFyIHNob3J0aGFuZCA9IHByb3BlcnR5V29yZHMuam9pbigiLSIpOworICAgICAgICAgICAg aWYgKCEoc2hvcnRoYW5kIGluIHVzZWQpICYmIHN0eWxlW3Nob3J0aGFuZF0gIT09IHVuZGVmaW5l ZCkgeworICAgICAgICAgICAgICAgIHVzZWRbc2hvcnRoYW5kXSA9IHRydWU7CisgICAgICAgICAg ICAgICAgcHJvcGVydGllc1tlbmQrK10gPSBzaG9ydGhhbmQ7CisgICAgICAgICAgICB9CisgICAg ICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gcHJvcGVydGllcy5zb3J0KCk7Cit9KSgpOworCitX ZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMuc3RhcnRzV2l0aCA9IGZ1bmN0aW9uKHByZWZpeCkK K3sKKyAgICB2YXIgZmlyc3RJbmRleCA9IHRoaXMuX2ZpcnN0SW5kZXhPZlByZWZpeChwcmVmaXgp OworICAgIGlmIChmaXJzdEluZGV4ID09PSAtMSkKKyAgICAgICAgcmV0dXJuIFtdOworCisgICAg dmFyIHJlc3VsdHMgPSBbXTsKKyAgICB3aGlsZSAodGhpc1tmaXJzdEluZGV4XS5pbmRleE9mKHBy ZWZpeCkgPT09IDApCisgICAgICAgIHJlc3VsdHMucHVzaCh0aGlzW2ZpcnN0SW5kZXgrK10pOwor ICAgIHJldHVybiByZXN1bHRzOworfQorCitXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMuZmly c3RTdGFydHNXaXRoID0gZnVuY3Rpb24ocHJlZml4KQoreworICAgIHZhciBmb3VuZEluZGV4ID0g dGhpcy5fZmlyc3RJbmRleE9mUHJlZml4KHByZWZpeCk7CisgICAgcmV0dXJuIChmb3VuZEluZGV4 ID09PSAtMSA/ICIiIDogdGhpc1tmb3VuZEluZGV4XSk7Cit9CisKK1dlYkluc3BlY3Rvci5DU1ND b21wbGV0aW9ucy5fZmlyc3RJbmRleE9mUHJlZml4ID0gZnVuY3Rpb24ocHJlZml4KQoreworICAg IGlmICghcHJlZml4KQorICAgICAgICByZXR1cm4gLTE7CisKKyAgICB2YXIgbWF4SW5kZXggPSB0 aGlzLmxlbmd0aCAtIDE7CisgICAgdmFyIG1pbkluZGV4ID0gMDsKKyAgICB2YXIgZm91bmRJbmRl eDsKKworICAgIGRvIHsKKyAgICAgICAgdmFyIG1pZGRsZUluZGV4ID0gKG1heEluZGV4ICsgbWlu SW5kZXgpID4+IDE7CisgICAgICAgIGlmICh0aGlzW21pZGRsZUluZGV4XS5pbmRleE9mKHByZWZp eCkgPT09IDApIHsKKyAgICAgICAgICAgIGZvdW5kSW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAg ICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgICAgIGlmICh0aGlzW21pZGRsZUluZGV4XSA8 IHByZWZpeCkKKyAgICAgICAgICAgIG1pbkluZGV4ID0gbWlkZGxlSW5kZXggKyAxOworICAgICAg ICBlbHNlCisgICAgICAgICAgICBtYXhJbmRleCA9IG1pZGRsZUluZGV4IC0gMTsKKyAgICB9IHdo aWxlIChtaW5JbmRleCA8PSBtYXhJbmRleCk7CisKKyAgICBpZiAoIWZvdW5kSW5kZXgpCisgICAg ICAgIHJldHVybiAtMTsKKworICAgIHdoaWxlIChmb3VuZEluZGV4ICYmIHRoaXNbZm91bmRJbmRl eCAtIDFdLmluZGV4T2YocHJlZml4KSA9PT0gMCkKKyAgICAgICAgZm91bmRJbmRleC0tOworCisg ICAgcmV0dXJuIGZvdW5kSW5kZXg7Cit9CisKK1dlYkluc3BlY3Rvci5DU1NDb21wbGV0aW9ucy5u ZXh0ID0gZnVuY3Rpb24oc3RyLCBwcmVmaXgpCit7CisgICAgcmV0dXJuIFdlYkluc3BlY3Rvci5D U1NDb21wbGV0aW9ucy5fY2xvc2VzdChzdHIsIHByZWZpeCwgMSk7Cit9CisKK1dlYkluc3BlY3Rv ci5DU1NDb21wbGV0aW9ucy5wcmV2aW91cyA9IGZ1bmN0aW9uKHN0ciwgcHJlZml4KQoreworICAg IHJldHVybiBXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMuX2Nsb3Nlc3Qoc3RyLCBwcmVmaXgs IC0xKTsKK30KKworV2ViSW5zcGVjdG9yLkNTU0NvbXBsZXRpb25zLl9jbG9zZXN0ID0gZnVuY3Rp b24oc3RyLCBwcmVmaXgsIHNoaWZ0KQoreworICAgIGlmICghc3RyKQorICAgICAgICByZXR1cm4g IiI7CisKKyAgICB2YXIgaW5kZXggPSB0aGlzLmluZGV4T2Yoc3RyKTsKKyAgICBpZiAoaW5kZXgg PT09IC0xKQorICAgICAgICByZXR1cm4gIiI7CisKKyAgICBpZiAoIXByZWZpeCkgeworICAgICAg ICBpbmRleCA9IChpbmRleCArIHRoaXMubGVuZ3RoICsgc2hpZnQpICUgdGhpcy5sZW5ndGg7Cisg ICAgICAgIHJldHVybiB0aGlzW2luZGV4XTsKKyAgICB9CisKKyAgICB2YXIgcHJvcGVydGllc1dp dGhQcmVmaXggPSB0aGlzLnN0YXJ0c1dpdGgocHJlZml4KTsKKyAgICB2YXIgaiA9IHByb3BlcnRp ZXNXaXRoUHJlZml4LmluZGV4T2Yoc3RyKTsKKyAgICBqID0gKGogKyBwcm9wZXJ0aWVzV2l0aFBy ZWZpeC5sZW5ndGggKyBzaGlmdCkgJSBwcm9wZXJ0aWVzV2l0aFByZWZpeC5sZW5ndGg7CisgICAg cmV0dXJuIHByb3BlcnRpZXNXaXRoUHJlZml4W2pdOworfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9p bnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxlc1NpZGViYXJQYW5lLmpzIGIvV2ViQ29yZS9pbnNwZWN0 b3IvZnJvbnQtZW5kL1N0eWxlc1NpZGViYXJQYW5lLmpzCmluZGV4IDE4YjdmMGYuLjY0ZjM5MjAg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9TdHlsZXNTaWRlYmFyUGFu ZS5qcworKysgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvU3R5bGVzU2lkZWJhclBhbmUu anMKQEAgLTEzMTUsNiArMTMxNSwxOCBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVF bGVtZW50LnByb3RvdHlwZSA9IHsKICAgICAgICAgZXZlbnQuc3RvcFByb3BhZ2F0aW9uKCk7CiAg ICAgfSwKIAorICAgIHJlc3RvcmVOYW1lRWxlbWVudDogZnVuY3Rpb24oKQorICAgIHsKKyAgICAg ICAgLy8gUmVzdG9yZSA8c3BhbiBjbGFzcz0id2Via2l0LWNzcy1wcm9wZXJ0eSI+IGlmIGl0IGRv ZXNuJ3QgeWV0IGV4aXN0IG9yIHdhcyBhY2NpZGVudGFsbHkgZGVsZXRlZC4KKyAgICAgICAgaWYg KHRoaXMubmFtZUVsZW1lbnQgPT09IHRoaXMubGlzdEl0ZW1FbGVtZW50LnF1ZXJ5U2VsZWN0b3Io Ii53ZWJraXQtY3NzLXByb3BlcnR5IikpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAg dGhpcy5uYW1lRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInNwYW4iKTsKKyAgICAg ICAgdGhpcy5uYW1lRWxlbWVudC5jbGFzc05hbWUgPSAid2Via2l0LWNzcy1wcm9wZXJ0eSI7Cisg ICAgICAgIHRoaXMubmFtZUVsZW1lbnQudGV4dENvbnRlbnQgPSAiIjsKKyAgICAgICAgdGhpcy5s aXN0SXRlbUVsZW1lbnQuaW5zZXJ0QmVmb3JlKHRoaXMubmFtZUVsZW1lbnQsIHRoaXMubGlzdEl0 ZW1FbGVtZW50LmZpcnN0Q2hpbGQpOworICAgIH0sCisKICAgICBzdGFydEVkaXRpbmc6IGZ1bmN0 aW9uKHNlbGVjdEVsZW1lbnQpCiAgICAgewogICAgICAgICAvLyBGSVhNRTogd2UgZG9uJ3QgYWxs b3cgZWRpdGluZyBvZiBsb25naGFuZCBwcm9wZXJ0aWVzIHVuZGVyIGEgc2hvcnRoYW5kIHJpZ2h0 IG5vdy4KQEAgLTEzMjQsNyArMTMzNiwxMiBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRy ZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKICAgICAgICAgaWYgKFdlYkluc3BlY3Rvci5pc0JlaW5n RWRpdGVkKHRoaXMubGlzdEl0ZW1FbGVtZW50KSB8fCAodGhpcy50cmVlT3V0bGluZS5zZWN0aW9u ICYmICF0aGlzLnRyZWVPdXRsaW5lLnNlY3Rpb24uZWRpdGFibGUpKQogICAgICAgICAgICAgcmV0 dXJuOwogCi0gICAgICAgIHZhciBjb250ZXh0ID0geyBleHBhbmRlZDogdGhpcy5leHBhbmRlZCwg aGFzQ2hpbGRyZW46IHRoaXMuaGFzQ2hpbGRyZW4sIGtleURvd25MaXN0ZW5lcjogdGhpcy5lZGl0 aW5nS2V5RG93bi5iaW5kKHRoaXMpIH07CisgICAgICAgIHZhciBjb250ZXh0ID0geworICAgICAg ICAgICAgZXhwYW5kZWQ6IHRoaXMuZXhwYW5kZWQsCisgICAgICAgICAgICBoYXNDaGlsZHJlbjog dGhpcy5oYXNDaGlsZHJlbiwKKyAgICAgICAgICAgIGtleURvd25MaXN0ZW5lcjogdGhpcy5lZGl0 aW5nS2V5RG93bi5iaW5kKHRoaXMpLAorICAgICAgICAgICAga2V5UHJlc3NMaXN0ZW5lcjogdGhp cy5lZGl0aW5nS2V5UHJlc3MuYmluZCh0aGlzKQorICAgICAgICB9OwogCiAgICAgICAgIC8vIExp ZSBhYm91dCBvdXIgY2hpbGRyZW4gdG8gcHJldmVudCBleHBhbmRpbmcgb24gZG91YmxlIGNsaWNr IGFuZCB0byBjb2xsYXBzZSBzaG9ydGhhbmRzLgogICAgICAgICB0aGlzLmhhc0NoaWxkcmVuID0g ZmFsc2U7CkBAIC0xMzMzLDExICsxMzUwLDQwIEBAIFdlYkluc3BlY3Rvci5TdHlsZVByb3BlcnR5 VHJlZUVsZW1lbnQucHJvdG90eXBlID0gewogICAgICAgICAgICAgc2VsZWN0RWxlbWVudCA9IHRo aXMubGlzdEl0ZW1FbGVtZW50OwogCiAgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LmFkZEV2 ZW50TGlzdGVuZXIoImtleWRvd24iLCBjb250ZXh0LmtleURvd25MaXN0ZW5lciwgZmFsc2UpOwor ICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hZGRFdmVudExpc3RlbmVyKCJrZXlwcmVzcyIs IGNvbnRleHQua2V5UHJlc3NMaXN0ZW5lciwgZmFsc2UpOwogCiAgICAgICAgIFdlYkluc3BlY3Rv ci5zdGFydEVkaXRpbmcodGhpcy5saXN0SXRlbUVsZW1lbnQsIHRoaXMuZWRpdGluZ0NvbW1pdHRl ZC5iaW5kKHRoaXMpLCB0aGlzLmVkaXRpbmdDYW5jZWxsZWQuYmluZCh0aGlzKSwgY29udGV4dCk7 CiAgICAgICAgIHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRCYXNlQW5kRXh0ZW50KHNlbGVjdEVs ZW1lbnQsIDAsIHNlbGVjdEVsZW1lbnQsIDEpOwogICAgIH0sCiAKKyAgICBlZGl0aW5nS2V5UHJl c3M6IGZ1bmN0aW9uKGV2ZW50KQorICAgIHsKKyAgICAgICAgdmFyIHNlbGVjdGlvbiA9IHdpbmRv dy5nZXRTZWxlY3Rpb24oKTsKKyAgICAgICAgdmFyIGNvbG9uSW5kZXggPSB0aGlzLmxpc3RJdGVt RWxlbWVudC50ZXh0Q29udGVudC5pbmRleE9mKCI6Iik7CisgICAgICAgIHZhciBzZWxlY3Rpb25M ZWZ0T2Zmc2V0ID0gZXZlbnQudGFyZ2V0LnNlbGVjdGlvbkxlZnRPZmZzZXQ7CisKKyAgICAgICAg aWYgKGNvbG9uSW5kZXggPCAwIHx8IHNlbGVjdGlvbkxlZnRPZmZzZXQgPD0gY29sb25JbmRleCkg eworICAgICAgICAgICAgLy8gQ29tcGxldGUgcHJvcGVydHkgbmFtZXMuCisgICAgICAgICAgICB2 YXIgY2hhcmFjdGVyID0gZXZlbnQuZGF0YS50b0xvd2VyQ2FzZSgpOworICAgICAgICAgICAgaWYg KGNoYXJhY3RlciAmJiAvW2Etei1dLy50ZXN0KGNoYXJhY3RlcikpIHsKKyAgICAgICAgICAgICAg ICB2YXIgcHJlZml4ID0gc2VsZWN0aW9uLmFuY2hvck5vZGUudGV4dENvbnRlbnQuc3Vic3RyaW5n KDAsIHNlbGVjdGlvbi5hbmNob3JPZmZzZXQpOworICAgICAgICAgICAgICAgIHZhciBwcm9wZXJ0 eSA9IFdlYkluc3BlY3Rvci5DU1NDb21wbGV0aW9ucy5maXJzdFN0YXJ0c1dpdGgocHJlZml4ICsg Y2hhcmFjdGVyKTsKKworICAgICAgICAgICAgICAgIHNlbGVjdGlvbi5kZWxldGVGcm9tRG9jdW1l bnQoKTsKKyAgICAgICAgICAgICAgICB0aGlzLnJlc3RvcmVOYW1lRWxlbWVudCgpOworCisgICAg ICAgICAgICAgICAgaWYgKHByb3BlcnR5KSB7CisgICAgICAgICAgICAgICAgICAgIGlmIChwcm9w ZXJ0eSAhPT0gdGhpcy5uYW1lRWxlbWVudC50ZXh0Q29udGVudCkKKyAgICAgICAgICAgICAgICAg ICAgICAgIHRoaXMubmFtZUVsZW1lbnQudGV4dENvbnRlbnQgPSBwcm9wZXJ0eTsKKyAgICAgICAg ICAgICAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5maXJzdENoaWxkLnNlbGVjdChwcmVmaXgubGVu Z3RoICsgMSk7CisgICAgICAgICAgICAgICAgICAgIGV2ZW50LnByZXZlbnREZWZhdWx0KCk7Cisg ICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgeworICAgICAg ICAgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIGNvbXBsZXRlIHByb3BlcnR5IHZhbHVlcy4KKyAg ICAgICAgfQorICAgIH0sCisKICAgICBlZGl0aW5nS2V5RG93bjogZnVuY3Rpb24oZXZlbnQpCiAg ICAgewogICAgICAgICB2YXIgYXJyb3dLZXlQcmVzc2VkID0gKGV2ZW50LmtleUlkZW50aWZpZXIg PT09ICJVcCIgfHwgZXZlbnQua2V5SWRlbnRpZmllciA9PT0gIkRvd24iKTsKQEAgLTEzOTYsOSAr MTQ0MiwyNCBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlw ZSA9IHsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgcmVwbGFjZW1lbnRTdHJpbmcgPSBw cmVmaXggKyBudW1iZXIgKyBzdWZmaXg7Ci0gICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICAv LyBGSVhNRTogdGhpcyBzaG91bGQgY3ljbGUgdGhyb3VnaCBrbm93biBrZXl3b3JkcyBmb3IgdGhl IGN1cnJlbnQgcHJvcGVydHkgbmFtZS4KKyAgICAgICAgfSBlbHNlIGlmIChzZWxlY3Rpb24uY29u dGFpbnNOb2RlKHRoaXMubmFtZUVsZW1lbnQsIHRydWUpKSB7CisgICAgICAgICAgICB2YXIgcHJl Zml4ID0gc2VsZWN0aW9uUmFuZ2Uuc3RhcnRDb250YWluZXIudGV4dENvbnRlbnQuc3Vic3RyaW5n KDAsIHNlbGVjdGlvblJhbmdlLnN0YXJ0T2Zmc2V0KTsKKyAgICAgICAgICAgIHZhciBwcm9wZXJ0 eTsKKworICAgICAgICAgICAgaWYgKGV2ZW50LmtleUlkZW50aWZpZXIgPT09ICJVcCIpCisgICAg ICAgICAgICAgICAgcHJvcGVydHkgPSBXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMucHJldmlv dXMod29yZFN0cmluZywgcHJlZml4KTsKKyAgICAgICAgICAgIGVsc2UgaWYgKGV2ZW50LmtleUlk ZW50aWZpZXIgPT09ICJEb3duIikKKyAgICAgICAgICAgICAgICBwcm9wZXJ0eSA9IFdlYkluc3Bl Y3Rvci5DU1NDb21wbGV0aW9ucy5uZXh0KHdvcmRTdHJpbmcsIHByZWZpeCk7CisKKyAgICAgICAg ICAgIHZhciBzdGFydE9mZnNldCA9IHNlbGVjdGlvblJhbmdlLnN0YXJ0T2Zmc2V0OworICAgICAg ICAgICAgaWYgKHByb3BlcnR5KSB7CisgICAgICAgICAgICAgICAgdGhpcy5uYW1lRWxlbWVudC50 ZXh0Q29udGVudCA9IHByb3BlcnR5OworICAgICAgICAgICAgICAgIHRoaXMubmFtZUVsZW1lbnQu Zmlyc3RDaGlsZC5zZWxlY3Qoc3RhcnRPZmZzZXQpOworICAgICAgICAgICAgfQorICAgICAgICAg ICAgZXZlbnQucHJldmVudERlZmF1bHQoKTsKICAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAg fSBlbHNlIHsKKyAgICAgICAgICAgIC8vIEZJWE1FOiB0aGlzIHNob3VsZCBjeWNsZSB0aHJvdWdo IGtub3duIGtleXdvcmRzIGZvciB0aGUgY3VycmVudCBwcm9wZXJ0eSB2YWx1ZS4KICAgICAgICAg fQogCiAgICAgICAgIHZhciByZXBsYWNlbWVudFRleHROb2RlID0gZG9jdW1lbnQuY3JlYXRlVGV4 dE5vZGUocmVwbGFjZW1lbnRTdHJpbmcpOwpAQCAtMTQzNCw2ICsxNDk1LDcgQEAgV2ViSW5zcGVj dG9yLlN0eWxlUHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUgPSB7CiAgICAgICAgIGlmIChj b250ZXh0LmV4cGFuZGVkKQogICAgICAgICAgICAgdGhpcy5leHBhbmQoKTsKICAgICAgICAgdGhp cy5saXN0SXRlbUVsZW1lbnQucmVtb3ZlRXZlbnRMaXN0ZW5lcigia2V5ZG93biIsIGNvbnRleHQu a2V5RG93bkxpc3RlbmVyLCBmYWxzZSk7CisgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LnJl bW92ZUV2ZW50TGlzdGVuZXIoImtleXByZXNzIiwgY29udGV4dC5rZXlQcmVzc0xpc3RlbmVyLCBm YWxzZSk7CiAgICAgICAgIGRlbGV0ZSB0aGlzLm9yaWdpbmFsQ1NTVGV4dDsKICAgICB9LAogCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvV2ViS2l0LnFyYyBiL1dlYkNv cmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XZWJLaXQucXJjCmluZGV4IGZkODQ1ODYuLmFkZDUwZTEg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XZWJLaXQucXJjCisrKyBi L1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XZWJLaXQucXJjCkBAIC0xOSw2ICsxOSw3IEBA CiAgICAgPGZpbGU+Q29uc29sZVZpZXcuanM8L2ZpbGU+CiAgICAgPGZpbGU+Q29udGV4dE1lbnUu anM8L2ZpbGU+CiAgICAgPGZpbGU+Q29va2llSXRlbXNWaWV3LmpzPC9maWxlPgorICAgIDxmaWxl PkNTU0NvbXBsZXRpb25zLmpzPC9maWxlPgogICAgIDxmaWxlPkNTU1N0eWxlTW9kZWwuanM8L2Zp bGU+CiAgICAgPGZpbGU+RGF0YWJhc2UuanM8L2ZpbGU+CiAgICAgPGZpbGU+RGF0YWJhc2VRdWVy eVZpZXcuanM8L2ZpbGU+CmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQv aW5zcGVjdG9yLmh0bWwgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0 bWwKaW5kZXggNGM1MTYzNC4uOGE4YjdkNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3Iv ZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sCisrKyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC9pbnNwZWN0b3IuaHRtbApAQCAtODIsNiArODIsNyBAQCBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogICAgIDxzY3JpcHQg dHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlByb3BlcnRpZXNTaWRlYmFyUGFuZS5qcyI+PC9z Y3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iRXZlbnRMaXN0 ZW5lcnNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2ph dmFzY3JpcHQiIHNyYz0iQ29sb3IuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQgdHlwZT0idGV4 dC9qYXZhc2NyaXB0IiBzcmM9IkNTU0NvbXBsZXRpb25zLmpzIj48L3NjcmlwdD4KICAgICA8c2Ny aXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJTdHlsZXNTaWRlYmFyUGFuZS5qcyI+PC9z Y3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iUGFuZWxFbmFi bGVyVmlldy5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQi IHNyYz0iV2VsY29tZVZpZXcuanMiPjwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNw ZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGllcy5qcyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC91dGlsaXRpZXMuanMKaW5kZXggYmIxOWRiZC4uMTMxMmU1YiAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9pbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGllcy5qcworKysgYi9XZWJDb3JlL2luc3BlY3Rv ci9mcm9udC1lbmQvdXRpbGl0aWVzLmpzCkBAIC0zMjgsNiArMzI4LDYzIEBAIEVsZW1lbnQucHJv dG90eXBlLm9mZnNldFJlbGF0aXZlVG9XaW5kb3cgPSBmdW5jdGlvbih0YXJnZXRXaW5kb3cpCiAg ICAgcmV0dXJuIGVsZW1lbnRPZmZzZXQ7CiB9CiAKK0tleWJvYXJkRXZlbnQucHJvdG90eXBlLl9f ZGVmaW5lR2V0dGVyX18oImRhdGEiLCBmdW5jdGlvbigpCit7CisgICAgLy8gRW11bGF0ZSAiZGF0 YSIgYXR0cmlidXRlIGZyb20gRE9NIDMgVGV4dElucHV0IGV2ZW50LgorICAgIC8vIFNlZSBodHRw Oi8vd3d3LnczLm9yZy9UUi9ET00tTGV2ZWwtMy1FdmVudHMvI2V2ZW50cy1FdmVudHMtVGV4dEV2 ZW50LWRhdGEKKyAgICBzd2l0Y2ggKHRoaXMudHlwZSkgeworICAgICAgICBjYXNlICJrZXlwcmVz cyI6CisgICAgICAgICAgICBpZiAoIXRoaXMuY3RybEtleSAmJiAhdGhpcy5tZXRhS2V5KQorICAg ICAgICAgICAgICAgIHJldHVybiBTdHJpbmcuZnJvbUNoYXJDb2RlKHRoaXMuY2hhckNvZGUpOwor ICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHJldHVybiAiIjsKKyAgICAgICAgY2Fz ZSAia2V5ZG93biI6CisgICAgICAgIGNhc2UgImtleXVwIjoKKyAgICAgICAgICAgIGlmICghdGhp cy5jdHJsS2V5ICYmICF0aGlzLm1ldGFLZXkgJiYgIXRoaXMuYWx0S2V5KQorICAgICAgICAgICAg ICAgIHJldHVybiBTdHJpbmcuZnJvbUNoYXJDb2RlKHRoaXMud2hpY2gpOworICAgICAgICAgICAg ZWxzZQorICAgICAgICAgICAgICAgIHJldHVybiAiIjsKKyAgICB9Cit9KTsKKworVGV4dC5wcm90 b3R5cGUuc2VsZWN0ID0gZnVuY3Rpb24oc3RhcnQsIGVuZCkKK3sKKyAgICBzdGFydCA9IHN0YXJ0 IHx8IDA7CisgICAgZW5kID0gZW5kIHx8IHRoaXMudGV4dENvbnRlbnQubGVuZ3RoOworCisgICAg aWYgKHN0YXJ0IDwgMCkKKyAgICAgICAgc3RhcnQgPSBlbmQgKyBzdGFydDsKKworICAgIHZhciBz ZWxlY3Rpb24gPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CisgICAgc2VsZWN0aW9uLnJlbW92ZUFs bFJhbmdlcygpOworICAgIHZhciByYW5nZSA9IGRvY3VtZW50LmNyZWF0ZVJhbmdlKCk7CisgICAg cmFuZ2Uuc2V0U3RhcnQodGhpcywgc3RhcnQpOworICAgIHJhbmdlLnNldEVuZCh0aGlzLCBlbmQp OworICAgIHNlbGVjdGlvbi5hZGRSYW5nZShyYW5nZSk7CisgICAgcmV0dXJuIHRoaXM7Cit9CisK K0VsZW1lbnQucHJvdG90eXBlLl9fZGVmaW5lR2V0dGVyX18oInNlbGVjdGlvbkxlZnRPZmZzZXQi LCBmdW5jdGlvbigpIHsKKyAgICAvLyBDYWxjdWxhdGUgc2VsZWN0aW9uIG9mZnNldCByZWxhdGl2 ZSB0byB0aGUgY3VycmVudCBlbGVtZW50LgorCisgICAgdmFyIHNlbGVjdGlvbiA9IHdpbmRvdy5n ZXRTZWxlY3Rpb24oKTsKKyAgICBpZiAoIXNlbGVjdGlvbi5jb250YWluc05vZGUodGhpcywgdHJ1 ZSkpCisgICAgICAgIHJldHVybiBudWxsOworCisgICAgdmFyIGxlZnRPZmZzZXQgPSBzZWxlY3Rp b24uYW5jaG9yT2Zmc2V0OworICAgIHZhciBub2RlID0gc2VsZWN0aW9uLmFuY2hvck5vZGU7CisK KyAgICB3aGlsZSAobm9kZSAhPT0gdGhpcykgeworICAgICAgICB3aGlsZSAobm9kZS5wcmV2aW91 c1NpYmxpbmcpIHsKKyAgICAgICAgICAgIG5vZGUgPSBub2RlLnByZXZpb3VzU2libGluZzsKKyAg ICAgICAgICAgIGxlZnRPZmZzZXQgKz0gbm9kZS50ZXh0Q29udGVudC5sZW5ndGg7CisgICAgICAg IH0KKyAgICAgICAgbm9kZSA9IG5vZGUucGFyZW50Tm9kZTsKKyAgICB9CisKKyAgICByZXR1cm4g bGVmdE9mZnNldDsKK30pOworCiBOb2RlLnByb3RvdHlwZS5pc1doaXRlc3BhY2UgPSBpc05vZGVX aGl0ZXNwYWNlOwogTm9kZS5wcm90b3R5cGUuZGlzcGxheU5hbWUgPSBub2RlRGlzcGxheU5hbWU7 CiBOb2RlLnByb3RvdHlwZS5pc0FuY2VzdG9yID0gZnVuY3Rpb24obm9kZSkKQEAgLTY3Miw2ICs3 MjksMTIgQEAgQXJyYXkucHJvdG90eXBlLmtleVNldCA9IGZ1bmN0aW9uKCkKICAgICByZXR1cm4g a2V5czsKIH0KIAorQXJyYXkuY29udmVydCA9IGZ1bmN0aW9uKGxpc3QpCit7CisgICAgLy8gQ2Fz dCBhcnJheS1saWtlIG9iamVjdCB0byBhbiBhcnJheS4KKyAgICByZXR1cm4gQXJyYXkucHJvdG90 eXBlLnNsaWNlLmNhbGwobGlzdCk7Cit9CisKIGZ1bmN0aW9uIGluc2VydGlvbkluZGV4Rm9yT2Jq ZWN0SW5MaXN0U29ydGVkQnlGdW5jdGlvbihhbk9iamVjdCwgYUxpc3QsIGFGdW5jdGlvbikKIHsK ICAgICAvLyBpbmRleE9mIHJldHVybnMgKC1sb3dlckJvdW5kIC0gMSkuIFRha2luZyAoLXJlc3Vs dCAtIDEpIHdvcmtzIG91dCB0byBsb3dlckJvdW5kLgo= 59206 2010-06-20 12:04:08 -0700 2010-06-20 15:32:16 -0700 Autocomplete CSS properties and cycle through them using arrow keys css_properties_autocomplete.patch text/plain 14138 me ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZjI4OTM0Yi4uZmVjNjBkMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAorMjAxMC0wNi0xOSAgTmlraXRhIFZhc2ls eWV2ICA8bWVAZWx2MXMucnU+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgV2ViIEluc3BlY3RvcjogQXV0by1jb21wbGV0aW9uIGZvciBDU1MgcHJvcGVy dHkgbmFtZXMgaW4gU3R5bGVzIHBhbmUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE3Mzc0CisKKyAgICAgICAgQWRkZWQgYXV0b2NvbXBsZXRpb24gZm9y IENTUyBwcm9wZXJ0aWVzLiBBIHN1Z2dlc3Rpb24gZm9yIGEgcHJvcGVydHkKKyAgICAgICAgc2hv d3Mgd2hlbiB5b3UgdHlwZS4gWW91IGNhbiBhbHNvIGN5Y2xlIHRocm91Z2gga25vd24gcHJvcGVy dHkgbmFtZXMKKyAgICAgICAgdXNpbmcgdGhlIFVwIGFuZCBEb3duIGFycm93IGtleXMuCisKKyAg ICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9DU1ND b21wbGV0aW9ucy5qczogQWRkZWQuCisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlv bnMpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkNTU0NvbXBsZXRpb25zLnN0YXJ0c1dpdGgpOgor ICAgICAgICAoV2ViSW5zcGVjdG9yLkNTU0NvbXBsZXRpb25zLmZpcnN0U3RhcnRzV2l0aCk6Cisg ICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMuX2ZpcnN0SW5kZXhPZlByZWZpeCk6 CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMubmV4dCk6CisgICAgICAgIChX ZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMucHJldmlvdXMpOgorICAgICAgICAoV2ViSW5zcGVj dG9yLkNTU0NvbXBsZXRpb25zLl9jbG9zZXN0KToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQt ZW5kL1N0eWxlc1NpZGViYXJQYW5lLmpzOgorICAgICAgICAoV2ViSW5zcGVjdG9yLlN0eWxlUHJv cGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUpOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1l bmQvV2ViS2l0LnFyYzoKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5o dG1sOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvdXRpbGl0aWVzLmpzOgorICAgICAg ICAoVGV4dC5wcm90b3R5cGUuc2VsZWN0KToKKyAgICAgICAgKCk6CisKIDIwMTAtMDYtMTcgIFN0 ZXBoZW4gV2hpdGUgIDxzZW5vcmJsYW5jb0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgRGF2aWQgTGV2aW4uCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1dl YkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDBjMGY1ODAuLjkyNzg2YTUgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0zODk3LDYg KzM4OTcsNyBAQAogICAgICAgICAgICAgJ2luc3BlY3Rvci9mcm9udC1lbmQvQ29uc29sZVZpZXcu anMnLAogICAgICAgICAgICAgJ2luc3BlY3Rvci9mcm9udC1lbmQvQ29udGV4dE1lbnUuanMnLAog ICAgICAgICAgICAgJ2luc3BlY3Rvci9mcm9udC1lbmQvQ29va2llSXRlbXNWaWV3LmpzJywKKyAg ICAgICAgICAgICdpbnNwZWN0b3IvZnJvbnQtZW5kL0NTU0NvbXBsZXRpb25zLmpzJywKICAgICAg ICAgICAgICdpbnNwZWN0b3IvZnJvbnQtZW5kL0NTU1N0eWxlTW9kZWwuanMnLAogICAgICAgICAg ICAgJ2luc3BlY3Rvci9mcm9udC1lbmQvRGF0YWJhc2UuanMnLAogICAgICAgICAgICAgJ2luc3Bl Y3Rvci9mcm9udC1lbmQvRGF0YWJhc2VRdWVyeVZpZXcuanMnLApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0NTU0NvbXBsZXRpb25zLmpzIGIvV2ViQ29yZS9pbnNwZWN0 b3IvZnJvbnQtZW5kL0NTU0NvbXBsZXRpb25zLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjU0ODU0NjQKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2luc3BlY3Rvci9m cm9udC1lbmQvQ1NTQ29tcGxldGlvbnMuanMKQEAgLTAsMCArMSwxMDIgQEAKK1dlYkluc3BlY3Rv ci5DU1NDb21wbGV0aW9ucyA9IChmdW5jdGlvbigpIHsKKyAgICB2YXIgdXNlZCA9IHt9OworICAg IHZhciBwcm9wZXJ0aWVzID0gW107CisgICAgdmFyIHN0eWxlID0gZG9jdW1lbnQuZG9jdW1lbnRF bGVtZW50LnN0eWxlOworICAgIHZhciBsaXN0ID0gZG9jdW1lbnQuZGVmYXVsdFZpZXcuZ2V0Q29t cHV0ZWRTdHlsZShkb2N1bWVudC5kb2N1bWVudEVsZW1lbnQsICIiKTsKKyAgICB2YXIgbGVuZ3Ro ID0gbGlzdC5sZW5ndGg7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBsZW5ndGg7ICsraSkKKyAg ICAgICAgdXNlZFtwcm9wZXJ0aWVzW2ldID0gbGlzdFtpXV0gPSB0cnVlOworCisgICAgZm9yICh2 YXIgaSA9IDAsIGVuZCA9IGxlbmd0aDsgaSA8IGxlbmd0aDsgKytpKSB7CisgICAgICAgIHZhciBw cm9wZXJ0eVdvcmRzID0gcHJvcGVydGllc1tpXS5zcGxpdCgiLSIpOworICAgICAgICB2YXIgaiA9 IHByb3BlcnR5V29yZHMubGVuZ3RoOworICAgICAgICB3aGlsZSAoLS1qKSB7CisgICAgICAgICAg ICBwcm9wZXJ0eVdvcmRzLnBvcCgpOworICAgICAgICAgICAgdmFyIHNob3J0aGFuZCA9IHByb3Bl cnR5V29yZHMuam9pbigiLSIpOworICAgICAgICAgICAgaWYgKCEoc2hvcnRoYW5kIGluIHVzZWQp ICYmIHN0eWxlW3Nob3J0aGFuZF0gIT09IHVuZGVmaW5lZCkgeworICAgICAgICAgICAgICAgIHVz ZWRbc2hvcnRoYW5kXSA9IHRydWU7CisgICAgICAgICAgICAgICAgcHJvcGVydGllc1tlbmQrK10g PSBzaG9ydGhhbmQ7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1 cm4gcHJvcGVydGllcy5zb3J0KCk7Cit9KSgpOworCitXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlv bnMuc3RhcnRzV2l0aCA9IGZ1bmN0aW9uKHByZWZpeCkKK3sKKyAgICB2YXIgZmlyc3RJbmRleCA9 IHRoaXMuX2ZpcnN0SW5kZXhPZlByZWZpeChwcmVmaXgpOworICAgIGlmIChmaXJzdEluZGV4ID09 PSAtMSkKKyAgICAgICAgcmV0dXJuIFtdOworCisgICAgdmFyIHJlc3VsdHMgPSBbXTsKKyAgICB3 aGlsZSAodGhpc1tmaXJzdEluZGV4XS5pbmRleE9mKHByZWZpeCkgPT09IDApCisgICAgICAgIHJl c3VsdHMucHVzaCh0aGlzW2ZpcnN0SW5kZXgrK10pOworICAgIHJldHVybiByZXN1bHRzOworfQor CitXZWJJbnNwZWN0b3IuQ1NTQ29tcGxldGlvbnMuZmlyc3RTdGFydHNXaXRoID0gZnVuY3Rpb24o cHJlZml4KQoreworICAgIHZhciBmb3VuZEluZGV4ID0gdGhpcy5fZmlyc3RJbmRleE9mUHJlZml4 KHByZWZpeCk7CisgICAgcmV0dXJuIChmb3VuZEluZGV4ID09PSAtMSA/ICIiIDogdGhpc1tmb3Vu ZEluZGV4XSk7Cit9CisKK1dlYkluc3BlY3Rvci5DU1NDb21wbGV0aW9ucy5fZmlyc3RJbmRleE9m UHJlZml4ID0gZnVuY3Rpb24ocHJlZml4KQoreworICAgIGlmICghcHJlZml4KQorICAgICAgICBy ZXR1cm4gLTE7CisKKyAgICB2YXIgbWF4SW5kZXggPSB0aGlzLmxlbmd0aCAtIDE7CisgICAgdmFy IG1pbkluZGV4ID0gMDsKKyAgICB2YXIgZm91bmRJbmRleDsKKworICAgIGRvIHsKKyAgICAgICAg dmFyIG1pZGRsZUluZGV4ID0gKG1heEluZGV4ICsgbWluSW5kZXgpID4+IDE7CisgICAgICAgIGlm ICh0aGlzW21pZGRsZUluZGV4XS5pbmRleE9mKHByZWZpeCkgPT09IDApIHsKKyAgICAgICAgICAg IGZvdW5kSW5kZXggPSBtaWRkbGVJbmRleDsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9 CisgICAgICAgIGlmICh0aGlzW21pZGRsZUluZGV4XSA8IHByZWZpeCkKKyAgICAgICAgICAgIG1p bkluZGV4ID0gbWlkZGxlSW5kZXggKyAxOworICAgICAgICBlbHNlCisgICAgICAgICAgICBtYXhJ bmRleCA9IG1pZGRsZUluZGV4IC0gMTsKKyAgICB9IHdoaWxlIChtaW5JbmRleCA8PSBtYXhJbmRl eCk7CisKKyAgICBpZiAoIWZvdW5kSW5kZXgpCisgICAgICAgIHJldHVybiAtMTsKKworICAgIHdo aWxlIChmb3VuZEluZGV4ICYmIHRoaXNbZm91bmRJbmRleCAtIDFdLmluZGV4T2YocHJlZml4KSA9 PT0gMCkKKyAgICAgICAgZm91bmRJbmRleC0tOworCisgICAgcmV0dXJuIGZvdW5kSW5kZXg7Cit9 CisKK1dlYkluc3BlY3Rvci5DU1NDb21wbGV0aW9ucy5uZXh0ID0gZnVuY3Rpb24oc3RyLCBwcmVm aXgpCit7CisgICAgcmV0dXJuIFdlYkluc3BlY3Rvci5DU1NDb21wbGV0aW9ucy5fY2xvc2VzdChz dHIsIHByZWZpeCwgMSk7Cit9CisKK1dlYkluc3BlY3Rvci5DU1NDb21wbGV0aW9ucy5wcmV2aW91 cyA9IGZ1bmN0aW9uKHN0ciwgcHJlZml4KQoreworICAgIHJldHVybiBXZWJJbnNwZWN0b3IuQ1NT Q29tcGxldGlvbnMuX2Nsb3Nlc3Qoc3RyLCBwcmVmaXgsIC0xKTsKK30KKworV2ViSW5zcGVjdG9y LkNTU0NvbXBsZXRpb25zLl9jbG9zZXN0ID0gZnVuY3Rpb24oc3RyLCBwcmVmaXgsIHNoaWZ0KQor eworICAgIGlmICghc3RyKQorICAgICAgICByZXR1cm4gIiI7CisKKyAgICB2YXIgaW5kZXggPSB0 aGlzLmluZGV4T2Yoc3RyKTsKKyAgICBpZiAoaW5kZXggPT09IC0xKQorICAgICAgICByZXR1cm4g IiI7CisKKyAgICBpZiAoIXByZWZpeCkgeworICAgICAgICBpbmRleCA9IChpbmRleCArIHRoaXMu bGVuZ3RoICsgc2hpZnQpICUgdGhpcy5sZW5ndGg7CisgICAgICAgIHJldHVybiB0aGlzW2luZGV4 XTsKKyAgICB9CisKKyAgICB2YXIgcHJvcGVydGllc1dpdGhQcmVmaXggPSB0aGlzLnN0YXJ0c1dp dGgocHJlZml4KTsKKyAgICB2YXIgaiA9IHByb3BlcnRpZXNXaXRoUHJlZml4LmluZGV4T2Yoc3Ry KTsKKyAgICBqID0gKGogKyBwcm9wZXJ0aWVzV2l0aFByZWZpeC5sZW5ndGggKyBzaGlmdCkgJSBw cm9wZXJ0aWVzV2l0aFByZWZpeC5sZW5ndGg7CisgICAgcmV0dXJuIHByb3BlcnRpZXNXaXRoUHJl Zml4W2pdOworfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxl c1NpZGViYXJQYW5lLmpzIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1N0eWxlc1NpZGVi YXJQYW5lLmpzCmluZGV4IDE4YjdmMGYuLmM5MTNjZDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5z cGVjdG9yL2Zyb250LWVuZC9TdHlsZXNTaWRlYmFyUGFuZS5qcworKysgYi9XZWJDb3JlL2luc3Bl Y3Rvci9mcm9udC1lbmQvU3R5bGVzU2lkZWJhclBhbmUuanMKQEAgLTEzMTUsNiArMTMxNSwxOCBA QCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKICAg ICAgICAgZXZlbnQuc3RvcFByb3BhZ2F0aW9uKCk7CiAgICAgfSwKIAorICAgIHJlc3RvcmVOYW1l RWxlbWVudDogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgLy8gUmVzdG9yZSA8c3BhbiBjbGFz cz0id2Via2l0LWNzcy1wcm9wZXJ0eSI+IGlmIGl0IGRvZXNuJ3QgeWV0IGV4aXN0IG9yIHdhcyBh Y2NpZGVudGFsbHkgZGVsZXRlZC4KKyAgICAgICAgaWYgKHRoaXMubmFtZUVsZW1lbnQgPT09IHRo aXMubGlzdEl0ZW1FbGVtZW50LnF1ZXJ5U2VsZWN0b3IoIi53ZWJraXQtY3NzLXByb3BlcnR5Iikp CisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudCA9IGRvY3Vt ZW50LmNyZWF0ZUVsZW1lbnQoInNwYW4iKTsKKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5jbGFz c05hbWUgPSAid2Via2l0LWNzcy1wcm9wZXJ0eSI7CisgICAgICAgIHRoaXMubmFtZUVsZW1lbnQu dGV4dENvbnRlbnQgPSAiIjsKKyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuaW5zZXJ0QmVm b3JlKHRoaXMubmFtZUVsZW1lbnQsIHRoaXMubGlzdEl0ZW1FbGVtZW50LmZpcnN0Q2hpbGQpOwor ICAgIH0sCisKICAgICBzdGFydEVkaXRpbmc6IGZ1bmN0aW9uKHNlbGVjdEVsZW1lbnQpCiAgICAg ewogICAgICAgICAvLyBGSVhNRTogd2UgZG9uJ3QgYWxsb3cgZWRpdGluZyBvZiBsb25naGFuZCBw cm9wZXJ0aWVzIHVuZGVyIGEgc2hvcnRoYW5kIHJpZ2h0IG5vdy4KQEAgLTEzMjQsNyArMTMzNiwx MiBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsK ICAgICAgICAgaWYgKFdlYkluc3BlY3Rvci5pc0JlaW5nRWRpdGVkKHRoaXMubGlzdEl0ZW1FbGVt ZW50KSB8fCAodGhpcy50cmVlT3V0bGluZS5zZWN0aW9uICYmICF0aGlzLnRyZWVPdXRsaW5lLnNl Y3Rpb24uZWRpdGFibGUpKQogICAgICAgICAgICAgcmV0dXJuOwogCi0gICAgICAgIHZhciBjb250 ZXh0ID0geyBleHBhbmRlZDogdGhpcy5leHBhbmRlZCwgaGFzQ2hpbGRyZW46IHRoaXMuaGFzQ2hp bGRyZW4sIGtleURvd25MaXN0ZW5lcjogdGhpcy5lZGl0aW5nS2V5RG93bi5iaW5kKHRoaXMpIH07 CisgICAgICAgIHZhciBjb250ZXh0ID0geworICAgICAgICAgICAgZXhwYW5kZWQ6IHRoaXMuZXhw YW5kZWQsCisgICAgICAgICAgICBoYXNDaGlsZHJlbjogdGhpcy5oYXNDaGlsZHJlbiwKKyAgICAg ICAgICAgIGtleURvd25MaXN0ZW5lcjogdGhpcy5lZGl0aW5nS2V5RG93bi5iaW5kKHRoaXMpLAor ICAgICAgICAgICAga2V5UHJlc3NMaXN0ZW5lcjogdGhpcy5lZGl0aW5nS2V5UHJlc3MuYmluZCh0 aGlzKQorICAgICAgICB9OwogCiAgICAgICAgIC8vIExpZSBhYm91dCBvdXIgY2hpbGRyZW4gdG8g cHJldmVudCBleHBhbmRpbmcgb24gZG91YmxlIGNsaWNrIGFuZCB0byBjb2xsYXBzZSBzaG9ydGhh bmRzLgogICAgICAgICB0aGlzLmhhc0NoaWxkcmVuID0gZmFsc2U7CkBAIC0xMzMzLDExICsxMzUw LDQyIEBAIFdlYkluc3BlY3Rvci5TdHlsZVByb3BlcnR5VHJlZUVsZW1lbnQucHJvdG90eXBlID0g ewogICAgICAgICAgICAgc2VsZWN0RWxlbWVudCA9IHRoaXMubGlzdEl0ZW1FbGVtZW50OwogCiAg ICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LmFkZEV2ZW50TGlzdGVuZXIoImtleWRvd24iLCBj b250ZXh0LmtleURvd25MaXN0ZW5lciwgZmFsc2UpOworICAgICAgICB0aGlzLmxpc3RJdGVtRWxl bWVudC5hZGRFdmVudExpc3RlbmVyKCJrZXlwcmVzcyIsIGNvbnRleHQua2V5UHJlc3NMaXN0ZW5l ciwgZmFsc2UpOwogCiAgICAgICAgIFdlYkluc3BlY3Rvci5zdGFydEVkaXRpbmcodGhpcy5saXN0 SXRlbUVsZW1lbnQsIHRoaXMuZWRpdGluZ0NvbW1pdHRlZC5iaW5kKHRoaXMpLCB0aGlzLmVkaXRp bmdDYW5jZWxsZWQuYmluZCh0aGlzKSwgY29udGV4dCk7CiAgICAgICAgIHdpbmRvdy5nZXRTZWxl Y3Rpb24oKS5zZXRCYXNlQW5kRXh0ZW50KHNlbGVjdEVsZW1lbnQsIDAsIHNlbGVjdEVsZW1lbnQs IDEpOwogICAgIH0sCiAKKyAgICBlZGl0aW5nS2V5UHJlc3M6IGZ1bmN0aW9uKGV2ZW50KQorICAg IHsKKyAgICAgICAgdmFyIHNlbGVjdGlvbiA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKTsKKyAgICAg ICAgdmFyIGNvbG9uSW5kZXggPSB0aGlzLmxpc3RJdGVtRWxlbWVudC50ZXh0Q29udGVudC5pbmRl eE9mKCI6Iik7CisgICAgICAgIHZhciBzZWxlY3Rpb25MZWZ0T2Zmc2V0ID0gZXZlbnQudGFyZ2V0 LnNlbGVjdGlvbkxlZnRPZmZzZXQ7CisKKyAgICAgICAgaWYgKGNvbG9uSW5kZXggPCAwIHx8IHNl bGVjdGlvbkxlZnRPZmZzZXQgPD0gY29sb25JbmRleCkgeworICAgICAgICAgICAgLy8gQ29tcGxl dGUgcHJvcGVydHkgbmFtZXMuCisgICAgICAgICAgICB2YXIgY2hhcmFjdGVyID0gZXZlbnQuZGF0 YS50b0xvd2VyQ2FzZSgpOworICAgICAgICAgICAgaWYgKGNoYXJhY3RlciAmJiAvW2Etei1dLy50 ZXN0KGNoYXJhY3RlcikpIHsKKyAgICAgICAgICAgICAgICB2YXIgcHJlZml4ID0gc2VsZWN0aW9u LmFuY2hvck5vZGUudGV4dENvbnRlbnQuc3Vic3RyaW5nKDAsIHNlbGVjdGlvbi5hbmNob3JPZmZz ZXQpOworICAgICAgICAgICAgICAgIHZhciBwcm9wZXJ0eSA9IFdlYkluc3BlY3Rvci5DU1NDb21w bGV0aW9ucy5maXJzdFN0YXJ0c1dpdGgocHJlZml4ICsgY2hhcmFjdGVyKTsKKworICAgICAgICAg ICAgICAgIGlmICghc2VsZWN0aW9uLmlzQ29sbGFwc2VkKQorICAgICAgICAgICAgICAgICAgICBz ZWxlY3Rpb24uZGVsZXRlRnJvbURvY3VtZW50KCk7CisKKyAgICAgICAgICAgICAgICB0aGlzLnJl c3RvcmVOYW1lRWxlbWVudCgpOworCisgICAgICAgICAgICAgICAgaWYgKHByb3BlcnR5KSB7Cisg ICAgICAgICAgICAgICAgICAgIGlmIChwcm9wZXJ0eSAhPT0gdGhpcy5uYW1lRWxlbWVudC50ZXh0 Q29udGVudCkKKyAgICAgICAgICAgICAgICAgICAgICAgIHRoaXMubmFtZUVsZW1lbnQudGV4dENv bnRlbnQgPSBwcm9wZXJ0eTsKKyAgICAgICAgICAgICAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5m aXJzdENoaWxkLnNlbGVjdChwcmVmaXgubGVuZ3RoICsgMSk7CisgICAgICAgICAgICAgICAgICAg IGV2ZW50LnByZXZlbnREZWZhdWx0KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAg fQorICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gRklYTUU6IFRoaXMgc2hvdWxkIGNv bXBsZXRlIHByb3BlcnR5IHZhbHVlcy4KKyAgICAgICAgfQorICAgIH0sCisKICAgICBlZGl0aW5n S2V5RG93bjogZnVuY3Rpb24oZXZlbnQpCiAgICAgewogICAgICAgICB2YXIgYXJyb3dLZXlQcmVz c2VkID0gKGV2ZW50LmtleUlkZW50aWZpZXIgPT09ICJVcCIgfHwgZXZlbnQua2V5SWRlbnRpZmll ciA9PT0gIkRvd24iKTsKQEAgLTEzOTYsOSArMTQ0NCwyNCBAQCBXZWJJbnNwZWN0b3IuU3R5bGVQ cm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKICAgICAgICAgICAgIH0KIAogICAgICAg ICAgICAgcmVwbGFjZW1lbnRTdHJpbmcgPSBwcmVmaXggKyBudW1iZXIgKyBzdWZmaXg7Ci0gICAg ICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogdGhpcyBzaG91bGQgY3ljbGUgdGhy b3VnaCBrbm93biBrZXl3b3JkcyBmb3IgdGhlIGN1cnJlbnQgcHJvcGVydHkgbmFtZS4KKyAgICAg ICAgfSBlbHNlIGlmIChzZWxlY3Rpb24uY29udGFpbnNOb2RlKHRoaXMubmFtZUVsZW1lbnQsIHRy dWUpKSB7CisgICAgICAgICAgICB2YXIgcHJlZml4ID0gc2VsZWN0aW9uUmFuZ2Uuc3RhcnRDb250 YWluZXIudGV4dENvbnRlbnQuc3Vic3RyaW5nKDAsIHNlbGVjdGlvblJhbmdlLnN0YXJ0T2Zmc2V0 KTsKKyAgICAgICAgICAgIHZhciBwcm9wZXJ0eTsKKworICAgICAgICAgICAgaWYgKGV2ZW50Lmtl eUlkZW50aWZpZXIgPT09ICJVcCIpCisgICAgICAgICAgICAgICAgcHJvcGVydHkgPSBXZWJJbnNw ZWN0b3IuQ1NTQ29tcGxldGlvbnMucHJldmlvdXMod29yZFN0cmluZywgcHJlZml4KTsKKyAgICAg ICAgICAgIGVsc2UgaWYgKGV2ZW50LmtleUlkZW50aWZpZXIgPT09ICJEb3duIikKKyAgICAgICAg ICAgICAgICBwcm9wZXJ0eSA9IFdlYkluc3BlY3Rvci5DU1NDb21wbGV0aW9ucy5uZXh0KHdvcmRT dHJpbmcsIHByZWZpeCk7CisKKyAgICAgICAgICAgIHZhciBzdGFydE9mZnNldCA9IHNlbGVjdGlv blJhbmdlLnN0YXJ0T2Zmc2V0OworICAgICAgICAgICAgaWYgKHByb3BlcnR5KSB7CisgICAgICAg ICAgICAgICAgdGhpcy5uYW1lRWxlbWVudC50ZXh0Q29udGVudCA9IHByb3BlcnR5OworICAgICAg ICAgICAgICAgIHRoaXMubmFtZUVsZW1lbnQuZmlyc3RDaGlsZC5zZWxlY3Qoc3RhcnRPZmZzZXQp OworICAgICAgICAgICAgfQorICAgICAgICAgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTsKICAg ICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIEZJWE1F OiB0aGlzIHNob3VsZCBjeWNsZSB0aHJvdWdoIGtub3duIGtleXdvcmRzIGZvciB0aGUgY3VycmVu dCBwcm9wZXJ0eSB2YWx1ZS4KICAgICAgICAgfQogCiAgICAgICAgIHZhciByZXBsYWNlbWVudFRl eHROb2RlID0gZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUocmVwbGFjZW1lbnRTdHJpbmcpOwpAQCAt MTQzNCw2ICsxNDk3LDcgQEAgV2ViSW5zcGVjdG9yLlN0eWxlUHJvcGVydHlUcmVlRWxlbWVudC5w cm90b3R5cGUgPSB7CiAgICAgICAgIGlmIChjb250ZXh0LmV4cGFuZGVkKQogICAgICAgICAgICAg dGhpcy5leHBhbmQoKTsKICAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQucmVtb3ZlRXZlbnRM aXN0ZW5lcigia2V5ZG93biIsIGNvbnRleHQua2V5RG93bkxpc3RlbmVyLCBmYWxzZSk7CisgICAg ICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LnJlbW92ZUV2ZW50TGlzdGVuZXIoImtleXByZXNzIiwg Y29udGV4dC5rZXlQcmVzc0xpc3RlbmVyLCBmYWxzZSk7CiAgICAgICAgIGRlbGV0ZSB0aGlzLm9y aWdpbmFsQ1NTVGV4dDsKICAgICB9LAogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9m cm9udC1lbmQvV2ViS2l0LnFyYyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XZWJLaXQu cXJjCmluZGV4IGZkODQ1ODYuLmFkZDUwZTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVjdG9y L2Zyb250LWVuZC9XZWJLaXQucXJjCisrKyBiL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9X ZWJLaXQucXJjCkBAIC0xOSw2ICsxOSw3IEBACiAgICAgPGZpbGU+Q29uc29sZVZpZXcuanM8L2Zp bGU+CiAgICAgPGZpbGU+Q29udGV4dE1lbnUuanM8L2ZpbGU+CiAgICAgPGZpbGU+Q29va2llSXRl bXNWaWV3LmpzPC9maWxlPgorICAgIDxmaWxlPkNTU0NvbXBsZXRpb25zLmpzPC9maWxlPgogICAg IDxmaWxlPkNTU1N0eWxlTW9kZWwuanM8L2ZpbGU+CiAgICAgPGZpbGU+RGF0YWJhc2UuanM8L2Zp bGU+CiAgICAgPGZpbGU+RGF0YWJhc2VRdWVyeVZpZXcuanM8L2ZpbGU+CmRpZmYgLS1naXQgYS9X ZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0bWwgYi9XZWJDb3JlL2luc3Bl Y3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0bWwKaW5kZXggNGM1MTYzNC4uOGE4YjdkNSAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sCisrKyBi L1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuaHRtbApAQCAtODIsNiArODIs NyBAQCBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlBy b3BlcnRpZXNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0 L2phdmFzY3JpcHQiIHNyYz0iRXZlbnRMaXN0ZW5lcnNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+ CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iQ29sb3IuanMiPjwvc2Ny aXB0PgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IkNTU0NvbXBsZXRp b25zLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3Jj PSJTdHlsZXNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0 L2phdmFzY3JpcHQiIHNyYz0iUGFuZWxFbmFibGVyVmlldy5qcyI+PC9zY3JpcHQ+CiAgICAgPHNj cmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iV2VsY29tZVZpZXcuanMiPjwvc2NyaXB0 PgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGllcy5qcyBi L1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC91dGlsaXRpZXMuanMKaW5kZXggYmIxOWRiZC4u MTMxMmU1YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL3V0aWxpdGll cy5qcworKysgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvdXRpbGl0aWVzLmpzCkBAIC0z MjgsNiArMzI4LDYzIEBAIEVsZW1lbnQucHJvdG90eXBlLm9mZnNldFJlbGF0aXZlVG9XaW5kb3cg PSBmdW5jdGlvbih0YXJnZXRXaW5kb3cpCiAgICAgcmV0dXJuIGVsZW1lbnRPZmZzZXQ7CiB9CiAK K0tleWJvYXJkRXZlbnQucHJvdG90eXBlLl9fZGVmaW5lR2V0dGVyX18oImRhdGEiLCBmdW5jdGlv bigpCit7CisgICAgLy8gRW11bGF0ZSAiZGF0YSIgYXR0cmlidXRlIGZyb20gRE9NIDMgVGV4dElu cHV0IGV2ZW50LgorICAgIC8vIFNlZSBodHRwOi8vd3d3LnczLm9yZy9UUi9ET00tTGV2ZWwtMy1F dmVudHMvI2V2ZW50cy1FdmVudHMtVGV4dEV2ZW50LWRhdGEKKyAgICBzd2l0Y2ggKHRoaXMudHlw ZSkgeworICAgICAgICBjYXNlICJrZXlwcmVzcyI6CisgICAgICAgICAgICBpZiAoIXRoaXMuY3Ry bEtleSAmJiAhdGhpcy5tZXRhS2V5KQorICAgICAgICAgICAgICAgIHJldHVybiBTdHJpbmcuZnJv bUNoYXJDb2RlKHRoaXMuY2hhckNvZGUpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAg ICAgIHJldHVybiAiIjsKKyAgICAgICAgY2FzZSAia2V5ZG93biI6CisgICAgICAgIGNhc2UgImtl eXVwIjoKKyAgICAgICAgICAgIGlmICghdGhpcy5jdHJsS2V5ICYmICF0aGlzLm1ldGFLZXkgJiYg IXRoaXMuYWx0S2V5KQorICAgICAgICAgICAgICAgIHJldHVybiBTdHJpbmcuZnJvbUNoYXJDb2Rl KHRoaXMud2hpY2gpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHJldHVybiAi IjsKKyAgICB9Cit9KTsKKworVGV4dC5wcm90b3R5cGUuc2VsZWN0ID0gZnVuY3Rpb24oc3RhcnQs IGVuZCkKK3sKKyAgICBzdGFydCA9IHN0YXJ0IHx8IDA7CisgICAgZW5kID0gZW5kIHx8IHRoaXMu dGV4dENvbnRlbnQubGVuZ3RoOworCisgICAgaWYgKHN0YXJ0IDwgMCkKKyAgICAgICAgc3RhcnQg PSBlbmQgKyBzdGFydDsKKworICAgIHZhciBzZWxlY3Rpb24gPSB3aW5kb3cuZ2V0U2VsZWN0aW9u KCk7CisgICAgc2VsZWN0aW9uLnJlbW92ZUFsbFJhbmdlcygpOworICAgIHZhciByYW5nZSA9IGRv Y3VtZW50LmNyZWF0ZVJhbmdlKCk7CisgICAgcmFuZ2Uuc2V0U3RhcnQodGhpcywgc3RhcnQpOwor ICAgIHJhbmdlLnNldEVuZCh0aGlzLCBlbmQpOworICAgIHNlbGVjdGlvbi5hZGRSYW5nZShyYW5n ZSk7CisgICAgcmV0dXJuIHRoaXM7Cit9CisKK0VsZW1lbnQucHJvdG90eXBlLl9fZGVmaW5lR2V0 dGVyX18oInNlbGVjdGlvbkxlZnRPZmZzZXQiLCBmdW5jdGlvbigpIHsKKyAgICAvLyBDYWxjdWxh dGUgc2VsZWN0aW9uIG9mZnNldCByZWxhdGl2ZSB0byB0aGUgY3VycmVudCBlbGVtZW50LgorCisg ICAgdmFyIHNlbGVjdGlvbiA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKTsKKyAgICBpZiAoIXNlbGVj dGlvbi5jb250YWluc05vZGUodGhpcywgdHJ1ZSkpCisgICAgICAgIHJldHVybiBudWxsOworCisg ICAgdmFyIGxlZnRPZmZzZXQgPSBzZWxlY3Rpb24uYW5jaG9yT2Zmc2V0OworICAgIHZhciBub2Rl ID0gc2VsZWN0aW9uLmFuY2hvck5vZGU7CisKKyAgICB3aGlsZSAobm9kZSAhPT0gdGhpcykgewor ICAgICAgICB3aGlsZSAobm9kZS5wcmV2aW91c1NpYmxpbmcpIHsKKyAgICAgICAgICAgIG5vZGUg PSBub2RlLnByZXZpb3VzU2libGluZzsKKyAgICAgICAgICAgIGxlZnRPZmZzZXQgKz0gbm9kZS50 ZXh0Q29udGVudC5sZW5ndGg7CisgICAgICAgIH0KKyAgICAgICAgbm9kZSA9IG5vZGUucGFyZW50 Tm9kZTsKKyAgICB9CisKKyAgICByZXR1cm4gbGVmdE9mZnNldDsKK30pOworCiBOb2RlLnByb3Rv dHlwZS5pc1doaXRlc3BhY2UgPSBpc05vZGVXaGl0ZXNwYWNlOwogTm9kZS5wcm90b3R5cGUuZGlz cGxheU5hbWUgPSBub2RlRGlzcGxheU5hbWU7CiBOb2RlLnByb3RvdHlwZS5pc0FuY2VzdG9yID0g ZnVuY3Rpb24obm9kZSkKQEAgLTY3Miw2ICs3MjksMTIgQEAgQXJyYXkucHJvdG90eXBlLmtleVNl dCA9IGZ1bmN0aW9uKCkKICAgICByZXR1cm4ga2V5czsKIH0KIAorQXJyYXkuY29udmVydCA9IGZ1 bmN0aW9uKGxpc3QpCit7CisgICAgLy8gQ2FzdCBhcnJheS1saWtlIG9iamVjdCB0byBhbiBhcnJh eS4KKyAgICByZXR1cm4gQXJyYXkucHJvdG90eXBlLnNsaWNlLmNhbGwobGlzdCk7Cit9CisKIGZ1 bmN0aW9uIGluc2VydGlvbkluZGV4Rm9yT2JqZWN0SW5MaXN0U29ydGVkQnlGdW5jdGlvbihhbk9i amVjdCwgYUxpc3QsIGFGdW5jdGlvbikKIHsKICAgICAvLyBpbmRleE9mIHJldHVybnMgKC1sb3dl ckJvdW5kIC0gMSkuIFRha2luZyAoLXJlc3VsdCAtIDEpIHdvcmtzIG91dCB0byBsb3dlckJvdW5k Lgo=