From cd1103e7d01a33f89f38303053b3af807fe1c486 Mon Sep 17 00:00:00 2001 From: Jordan Santell Date: Thu, 8 Oct 2015 18:08:09 -0700 Subject: [PATCH] Bug 1213138 - Add react-redux library to developer tools. r=gerv --- .../client/shared/vendor/REACT_REDUX_LICENSE | 21 + .../shared/vendor/REACT_REDUX_UPGRADING | 9 + devtools/client/shared/vendor/moz.build | 1 + devtools/client/shared/vendor/react-redux.js | 724 ++++++++++++++++++ toolkit/content/license.html | 29 + 5 files changed, 784 insertions(+) create mode 100644 devtools/client/shared/vendor/REACT_REDUX_LICENSE create mode 100644 devtools/client/shared/vendor/REACT_REDUX_UPGRADING create mode 100644 devtools/client/shared/vendor/react-redux.js diff --git a/devtools/client/shared/vendor/REACT_REDUX_LICENSE b/devtools/client/shared/vendor/REACT_REDUX_LICENSE new file mode 100644 index 000000000000..af2353dca4ed --- /dev/null +++ b/devtools/client/shared/vendor/REACT_REDUX_LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 Dan Abramov + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/devtools/client/shared/vendor/REACT_REDUX_UPGRADING b/devtools/client/shared/vendor/REACT_REDUX_UPGRADING new file mode 100644 index 000000000000..7739751dbe23 --- /dev/null +++ b/devtools/client/shared/vendor/REACT_REDUX_UPGRADING @@ -0,0 +1,9 @@ +"react-redux" uses UMD style loading to work in many different environments. +It assumes that "react" and "redux" are both included via `require("react")` +as in node or browserify, but the paths to our react and redux installation are different. + +If upgrading react-redux, define the correct paths and replace the require statements +for the module.exports case with the correct paths. + +Path to react: "devtools/client/shared/vendor/react" +Path to redux: "devtools/client/shared/vendor/redux" diff --git a/devtools/client/shared/vendor/moz.build b/devtools/client/shared/vendor/moz.build index 4995bc32f8fb..1a0c240401c6 100644 --- a/devtools/client/shared/vendor/moz.build +++ b/devtools/client/shared/vendor/moz.build @@ -12,6 +12,7 @@ if CONFIG['DEBUG_JS_MODULES']: ] modules += [ + 'react-redux.js', 'react.js', 'redux.js', ] diff --git a/devtools/client/shared/vendor/react-redux.js b/devtools/client/shared/vendor/react-redux.js new file mode 100644 index 000000000000..562f4916f210 --- /dev/null +++ b/devtools/client/shared/vendor/react-redux.js @@ -0,0 +1,724 @@ +var REACT_PATH = "devtools/client/shared/vendor/react"; +var REDUX_PATH = "devtools/client/shared/vendor/redux"; + +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require(REACT_PATH), require(REDUX_PATH)); + else if(typeof define === 'function' && define.amd) + define(["react", "redux"], factory); + else if(typeof exports === 'object') + exports["ReactRedux"] = factory(require("react"), require("redux")); + else + root["ReactRedux"] = factory(root["React"], root["Redux"]); +})(this, function(__WEBPACK_EXTERNAL_MODULE_10__, __WEBPACK_EXTERNAL_MODULE_11__) { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; + +/******/ // The require function +/******/ function __webpack_require__(moduleId) { + +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; + +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = true; + +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } + + +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; + +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(10); + + var _react2 = _interopRequireDefault(_react); + + var _componentsCreateAll = __webpack_require__(2); + + var _componentsCreateAll2 = _interopRequireDefault(_componentsCreateAll); + + var _createAll = _componentsCreateAll2['default'](_react2['default']); + + var Provider = _createAll.Provider; + var connect = _createAll.connect; + exports.Provider = Provider; + exports.connect = connect; + +/***/ }, +/* 1 */ +/***/ function(module, exports) { + + "use strict"; + + exports.__esModule = true; + exports["default"] = createStoreShape; + + function createStoreShape(PropTypes) { + return PropTypes.shape({ + subscribe: PropTypes.func.isRequired, + dispatch: PropTypes.func.isRequired, + getState: PropTypes.func.isRequired + }); + } + + module.exports = exports["default"]; + +/***/ }, +/* 2 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = createAll; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _createProvider = __webpack_require__(4); + + var _createProvider2 = _interopRequireDefault(_createProvider); + + var _createConnect = __webpack_require__(3); + + var _createConnect2 = _interopRequireDefault(_createConnect); + + function createAll(React) { + var Provider = _createProvider2['default'](React); + var connect = _createConnect2['default'](React); + + return { Provider: Provider, connect: connect }; + } + + module.exports = exports['default']; + +/***/ }, +/* 3 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; + + exports['default'] = createConnect; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _utilsCreateStoreShape = __webpack_require__(1); + + var _utilsCreateStoreShape2 = _interopRequireDefault(_utilsCreateStoreShape); + + var _utilsShallowEqual = __webpack_require__(6); + + var _utilsShallowEqual2 = _interopRequireDefault(_utilsShallowEqual); + + var _utilsIsPlainObject = __webpack_require__(5); + + var _utilsIsPlainObject2 = _interopRequireDefault(_utilsIsPlainObject); + + var _utilsWrapActionCreators = __webpack_require__(7); + + var _utilsWrapActionCreators2 = _interopRequireDefault(_utilsWrapActionCreators); + + var _hoistNonReactStatics = __webpack_require__(8); + + var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics); + + var _invariant = __webpack_require__(9); + + var _invariant2 = _interopRequireDefault(_invariant); + + var defaultMapStateToProps = function defaultMapStateToProps() { + return {}; + }; + var defaultMapDispatchToProps = function defaultMapDispatchToProps(dispatch) { + return { dispatch: dispatch }; + }; + var defaultMergeProps = function defaultMergeProps(stateProps, dispatchProps, parentProps) { + return _extends({}, parentProps, stateProps, dispatchProps); + }; + + function getDisplayName(Component) { + return Component.displayName || Component.name || 'Component'; + } + + // Helps track hot reloading. + var nextVersion = 0; + + function createConnect(React) { + var Component = React.Component; + var PropTypes = React.PropTypes; + + var storeShape = _utilsCreateStoreShape2['default'](PropTypes); + + return function connect(mapStateToProps, mapDispatchToProps, mergeProps) { + var options = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3]; + + var shouldSubscribe = Boolean(mapStateToProps); + var finalMapStateToProps = mapStateToProps || defaultMapStateToProps; + var finalMapDispatchToProps = _utilsIsPlainObject2['default'](mapDispatchToProps) ? _utilsWrapActionCreators2['default'](mapDispatchToProps) : mapDispatchToProps || defaultMapDispatchToProps; + var finalMergeProps = mergeProps || defaultMergeProps; + var shouldUpdateStateProps = finalMapStateToProps.length > 1; + var shouldUpdateDispatchProps = finalMapDispatchToProps.length > 1; + var _options$pure = options.pure; + var pure = _options$pure === undefined ? true : _options$pure; + + // Helps track hot reloading. + var version = nextVersion++; + + function computeStateProps(store, props) { + var state = store.getState(); + var stateProps = shouldUpdateStateProps ? finalMapStateToProps(state, props) : finalMapStateToProps(state); + + _invariant2['default'](_utilsIsPlainObject2['default'](stateProps), '`mapStateToProps` must return an object. Instead received %s.', stateProps); + return stateProps; + } + + function computeDispatchProps(store, props) { + var dispatch = store.dispatch; + + var dispatchProps = shouldUpdateDispatchProps ? finalMapDispatchToProps(dispatch, props) : finalMapDispatchToProps(dispatch); + + _invariant2['default'](_utilsIsPlainObject2['default'](dispatchProps), '`mapDispatchToProps` must return an object. Instead received %s.', dispatchProps); + return dispatchProps; + } + + function _computeNextState(stateProps, dispatchProps, parentProps) { + var mergedProps = finalMergeProps(stateProps, dispatchProps, parentProps); + _invariant2['default'](_utilsIsPlainObject2['default'](mergedProps), '`mergeProps` must return an object. Instead received %s.', mergedProps); + return mergedProps; + } + + return function wrapWithConnect(WrappedComponent) { + var Connect = (function (_Component) { + _inherits(Connect, _Component); + + Connect.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) { + if (!pure) { + this.updateStateProps(nextProps); + this.updateDispatchProps(nextProps); + this.updateState(nextProps); + return true; + } + + var storeChanged = nextState.storeState !== this.state.storeState; + var propsChanged = !_utilsShallowEqual2['default'](nextProps, this.props); + var mapStateProducedChange = false; + var dispatchPropsChanged = false; + + if (storeChanged || propsChanged && shouldUpdateStateProps) { + mapStateProducedChange = this.updateStateProps(nextProps); + } + + if (propsChanged && shouldUpdateDispatchProps) { + dispatchPropsChanged = this.updateDispatchProps(nextProps); + } + + if (propsChanged || mapStateProducedChange || dispatchPropsChanged) { + this.updateState(nextProps); + return true; + } + + return false; + }; + + function Connect(props, context) { + _classCallCheck(this, Connect); + + _Component.call(this, props, context); + this.version = version; + this.store = props.store || context.store; + + _invariant2['default'](this.store, 'Could not find "store" in either the context or ' + ('props of "' + this.constructor.displayName + '". ') + 'Either wrap the root component in a , ' + ('or explicitly pass "store" as a prop to "' + this.constructor.displayName + '".')); + + this.stateProps = computeStateProps(this.store, props); + this.dispatchProps = computeDispatchProps(this.store, props); + this.state = { storeState: null }; + this.updateState(); + } + + Connect.prototype.computeNextState = function computeNextState() { + var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; + + return _computeNextState(this.stateProps, this.dispatchProps, props); + }; + + Connect.prototype.updateStateProps = function updateStateProps() { + var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; + + var nextStateProps = computeStateProps(this.store, props); + if (_utilsShallowEqual2['default'](nextStateProps, this.stateProps)) { + return false; + } + + this.stateProps = nextStateProps; + return true; + }; + + Connect.prototype.updateDispatchProps = function updateDispatchProps() { + var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; + + var nextDispatchProps = computeDispatchProps(this.store, props); + if (_utilsShallowEqual2['default'](nextDispatchProps, this.dispatchProps)) { + return false; + } + + this.dispatchProps = nextDispatchProps; + return true; + }; + + Connect.prototype.updateState = function updateState() { + var props = arguments.length <= 0 || arguments[0] === undefined ? this.props : arguments[0]; + + this.nextState = this.computeNextState(props); + }; + + Connect.prototype.isSubscribed = function isSubscribed() { + return typeof this.unsubscribe === 'function'; + }; + + Connect.prototype.trySubscribe = function trySubscribe() { + if (shouldSubscribe && !this.unsubscribe) { + this.unsubscribe = this.store.subscribe(this.handleChange.bind(this)); + this.handleChange(); + } + }; + + Connect.prototype.tryUnsubscribe = function tryUnsubscribe() { + if (this.unsubscribe) { + this.unsubscribe(); + this.unsubscribe = null; + } + }; + + Connect.prototype.componentDidMount = function componentDidMount() { + this.trySubscribe(); + }; + + Connect.prototype.componentWillUnmount = function componentWillUnmount() { + this.tryUnsubscribe(); + }; + + Connect.prototype.handleChange = function handleChange() { + if (!this.unsubscribe) { + return; + } + + this.setState({ + storeState: this.store.getState() + }); + }; + + Connect.prototype.getWrappedInstance = function getWrappedInstance() { + return this.refs.wrappedInstance; + }; + + Connect.prototype.render = function render() { + return React.createElement(WrappedComponent, _extends({ ref: 'wrappedInstance' + }, this.nextState)); + }; + + return Connect; + })(Component); + + Connect.displayName = 'Connect(' + getDisplayName(WrappedComponent) + ')'; + Connect.WrappedComponent = WrappedComponent; + Connect.contextTypes = { + store: storeShape + }; + Connect.propTypes = { + store: storeShape + }; + + if (true) { + Connect.prototype.componentWillUpdate = function componentWillUpdate() { + if (this.version === version) { + return; + } + + // We are hot reloading! + this.version = version; + + // Update the state and bindings. + this.trySubscribe(); + this.updateStateProps(); + this.updateDispatchProps(); + this.updateState(); + }; + } + + return _hoistNonReactStatics2['default'](Connect, WrappedComponent); + }; + }; + } + + module.exports = exports['default']; + +/***/ }, +/* 4 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = createProvider; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } + + function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + + var _utilsCreateStoreShape = __webpack_require__(1); + + var _utilsCreateStoreShape2 = _interopRequireDefault(_utilsCreateStoreShape); + + function isUsingOwnerContext(React) { + var version = React.version; + + if (typeof version !== 'string') { + return true; + } + + var sections = version.split('.'); + var major = parseInt(sections[0], 10); + var minor = parseInt(sections[1], 10); + + return major === 0 && minor === 13; + } + + function createProvider(React) { + var Component = React.Component; + var PropTypes = React.PropTypes; + var Children = React.Children; + + var storeShape = _utilsCreateStoreShape2['default'](PropTypes); + var requireFunctionChild = isUsingOwnerContext(React); + + var didWarnAboutChild = false; + function warnAboutFunctionChild() { + if (didWarnAboutChild || requireFunctionChild) { + return; + } + + didWarnAboutChild = true; + console.error( // eslint-disable-line no-console + 'With React 0.14 and later versions, you no longer need to ' + 'wrap child into a function.'); + } + function warnAboutElementChild() { + if (didWarnAboutChild || !requireFunctionChild) { + return; + } + + didWarnAboutChild = true; + console.error( // eslint-disable-line no-console + 'With React 0.13, you need to ' + 'wrap child into a function. ' + 'This restriction will be removed with React 0.14.'); + } + + var didWarnAboutReceivingStore = false; + function warnAboutReceivingStore() { + if (didWarnAboutReceivingStore) { + return; + } + + didWarnAboutReceivingStore = true; + console.error( // eslint-disable-line no-console + ' does not support changing `store` on the fly. ' + 'It is most likely that you see this error because you updated to ' + 'Redux 2.x and React Redux 2.x which no longer hot reload reducers ' + 'automatically. See https://github.com/rackt/react-redux/releases/' + 'tag/v2.0.0 for the migration instructions.'); + } + + var Provider = (function (_Component) { + _inherits(Provider, _Component); + + Provider.prototype.getChildContext = function getChildContext() { + return { store: this.store }; + }; + + function Provider(props, context) { + _classCallCheck(this, Provider); + + _Component.call(this, props, context); + this.store = props.store; + } + + Provider.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { + var store = this.store; + var nextStore = nextProps.store; + + if (store !== nextStore) { + warnAboutReceivingStore(); + } + }; + + Provider.prototype.render = function render() { + var children = this.props.children; + + if (typeof children === 'function') { + warnAboutFunctionChild(); + children = children(); + } else { + warnAboutElementChild(); + } + + return Children.only(children); + }; + + return Provider; + })(Component); + + Provider.childContextTypes = { + store: storeShape.isRequired + }; + Provider.propTypes = { + store: storeShape.isRequired, + children: (requireFunctionChild ? PropTypes.func : PropTypes.element).isRequired + }; + + return Provider; + } + + module.exports = exports['default']; + +/***/ }, +/* 5 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = isPlainObject; + var fnToString = function fnToString(fn) { + return Function.prototype.toString.call(fn); + }; + + /** + * @param {any} obj The object to inspect. + * @returns {boolean} True if the argument appears to be a plain object. + */ + + function isPlainObject(obj) { + if (!obj || typeof obj !== 'object') { + return false; + } + + var proto = typeof obj.constructor === 'function' ? Object.getPrototypeOf(obj) : Object.prototype; + + if (proto === null) { + return true; + } + + var constructor = proto.constructor; + + return typeof constructor === 'function' && constructor instanceof constructor && fnToString(constructor) === fnToString(Object); + } + + module.exports = exports['default']; + +/***/ }, +/* 6 */ +/***/ function(module, exports) { + + "use strict"; + + exports.__esModule = true; + exports["default"] = shallowEqual; + + function shallowEqual(objA, objB) { + if (objA === objB) { + return true; + } + + var keysA = Object.keys(objA); + var keysB = Object.keys(objB); + + if (keysA.length !== keysB.length) { + return false; + } + + // Test for A's keys different from B. + var hasOwn = Object.prototype.hasOwnProperty; + for (var i = 0; i < keysA.length; i++) { + if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) { + return false; + } + } + + return true; + } + + module.exports = exports["default"]; + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = wrapActionCreators; + + var _redux = __webpack_require__(11); + + function wrapActionCreators(actionCreators) { + return function (dispatch) { + return _redux.bindActionCreators(actionCreators, dispatch); + }; + } + + module.exports = exports['default']; + +/***/ }, +/* 8 */ +/***/ function(module, exports) { + + /** + * Copyright 2015, Yahoo! Inc. + * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. + */ + 'use strict'; + + var REACT_STATICS = { + childContextTypes: true, + contextTypes: true, + defaultProps: true, + displayName: true, + getDefaultProps: true, + mixins: true, + propTypes: true, + type: true + }; + + var KNOWN_STATICS = { + name: true, + length: true, + prototype: true, + caller: true, + arguments: true, + arity: true + }; + + module.exports = function hoistNonReactStatics(targetComponent, sourceComponent) { + var keys = Object.getOwnPropertyNames(sourceComponent); + for (var i=0; iqcms License
  • QR Code Generator License
  • React License
    • +
  • React-Redux License
  • Red Hat xdg_user_dir_lookup License
  • Redux License
  • Russian Spellchecking Dictionary License
    • @@ -4480,6 +4481,34 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    +

    React-Redux License

    + +

    This license applies to the file + devtools/client/shared/vendor/react-redux.js.

    +
    +Copyright (c) 2015 Dan Abramov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
    + +
    +

    Red Hat xdg_user_dir_lookup License

    This license applies to the