{"query_id": "q-en-react-8504f1740628b9865d457c3a339d2f782319aaa42fdff1af8180b77ba4b9b7a4", "query": "The last two assertions in this new test don't pass because of the duck-typing check in . Not quite sure what you had in mind here. Not every object whose is a component class is a valid descriptor\u2026 right?\nThis is an intermediate step. Currently the duck typing is flawed regardless. Descriptors will probably get an inheritance chain so that instanceof ReactDescriptor works as a safer check. Only descriptors should pass. We could probably check for props too. It is expected that component classes themselves fail the test. Therefore it should also be renamed. On Feb 24, 2014, at 7:42 AM, Ben Alpert wrote:\nRight -- with the current code, returns true when passed a component class, which is wrong.\nThat's right. We should add that unit test. Out of curiosity, how did you find this? On Feb 24, 2014, at 1:51 PM, Ben Alpert wrote:\nI was adding a warning for passing a component class to renderComponent because of this Stack Overflow question:\nI think this is fixed. Not sure if we have a solid unit test to cover this.", "positive_passages": [{"docid": "doc-en-react-03965b5830162a723889287e9ea7d4a7dd65eea7c43058d52af7de046f28a267", "text": " /** * Copyright 2013-2014 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the \"License\"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an \"AS IS\" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * * @jsx React.DOM * @emails react-core */ \"use strict\"; var React; var ReactDescriptor; describe('ReactDescriptor', function() { beforeEach(function() { React = require('React'); ReactDescriptor = require('ReactDescriptor'); }); it('should identify valid descriptors correctly', function() { var Component = React.createClass({ render: function() { return
; } }); expect(ReactDescriptor.isValidDescriptor(
)).toEqual(true); expect(ReactDescriptor.isValidDescriptor()).toEqual(true); expect(ReactDescriptor.isValidDescriptor(null)).toEqual(false); expect(ReactDescriptor.isValidDescriptor(true)).toEqual(false); expect(ReactDescriptor.isValidDescriptor({})).toEqual(false); expect(ReactDescriptor.isValidDescriptor(\"string\")).toEqual(false); expect(ReactDescriptor.isValidDescriptor(React.DOM.div)).toEqual(false); expect(ReactDescriptor.isValidDescriptor(Component)).toEqual(false); }); }); ", "commid": "react_pr_1394"}], "negative_passages": []} {"query_id": "q-en-react-af28cccd15a54992f5cc048710312a6aeb6577db9cc5753621e969152ef7c8f3", "query": "React adds a scroll listener that tracks and caches the scroll position (I assume for some undocumented internal purpose). Additionally, the scroll listener forces a synchronous layout (see screenshot). This seems wasteful, especially considering that the values tracked are never exposed in the API. What is the scroll listener used for? Can it be removed? !\nViewportMetrics is used to normalize pageX and pageY on mouse events: . Perhaps ironically, it was created to prevent synchronous layouts during mouse event handlers.\nI wish these values (as well as the event) were somehow exposed.\n:+1:\nBTW you can obviously have this if you use a Webpack-like bundler:\nWell, is only used for IE8 and possibly other very old browsers (), so we should be able to just disable it for all other browsers and everyone is happy right? (Could still be optimized slightly for IE8... if anyone cares) Also, That makes no sense at all to me, does not take an argument, yet we get the scroll position and provide it as an argument. Instead, gets the scroll position internally and uses that? So we call twice, but only use the result once (also, this should be broken for events inside iframes, for IE8). Also2, I'm pretty sure any browsers that supports touch, also supports . cc\nI agree that we shouldn't be tracking it in other browsers if we don't need it. I don't know if there's a way to predict whether we'll have .pageX and .pageY before mouse events actually come in.\n:)\nAnother idea being just let resize/scroll set a flag, when a mouse event is created, if the flag is set, update viewport metrics. That way we only update it when needed, but could potentially cause a reflow if there are other events before it (very unlikely though I imagine).\nThis issue causes React based longer lists unusable on mobile.\nIs there any progress on this issue? I\u2019m not sure if this is the root-cause for pages rendered with react scrolling extremely slow with firefox mobile on android (e.g. this react website ).\nIs that your site? If so, you can try commenting out the logic in refreshScrollValues to see if it makes a difference. If it does, I'm happy to prioritize and try to get it in.\nNo, that is not my site, it is an example react & fluxible page (see: ), but we have exactly the same issues with scrolling on firefox mobile. I\u2019ve applied the changes in manually and it doesn\u2019t solves the problem, so this issue might be unrelated to my problem. I will investigate further. Thanks for considering to prioritize this. Much appreciated.", "positive_passages": [{"docid": "doc-en-react-60905e7c7989fb0566ee3fb085b2768fd99e55423986897b205141bb9d5e99a3", "text": "* React Core . General Purpose Event Plugin System */ var hasEventPageXY; var alreadyListeningTo = {}; var isMonitoringScrollValue = false; var reactTopListenersCounter = 0;", "commid": "react_pr_6129"}], "negative_passages": []} {"query_id": "q-en-react-af28cccd15a54992f5cc048710312a6aeb6577db9cc5753621e969152ef7c8f3", "query": "React adds a scroll listener that tracks and caches the scroll position (I assume for some undocumented internal purpose). Additionally, the scroll listener forces a synchronous layout (see screenshot). This seems wasteful, especially considering that the values tracked are never exposed in the API. What is the scroll listener used for? Can it be removed? !\nViewportMetrics is used to normalize pageX and pageY on mouse events: . Perhaps ironically, it was created to prevent synchronous layouts during mouse event handlers.\nI wish these values (as well as the event) were somehow exposed.\n:+1:\nBTW you can obviously have this if you use a Webpack-like bundler:\nWell, is only used for IE8 and possibly other very old browsers (), so we should be able to just disable it for all other browsers and everyone is happy right? (Could still be optimized slightly for IE8... if anyone cares) Also, That makes no sense at all to me, does not take an argument, yet we get the scroll position and provide it as an argument. Instead, gets the scroll position internally and uses that? So we call twice, but only use the result once (also, this should be broken for events inside iframes, for IE8). Also2, I'm pretty sure any browsers that supports touch, also supports . cc\nI agree that we shouldn't be tracking it in other browsers if we don't need it. I don't know if there's a way to predict whether we'll have .pageX and .pageY before mouse events actually come in.\n:)\nAnother idea being just let resize/scroll set a flag, when a mouse event is created, if the flag is set, update viewport metrics. That way we only update it when needed, but could potentially cause a reflow if there are other events before it (very unlikely though I imagine).\nThis issue causes React based longer lists unusable on mobile.\nIs there any progress on this issue? I\u2019m not sure if this is the root-cause for pages rendered with react scrolling extremely slow with firefox mobile on android (e.g. this react website ).\nIs that your site? If so, you can try commenting out the logic in refreshScrollValues to see if it makes a difference. If it does, I'm happy to prioritize and try to get it in.\nNo, that is not my site, it is an example react & fluxible page (see: ), but we have exactly the same issues with scrolling on firefox mobile. I\u2019ve applied the changes in manually and it doesn\u2019t solves the problem, so this issue might be unrelated to my problem. I will investigate further. Thanks for considering to prioritize this. Much appreciated.", "positive_passages": [{"docid": "doc-en-react-53ad83bc411cd1f32a7a7cd5095029155d5ccb095cc51c4f6c09b6ffdfbe7394", "text": "* Listens to window scroll and resize events. We cache scroll values so that * application code can access them without triggering reflows. * * ViewportMetrics is only used by SyntheticMouse/TouchEvent and only when * pageX/pageY isn't supported (legacy browsers). * * NOTE: Scroll events do not bubble. * * @see http://www.quirksmode.org/dom/events/scroll.html */ ensureScrollValueMonitoring: function() { if (!isMonitoringScrollValue) { ensureScrollValueMonitoring: function(){ if (hasEventPageXY === undefined) { hasEventPageXY = document.createEvent && 'pageX' in document.createEvent('MouseEvent'); } if (!hasEventPageXY && !isMonitoringScrollValue) { var refresh = ViewportMetrics.refreshScrollValues; ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh); isMonitoringScrollValue = true;", "commid": "react_pr_6129"}], "negative_passages": []} {"query_id": "q-en-react-16680cd16785bd149ce8f71ec27813f47ce0e569c64f71f4fc951f60d8a8becc", "query": "I am working on a project that has strict accessibility requirements. The table I am putting some data in has to implement headers and ids attributes to meet accessibility. See W3 techniques here Unfortunately the \"headers\" attribute is being stripped out because it's not supported by React (it's not on the supported attributes list). Can you please add support for the missing standard attribute called \"headers\"?\n+1\nAs a workaround I believe on a you can grab the DOMNode with a ref and add what you need.", "positive_passages": [{"docid": "doc-en-react-6e3497be782356eca9011a06a8cd1c87499f85f6464b0bdc794757dfabda927b", "text": "form: MUST_USE_ATTRIBUTE, formNoValidate: HAS_BOOLEAN_VALUE, frameBorder: MUST_USE_ATTRIBUTE, headers: null, height: MUST_USE_ATTRIBUTE, hidden: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE, href: null,", "commid": "react_pr_2553"}], "negative_passages": []} {"query_id": "q-en-react-dd628f4e74860ad5503f70abb342c44d4f269762880b09391d2158fc46e2c2fb", "query": "If we claim to support IE8, and users are testing their code locally in IE8, they might get thrown into compatibility mode by default. This will cause their webapp to blow up, and they will be confused because IE8 is a supported browser. For background, check out this thread: Users can get out of compatibility mode by adding this tag: Since the current failure is cryptic, and it's easy to detect when IE8 is in compatibility mode (), we should probably add a warning to give a hint to the user that even though they're using IE8, they're actually in compatibility mode (effectively IE7) and should add the meta tag or use one of the other various workarounds.", "positive_passages": [{"docid": "doc-en-react-24c9add1408fb48a3cb885faa2416ac6f2eaf2390804830565af58f69cc78e2e", "text": "var assign = require('Object.assign'); var findDOMNode = require('findDOMNode'); var onlyChild = require('onlyChild'); var warning = require('warning'); ReactDefaultInjection.inject();", "commid": "react_pr_3323"}], "negative_passages": []} {"query_id": "q-en-react-dd628f4e74860ad5503f70abb342c44d4f269762880b09391d2158fc46e2c2fb", "query": "If we claim to support IE8, and users are testing their code locally in IE8, they might get thrown into compatibility mode by default. This will cause their webapp to blow up, and they will be confused because IE8 is a supported browser. For background, check out this thread: Users can get out of compatibility mode by adding this tag: Since the current failure is cryptic, and it's easy to detect when IE8 is in compatibility mode (), we should probably add a warning to give a hint to the user that even though they're using IE8, they're actually in compatibility mode (effectively IE7) and should add the meta tag or use one of the other various workarounds.", "positive_passages": [{"docid": "doc-en-react-98cd49c00676a483b8bb9831879fa49838f40b437120186f4fda5e0af888bf58", "text": "} } // If we're in IE8, check to see if we are in combatibility mode and provide // information on preventing compatibility mode var ieCompatibilityMode = document.documentMode && document.documentMode < 8; warning( !ieCompatibilityMode, 'Internet Explorer is running in compatibility mode, please add the following ' + 'tag to your HTML to prevent this from happening: ' + '' ); var expectedFeatures = [ // shims Array.isArray,", "commid": "react_pr_3323"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-b8552e574aa63e00ff7351642a17caf16de211243d02c96e8eb0e205f2b901df", "text": "var MARKDOWN_COMPONENT = ` var converter = new Showdown.converter(); var MarkdownEditor = React.createClass({ getInitialState: function() { return {value: 'Type some *markdown* here!'};", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-4ea2cc92e2a4b7cb71fe9907df30e1a5477772eb55fe5a3809dd716aa0aa3557", "text": "
__html: converter.makeHtml(this.state.value) __html: marked(this.state.value, {sanitize: true}) }} />
", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-2be836c71d84ab1ae1a8bac90b0a5eeae0f38355b7cedb761ac3c10c9092c0d9", "text": " ", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-20ce2b27ca5a000860017820efe9643aa6f9e00c779b16e6ed8aeeb6eb93ec59", "text": "Markdown is a simple way to format your text inline. For example, surrounding text with asterisks will make it emphasized. First, add the third-party **Showdown** library to your application. This is a JavaScript library which takes Markdown text and converts it to raw HTML. This requires a script tag in your head (which we have already included in the React playground): First, add the third-party library **marked** to your application. This is a JavaScript library which takes Markdown text and converts it to raw HTML. This requires a script tag in your head (which we have already included in the React playground): ```html{7} ", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-b1519f314bfffaf415cf930144d222c8a1f05b3be25746cc6b8ac66f08522fa8", "text": " ``` Next, let's convert the comment text to Markdown and output it: ```javascript{2,10} ```javascript{9} // tutorial6.js var converter = new Showdown.converter(); var Comment = React.createClass({ render: function() { return (", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-f877b520452d96b851af3f845bd6425f3d0d405a62ed065724b86124e4200801", "text": "

{this.props.author}

{converter.makeHtml(this.props.children.toString())} {marked(this.props.children.toString())}
); } }); ``` All we're doing here is calling the Showdown library. We need to convert `this.props.children` from React's wrapped text to a raw string that Showdown will understand so we explicitly call `toString()`. All we're doing here is calling the marked library. We need to convert `this.props.children` from React's wrapped text to a raw string that marked will understand so we explicitly call `toString()`. But there's a problem! Our rendered comments look like this in the browser: \"`

`This is ``another`` comment`

`\". We want those tags to actually render as HTML. That's React protecting you from an XSS attack. There's a way to get around it but the framework warns you not to use it: ```javascript{5,11} ```javascript{4,10} // tutorial7.js var converter = new Showdown.converter(); var Comment = React.createClass({ render: function() { var rawMarkup = converter.makeHtml(this.props.children.toString()); var rawMarkup = marked(this.props.children.toString(), {sanitize: true}); return (

", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-564d32c40fb2c0c6d1a71ba75d5b644cc5c140e76114a8e2db89df198345e08a", "text": "}); ``` This is a special API that intentionally makes it difficult to insert raw HTML, but for Showdown we'll take advantage of this backdoor. This is a special API that intentionally makes it difficult to insert raw HTML, but for marked we'll take advantage of this backdoor. **Remember:** by using this feature you're relying on Showdown to be secure. **Remember:** by using this feature you're relying on marked to be secure. In this case, we pass `sanitize: true` which tells marked to escape any HTML markup in the source instead of passing it through unchanged. ### Hook up the data model", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-9df92b0e5d61e86c236bdc38559c41b06e0c72a3c7e46abcf312215f2ca96a57", "text": "

A Component Using External Plugins

React is flexible and provides hooks that allow you to interface with other libraries and frameworks. This example uses Showdown, an external other libraries and frameworks. This example uses **marked**, an external Markdown library, to convert the textarea's value in real-time.


", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-d3ae4a1acc61fdbcb7663668bbb60e23452eda1e31b97abf9aacc538395b6a97", "text": " /** * marked - a markdown parser * Copyright (c) 2011-2014, Christopher Jeffrey. (MIT Licensed) * https://github.com/chjj/marked */ (function(){var block={newline:/^n+/,code:/^( {4}[^n]+n*)+/,fences:noop,hr:/^( *[-*_]){3,} *(?:n+|$)/,heading:/^ *(#{1,6}) *([^n]+?) *#* *(?:n+|$)/,nptable:noop,lheading:/^([^n]+)n *(=|-){2,} *(?:n+|$)/,blockquote:/^( *>[^n]+(n(?!def)[^n]+)*n*)+/,list:/^( *)(bull) [sS]+?(?:hr|def|n{2,}(?! )(?!1bull )n*|s*$)/,html:/^ *(?:comment|closed|closing) *(?:n{2,}|s*$)/,def:/^ *[([^]]+)]: *]+)>?(?: +[\"(]([^n]+)[\")])? *(?:n+|$)/,table:noop,paragraph:/^((?:[^n]+n?(?!hr|heading|lheading|blockquote|tag|def))+)n*/,text:/^[^n]+/};block.bullet=/(?:[*+-]|d+.)/;block.item=/^( *)(bull) [^n]*(?:n(?!1bull )[^n]*)*/;block.item=replace(block.item,\"gm\")(/bull/g,block.bullet)();block.list=replace(block.list)(/bull/g,block.bullet)(\"hr\",\"n+(?=1?(?:[-*_] *){3,}(?:n+|$))\")(\"def\",\"n+(?=\"+block.def.source+\")\")();block.blockquote=replace(block.blockquote)(\"def\",block.def)();block._tag=\"(?!(?:\"+\"a|em|strong|small|s|cite|q|dfn|abbr|data|time|code\"+\"|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo\"+\"|span|br|wbr|ins|del|img)b)w+(?!:/|[^ws@]*@)b\";block.html=replace(block.html)(\"comment\",//)(\"closed\",/<(tag)[sS]+?/)(\"closing\",/])*?>/)(/tag/g,block._tag)();block.paragraph=replace(block.paragraph)(\"hr\",block.hr)(\"heading\",block.heading)(\"lheading\",block.lheading)(\"blockquote\",block.blockquote)(\"tag\",\"<\"+block._tag)(\"def\",block.def)();block.normal=merge({},block);block.gfm=merge({},block.normal,{fences:/^ *(`{3,}|~{3,}) *(S+)? *n([sS]+?)s*1 *(?:n+|$)/,paragraph:/^/});block.gfm.paragraph=replace(block.paragraph)(\"(?!\",\"(?!\"+block.gfm.fences.source.replace(\"1\",\"2\")+\"|\"+block.list.source.replace(\"1\",\"3\")+\"|\")();block.tables=merge({},block.gfm,{nptable:/^ *(S.*|.*)n *([-:]+ *|[-| :]*)n((?:.*|.*(?:n|$))*)n*/,table:/^ *|(.+)n *|( *[-:]+[-| :]*)n((?: *|.*(?:n|$))*)n*/});function Lexer(options){this.tokens=[];this.tokens.links={};this.options=options||marked.defaults;this.rules=block.normal;if(this.options.gfm){if(this.options.tables){this.rules=block.tables}else{this.rules=block.gfm}}}Lexer.rules=block;Lexer.lex=function(src,options){var lexer=new Lexer(options);return lexer.lex(src)};Lexer.prototype.lex=function(src){src=src.replace(/rn|r/g,\"n\").replace(/t/g,\" \").replace(/u00a0/g,\" \").replace(/u2424/g,\"n\");return this.token(src,true)};Lexer.prototype.token=function(src,top,bq){var src=src.replace(/^ +$/gm,\"\"),next,loose,cap,bull,b,item,space,i,l;while(src){if(cap=this.rules.newline.exec(src)){src=src.substring(cap[0].length);if(cap[0].length>1){this.tokens.push({type:\"space\"})}}if(cap=this.rules.code.exec(src)){src=src.substring(cap[0].length);cap=cap[0].replace(/^ {4}/gm,\"\");this.tokens.push({type:\"code\",text:!this.options.pedantic?cap.replace(/n+$/,\"\"):cap});continue}if(cap=this.rules.fences.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:\"code\",lang:cap[2],text:cap[3]});continue}if(cap=this.rules.heading.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:\"heading\",depth:cap[1].length,text:cap[2]});continue}if(top&&(cap=this.rules.nptable.exec(src))){src=src.substring(cap[0].length);item={type:\"table\",header:cap[1].replace(/^ *| *| *$/g,\"\").split(/ *| */),align:cap[2].replace(/^ *|| *$/g,\"\").split(/ *| */),cells:cap[3].replace(/n$/,\"\").split(\"n\")};for(i=0;i ?/gm,\"\");this.token(cap,top,true);this.tokens.push({type:\"blockquote_end\"});continue}if(cap=this.rules.list.exec(src)){src=src.substring(cap[0].length);bull=cap[2];this.tokens.push({type:\"list_start\",ordered:bull.length>1});cap=cap[0].match(this.rules.item);next=false;l=cap.length;i=0;for(;i1&&b.length>1)){src=cap.slice(i+1).join(\"n\")+src;i=l-1}}loose=next||/nn(?!s*$)/.test(item);if(i!==l-1){next=item.charAt(item.length-1)===\"n\";if(!loose)loose=next}this.tokens.push({type:loose?\"loose_item_start\":\"list_item_start\"});this.token(item,false,bq);this.tokens.push({type:\"list_item_end\"})}this.tokens.push({type:\"list_end\"});continue}if(cap=this.rules.html.exec(src)){src=src.substring(cap[0].length);this.tokens.push({type:this.options.sanitize?\"paragraph\":\"html\",pre:cap[1]===\"pre\"||cap[1]===\"script\"||cap[1]===\"style\",text:cap[0]});continue}if(!bq&&top&&(cap=this.rules.def.exec(src))){src=src.substring(cap[0].length);this.tokens.links[cap[1].toLowerCase()]={href:cap[2],title:cap[3]};continue}if(top&&(cap=this.rules.table.exec(src))){src=src.substring(cap[0].length);item={type:\"table\",header:cap[1].replace(/^ *| *| *$/g,\"\").split(/ *| */),align:cap[2].replace(/^ *|| *$/g,\"\").split(/ *| */),cells:cap[3].replace(/(?: *| *)?n$/,\"\").split(\"n\")};for(i=0;i])/,autolink:/^<([^ >]+(@|:/)[^ >]+)>/,url:noop,tag:/^|^])*?>/,link:/^!?[(inside)](href)/,reflink:/^!?[(inside)]s*[([^]]*)]/,nolink:/^!?[((?:[[^]]*]|[^[]])*)]/,strong:/^__([sS]+?)__(?!_)|^**([sS]+?)**(?!*)/,em:/^b_((?:__|[sS])+?)_b|^*((?:**|[sS])+?)*(?!*)/,code:/^(`+)s*([sS]*?[^`])s*1(?!`)/,br:/^ {2,}n(?!s*$)/,del:noop,text:/^[sS]+?(?=[?(?:s+['\"]([sS]*?)['\"])?s*/;inline.link=replace(inline.link)(\"inside\",inline._inside)(\"href\",inline._href)();inline.reflink=replace(inline.reflink)(\"inside\",inline._inside)();inline.normal=merge({},inline);inline.pedantic=merge({},inline.normal,{strong:/^__(?=S)([sS]*?S)__(?!_)|^**(?=S)([sS]*?S)**(?!*)/,em:/^_(?=S)([sS]*?S)_(?!_)|^*(?=S)([sS]*?S)*(?!*)/});inline.gfm=merge({},inline.normal,{escape:replace(inline.escape)(\"])\",\"~|])\")(),url:/^(https?://[^s<]+[^<.,:;\"')]s])/,del:/^~~(?=S)([sS]*?S)~~/,text:replace(inline.text)(\"]|\",\"~]|\")(\"|\",\"|https?://|\")()});inline.breaks=merge({},inline.gfm,{br:replace(inline.br)(\"{2,}\",\"*\")(),text:replace(inline.gfm.text)(\"{2,}\",\"*\")()});function InlineLexer(links,options){this.options=options||marked.defaults;this.links=links;this.rules=inline.normal;this.renderer=this.options.renderer||new Renderer;this.renderer.options=this.options;if(!this.links){throw new Error(\"Tokens array requires a `links` property.\")}if(this.options.gfm){if(this.options.breaks){this.rules=inline.breaks}else{this.rules=inline.gfm}}else if(this.options.pedantic){this.rules=inline.pedantic}}InlineLexer.rules=inline;InlineLexer.output=function(src,links,options){var inline=new InlineLexer(links,options);return inline.output(src)};InlineLexer.prototype.output=function(src){var out=\"\",link,text,href,cap;while(src){if(cap=this.rules.escape.exec(src)){src=src.substring(cap[0].length);out+=cap[1];continue}if(cap=this.rules.autolink.exec(src)){src=src.substring(cap[0].length);if(cap[2]===\"@\"){text=cap[1].charAt(6)===\":\"?this.mangle(cap[1].substring(7)):this.mangle(cap[1]);href=this.mangle(\"mailto:\")+text}else{text=escape(cap[1]);href=text}out+=this.renderer.link(href,null,text);continue}if(!this.inLink&&(cap=this.rules.url.exec(src))){src=src.substring(cap[0].length);text=escape(cap[1]);href=text;out+=this.renderer.link(href,null,text);continue}if(cap=this.rules.tag.exec(src)){if(!this.inLink&&/^/i.test(cap[0])){this.inLink=false}src=src.substring(cap[0].length);out+=this.options.sanitize?escape(cap[0]):cap[0];continue}if(cap=this.rules.link.exec(src)){src=src.substring(cap[0].length);this.inLink=true;out+=this.outputLink(cap,{href:cap[2],title:cap[3]});this.inLink=false;continue}if((cap=this.rules.reflink.exec(src))||(cap=this.rules.nolink.exec(src))){src=src.substring(cap[0].length);link=(cap[2]||cap[1]).replace(/s+/g,\" \");link=this.links[link.toLowerCase()];if(!link||!link.href){out+=cap[0].charAt(0);src=cap[0].substring(1)+src;continue}this.inLink=true;out+=this.outputLink(cap,link);this.inLink=false;continue}if(cap=this.rules.strong.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.strong(this.output(cap[2]||cap[1]));continue}if(cap=this.rules.em.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.em(this.output(cap[2]||cap[1]));continue}if(cap=this.rules.code.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.codespan(escape(cap[2],true));continue}if(cap=this.rules.br.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.br();continue}if(cap=this.rules.del.exec(src)){src=src.substring(cap[0].length);out+=this.renderer.del(this.output(cap[1]));continue}if(cap=this.rules.text.exec(src)){src=src.substring(cap[0].length);out+=escape(this.smartypants(cap[0]));continue}if(src){throw new Error(\"Infinite loop on byte: \"+src.charCodeAt(0))}}return out};InlineLexer.prototype.outputLink=function(cap,link){var href=escape(link.href),title=link.title?escape(link.title):null;return cap[0].charAt(0)!==\"!\"?this.renderer.link(href,title,this.output(cap[1])):this.renderer.image(href,title,escape(cap[1]))};InlineLexer.prototype.smartypants=function(text){if(!this.options.smartypants)return text;return text.replace(/--/g,\"\u2014\").replace(/(^|[-u2014/([{\"s])'/g,\"$1\u2018\").replace(/'/g,\"\u2019\").replace(/(^|[-u2014/([{u2018s])\"/g,\"$1\u201c\").replace(/\"/g,\"\u201d\").replace(/.{3}/g,\"\u2026\")};InlineLexer.prototype.mangle=function(text){var out=\"\",l=text.length,i=0,ch;for(;i.5){ch=\"x\"+ch.toString(16)}out+=\"&#\"+ch+\";\"}return out};function Renderer(options){this.options=options||{}}Renderer.prototype.code=function(code,lang,escaped){if(this.options.highlight){var out=this.options.highlight(code,lang);if(out!=null&&out!==code){escaped=true;code=out}}if(!lang){return\"
\"+(escaped?code:escape(code,true))+\"n
\"}return'
'+(escaped?code:escape(code,true))+\"n
n\"};Renderer.prototype.blockquote=function(quote){return\"
n\"+quote+\"
n\"};Renderer.prototype.html=function(html){return html};Renderer.prototype.heading=function(text,level,raw){return\"'+text+\"n\"};Renderer.prototype.hr=function(){return this.options.xhtml?\"
n\":\"
n\"};Renderer.prototype.list=function(body,ordered){var type=ordered?\"ol\":\"ul\";return\"<\"+type+\">n\"+body+\"n\"};Renderer.prototype.listitem=function(text){return\"
  • \"+text+\"
  • n\"};Renderer.prototype.paragraph=function(text){return\"

    \"+text+\"

    n\"};Renderer.prototype.table=function(header,body){return\"n\"+\"n\"+header+\"n\"+\"n\"+body+\"n\"+\"
    n\"};Renderer.prototype.tablerow=function(content){return\"n\"+content+\"n\"};Renderer.prototype.tablecell=function(content,flags){var type=flags.header?\"th\":\"td\";var tag=flags.align?\"<\"+type+' style=\"text-align:'+flags.align+'\">':\"<\"+type+\">\";return tag+content+\"n\"};Renderer.prototype.strong=function(text){return\"\"+text+\"\"};Renderer.prototype.em=function(text){return\"\"+text+\"\"};Renderer.prototype.codespan=function(text){return\"\"+text+\"\"};Renderer.prototype.br=function(){return this.options.xhtml?\"
    \":\"
    \"};Renderer.prototype.del=function(text){return\"\"+text+\"\"};Renderer.prototype.link=function(href,title,text){if(this.options.sanitize){try{var prot=decodeURIComponent(unescape(href)).replace(/[^w:]/g,\"\").toLowerCase()}catch(e){return\"\"}if(prot.indexOf(\"javascript:\")===0){return\"\"}}var out='
    \"+text+\"\";return out};Renderer.prototype.image=function(href,title,text){var out='\"'+text+'\"';if(title){out+='\":\">\";return out};function Parser(options){this.tokens=[];this.token=null;this.options=options||marked.defaults;this.options.renderer=this.options.renderer||new Renderer;this.renderer=this.options.renderer;this.renderer.options=this.options}Parser.parse=function(src,options,renderer){var parser=new Parser(options,renderer);return parser.parse(src)};Parser.prototype.parse=function(src){this.inline=new InlineLexer(src.links,this.options,this.renderer);this.tokens=src.reverse();var out=\"\";while(this.next()){out+=this.tok()}return out};Parser.prototype.next=function(){return this.token=this.tokens.pop()};Parser.prototype.peek=function(){return this.tokens[this.tokens.length-1]||0};Parser.prototype.parseText=function(){var body=this.token.text;while(this.peek().type===\"text\"){body+=\"n\"+this.next().text}return this.inline.output(body)};Parser.prototype.tok=function(){switch(this.token.type){case\"space\":{return\"\"}case\"hr\":{return this.renderer.hr()}case\"heading\":{return this.renderer.heading(this.inline.output(this.token.text),this.token.depth,this.token.text)}case\"code\":{return this.renderer.code(this.token.text,this.token.lang,this.token.escaped)}case\"table\":{var header=\"\",body=\"\",i,row,cell,flags,j;cell=\"\";for(i=0;i/g,\">\").replace(/\"/g,\""\").replace(/'/g,\"'\")}function unescape(html){return html.replace(/&([#w]+);/g,function(_,n){n=n.toLowerCase();if(n===\"colon\")return\":\";if(n.charAt(0)===\"#\"){return n.charAt(1)===\"x\"?String.fromCharCode(parseInt(n.substring(2),16)):String.fromCharCode(+n.substring(1))}return\"\"})}function replace(regex,opt){regex=regex.source;opt=opt||\"\";return function self(name,val){if(!name)return new RegExp(regex,opt);val=val.source||val;val=val.replace(/(^|[^[])^/g,\"$1\");regex=regex.replace(name,val);return self}}function noop(){}noop.exec=noop;function merge(obj){var i=1,target,key;for(;iAn error occured:

    \"+escape(e.message+\"\",true)+\"
    \"}throw e}}marked.options=marked.setOptions=function(opt){merge(marked.defaults,opt);return marked};marked.defaults={gfm:true,tables:true,breaks:false,pedantic:false,sanitize:false,smartLists:false,silent:false,highlight:null,langPrefix:\"lang-\",smartypants:false,headerPrefix:\"\",renderer:new Renderer,xhtml:false};marked.Parser=Parser;marked.parser=Parser.parse;marked.Renderer=Renderer;marked.Lexer=Lexer;marked.lexer=Lexer.lex;marked.InlineLexer=InlineLexer;marked.inlineLexer=InlineLexer.output;marked.parse=marked;if(typeof exports===\"object\"){module.exports=marked}else if(typeof define===\"function\"&&define.amd){define(function(){return marked})}else{this.marked=marked}}).call(function(){return this||(typeof window!==\"undefined\"?window:global)}());
    No newline at end of file", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-bda68aba5b773f0e231d8ae9f598c5dea11ff75961a86d42353566558f7ff8f7", "query": "Since copy+pasting our code makes it too easy for people to XSS themselves, lets just add a comment in there about it.\nPR at - let me know if that's what you had in mind!\nMy intuition is that it makes more sense to fix the example (call a sanitization library) or to change the example completely (demonstrate something else that is safer). It looks really bad to have a security warning on the homepage of the react site. Makes it seem like our framework encourages unsafe operations, rather than a safe-by-default way of doing things.\nShould switch the demo to use a different library like markdown-js that escapes everything and doesn't support HTML:\nmarkdown-js looks good. First attempt: ,output Code licensed if someone wants to turn this into a coherent example; I've signed the CLA.\nThat's a good suggestion too :) - what are your thoughts? I'm happy to change the example to use like people have suggested above. nice usage example :+1:\nUh yea, that sounds fine to me. This behavior is definitely non-standard markdown but it's an example so not a big deal. We should probably do the same for the tutorial while we're here. And it's on cdnjs so that's all pretty easy:\nJust going to use marked instead, which I'm already familiar with and has an option to sanitize input.", "positive_passages": [{"docid": "doc-en-react-320fb007e8626bf23a4b5d9396e86f181bc8b6c98f43abd30ac69de3fc173817", "text": " // // showdown.js -- A javascript port of Markdown. // // Copyright (c) 2007 John Fraser. // // Original Markdown Copyright (c) 2004-2005 John Gruber // // // Redistributable under a BSD-style open source license. // See license.txt for more information. // // The full source distribution is at: // //\t\t\t\tA A L //\t\t\t\tT C A //\t\t\t\tT K B // // // // // Wherever possible, Showdown is a straight, line-by-line port // of the Perl version of Markdown. // // This is not a normal parser design; it's basically just a // series of string substitutions. It's hard to read and // maintain this way, but keeping Showdown close to the original // design makes it easier to port new features. // // More importantly, Showdown behaves like markdown.pl in most // edge cases. So web applications can do client-side preview // in Javascript, and then build identical HTML on the server. // // This port needs the new RegExp functionality of ECMA 262, // 3rd Edition (i.e. Javascript 1.5). Most modern web browsers // should do fine. Even with the new regular expression features, // We do a lot of work to emulate Perl's regex functionality. // The tricky changes in this file mostly have the \"attacklab:\" // label. Major or self-explanatory changes don't. // // Smart diff tools like Araxis Merge will be able to match up // this file with markdown.pl in a useful way. A little tweaking // helps: in a copy of markdown.pl, replace \"#\" with \"//\" and // replace \"$text\" with \"text\". Be sure to ignore whitespace // and line endings. // // // Showdown usage: // // var text = \"Markdown *rocks*.\"; // // var converter = new Showdown.converter(); // var html = converter.makeHtml(text); // // alert(html); // // Note: move the sample code to the bottom of this // file before uncommenting it. // // // Showdown namespace // var Showdown = {}; // // converter // // Wraps all \"globals\" so that the only thing // exposed is makeHtml(). // Showdown.converter = function() { // // Globals: // // Global hashes, used by various utility routines var g_urls; var g_titles; var g_html_blocks; // Used to track when we're inside an ordered or unordered list // (see _ProcessListItems() for details): var g_list_level = 0; this.makeHtml = function(text) { // // Main function. The order in which other subs are called here is // essential. Link and image substitutions need to happen before // _EscapeSpecialCharsWithinTagAttributes(), so that any *'s or _'s in the // and tags get encoded. // // Clear the global hashes. If we don't clear these, you get conflicts // from other articles when generating a page which contains more than // one article (e.g. an index page that shows the N most recent // articles): g_urls = new Array(); g_titles = new Array(); g_html_blocks = new Array(); // attacklab: Replace ~ with ~T // This lets us use tilde as an escape char to avoid md5 hashes // The choice of character is arbitray; anything that isn't // magic in Markdown will work. text = text.replace(/~/g,\"~T\"); // attacklab: Replace $ with ~D // RegExp interprets $ as a special character // when it's in a replacement string text = text.replace(/$/g,\"~D\"); // Standardize line endings text = text.replace(/rn/g,\"n\"); // DOS to Unix text = text.replace(/r/g,\"n\"); // Mac to Unix // Make sure text begins and ends with a couple of newlines: text = \"nn\" + text + \"nn\"; // Convert all tabs to spaces. text = _Detab(text); // Strip any lines consisting only of spaces and tabs. // This makes subsequent regexen easier to write, because we can // match consecutive blank lines with /n+/ instead of something // contorted like /[ t]*n+/ . text = text.replace(/^[ t]+$/mg,\"\"); // Turn block-level HTML blocks into hash entries text = _HashHTMLBlocks(text); // Strip link definitions, store in hashes. text = _StripLinkDefinitions(text); text = _RunBlockGamut(text); text = _UnescapeSpecialChars(text); // attacklab: Restore dollar signs text = text.replace(/~D/g,\"$$\"); // attacklab: Restore tildes text = text.replace(/~T/g,\"~\"); return text; } var _StripLinkDefinitions = function(text) { // // Strips link definitions from text, stores the URLs and titles in // hash references. // // Link defs are in the form: ^[id]: url \"optional title\" /* var text = text.replace(/ ^[ ]{0,3}[(.+)]: // id = $1 attacklab: g_tab_width - 1 [ t]* n?\t\t\t\t// maybe *one* newline [ t]* ?\t\t\t// url = $2 [ t]* n?\t\t\t\t// maybe one newline [ t]* (?: (n*)\t\t\t\t// any lines skipped = $3 attacklab: lookbehind removed [\"(] (.+?)\t\t\t\t// title = $4 [\")] [ t]* )?\t\t\t\t\t// title is optional (?:n+|$) /gm, function(){...}); */ var text = text.replace(/^[ ]{0,3}[(.+)]:[ t]*n?[ t]*?[ t]*n?[ t]*(?:(n*)[\"(](.+?)[\")][ t]*)?(?:n+|Z)/gm, function (wholeMatch,m1,m2,m3,m4) { m1 = m1.toLowerCase(); g_urls[m1] = _EncodeAmpsAndAngles(m2); // Link IDs are case-insensitive if (m3) { // Oops, found blank lines, so it's not a title. // Put back the parenthetical statement we stole. return m3+m4; } else if (m4) { g_titles[m1] = m4.replace(/\"/g,\""\"); } // Completely remove the definition from the text return \"\"; } ); return text; } var _HashHTMLBlocks = function(text) { // attacklab: Double up blank lines to reduce lookaround text = text.replace(/n/g,\"nn\"); // Hashify HTML blocks: // We only want to do this for block-level HTML tags, such as headers, // lists, and tables. That's because we still want to wrap

    s around // \"paragraphs\" that are wrapped in non-block-level tags, such as anchors, // phrase emphasis, and spans. The list of tags we're looking for is // hard-coded: var block_tags_a = \"p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del\" var block_tags_b = \"p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math\" // First, look for nested blocks, e.g.: //

    //
    // tags for inner block must be indented. //
    //
    // // The outermost tags must start at the left margin for this to match, and // the inner nested divs must be indented. // We need to do this before the next, more liberal match, because the next // match will start at the first `
    ` and stop at the first `
    `. // attacklab: This regex can be expensive when it fails. /* var text = text.replace(/ (\t\t\t\t\t\t// save in $1 ^\t\t\t\t\t// start of line (with /m) <($block_tags_a)\t// start tag = $2 b\t\t\t\t\t// word break // attacklab: hack around khtml/pcre bug... [^r]*?n\t\t\t// any number of lines, minimally matching \t\t\t\t// the matching end tag [ t]*\t\t\t\t// trailing spaces/tabs (?=n+)\t\t\t\t// followed by a newline )\t\t\t\t\t\t// attacklab: there are sentinel newlines at end of document /gm,function(){...}}; */ text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del)b[^r]*?n[ t]*(?=n+))/gm,hashElement); // // Now match more liberally, simply from `n` to `n` // /* var text = text.replace(/ (\t\t\t\t\t\t// save in $1 ^\t\t\t\t\t// start of line (with /m) <($block_tags_b)\t// start tag = $2 b\t\t\t\t\t// word break // attacklab: hack around khtml/pcre bug... [^r]*?\t\t\t\t// any number of lines, minimally matching .*\t\t\t\t// the matching end tag [ t]*\t\t\t\t// trailing spaces/tabs (?=n+)\t\t\t\t// followed by a newline )\t\t\t\t\t\t// attacklab: there are sentinel newlines at end of document /gm,function(){...}}; */ text = text.replace(/^(<(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math)b[^r]*?.*[ t]*(?=n+)n)/gm,hashElement); // Special case just for
    . It was easier to make a special case than // to make the other regex more complicated. /* text = text.replace(/ (\t\t\t\t\t\t// save in $1 nn\t\t\t\t// Starting after a blank line [ ]{0,3} (<(hr)\t\t\t\t// start tag = $2 b\t\t\t\t\t// word break ([^<>])*?\t\t\t// /?>)\t\t\t\t// the matching end tag [ t]* (?=n{2,})\t\t\t// followed by a blank line ) /g,hashElement); */ text = text.replace(/(n[ ]{0,3}(<(hr)b([^<>])*?/?>)[ t]*(?=n{2,}))/g,hashElement); // Special case for standalone HTML comments: /* text = text.replace(/ (\t\t\t\t\t\t// save in $1 nn\t\t\t\t// Starting after a blank line [ ]{0,3}\t\t\t// attacklab: g_tab_width - 1 [ t]* (?=n{2,})\t\t\t// followed by a blank line ) /g,hashElement); */ text = text.replace(/(nn[ ]{0,3}[ t]*(?=n{2,}))/g,hashElement); // PHP and ASP-style processor instructions ( and <%...%>) /* text = text.replace(/ (?: nn\t\t\t\t// Starting after a blank line ) (\t\t\t\t\t\t// save in $1 [ ]{0,3}\t\t\t// attacklab: g_tab_width - 1 (?: <([?%])\t\t\t// $2 [^r]*? 2> ) [ t]* (?=n{2,})\t\t\t// followed by a blank line ) /g,hashElement); */ text = text.replace(/(?:nn)([ ]{0,3}(?:<([?%])[^r]*?2>)[ t]*(?=n{2,}))/g,hashElement); // attacklab: Undo double lines (see comment at top of this function) text = text.replace(/nn/g,\"n\"); return text; } var hashElement = function(wholeMatch,m1) { var blockText = m1; // Undo double lines blockText = blockText.replace(/nn/g,\"n\"); blockText = blockText.replace(/^n/,\"\"); // strip trailing blank lines blockText = blockText.replace(/n+$/g,\"\"); // Replace the element text with a marker (\"~KxK\" where x is its key) blockText = \"nn~K\" + (g_html_blocks.push(blockText)-1) + \"Knn\"; return blockText; }; var _RunBlockGamut = function(text) { // // These are all the transformations that form block-level // tags like paragraphs, headers, and list items. // text = _DoHeaders(text); // Do Horizontal Rules: var key = hashBlock(\"
    \"); text = text.replace(/^[ ]{0,2}([ ]?*[ ]?){3,}[ t]*$/gm,key); text = text.replace(/^[ ]{0,2}([ ]?-[ ]?){3,}[ t]*$/gm,key); text = text.replace(/^[ ]{0,2}([ ]?_[ ]?){3,}[ t]*$/gm,key); text = _DoLists(text); text = _DoCodeBlocks(text); text = _DoBlockQuotes(text); // We already ran _HashHTMLBlocks() before, in Markdown(), but that // was to escape raw HTML in the original Markdown source. This time, // we're escaping the markup we've just created, so that we don't wrap //

    tags around block-level tags. text = _HashHTMLBlocks(text); text = _FormParagraphs(text); return text; } var _RunSpanGamut = function(text) { // // These are all the transformations that occur *within* block-level // tags like paragraphs, headers, and list items. // text = _DoCodeSpans(text); text = _EscapeSpecialCharsWithinTagAttributes(text); text = _EncodeBackslashEscapes(text); // Process anchor and image tags. Images must come first, // because ![foo][f] looks like an anchor. text = _DoImages(text); text = _DoAnchors(text); // Make links out of things like `` // Must come after _DoAnchors(), because you can use < and > // delimiters in inline links like [this](). text = _DoAutoLinks(text); text = _EncodeAmpsAndAngles(text); text = _DoItalicsAndBold(text); // Do hard breaks: text = text.replace(/ +n/g,\"
    n\"); return text; } var _EscapeSpecialCharsWithinTagAttributes = function(text) { // // Within tags -- meaning between < and > -- encode [ ` * _] so they // don't conflict with their use in Markdown for code, italics and strong. // // Build a regex to find HTML tags and comments. See Friedl's // \"Mastering Regular Expressions\", 2nd Ed., pp. 200-201. var regex = /(<[a-z/!$](\"[^\"]*\"|'[^']*'|[^'\">])*>|)/gi; text = text.replace(regex, function(wholeMatch) { var tag = wholeMatch.replace(/(.)(?=.)/g,\"$1`\"); tag = escapeCharacters(tag,\"`*_\"); return tag; }); return text; } var _DoAnchors = function(text) { // // Turn Markdown link shortcuts into XHTML
    tags. // // // First, handle reference-style links: [link text] [id] // /* text = text.replace(/ (\t\t\t\t\t\t\t// wrap whole match in $1 [ ( (?: [[^]]*]\t\t// allow brackets nested one level | [^[]\t\t\t// or anything else )* ) ] [ ]?\t\t\t\t\t// one optional space (?:n[ ]*)?\t\t\t\t// one optional newline followed by spaces [ (.*?)\t\t\t\t\t// id = $3 ] )()()()()\t\t\t\t\t// pad remaining backreferences /g,_DoAnchors_callback); */ text = text.replace(/([((?:[[^]]*]|[^[]])*)][ ]?(?:n[ ]*)?[(.*?)])()()()()/g,writeAnchorTag); // // Next, inline-style links: [link text](url \"optional title\") // /* text = text.replace(/ (\t\t\t\t\t\t// wrap whole match in $1 [ ( (?: [[^]]*]\t// allow brackets nested one level | [^[]]\t\t\t// or anything else ) ) ] (\t\t\t\t\t\t// literal paren [ t]* ()\t\t\t\t\t\t// no id, so leave $3 empty ?\t\t\t\t// href = $4 [ t]* (\t\t\t\t\t\t// $5 (['\"])\t\t\t\t// quote char = $6 (.*?)\t\t\t\t// Title = $7 6\t\t\t\t\t// matching quote [ t]*\t\t\t\t// ignore any spaces/tabs between closing quote and ) )?\t\t\t\t\t\t// title is optional ) ) /g,writeAnchorTag); */ text = text.replace(/([((?:[[^]]*]|[^[]])*)]([ t]*()?[ t]*((['\"])(.*?)6[ t]*)?))/g,writeAnchorTag); // // Last, handle reference-style shortcuts: [link text] // These must come last in case you've also got [link test][1] // or [link test](/foo) // /* text = text.replace(/ (\t\t \t\t\t\t\t// wrap whole match in $1 [ ([^[]]+)\t\t\t\t// link text = $2; can't contain '[' or ']' ] )()()()()()\t\t\t\t\t// pad rest of backreferences /g, writeAnchorTag); */ text = text.replace(/([([^[]]+)])()()()()()/g, writeAnchorTag); return text; } var writeAnchorTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) { if (m7 == undefined) m7 = \"\"; var whole_match = m1; var link_text = m2; var link_id\t = m3.toLowerCase(); var url\t\t= m4; var title\t= m7; if (url == \"\") { if (link_id == \"\") { // lower-case and turn embedded newlines into spaces link_id = link_text.toLowerCase().replace(/ ?n/g,\" \"); } url = \"#\"+link_id; if (g_urls[link_id] != undefined) { url = g_urls[link_id]; if (g_titles[link_id] != undefined) { title = g_titles[link_id]; } } else { if (whole_match.search(/(s*)$/m)>-1) { // Special case for explicit empty url url = \"\"; } else { return whole_match; } } } url = escapeCharacters(url,\"*_\"); var result = \"\" + link_text + \"\"; return result; } var _DoImages = function(text) { // // Turn Markdown image shortcuts into tags. // // // First, handle reference-style labeled images: ![alt text][id] // /* text = text.replace(/ (\t\t\t\t\t\t// wrap whole match in $1 ![ (.*?)\t\t\t\t// alt text = $2 ] [ ]?\t\t\t\t// one optional space (?:n[ ]*)?\t\t\t// one optional newline followed by spaces [ (.*?)\t\t\t\t// id = $3 ] )()()()()\t\t\t\t// pad rest of backreferences /g,writeImageTag); */ text = text.replace(/(![(.*?)][ ]?(?:n[ ]*)?[(.*?)])()()()()/g,writeImageTag); // // Next, handle inline images: ![alt text](url \"optional title\") // Don't forget: encode * and _ /* text = text.replace(/ (\t\t\t\t\t\t// wrap whole match in $1 ![ (.*?)\t\t\t\t// alt text = $2 ] s?\t\t\t\t\t// One optional whitespace character (\t\t\t\t\t// literal paren [ t]* ()\t\t\t\t\t// no id, so leave $3 empty ?\t\t\t// src url = $4 [ t]* (\t\t\t\t\t// $5 (['\"])\t\t\t// quote char = $6 (.*?)\t\t\t// title = $7 6\t\t\t\t// matching quote [ t]* )?\t\t\t\t\t// title is optional ) ) /g,writeImageTag); */ text = text.replace(/(![(.*?)]s?([ t]*()?[ t]*((['\"])(.*?)6[ t]*)?))/g,writeImageTag); return text; } var writeImageTag = function(wholeMatch,m1,m2,m3,m4,m5,m6,m7) { var whole_match = m1; var alt_text = m2; var link_id\t = m3.toLowerCase(); var url\t\t= m4; var title\t= m7; if (!title) title = \"\"; if (url == \"\") { if (link_id == \"\") { // lower-case and turn embedded newlines into spaces link_id = alt_text.toLowerCase().replace(/ ?n/g,\" \"); } url = \"#\"+link_id; if (g_urls[link_id] != undefined) { url = g_urls[link_id]; if (g_titles[link_id] != undefined) { title = g_titles[link_id]; } } else { return whole_match; } } alt_text = alt_text.replace(/\"/g,\""\"); url = escapeCharacters(url,\"*_\"); var result = \"\"\"\"; return result; } var _DoHeaders = function(text) { // Setext-style headers: //\tHeader 1 //\t======== // //\tHeader 2 //\t-------- // text = text.replace(/^(.+)[ t]*n=+[ t]*n+/gm, function(wholeMatch,m1){return hashBlock('

    ' + _RunSpanGamut(m1) + \"

    \");}); text = text.replace(/^(.+)[ t]*n-+[ t]*n+/gm, function(matchFound,m1){return hashBlock('

    ' + _RunSpanGamut(m1) + \"

    \");}); // atx-style headers: // # Header 1 // ## Header 2 // ## Header 2 with closing hashes ## // ... // ###### Header 6 // /* text = text.replace(/ ^(#{1,6})\t\t\t\t// $1 = string of #'s [ t]* (.+?)\t\t\t\t\t// $2 = Header text [ t]* #*\t\t\t\t\t\t// optional closing #'s (not counted) n+ /gm, function() {...}); */ text = text.replace(/^(#{1,6})[ t]*(.+?)[ t]*#*n+/gm, function(wholeMatch,m1,m2) { var h_level = m1.length; return hashBlock(\"' + _RunSpanGamut(m2) + \"\"); }); function headerId(m) { return m.replace(/[^w]/g, '').toLowerCase(); } return text; } // This declaration keeps Dojo compressor from outputting garbage: var _ProcessListItems; var _DoLists = function(text) { // // Form HTML ordered (numbered) and unordered (bulleted) lists. // // attacklab: add sentinel to hack around khtml/safari bug: // http://bugs.webkit.org/show_bug.cgi?id=11231 text += \"~0\"; // Re-usable pattern to match any entirel ul or ol list: /* var whole_list = / (\t\t\t\t\t\t\t\t\t// $1 = whole list (\t\t\t\t\t\t\t\t// $2 [ ]{0,3}\t\t\t\t\t// attacklab: g_tab_width - 1 ([*+-]|d+[.])\t\t\t\t// $3 = first list item marker [ t]+ ) [^r]+? (\t\t\t\t\t\t\t\t// $4 ~0\t\t\t\t\t\t\t// sentinel for workaround; should be $ | n{2,} (?=S) (?!\t\t\t\t\t\t\t// Negative lookahead for another list item marker [ t]* (?:[*+-]|d+[.])[ t]+ ) ) )/g */ var whole_list = /^(([ ]{0,3}([*+-]|d+[.])[ t]+)[^r]+?(~0|n{2,}(?=S)(?![ t]*(?:[*+-]|d+[.])[ t]+)))/gm; if (g_list_level) { text = text.replace(whole_list,function(wholeMatch,m1,m2) { var list = m1; var list_type = (m2.search(/[*+-]/g)>-1) ? \"ul\" : \"ol\"; // Turn double returns into triple returns, so that we can make a // paragraph for the last item in a list, if necessary: list = list.replace(/n{2,}/g,\"nnn\");; var result = _ProcessListItems(list); // Trim any trailing whitespace, to put the closing `` // up on the preceding line, to get it past the current stupid // HTML block parser. This is a hack to work around the terrible // hack that is the HTML block parser. result = result.replace(/s+$/,\"\"); result = \"<\"+list_type+\">\" + result + \"n\"; return result; }); } else { whole_list = /(nn|^n?)(([ ]{0,3}([*+-]|d+[.])[ t]+)[^r]+?(~0|n{2,}(?=S)(?![ t]*(?:[*+-]|d+[.])[ t]+)))/g; text = text.replace(whole_list,function(wholeMatch,m1,m2,m3) { var runup = m1; var list = m2; var list_type = (m3.search(/[*+-]/g)>-1) ? \"ul\" : \"ol\"; // Turn double returns into triple returns, so that we can make a // paragraph for the last item in a list, if necessary: var list = list.replace(/n{2,}/g,\"nnn\");; var result = _ProcessListItems(list); result = runup + \"<\"+list_type+\">n\" + result + \"n\"; return result; }); } // attacklab: strip sentinel text = text.replace(/~0/,\"\"); return text; } _ProcessListItems = function(list_str) { // // Process the contents of a single ordered or unordered list, splitting it // into individual list items. // // The $g_list_level global keeps track of when we're inside a list. // Each time we enter a list, we increment it; when we leave a list, // we decrement. If it's zero, we're not in a list anymore. // // We do this because when we're not inside a list, we want to treat // something like this: // // I recommend upgrading to version // 8. Oops, now this line is treated // as a sub-list. // // As a single paragraph, despite the fact that the second line starts // with a digit-period-space sequence. // // Whereas when we're inside a list (or sub-list), that line will be // treated as the start of a sub-list. What a kludge, huh? This is // an aspect of Markdown's syntax that's hard to parse perfectly // without resorting to mind-reading. Perhaps the solution is to // change the syntax rules such that sub-lists must start with a // starting cardinal number; e.g. \"1.\" or \"a.\". g_list_level++; // trim trailing blank lines: list_str = list_str.replace(/n{2,}$/,\"n\"); // attacklab: add sentinel to emulate z list_str += \"~0\"; /* list_str = list_str.replace(/ (n)?\t\t\t\t\t\t\t// leading line = $1 (^[ t]*)\t\t\t\t\t\t// leading whitespace = $2 ([*+-]|d+[.]) [ t]+\t\t\t// list marker = $3 ([^r]+?\t\t\t\t\t\t// list item text = $4 (n{1,2})) (?= n* (~0 | 2 ([*+-]|d+[.]) [ t]+)) /gm, function(){...}); */ list_str = list_str.replace(/(n)?(^[ t]*)([*+-]|d+[.])[ t]+([^r]+?(n{1,2}))(?=n*(~0|2([*+-]|d+[.])[ t]+))/gm, function(wholeMatch,m1,m2,m3,m4){ var item = m4; var leading_line = m1; var leading_space = m2; if (leading_line || (item.search(/n{2,}/)>-1)) { item = _RunBlockGamut(_Outdent(item)); } else { // Recursion for sub-lists: item = _DoLists(_Outdent(item)); item = item.replace(/n$/,\"\"); // chomp(item) item = _RunSpanGamut(item); } return \"
  • \" + item + \"
  • n\"; } ); // attacklab: strip sentinel list_str = list_str.replace(/~0/g,\"\"); g_list_level--; return list_str; } var _DoCodeBlocks = function(text) { // // Process Markdown `
    ` blocks. // /* text = text.replace(text, /(?:nn|^) (\t\t\t\t\t\t\t\t// $1 = the code block -- one or more lines, starting with a space/tab (?: (?:[ ]{4}|t)\t\t\t// Lines must start with a tab or a tab-width of spaces - attacklab: g_tab_width .*n+ )+ ) (n*[ ]{0,3}[^ tn]|(?=~0))\t// attacklab: g_tab_width /g,function(){...}); */ // attacklab: sentinel workarounds for lack of A and Z, safarikhtml bug text += \"~0\"; text = text.replace(/(?:nn|^)((?:(?:[ ]{4}|t).*n+)+)(n*[ ]{0,3}[^ tn]|(?=~0))/g, function(wholeMatch,m1,m2) { var codeblock = m1; var nextChar = m2; codeblock = _EncodeCode( _Outdent(codeblock)); codeblock = _Detab(codeblock); codeblock = codeblock.replace(/^n+/g,\"\"); // trim leading newlines codeblock = codeblock.replace(/n+$/g,\"\"); // trim trailing whitespace codeblock = \"
    \" + codeblock + \"n
    \"; return hashBlock(codeblock) + nextChar; } ); // attacklab: strip sentinel text = text.replace(/~0/,\"\"); return text; } var hashBlock = function(text) { text = text.replace(/(^n+|n+$)/g,\"\"); return \"nn~K\" + (g_html_blocks.push(text)-1) + \"Knn\"; } var _DoCodeSpans = function(text) { // // * Backtick quotes are used for spans. // // * You can use multiple backticks as the delimiters if you want to //\t include literal backticks in the code span. So, this input: // //\t\t Just type ``foo `bar` baz`` at the prompt. // //\t Will translate to: // //\t\t

    Just type foo `bar` baz at the prompt.

    // //\tThere's no arbitrary limit to the number of backticks you //\tcan use as delimters. If you need three consecutive backticks //\tin your code, use four for delimiters, etc. // // * You can use spaces to get literal backticks at the edges: // //\t\t ... type `` `bar` `` ... // //\t Turns to: // //\t\t ... type `bar` ... // /* text = text.replace(/ (^|[^])\t\t\t\t\t// Character before opening ` can't be a backslash (`+)\t\t\t\t\t\t// $2 = Opening run of ` (\t\t\t\t\t\t\t// $3 = The code block [^r]*? [^`]\t\t\t\t\t// attacklab: work around lack of lookbehind ) 2\t\t\t\t\t\t\t// Matching closer (?!`) /gm, function(){...}); */ text = text.replace(/(^|[^])(`+)([^r]*?[^`])2(?!`)/gm, function(wholeMatch,m1,m2,m3,m4) { var c = m3; c = c.replace(/^([ t]*)/g,\"\");\t// leading whitespace c = c.replace(/[ t]*$/g,\"\");\t// trailing whitespace c = _EncodeCode(c); return m1+\"\"+c+\"\"; }); return text; } var _EncodeCode = function(text) { // // Encode/escape certain characters inside Markdown code runs. // The point is that in code, these characters are literals, // and lose their special Markdown meanings. // // Encode all ampersands; HTML entities are not // entities within a Markdown code span. text = text.replace(/&/g,\"&\"); // Do the angle bracket song and dance: text = text.replace(//g,\">\"); // Now, escape characters that are magic in Markdown: text = escapeCharacters(text,\"*_{}[]\",false); // jj the line above breaks this: //--- //* Item // 1. Subitem // special char: * //--- return text; } var _DoItalicsAndBold = function(text) { // must go first: text = text.replace(/(**|__)(?=S)([^r]*?S[*_]*)1/g, \"$2\"); text = text.replace(/(*|_)(?=S)([^r]*?S)1/g, \"$2\"); return text; } var _DoBlockQuotes = function(text) { /* text = text.replace(/ (\t\t\t\t\t\t\t\t// Wrap whole match in $1 ( ^[ t]*>[ t]?\t\t\t// '>' at the start of a line .+n\t\t\t\t\t// rest of the first line (.+n)*\t\t\t\t\t// subsequent consecutive lines n*\t\t\t\t\t\t// blanks )+ ) /gm, function(){...}); */ text = text.replace(/((^[ t]*>[ t]?.+n(.+n)*n*)+)/gm, function(wholeMatch,m1) { var bq = m1; // attacklab: hack around Konqueror 3.5.4 bug: // \"----------bug\".replace(/^-/g,\"\") == \"bug\" bq = bq.replace(/^[ t]*>[ t]?/gm,\"~0\");\t// trim one level of quoting // attacklab: clean up hack bq = bq.replace(/~0/g,\"\"); bq = bq.replace(/^[ t]+$/gm,\"\");\t\t// trim whitespace-only lines bq = _RunBlockGamut(bq);\t\t\t\t// recurse bq = bq.replace(/(^|n)/g,\"$1 \"); // These leading spaces screw with
     content, so we need to fix that: bq = bq.replace( /(s*
    [^r]+?
    )/gm, function(wholeMatch,m1) { var pre = m1; // attacklab: hack around Konqueror 3.5.4 bug: pre = pre.replace(/^ /mg,\"~0\"); pre = pre.replace(/~0/g,\"\"); return pre; }); return hashBlock(\"
    n\" + bq + \"n
    \"); }); return text; } var _FormParagraphs = function(text) { // // Params: // $text - string to process with html

    tags // // Strip leading and trailing lines: text = text.replace(/^n+/g,\"\"); text = text.replace(/n+$/g,\"\"); var grafs = text.split(/n{2,}/g); var grafsOut = new Array(); // // Wrap

    tags. // var end = grafs.length; for (var i=0; i= 0) { grafsOut.push(str); } else if (str.search(/S/) >= 0) { str = _RunSpanGamut(str); str = str.replace(/^([ t]*)/g,\"

    \"); str += \"

    \" grafsOut.push(str); } } // // Unhashify HTML blocks // end = grafsOut.length; for (var i=0; i= 0) { var blockText = g_html_blocks[RegExp.$1]; blockText = blockText.replace(/$/g,\"$$$$\"); // Escape any dollar signs grafsOut[i] = grafsOut[i].replace(/~Kd+K/,blockText); } } return grafsOut.join(\"nn\"); } var _EncodeAmpsAndAngles = function(text) { // Smart processing for ampersands and angle brackets that need to be encoded. // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin: // http://bumppo.net/projects/amputator/ text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|w+);)/g,\"&\"); // Encode naked <'s text = text.replace(/<(?![a-z/?$!])/gi,\"<\"); return text; } var _EncodeBackslashEscapes = function(text) { // // Parameter: String. // Returns:\tThe string, with after processing the following backslash //\t\t\t escape sequences. // // attacklab: The polite way to do this is with the new // escapeCharacters() function: // // \ttext = escapeCharacters(text,\"\",true); // \ttext = escapeCharacters(text,\"`*_{}[]()>#+-.!\",true); // // ...but we're sidestepping its use of the (slow) RegExp constructor // as an optimization for Firefox. This function gets called a LOT. text = text.replace(/()/g,escapeCharacters_callback); text = text.replace(/([`*_{}[]()>#+-.!])/g,escapeCharacters_callback); return text; } var _DoAutoLinks = function(text) { text = text.replace(/<((https?|ftp|dict):[^'\">s]+)>/gi,\"$1\"); // Email addresses: /* text = text.replace(/ < (?:mailto:)? ( [-.w]+ @ [-a-z0-9]+(.[-a-z0-9]+)*.[a-z]+ ) > /gi, _DoAutoLinks_callback()); */ text = text.replace(/<(?:mailto:)?([-.w]+@[-a-z0-9]+(.[-a-z0-9]+)*.[a-z]+)>/gi, function(wholeMatch,m1) { return _EncodeEmailAddress( _UnescapeSpecialChars(m1) ); } ); return text; } var _EncodeEmailAddress = function(addr) { // // Input: an email address, e.g. \"foo@example.com\" // // Output: the email address as a mailto link, with each character //\tof the address encoded as either a decimal or hex entity, in //\tthe hopes of foiling most address harvesting spam bots. E.g.: // //\tfoo //\t @example.com // // Based on a filter by Matthew Wickline, posted to the BBEdit-Talk // mailing list: // // attacklab: why can't javascript speak hex? function char2hex(ch) { var hexDigits = '0123456789ABCDEF'; var dec = ch.charCodeAt(0); return(hexDigits.charAt(dec>>4) + hexDigits.charAt(dec&15)); } var encode = [ function(ch){return \"&#\"+ch.charCodeAt(0)+\";\";}, function(ch){return \"&#x\"+char2hex(ch)+\";\";}, function(ch){return ch;} ]; addr = \"mailto:\" + addr; addr = addr.replace(/./g, function(ch) { if (ch == \"@\") { // this *must* be encoded. I insist. ch = encode[Math.floor(Math.random()*2)](ch); } else if (ch !=\":\") { // leave ':' alone (to spot mailto: later) var r = Math.random(); // roughly 10% raw, 45% hex, 45% dec ch = ( r > .9 ?\tencode[2](ch) : r > .45 ?\tencode[1](ch) : encode[0](ch) ); } return ch; }); addr = \"\" + addr + \"\"; addr = addr.replace(/\">.+:/g,\"\">\"); // strip the mailto: from the visible part return addr; } var _UnescapeSpecialChars = function(text) { // // Swap back in all the special characters we've hidden. // text = text.replace(/~E(d+)E/g, function(wholeMatch,m1) { var charCodeToReplace = parseInt(m1); return String.fromCharCode(charCodeToReplace); } ); return text; } var _Outdent = function(text) { // // Remove one level of line-leading tabs or spaces // // attacklab: hack around Konqueror 3.5.4 bug: // \"----------bug\".replace(/^-/g,\"\") == \"bug\" text = text.replace(/^(t|[ ]{1,4})/gm,\"~0\"); // attacklab: g_tab_width // attacklab: clean up hack text = text.replace(/~0/g,\"\") return text; } var _Detab = function(text) { // attacklab: Detab's completely rewritten for speed. // In perl we could fix it by anchoring the regexp with G. // In javascript we're less fortunate. // expand first n-1 tabs text = text.replace(/t(?=t)/g,\" \"); // attacklab: g_tab_width // replace the nth with two sentinels text = text.replace(/t/g,\"~A~B\"); // use the sentinel to anchor our regex so it doesn't explode text = text.replace(/~B(.+?)~A/g, function(wholeMatch,m1,m2) { var leadingText = m1; var numSpaces = 4 - leadingText.length % 4; // attacklab: g_tab_width // there *must* be a better way to do this: for (var i=0; i No newline at end of file", "commid": "react_pr_3663"}], "negative_passages": []} {"query_id": "q-en-react-795741901fb82091b7a486876f357df0a3316ec909e9dfe8a9ecdec72a57a791", "query": "Calling on in a component being Shallow Rendered will result in the error being thrown. I set up a test case:\nWho would be best to answer this one?\nSeems like a valid bug report \u2014 thanks and the test case is rad. I may not be able to look at this for a while, unfortunately.\nno worries let me know if you need any more info from me. This was on React 14 beta btw (not sure if that matters)\nI have the same issue. A simpler example that throws the error:\nAny way of getting around this issue? I am currently running into it.\nSorry about the slow response from us (FB) here. I'm the principal author of the shallow render feature, but React core isn't my main gig and I've been swamped with product work. I don't have an offhand answer for you, but I've just put time on my calendar to look into this next week. Jim, Ben, Paul \u2014 if by chance one of you happened to take care of this before then, I wouldn't be mad :)\nAn update on my end. I think that my problem actually went away when I deduped my npm dependencies to remove an extra react version that was causing issues. If this error pops up again I'll let you know. Thanks for the response! On Fri, Aug 28, 2015, 9:38 PM Scott Feeney wrote:\nHmm I am still able to reproduce this issue in my test case after running npm dedupe\nJust to clarify, my previous comment wasn't supposed to mean that the issue has gone away. I think I was seeing a separate issue caused by multiple react versions that I misidentified as this issue (I hope that makes sense).\nI am getting this error, too. I'm using react v0.14.0-rc1. Looking at the code : Apparently .\nNote that shallow rendered components override to return a instead of whatever it normally returns. That still shouldn't be undefined and should have a attribute, though.\nI'm experiencing this issue too - your suggestion gets me past the initial error & on to in\nPretty sure this breaks many other things outside of , but I noticed moving to be directly above in fixed this for me.\nWe are also affected by this issue. I think shallow rendering is a really cool feature for testing, but unfortunately I can't use it for some of our components due to this bug.\nI created pull request with a fix that works for me. Can someone else verify?\nAny workaround for this issue?\n:+1: Having same issue\nJust ran into this too :/\nAny update on this? I see that 0.14.3 was released, but these kind of tests are still failing.\nI think I have to add a test to my pull request before it can be merged, but I did not get around to do it yet.\nClosing in favor of which should merge soon.", "positive_passages": [{"docid": "doc-en-react-5ad035ad18a9a4e413908b84058063bb2d78ef427b0c8bda49a2e77301cb9a4a", "text": "if (!context) { context = emptyObject; } var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(true); this._render(element, transaction, context); ReactUpdates.ReactReconcileTransaction.release(transaction); ReactUpdates.batchedUpdates(_batchedRender, this, element, context); return this.getRenderOutput(); }; function _batchedRender(renderer, element, context) { var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(true); renderer._render(element, transaction, context); ReactUpdates.ReactReconcileTransaction.release(transaction); } ReactShallowRenderer.prototype.getRenderOutput = function() { return ( (this._instance && this._instance._renderedComponent &&", "commid": "react_pr_5561"}], "negative_passages": []} {"query_id": "q-en-react-795741901fb82091b7a486876f357df0a3316ec909e9dfe8a9ecdec72a57a791", "query": "Calling on in a component being Shallow Rendered will result in the error being thrown. I set up a test case:\nWho would be best to answer this one?\nSeems like a valid bug report \u2014 thanks and the test case is rad. I may not be able to look at this for a while, unfortunately.\nno worries let me know if you need any more info from me. This was on React 14 beta btw (not sure if that matters)\nI have the same issue. A simpler example that throws the error:\nAny way of getting around this issue? I am currently running into it.\nSorry about the slow response from us (FB) here. I'm the principal author of the shallow render feature, but React core isn't my main gig and I've been swamped with product work. I don't have an offhand answer for you, but I've just put time on my calendar to look into this next week. Jim, Ben, Paul \u2014 if by chance one of you happened to take care of this before then, I wouldn't be mad :)\nAn update on my end. I think that my problem actually went away when I deduped my npm dependencies to remove an extra react version that was causing issues. If this error pops up again I'll let you know. Thanks for the response! On Fri, Aug 28, 2015, 9:38 PM Scott Feeney wrote:\nHmm I am still able to reproduce this issue in my test case after running npm dedupe\nJust to clarify, my previous comment wasn't supposed to mean that the issue has gone away. I think I was seeing a separate issue caused by multiple react versions that I misidentified as this issue (I hope that makes sense).\nI am getting this error, too. I'm using react v0.14.0-rc1. Looking at the code : Apparently .\nNote that shallow rendered components override to return a instead of whatever it normally returns. That still shouldn't be undefined and should have a attribute, though.\nI'm experiencing this issue too - your suggestion gets me past the initial error & on to in\nPretty sure this breaks many other things outside of , but I noticed moving to be directly above in fixed this for me.\nWe are also affected by this issue. I think shallow rendering is a really cool feature for testing, but unfortunately I can't use it for some of our components due to this bug.\nI created pull request with a fix that works for me. Can someone else verify?\nAny workaround for this issue?\n:+1: Having same issue\nJust ran into this too :/\nAny update on this? I see that 0.14.3 was released, but these kind of tests are still failing.\nI think I have to add a test to my pull request before it can be merged, but I did not get around to do it yet.\nClosing in favor of which should merge soon.", "positive_passages": [{"docid": "doc-en-react-3254a23f86d127eb63cb4fb31cd7a2ad33f0e948cb50c4f3065100a7118a5f8e", "text": "expect(result.props.className).toEqual('clicked'); }); it('can setState in componentWillMount when shallow rendering', function() { var SimpleComponent = React.createClass({ componentWillMount() { this.setState({groovy: 'doovy'}); }, render() { return
    {this.state.groovy}
    ; }, }); var shallowRenderer = ReactTestUtils.createRenderer(); var result = shallowRenderer.render(); expect(result).toEqual(
    doovy
    ); });
    it('can pass context when shallowly rendering', function() { var SimpleComponent = React.createClass({ contextTypes: {", "commid": "react_pr_5561"}], "negative_passages": []} {"query_id": "q-en-react-1def5d8af304d4cceb1351c6e7c9af25c0fb6336e4edda68a67920ef2caca0bc", "query": "I'm trying to use the attribute as described here: Unfortunately, sometimes returns , when is called multiple times. MWE:\nThis is intended \u2013 when the component is unmounted or the ref changes, the old ref gets called with null before it's called with the new value (or the same component instance again). If you store the instance on your component, this effect should be unobservable as long as your component is mounted, but it prevents memory leaks. If you want to do something with in the ref handler, you should check if it's null.\nThanks for the information! I think this might be worth mentioning in the docs.", "positive_passages": [{"docid": "doc-en-react-f9d164a4a2c41f939211fc8c276c93667997e4272ced4685230610b3a8a9731a", "text": "1. Assign a `ref` attribute to anything returned from `render` such as: ```html ``` ```html ``` 2. In some other code (typically event handler code), access the **backing instance** via `this.refs` as in: ```javascript this.refs.myInput ``` ```javascript this.refs.myInput ``` You can access the component's DOM node directly by calling `React.findDOMNode(this.refs.myInput)`.", "commid": "react_pr_4664"}], "negative_passages": []} {"query_id": "q-en-react-1def5d8af304d4cceb1351c6e7c9af25c0fb6336e4edda68a67920ef2caca0bc", "query": "I'm trying to use the attribute as described here: Unfortunately, sometimes returns , when is called multiple times. MWE:\nThis is intended \u2013 when the component is unmounted or the ref changes, the old ref gets called with null before it's called with the new value (or the same component instance again). If you store the instance on your component, this effect should be unobservable as long as your component is mounted, but it prevents memory leaks. If you want to do something with in the ref handler, you should check if it's null.\nThanks for the information! I think this might be worth mentioning in the docs.", "positive_passages": [{"docid": "doc-en-react-3c6a06f44e410510877b85ff85d9a7aeedb7fe44f349894d108971ebb8594571", "text": "It's as simple as assigning a `ref` attribute to anything returned from `render` such as: ```html ``` ```html render: function() { return this._input = c} } />; }, componentDidMount: function() { this._input.focus(); }, ``` or ```html render: function() { return ( ); }, ``` Note that when the referenced component is unmounted and whenever the ref changes, the old ref will be called with `null` as an argument. This prevents memory leaks in the case that the instance is stored, as in the first example. Note that when writing refs with inline function expressions as in the examples here, React sees a different function object each time so on every update, ref will be called with `null` immediately before it's called with the component instance. ## Completing the Example", "commid": "react_pr_4664"}], "negative_passages": []} {"query_id": "q-en-react-e67de791693db938af10b78c2ee6743684ef35b812d1374870cdb39182ae80b2", "query": "Issue with the reproducible example . Full build contains non-standard iterator. Theoretical, it can be to ES in the future, it can be (or already ) to another libraries. should take into account possibility iterable numbers.\nWell, the good news is that if this is already on enough pages, then introducing iterable numbers may not be web compatible anyway. I think that this is only in DEV only code. Unfortunately a lot of pages incorrectly uses the DEV build of React.\n\"good news\"", "positive_passages": [{"docid": "doc-en-react-dbd19929f33e758017c96fcd0647db2a637832924b640b1cfd30732c8d156bbe", "text": "* @param {*} parentType node's parent's type. */ function validateChildKeys(node, parentType) { if (typeof node !== 'object') { return; } if (Array.isArray(node)) { for (var i = 0; i < node.length; i++) { var child = node[i];", "commid": "react_pr_4823"}], "negative_passages": []} {"query_id": "q-en-react-e67de791693db938af10b78c2ee6743684ef35b812d1374870cdb39182ae80b2", "query": "Issue with the reproducible example . Full build contains non-standard iterator. Theoretical, it can be to ES in the future, it can be (or already ) to another libraries. should take into account possibility iterable numbers.\nWell, the good news is that if this is already on enough pages, then introducing iterable numbers may not be web compatible anyway. I think that this is only in DEV only code. Unfortunately a lot of pages incorrectly uses the DEV build of React.\n\"good news\"", "positive_passages": [{"docid": "doc-en-react-a16d084bfe68f2f91f3fb88388c4a1abb2300f395e049656f487a78845a3a100", "text": "expect(console.error.argsForCall.length).toBe(0); }); it('should not enumerate enumerable numbers (#4776)', function() { /*eslint-disable no-extend-native */ Number.prototype['@@iterator'] = function() { throw new Error('number iterator called'); }; /*eslint-enable no-extend-native */ try { void (
    {5} {12} {13}
    ); } finally { delete Number.prototype['@@iterator']; } });
    });", "commid": "react_pr_4823"}], "negative_passages": []} {"query_id": "q-en-react-e67de791693db938af10b78c2ee6743684ef35b812d1374870cdb39182ae80b2", "query": "Issue with the reproducible example . Full build contains non-standard iterator. Theoretical, it can be to ES in the future, it can be (or already ) to another libraries. should take into account possibility iterable numbers.\nWell, the good news is that if this is already on enough pages, then introducing iterable numbers may not be web compatible anyway. I think that this is only in DEV only code. Unfortunately a lot of pages incorrectly uses the DEV build of React.\n\"good news\"", "positive_passages": [{"docid": "doc-en-react-7dc7a35ee6bbd0b5ab9b398962b134075cba411420398775f54f389be456d4e5", "text": "); }); it('should not enumerate enumerable numbers (#4776)', function() { /*eslint-disable no-extend-native */ Number.prototype['@@iterator'] = function() { throw new Error('number iterator called'); }; /*eslint-enable no-extend-native */ try { var instance = (
    {5} {12} {13}
    ); var traverseFn = jasmine.createSpy(); traverseAllChildren(instance.props.children, traverseFn, null); expect(traverseFn.calls.length).toBe(3); expect(traverseFn).toHaveBeenCalledWith( null, 5, '.0' ); expect(traverseFn).toHaveBeenCalledWith( null, 12, '.1' ); expect(traverseFn).toHaveBeenCalledWith( null, 13, '.2' ); } finally { delete Number.prototype['@@iterator']; } });
    });", "commid": "react_pr_4823"}], "negative_passages": []} {"query_id": "q-en-react-c5fdcaf06bf83f9011e0945d502600fbda0b23da3dda3cc70ca0b979475789b1", "query": "I'm still quite new to React, but I guess this is a bug in the React framework introduced in 0.14. Seems like all listeners attached with JSX are broken in native Android browser for Android LTE 4.3, when compiling code with NODEENV development. Everything works fine with NODEENV production compilation. I've tracked it down to being related to ReactErrorUtils, that in development mode do guards on events. The source code: If I simply remove that part of code after compiling the React app, the listeners starts working again. I guess this is not intentional, but instead a bug? To reproduce problem in Android LTE 4.3 (code that works in e.g. Chrome Browser): Using the pre-compiled Getting Started lib\nHm. That's unfortunate. I guess we'll try to find a feature test for this and patch it.", "positive_passages": [{"docid": "doc-en-react-4fac6b6e044cd45c65f21975a0980224f8a6c66340830a75ffb5bb5174bb7ffe", "text": "* real browser event. */ if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof Event === 'function') { typeof window.dispatchEvent === 'function') { var fakeNode = document.createElement('react'); ReactErrorUtils.invokeGuardedCallback = function(name, func, a, b) { var boundFunc = func.bind(null, a, b); fakeNode.addEventListener(name, boundFunc, false); fakeNode.dispatchEvent(new Event(name)); var evt = document.createEvent('Event'); evt.initEvent(name, false, false); fakeNode.dispatchEvent(evt); fakeNode.removeEventListener(name, boundFunc, false); }; }", "commid": "react_pr_5157"}], "negative_passages": []} {"query_id": "q-en-react-c2a3cc3ca43cfe1a4652396cfc14adfa6f68aff3900143c7249698f9178b404e", "query": "Oddly enough, the two examples below are not equal as I thought they would be. The error is as follows: I'm assuming that is because the function as assuming an optional callback. But I would expect your code to do a typeof check, and not just a defined check. Can we change it to do a check? I can submit a PR.\nWell, the typecheck happens with that exact typecheck, just not directly in forceupdate. Here's forceUpdate: and where the invariant happens: FWIW, is not the same as due to an important distinction. The former makes a new function that is bound but it will pass along any arguments. The latter also is a new function but it explicitly doesn't pass any arguments. So the former gets the event passed along while the latter just drops it. The event isn't callable, thus the invariant. We need to do the typecheck so I guess we could discuss whether we keep it as an invariant or a warning. But it is a misuse of the API.\nTo follow up on that, the more \"equal\" thing would be: Which should throw the same error that you see with your first bind example.\nCorrect. Yes, I understand all of that. It wasn't toooo hard for me to understand what is happening. And it is a misuse of the API. So I guess, I would consider adding the argument type to the invariant to help make it clearer? Something more like: It's kind of moot. But It confused me for a second. Might confuse others also.", "positive_passages": [{"docid": "doc-en-react-d7c85deab10b3e9127ea12199d4edd03abb25c028c0a29cd022bc538290985a9", "text": "invariant( typeof callback === 'function', 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + '`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 'isn't callable.' '`setState`, `replaceState`, or `forceUpdate` with a callback of type ' + '%s. A function is expected', typeof callback === 'object' && Object.keys(callback).length && Object.keys(callback).length < 20 ? typeof callback + ' (keys: ' + Object.keys(callback) + ')' : typeof callback ); var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);", "commid": "react_pr_5193"}], "negative_passages": []} {"query_id": "q-en-react-c2a3cc3ca43cfe1a4652396cfc14adfa6f68aff3900143c7249698f9178b404e", "query": "Oddly enough, the two examples below are not equal as I thought they would be. The error is as follows: I'm assuming that is because the function as assuming an optional callback. But I would expect your code to do a typeof check, and not just a defined check. Can we change it to do a check? I can submit a PR.\nWell, the typecheck happens with that exact typecheck, just not directly in forceupdate. Here's forceUpdate: and where the invariant happens: FWIW, is not the same as due to an important distinction. The former makes a new function that is bound but it will pass along any arguments. The latter also is a new function but it explicitly doesn't pass any arguments. So the former gets the event passed along while the latter just drops it. The event isn't callable, thus the invariant. We need to do the typecheck so I guess we could discuss whether we keep it as an invariant or a warning. But it is a misuse of the API.\nTo follow up on that, the more \"equal\" thing would be: Which should throw the same error that you see with your first bind example.\nCorrect. Yes, I understand all of that. It wasn't toooo hard for me to understand what is happening. And it is a misuse of the API. So I guess, I would consider adding the argument type to the invariant to help make it clearer? Something more like: It's kind of moot. But It confused me for a second. Might confuse others also.", "positive_passages": [{"docid": "doc-en-react-f086e61118df133782bdc4dd227f820bf385fe078fb698f61896d7dd090bc3b6", "text": "invariant( typeof callback === 'function', 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + '`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 'isn't callable.' '`setState`, `replaceState`, or `forceUpdate` with a callback of type ' + '%s. A function is expected', typeof callback === 'object' && Object.keys(callback).length && Object.keys(callback).length < 20 ? typeof callback + ' (keys: ' + Object.keys(callback) + ')' : typeof callback ); if (internalInstance._pendingCallbacks) { internalInstance._pendingCallbacks.push(callback);", "commid": "react_pr_5193"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-16718054d599960fb547cad39f0c28c62dc62abbf70ae84fa52bad93c51f61eb", "text": "*/ function createLinkTypeChecker(linkType) { var shapes = { value: typeof linkType === 'undefined' ? value: linkType === undefined ? React.PropTypes.any.isRequired : linkType.isRequired, requestChange: React.PropTypes.func.isRequired,", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-60af45ec1f480055eb1da3aa72b1b6bee7c170264b9ca5e258208a4c701ce06e", "text": "var initialState = this.getInitialState ? this.getInitialState() : null; if (__DEV__) { // We allow auto-mocks to proceed as if they're returning null. if (typeof initialState === 'undefined' && if (initialState === undefined && this.getInitialState._isMockFunction) { // This is probably bad practice. Consider warning here and // deprecating this convenience.", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-4303336dbe20c3151c6ec21af764ec55a88d5af7c27417a68dbe1b7af1dde83a", "text": "if (type && type.defaultProps) { var defaultProps = type.defaultProps; for (propName in defaultProps) { if (typeof props[propName] === 'undefined') { if (props[propName] === undefined) { props[propName] = defaultProps[propName]; } }", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-525b5ea24f395571732d5a3b24f3c928eb3ee2772bc0f40ce891fdd7916b784f", "text": "var range = document.selection.createRange().duplicate(); var start, end; if (typeof offsets.end === 'undefined') { if (offsets.end === undefined) { start = offsets.start; end = start; } else if (offsets.start > offsets.end) {", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-797989d816390e62cad5af1a74efbaa513c6d5a954f9400ea09c415dfbba982b", "text": "var selection = window.getSelection(); var length = node[getTextContentAccessor()].length; var start = Math.min(offsets.start, length); var end = typeof offsets.end === 'undefined' ? var end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-16e6dfb06fc612e47a4fda361c5e5e78919b4bd19f2a6af595b015f7188b167b", "text": "setSelection: function(input, offsets) { var start = offsets.start; var end = offsets.end; if (typeof end === 'undefined') { if (end === undefined) { end = start; }", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-e9c7c9063ed3379443aa17d427434c8c3fe1a3eabb11ff94c3ee243651c7c899", "text": "Component.displayName || Component.name || 'Component'; warning( typeof inst.props === 'undefined' || !propsMutated, inst.props === undefined || !propsMutated, '%s(...): When calling super() in `%s`, make sure to pass ' + 'up the same props that your component's constructor was passed.', componentName, componentName", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-1a52540bee65855f0ee1d5bdd24a06bfdf2ba93b15fbb9f3cb5744a494ed42c1", "text": "if (__DEV__) { warning( typeof shouldUpdate !== 'undefined', shouldUpdate !== undefined, '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', this.getName() || 'ReactCompositeComponent'", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-ebfcb743aff813e9c4529ab43570cce674092783fd3ef9a2cd7ff39596fc8553", "query": "Introduction I found a bug on resolving default props when component props have property with HTMLAllCollection. React ignores value and uses default value (it should take that collection). isIE9OrLower (look at the end of topic) is simple function to test Internet Explorer in version 9 or lower. Simple use case: Chrome/Firefox/modern IE (yeah, i know....) returns HTMLAllColection (as ), but old IE returns true. HTMLAllCollection is weird collection: Source of bug and fix release: 0.14.7 file: line: 9149 code (bug): if (typeof props[propName] === 'undefined') { code (fix): if (props[propName] === undefined) { Btw, === undefined is faster than typeof === 'undefined' on Chrome and IE. Reproduction Open in Firefox / Chrome / IE10 or higher. Fiddle: Raw: Workaround Change to\nHaha, browsers suck. Want to submit a PR? It looks like we do that thing unnecessarily in a few places in the React codebase. Note that we do need to use typeof if the binding might not exist, so we need to look at each case individually to make sure the change is valid there.\nI went through the react repo configuration (build, tests execution). Fix didn't break anything, but so far I didn't find solution to make good test (phantomjs doesn't have property). (HTMLAllCollection) is probably the only exception to the typeof and is not a html standard. Any suggestions to the unit test for this fix/improvement?\nAs long as you tested it manually and it worked in IE, I think we can accept this change without a unit test.\nFixed in\nlol what even\nI can't reproduce being in IE 8 or IE 9 on Windows 7, either in standards or quirks mode. What am I missing?\nIE < 10 is fine. Problem occurs when using modern browser like Chrome, Firefox, IE = 10 or Edge. They returns . component prop as in Chrome. will compare your prop with default prop (which is ). on Chrome is so React treats it as missing value. Default prop () will be selected. the end, prop will be always set to on modern browser in this case.\nOh! Sorry I totally misread. Yes I can repro this.", "positive_passages": [{"docid": "doc-en-react-d863a1f621824d3cc26b604100087f233debf571a19bb2b9f32f80ce469692b9", "text": "var renderedComponent = inst.render(); if (__DEV__) { // We allow auto-mocks to proceed as if they're returning null. if (typeof renderedComponent === 'undefined' && if (renderedComponent === undefined && inst.render._isMockFunction) { // This is probably bad practice. Consider warning here and // deprecating this convenience.", "commid": "react_pr_5965"}], "negative_passages": []} {"query_id": "q-en-react-32d61b30277c185f7229705afa6b94f0b47d1322e084100863712b1625ad5cd2", "query": "The have this at the beginning: But there're a number of instances of JSX in the file. For example, . the note be removed or clarified? JSX be purged from the file? adding tests to this file should they be free of JSX? In certain contexts but not others?\nNormally, our style is to use jsx within tests. I think some of the tests explicitly aren't using jsx, and that's the point. Perhaps it would be better to copy-paste that message into each of the tests that doesn't use jsx, since it's easy to miss the note up at the top and having the note at the top is somewhat ambiguous.\nThanks for the feedback. Yeah, for both of those reasons I'd say :+1: to either that or splitting it into two files if that made sense to you (would help with the ease of missing it if it's just at the top and make the alternative of repeating it within the file unnecessary): .\nI'd be happy to submit a PR for either of these cases!\nI think I prefer having the inline comment copy-pasted. A little copy-pasting never hurt anyone (). I'd take a PR for this, assuming no one else objects.", "positive_passages": [{"docid": "doc-en-react-8ba2e753847667907bafc3c0a7f72176b3dc917fd07af1855359d8cb779fcb82", "text": "'use strict'; // NOTE: We're explicitly not using JSX in this file. This is intended to test // classic JS without JSX. var React; var ReactDOM; var ReactTestUtils;", "commid": "react_pr_6159"}], "negative_passages": []} {"query_id": "q-en-react-32d61b30277c185f7229705afa6b94f0b47d1322e084100863712b1625ad5cd2", "query": "The have this at the beginning: But there're a number of instances of JSX in the file. For example, . the note be removed or clarified? JSX be purged from the file? adding tests to this file should they be free of JSX? In certain contexts but not others?\nNormally, our style is to use jsx within tests. I think some of the tests explicitly aren't using jsx, and that's the point. Perhaps it would be better to copy-paste that message into each of the tests that doesn't use jsx, since it's easy to miss the note up at the top and having the note at the top is somewhat ambiguous.\nThanks for the feedback. Yeah, for both of those reasons I'd say :+1: to either that or splitting it into two files if that made sense to you (would help with the ease of missing it if it's just at the top and make the alternative of repeating it within the file unnecessary): .\nI'd be happy to submit a PR for either of these cases!\nI think I prefer having the inline comment copy-pasted. A little copy-pasting never hurt anyone (). I'd take a PR for this, assuming no one else objects.", "positive_passages": [{"docid": "doc-en-react-fabad33f48c0e52e8d12a128cf490c1d9f7284e27fe7c057f17631ac4758408e", "text": "React = require('React'); ReactDOM = require('ReactDOM'); ReactTestUtils = require('ReactTestUtils'); // NOTE: We're explicitly not using JSX here. This is intended to test // classic JS without JSX. ComponentClass = React.createClass({ render: function() { return React.createElement('div');", "commid": "react_pr_6159"}], "negative_passages": []} {"query_id": "q-en-react-32d61b30277c185f7229705afa6b94f0b47d1322e084100863712b1625ad5cd2", "query": "The have this at the beginning: But there're a number of instances of JSX in the file. For example, . the note be removed or clarified? JSX be purged from the file? adding tests to this file should they be free of JSX? In certain contexts but not others?\nNormally, our style is to use jsx within tests. I think some of the tests explicitly aren't using jsx, and that's the point. Perhaps it would be better to copy-paste that message into each of the tests that doesn't use jsx, since it's easy to miss the note up at the top and having the note at the top is somewhat ambiguous.\nThanks for the feedback. Yeah, for both of those reasons I'd say :+1: to either that or splitting it into two files if that made sense to you (would help with the ease of missing it if it's just at the top and make the alternative of repeating it within the file unnecessary): .\nI'd be happy to submit a PR for either of these cases!\nI think I prefer having the inline comment copy-pasted. A little copy-pasting never hurt anyone (). I'd take a PR for this, assuming no one else objects.", "positive_passages": [{"docid": "doc-en-react-ab6a59e560d4a38796cbf0ecefb8f54ec6e62677f75c9b558bcd1aed86aaa231", "text": "expect(console.error.argsForCall.length).toBe(0); }); // NOTE: We're explicitly not using JSX here. This is intended to test // classic JS without JSX. it('allows static methods to be called using the type property', function() { spyOn(console, 'error');", "commid": "react_pr_6159"}], "negative_passages": []} {"query_id": "q-en-react-32d61b30277c185f7229705afa6b94f0b47d1322e084100863712b1625ad5cd2", "query": "The have this at the beginning: But there're a number of instances of JSX in the file. For example, . the note be removed or clarified? JSX be purged from the file? adding tests to this file should they be free of JSX? In certain contexts but not others?\nNormally, our style is to use jsx within tests. I think some of the tests explicitly aren't using jsx, and that's the point. Perhaps it would be better to copy-paste that message into each of the tests that doesn't use jsx, since it's easy to miss the note up at the top and having the note at the top is somewhat ambiguous.\nThanks for the feedback. Yeah, for both of those reasons I'd say :+1: to either that or splitting it into two files if that made sense to you (would help with the ease of missing it if it's just at the top and make the alternative of repeating it within the file unnecessary): .\nI'd be happy to submit a PR for either of these cases!\nI think I prefer having the inline comment copy-pasted. A little copy-pasting never hurt anyone (). I'd take a PR for this, assuming no one else objects.", "positive_passages": [{"docid": "doc-en-react-e7296faeb4c599cca5f493db1a0b2920ed0d817d761da536e0feaa8aab8ba49c", "text": "expect(console.error.argsForCall.length).toBe(0); }); // NOTE: We're explicitly not using JSX here. This is intended to test // classic JS without JSX. it('identifies valid elements', function() { var Component = React.createClass({ render: function() {", "commid": "react_pr_6159"}], "negative_passages": []} {"query_id": "q-en-react-32d61b30277c185f7229705afa6b94f0b47d1322e084100863712b1625ad5cd2", "query": "The have this at the beginning: But there're a number of instances of JSX in the file. For example, . the note be removed or clarified? JSX be purged from the file? adding tests to this file should they be free of JSX? In certain contexts but not others?\nNormally, our style is to use jsx within tests. I think some of the tests explicitly aren't using jsx, and that's the point. Perhaps it would be better to copy-paste that message into each of the tests that doesn't use jsx, since it's easy to miss the note up at the top and having the note at the top is somewhat ambiguous.\nThanks for the feedback. Yeah, for both of those reasons I'd say :+1: to either that or splitting it into two files if that made sense to you (would help with the ease of missing it if it's just at the top and make the alternative of repeating it within the file unnecessary): .\nI'd be happy to submit a PR for either of these cases!\nI think I prefer having the inline comment copy-pasted. A little copy-pasting never hurt anyone (). I'd take a PR for this, assuming no one else objects.", "positive_passages": [{"docid": "doc-en-react-64209b247f6afc5147a98856632f95f25e01ee8702aceb933b2e72118d238d0d", "text": "expect(typeof Component.specialType.isRequired).toBe('function'); }); // NOTE: We're explicitly not using JSX here. This is intended to test // classic JS without JSX. it('is indistinguishable from a plain object', function() { var element = React.createElement('div', {className: 'foo'}); var object = {}; expect(element.constructor).toBe(object.constructor); }); // NOTE: We're explicitly not using JSX here. This is intended to test // classic JS without JSX. it('should use default prop value when removing a prop', function() { var Component = React.createClass({ getDefaultProps: function() {", "commid": "react_pr_6159"}], "negative_passages": []} {"query_id": "q-en-react-32d61b30277c185f7229705afa6b94f0b47d1322e084100863712b1625ad5cd2", "query": "The have this at the beginning: But there're a number of instances of JSX in the file. For example, . the note be removed or clarified? JSX be purged from the file? adding tests to this file should they be free of JSX? In certain contexts but not others?\nNormally, our style is to use jsx within tests. I think some of the tests explicitly aren't using jsx, and that's the point. Perhaps it would be better to copy-paste that message into each of the tests that doesn't use jsx, since it's easy to miss the note up at the top and having the note at the top is somewhat ambiguous.\nThanks for the feedback. Yeah, for both of those reasons I'd say :+1: to either that or splitting it into two files if that made sense to you (would help with the ease of missing it if it's just at the top and make the alternative of repeating it within the file unnecessary): .\nI'd be happy to submit a PR for either of these cases!\nI think I prefer having the inline comment copy-pasted. A little copy-pasting never hurt anyone (). I'd take a PR for this, assuming no one else objects.", "positive_passages": [{"docid": "doc-en-react-8ae28a8f472ffe10d2a8836e6342fd2a29f611d02cfab24abe965c2fb4638421", "text": "expect(instance.props.fruit).toBe('persimmon'); }); // NOTE: We're explicitly not using JSX here. This is intended to test // classic JS without JSX. it('should normalize props with default values', function() { var Component = React.createClass({ getDefaultProps: function() {", "commid": "react_pr_6159"}], "negative_passages": []} {"query_id": "q-en-react-32d61b30277c185f7229705afa6b94f0b47d1322e084100863712b1625ad5cd2", "query": "The have this at the beginning: But there're a number of instances of JSX in the file. For example, . the note be removed or clarified? JSX be purged from the file? adding tests to this file should they be free of JSX? In certain contexts but not others?\nNormally, our style is to use jsx within tests. I think some of the tests explicitly aren't using jsx, and that's the point. Perhaps it would be better to copy-paste that message into each of the tests that doesn't use jsx, since it's easy to miss the note up at the top and having the note at the top is somewhat ambiguous.\nThanks for the feedback. Yeah, for both of those reasons I'd say :+1: to either that or splitting it into two files if that made sense to you (would help with the ease of missing it if it's just at the top and make the alternative of repeating it within the file unnecessary): .\nI'd be happy to submit a PR for either of these cases!\nI think I prefer having the inline comment copy-pasted. A little copy-pasting never hurt anyone (). I'd take a PR for this, assuming no one else objects.", "positive_passages": [{"docid": "doc-en-react-8d8776f60a0c68e6595b528aa24ecfb4546b87995510e0d336939187e0334699", "text": "expect(console.error.argsForCall.length).toBe(0); }); // NOTE: We're explicitly not using JSX here. This is intended to test // classic JS without JSX. it('identifies elements, but not JSON, if Symbols are supported', function() { // Rudimentary polyfill // Once all jest engines support Symbols natively we can swap this to test", "commid": "react_pr_6159"}], "negative_passages": []} {"query_id": "q-en-react-7105d41f53f0318f45440b370c4bc8358501f54011301facb4e1bf93cf13e422", "query": "(I am using 15rc2 because I need all the svg tags) I am rendering a foreignObject svg tag. According to I put body tag inside that tag and then whatever html I want in there. renderToString on the server leaves the body tag in place, and gives it a react-dataid. However when rendered on the client that body tag is removed. So when I look at the live elements, the body inside foreignObjects is gone, along with it's data-reactid. The server source ( ie view page source ) shows that the body tag was rendered with the missing react-dataid. The result is that you get a \u201cInvariant Violation: Unable to find element with ID XX\u201d, when the page updates, and somethings don't work. Removing the body from inside the foreignObject tag seems to solve the problem, but I don't know if that is an \"OK\" solution to this or if that body tag is necessary in some scenarios. But in either case this seems to be a scenario where server rendering results in different DOM/HTML then client rendering. Is this a problem, or is the body tag not supposed to there anyway? Todd\nWe never render the on the client side - only on the server side. Can you provide a jsfiddle that demonstrates the invariant violation?\nThanks for tracking down more specifically. Could be that browsers don't actually support that body usage? Or when actually parsed from markup, the body node doesn't exist (which seems likely and matches up with what we see in other situations where the browser changes markup). I won't have a chance to look into this more for a few days - it might be best to just use your alternate approach for now.\nI can remove the body tag. It seems to work ok with out it. Whats clear at this point is that if the server sends the body tag, it is not parsed into a DOM node, at least on mac with Chrome and Safari. That results in the error, since the data-reactid for the body is missing. IE doesn't support foreignObject so its not relevant there. MS Edge does, but I haven't tested it.\nIt seems so. Even without React, I can\u2019t get Chrome (or Firefox for that matter) to make an actual node: \"screen expect(isTagStackValid(['body', 'body'])).toBe(false); expect(isTagStackValid(['svg', 'foreignObject', 'body', 'p'])).toBe(false); }); });", "commid": "react_pr_6469"}], "negative_passages": []} {"query_id": "q-en-react-7105d41f53f0318f45440b370c4bc8358501f54011301facb4e1bf93cf13e422", "query": "(I am using 15rc2 because I need all the svg tags) I am rendering a foreignObject svg tag. According to I put body tag inside that tag and then whatever html I want in there. renderToString on the server leaves the body tag in place, and gives it a react-dataid. However when rendered on the client that body tag is removed. So when I look at the live elements, the body inside foreignObjects is gone, along with it's data-reactid. The server source ( ie view page source ) shows that the body tag was rendered with the missing react-dataid. The result is that you get a \u201cInvariant Violation: Unable to find element with ID XX\u201d, when the page updates, and somethings don't work. Removing the body from inside the foreignObject tag seems to solve the problem, but I don't know if that is an \"OK\" solution to this or if that body tag is necessary in some scenarios. But in either case this seems to be a scenario where server rendering results in different DOM/HTML then client rendering. Is this a problem, or is the body tag not supposed to there anyway? Todd\nWe never render the on the client side - only on the server side. Can you provide a jsfiddle that demonstrates the invariant violation?\nThanks for tracking down more specifically. Could be that browsers don't actually support that body usage? Or when actually parsed from markup, the body node doesn't exist (which seems likely and matches up with what we see in other situations where the browser changes markup). I won't have a chance to look into this more for a few days - it might be best to just use your alternate approach for now.\nI can remove the body tag. It seems to work ok with out it. Whats clear at this point is that if the server sends the body tag, it is not parsed into a DOM node, at least on mac with Chrome and Safari. That results in the error, since the data-reactid for the body is missing. IE doesn't support foreignObject so its not relevant there. MS Edge does, but I haven't tested it.\nIt seems so. Even without React, I can\u2019t get Chrome (or Firefox for that matter) to make an actual node: \"screen case 'body': case 'caption': case 'col': case 'colgroup':", "commid": "react_pr_6469"}], "negative_passages": []} {"query_id": "q-en-react-3d98ae18f9257a516b9db4fe9f78cf6bbef3f1800e1fd3c1d3d3398c954d179e", "query": "Identical app. I call after the app is loaded. React 0.14.7: function stripComplexValues(key, value) { if (typeof value !== 'object' || Array.isArray(value) || value == null) { return value; } var prototype = Object.getPrototypeOf(value); if (!prototype || prototype === Object.prototype) { return value; } return ''; } // This implementation of ReactPerf is going away some time mid 15.x. // While we plan to keep most of the API, the actual format of measurements // will change dramatically. To signal this, we wrap them into an opaque-ish", "commid": "react_pr_6289"}], "negative_passages": []} {"query_id": "q-en-react-3d98ae18f9257a516b9db4fe9f78cf6bbef3f1800e1fd3c1d3d3398c954d179e", "query": "Identical app. I call after the app is loaded. React 0.14.7: result.args = JSON.stringify(item.args); result.args = JSON.stringify(item.args, stripComplexValues); return result; })); console.log(", "commid": "react_pr_6289"}], "negative_passages": []} {"query_id": "q-en-react-3d98ae18f9257a516b9db4fe9f78cf6bbef3f1800e1fd3c1d3d3398c954d179e", "query": "Identical app. I call after the app is loaded. React 0.14.7: it('should print a table after calling printOperations', function() { var container = document.createElement('div'); var measurements = measure(() => { ReactDOM.render(
    hey
    , container); }); spyOn(console, 'table'); ReactDefaultPerf.printOperations(measurements); expect(console.table.calls.length).toBe(1); expect(console.table.argsForCall[0][0]).toEqual([{ 'data-reactid': '', type: 'set innerHTML', args: '{\"node\":\"\",\"children\":[],\"html\":null,\"text\":null}', }]); }); it('warns once when using getMeasurementsSummaryMap', function() { var measurements = measure(() => {}); spyOn(console, 'error');", "commid": "react_pr_6289"}], "negative_passages": []} {"query_id": "q-en-react-bf40d349cb3bac46d4f001bd6fcbb73da8b38fb6656956f6faa2afad9a275397", "query": "To reproduce, open Error is logged to browser dev tools (in Chrome & Firefox, somehow not in Safari). Happens on v15.0.0-rc.2 and on latest master version. The assignment of additional event data to the newly created SyntheticEvent triggers a console error:\nThanks for reporting. We'll get this fixed.\nAre we not checking for unexpected warnings in tests? Should we? Curious how this crept in unnoticed.\nnode doesn't support Proxies so none of that code is actually getting tested :/ Even running with flag (which we do at least with ) doesn't enable it since it's \"in progress\". We could probably run with to force it on.", "positive_passages": [{"docid": "doc-en-react-19a55b5d1e2e38eba4e2a1b64ee68e0e3babc09e5a5276c08790e8edc8a0b433", "text": "); }); it('should properly log warnings when events simulated with rendered components', function() { // TODO: reenable this test. We are currently silencing these warnings when // using TestUtils.Simulate to avoid spurious warnings that result from the // way we simulate events. xit('should properly log warnings when events simulated with rendered components', function() { spyOn(console, 'error'); var event; var element = document.createElement('div');", "commid": "react_pr_6380"}], "negative_passages": []} {"query_id": "q-en-react-bf40d349cb3bac46d4f001bd6fcbb73da8b38fb6656956f6faa2afad9a275397", "query": "To reproduce, open Error is logged to browser dev tools (in Chrome & Firefox, somehow not in Safari). Happens on v15.0.0-rc.2 and on latest master version. The assignment of additional event data to the newly created SyntheticEvent triggers a console error:\nThanks for reporting. We'll get this fixed.\nAre we not checking for unexpected warnings in tests? Should we? Curious how this crept in unnoticed.\nnode doesn't support Proxies so none of that code is actually getting tested :/ Even running with flag (which we do at least with ) doesn't enable it since it's \"in progress\". We could probably run with to force it on.", "positive_passages": [{"docid": "doc-en-react-07c6e03cfc670a2f9254bdc3abbf8762aa84a413a6d8ba1438682e58fc2a6dca", "text": "fakeNativeEvent, node ); // Since we aren't using pooling, always persist the event. This will make // sure it's marked and won't warn when setting additional properties. event.persist(); Object.assign(event, eventData); if (dispatchConfig.phasedRegistrationNames) {", "commid": "react_pr_6380"}], "negative_passages": []} {"query_id": "q-en-react-bf40d349cb3bac46d4f001bd6fcbb73da8b38fb6656956f6faa2afad9a275397", "query": "To reproduce, open Error is logged to browser dev tools (in Chrome & Firefox, somehow not in Safari). Happens on v15.0.0-rc.2 and on latest master version. The assignment of additional event data to the newly created SyntheticEvent triggers a console error:\nThanks for reporting. We'll get this fixed.\nAre we not checking for unexpected warnings in tests? Should we? Curious how this crept in unnoticed.\nnode doesn't support Proxies so none of that code is actually getting tested :/ Even running with flag (which we do at least with ) doesn't enable it since it's \"in progress\". We could probably run with to force it on.", "positive_passages": [{"docid": "doc-en-react-53449e4b871275de3f9da580466427072f2955c5078a0a1c5e4e5546f03b54be", "text": "expect(handler).not.toHaveBeenCalled(); }); it('should not warn when simulating events with extra properties', function() { spyOn(console, 'error'); var CLIENT_X = 100; var Component = React.createClass({ handleClick: function(e) { expect(e.clientX).toBe(CLIENT_X); }, render: function() { return
    ; }, }); var element = document.createElement('div'); var instance = ReactDOM.render(, element); ReactTestUtils.Simulate.click( ReactDOM.findDOMNode(instance), {clientX: CLIENT_X} ); expect(console.error.calls.length).toBe(0); }); it('can scry with stateless components involved', function() { var Stateless = () =>

    ; var SomeComponent = React.createClass({", "commid": "react_pr_6380"}], "negative_passages": []} {"query_id": "q-en-react-1726598a94edc3c2f874889fcbe58faf34610b1d7dd3b6cefc52cd7251ff49c1", "query": "has two calls to the Component class construction which are missing use of the 'new' operator. The calls are like this: Component(publicProps, publicContext, updateQueue) and are here: and here:\nThis is intentional. We check if we need to construct , and then use it to either call or not. This lets us support functional components and factory components:", "positive_passages": [{"docid": "doc-en-react-bae16eec0dd3565842ce436106ef68828fe80fc84476082d1fd119fcb4e0acbc", "text": "var args = [ \"bin/jsx\", \"--cache-dir\", \".module-cache\", config.sourceDir, config.outputDir ];", "commid": "react_pr_72"}], "negative_passages": []} {"query_id": "q-en-react-dedf4fd2183c619deccd280e1061ebe42854a38ff79bb4a0837386e24f1b5a9a", "query": "Do you want to request a feature or report a bug? This is more of a documentation discussion What is the current behavior? Currently, the contributing guide lists the lint step before running prettier. For example, says: If the current behavior is a bug, please provide the steps to reproduce and if possible a minimal demo of the problem via or similar (template: ). What is the expected behavior? I think it would make more sense to run prettier first, since it can automatically get rid of certain lint errors (like single-quotes or comma-dangle). A first-time contributor following the steps in order might waste time fixing things manually at the lint step before proceeding to the formatting step. Which versions of React, and which browser / OS are affected by this issue? Did this work in previous versions of React? N/A\nHappy to take PR fixing it.\nThanks to reminding, I make a PR for it.\nSeems like this was fixed.", "positive_passages": [{"docid": "doc-en-react-015709363245c9604cb6df90cb9e3bacb19c5f235e4ef638ae9f6d33eeefc145", "text": "2. If you've added code that should be tested, add tests! 3. If you've changed APIs, update the documentation. 4. Ensure the test suite passes (`npm test`). 5. Make sure your code lints (`npm run lint`). 6. Format your code with [prettier](https://github.com/prettier/prettier) (`npm run prettier`). 5. Format your code with [prettier](https://github.com/prettier/prettier) (`npm run prettier`). 6. Make sure your code lints (`npm run lint`). 7. Run the [Flow](https://flowtype.org/) typechecks (`npm run flow`). 8. If you added or removed any tests, run `./scripts/fiber/record-tests` before submitting the pull request, and commit the resulting changes. 9. If you haven't already, complete the CLA.", "commid": "react_pr_10094"}], "negative_passages": []} {"query_id": "q-en-react-32a7059d8beab748b4069c493b1b924912890d7a4bafbb343ae7c740995d25f2", "query": "We don't use rAF for scheduling anything anymore, yet we still enable it in ReactDOMFrameScheduling. It can probably be simplified a bit by not exposing it.", "positive_passages": [{"docid": "doc-en-react-8b6ecb04811a9c7d02e42d3b7da07fad0ace853399c921c809a454a8a2bad3a9", "text": "var invariant = require('fbjs/lib/invariant'); var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment'); // TODO: There's no way to cancel these, because Fiber doesn't atm. let rAF: (callback: (time: number) => void) => number; // TODO: There's no way to cancel, because Fiber doesn't atm. let rIC: (callback: (deadline: Deadline) => void) => number; if (!ExecutionEnvironment.canUseDOM) { rAF = function(frameCallback: (time: number) => void): number { setTimeout(frameCallback, 16); return 0; }; rIC = function(frameCallback: (deadline: Deadline) => void): number { setTimeout(() => { frameCallback({", "commid": "react_pr_10337"}], "negative_passages": []} {"query_id": "q-en-react-32a7059d8beab748b4069c493b1b924912890d7a4bafbb343ae7c740995d25f2", "query": "We don't use rAF for scheduling anything anymore, yet we still enable it in ReactDOMFrameScheduling. It can probably be simplified a bit by not exposing it.", "positive_passages": [{"docid": "doc-en-react-20dc3a0550a2b64bd4f76ecefeb53082a0f67bb0e79984bd6a193b70a590cf0d", "text": "'polyfill in older browsers.', ); } else if (typeof requestIdleCallback !== 'function') { // Wrap requestAnimationFrame and polyfill requestIdleCallback. // Polyfill requestIdleCallback. var scheduledRAFCallback = null; var scheduledRICCallback = null;", "commid": "react_pr_10337"}], "negative_passages": []} {"query_id": "q-en-react-32a7059d8beab748b4069c493b1b924912890d7a4bafbb343ae7c740995d25f2", "query": "We don't use rAF for scheduling anything anymore, yet we still enable it in ReactDOMFrameScheduling. It can probably be simplified a bit by not exposing it.", "positive_passages": [{"docid": "doc-en-react-46379f96675d33badbd23c4b834640a2259336e911ae323561f0671744a47cb9", "text": "isIdleScheduled = false; var callback = scheduledRICCallback; scheduledRICCallback = null; if (callback) { if (callback !== null) { callback(frameDeadlineObject); } };", "commid": "react_pr_10337"}], "negative_passages": []} {"query_id": "q-en-react-32a7059d8beab748b4069c493b1b924912890d7a4bafbb343ae7c740995d25f2", "query": "We don't use rAF for scheduling anything anymore, yet we still enable it in ReactDOMFrameScheduling. It can probably be simplified a bit by not exposing it.", "positive_passages": [{"docid": "doc-en-react-73679dbb6bb881f78c0c2f106314c248a5651db91d377fc6dd7e202f640758d3", "text": "} var callback = scheduledRAFCallback; scheduledRAFCallback = null; if (callback) { if (callback !== null) { callback(rafTime); } }; rAF = function(callback: (time: number) => void): number { // This assumes that we only schedule one callback at a time because that's // how Fiber uses it. scheduledRAFCallback = callback; if (!isAnimationFrameScheduled) { // If rIC didn't already schedule one, we need to schedule a frame. isAnimationFrameScheduled = true; requestAnimationFrame(animationTick); } return 0; }; rIC = function(callback: (deadline: Deadline) => void): number { // This assumes that we only schedule one callback at a time because that's // how Fiber uses it.", "commid": "react_pr_10337"}], "negative_passages": []} {"query_id": "q-en-react-32a7059d8beab748b4069c493b1b924912890d7a4bafbb343ae7c740995d25f2", "query": "We don't use rAF for scheduling anything anymore, yet we still enable it in ReactDOMFrameScheduling. It can probably be simplified a bit by not exposing it.", "positive_passages": [{"docid": "doc-en-react-d872a3e70fbb39378c2818af703116703dc2d785b89f93dd6dc2b16d6f0836ea", "text": "return 0; }; } else { rAF = requestAnimationFrame; rIC = requestIdleCallback; } exports.rAF = rAF; exports.rIC = rIC;", "commid": "react_pr_10337"}], "negative_passages": []} {"query_id": "q-en-react-b85c2f634aeb025a447d3abfc3da8c2e6faeaecd8a47e2e1d570cf04625729f3", "query": "Do you want to request a feature or report a bug? bug What is the current behavior? In the render Fragments example, the JSX tag is closed prematurely. If the current behavior is a bug, please provide the steps to reproduce and if possible a minimal demo of the problem via or similar (template: ). \u2014 What is the expected behavior? Which versions of React, and which browser / OS are affected by this issue? Did this work in previous versions of React? React 16.0.0 documentation website on Chrome Android. Previously array Fragments weren't supported.", "positive_passages": [{"docid": "doc-en-react-2d1b8484c030396317a953d09cfab995f2fc2c5e685ad8ebcfa08cecc4a3b1db", "text": "```javascript render() { return [
  • First item
  • ,
  • Second item
  • ,
  • Third item
  • ,
  • First item
  • ,
  • Second item
  • ,
  • Third item
  • ,
    ]; } ```", "commid": "react_pr_10885"}], "negative_passages": []} {"query_id": "q-en-react-44070ddcc79a671b0d3a2ac9ea44e2784e43769830f718e08b1dd5ef06cf2537", "query": "The current default behavior is that keyboard users will get to the code sections of the live editor and get stuck. Can someone configure ignoreTabKey which makes the editor ignore tab key presses so that keyboard users can tab past the editor without getting stuck? Chrome on Windows atm and cannot edit it to submit a fix. Sorry about that :(\nThanks for bringing this to our attention", "positive_passages": [{"docid": "doc-en-react-331e6031c961e9da6f4709ef6a4e6c72a4975cd55ed2c1d86dc410d20eafe954", "text": "}, }} className=\"gatsby-highlight\">
    {error &&", "commid": "react_pr_10992"}], "negative_passages": []} {"query_id": "q-en-react-abb3470d8306964cd5c09e50d6c4767d91e0739ecf0a7525b15a80749def46f0", "query": "Do you want to request a feature or report a bug? Improvement What is the current behavior? does not currently support the property. () is nice to have when you want to write key-specific handling\u2014rather than input-specific (dependent on layout and modifier keys) handling. What is the expected behavior? already exposes a property. It should have a property as well. Currently, if you want to use the 's , you must access it through 's . Which versions of React, and which browser / OS are affected by this issue? Did this work in previous versions of React? Affects React 16 and earlier (I assume).\nI created the PR for this.\nthe above PR is stale and closed; should I pick this up? planning to replicate the same and follow the PR suggestions; any tips or idea?\nCan you give me an idea of how widely supported it is?\nAccording to it is supported in all major desktop browsers. Are there any plans to implement this? I am not sure whether I should mark it with until this issue is resolved or don't use it at all.\nThis issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contribution.\nClosing this issue after a prolonged period of inactivity. If this issue is still present in the latest release, please create a new issue with up-to-date information. Thank you!", "positive_passages": [{"docid": "doc-en-react-9319f132e6525d6239aa66ad0880f7f380fa4e0b62bdaa38f78684b548071870", "text": "function getUnboundedScrollPosition(scrollable) { if (scrollable === window) { return { x: document.documentElement.scrollLeft || document.body.scrollLeft, y: document.documentElement.scrollTop || document.body.scrollTop x: window.pageXOffset || document.documentElement.scrollLeft, y: window.pageYOffset || document.documentElement.scrollTop }; } return {", "commid": "react_pr_643"}], "negative_passages": []} {"query_id": "q-en-react-11ac5bb9256388708266007fff66256fb5f39b0331720f085eb132493871f883", "query": "