decidim 0.27.8 → 0.28.0.rc4

data/packages/webpacker/node_modules/argparse/lib/sub.js

@@ -0,0 +1,67 @@
+// Limited implementation of python % string operator, supports only %s and %r for now
+// (other formats are not used here, but may appear in custom templates)
+
+'use strict'
+
+const { inspect } = require('util')
+
+
+module.exports = function sub(pattern, ...values) {
+    let regex = /%(?:(%)|(-)?(\*)?(?:\((\w+)\))?([A-Za-z]))/g
+
+    let result = pattern.replace(regex, function (_, is_literal, is_left_align, is_padded, name, format) {
+        if (is_literal) return '%'
+
+        let padded_count = 0
+        if (is_padded) {
+            if (values.length === 0) throw new TypeError('not enough arguments for format string')
+            padded_count = values.shift()
+            if (!Number.isInteger(padded_count)) throw new TypeError('* wants int')
+        }
+
+        let str
+        if (name !== undefined) {
+            let dict = values[0]
+            if (typeof dict !== 'object' || dict === null) throw new TypeError('format requires a mapping')
+            if (!(name in dict)) throw new TypeError(`no such key: '${name}'`)
+            str = dict[name]
+        } else {
+            if (values.length === 0) throw new TypeError('not enough arguments for format string')
+            str = values.shift()
+        }
+
+        switch (format) {
+            case 's':
+                str = String(str)
+                break
+            case 'r':
+                str = inspect(str)
+                break
+            case 'd':
+            case 'i':
+                if (typeof str !== 'number') {
+                    throw new TypeError(`%${format} format: a number is required, not ${typeof str}`)
+                }
+                str = String(str.toFixed(0))
+                break
+            default:
+                throw new TypeError(`unsupported format character '${format}'`)
+        }
+
+        if (padded_count > 0) {
+            return is_left_align ? str.padEnd(padded_count) : str.padStart(padded_count)
+        } else {
+            return str
+        }
+    })
+
+    if (values.length) {
+        if (values.length === 1 && typeof values[0] === 'object' && values[0] !== null) {
+            // mapping
+        } else {
+            throw new TypeError('not all arguments converted during string formatting')
+        }
+    }
+
+    return result
+}

data/packages/webpacker/node_modules/argparse/lib/textwrap.js

@@ -0,0 +1,440 @@
+// Partial port of python's argparse module, version 3.9.0 (only wrap and fill functions):
+// https://github.com/python/cpython/blob/v3.9.0b4/Lib/textwrap.py
+
+'use strict'
+
+/*
+ * Text wrapping and filling.
+ */
+
+// Copyright (C) 1999-2001 Gregory P. Ward.
+// Copyright (C) 2002, 2003 Python Software Foundation.
+// Copyright (C) 2020 argparse.js authors
+// Originally written by Greg Ward <gward@python.net>
+
+// Hardcode the recognized whitespace characters to the US-ASCII
+// whitespace characters.  The main reason for doing this is that
+// some Unicode spaces (like \u00a0) are non-breaking whitespaces.
+//
+// This less funky little regex just split on recognized spaces. E.g.
+//   "Hello there -- you goof-ball, use the -b option!"
+// splits into
+//   Hello/ /there/ /--/ /you/ /goof-ball,/ /use/ /the/ /-b/ /option!/
+const wordsep_simple_re = /([\t\n\x0b\x0c\r ]+)/
+
+class TextWrapper {
+    /*
+     *  Object for wrapping/filling text.  The public interface consists of
+     *  the wrap() and fill() methods; the other methods are just there for
+     *  subclasses to override in order to tweak the default behaviour.
+     *  If you want to completely replace the main wrapping algorithm,
+     *  you'll probably have to override _wrap_chunks().
+     *
+     *  Several instance attributes control various aspects of wrapping:
+     *    width (default: 70)
+     *      the maximum width of wrapped lines (unless break_long_words
+     *      is false)
+     *    initial_indent (default: "")
+     *      string that will be prepended to the first line of wrapped
+     *      output.  Counts towards the line's width.
+     *    subsequent_indent (default: "")
+     *      string that will be prepended to all lines save the first
+     *      of wrapped output; also counts towards each line's width.
+     *    expand_tabs (default: true)
+     *      Expand tabs in input text to spaces before further processing.
+     *      Each tab will become 0 .. 'tabsize' spaces, depending on its position
+     *      in its line.  If false, each tab is treated as a single character.
+     *    tabsize (default: 8)
+     *      Expand tabs in input text to 0 .. 'tabsize' spaces, unless
+     *      'expand_tabs' is false.
+     *    replace_whitespace (default: true)
+     *      Replace all whitespace characters in the input text by spaces
+     *      after tab expansion.  Note that if expand_tabs is false and
+     *      replace_whitespace is true, every tab will be converted to a
+     *      single space!
+     *    fix_sentence_endings (default: false)
+     *      Ensure that sentence-ending punctuation is always followed
+     *      by two spaces.  Off by default because the algorithm is
+     *      (unavoidably) imperfect.
+     *    break_long_words (default: true)
+     *      Break words longer than 'width'.  If false, those words will not
+     *      be broken, and some lines might be longer than 'width'.
+     *    break_on_hyphens (default: true)
+     *      Allow breaking hyphenated words. If true, wrapping will occur
+     *      preferably on whitespaces and right after hyphens part of
+     *      compound words.
+     *    drop_whitespace (default: true)
+     *      Drop leading and trailing whitespace from lines.
+     *    max_lines (default: None)
+     *      Truncate wrapped lines.
+     *    placeholder (default: ' [...]')
+     *      Append to the last line of truncated text.
+     */
+
+    constructor(options = {}) {
+        let {
+            width = 70,
+            initial_indent = '',
+            subsequent_indent = '',
+            expand_tabs = true,
+            replace_whitespace = true,
+            fix_sentence_endings = false,
+            break_long_words = true,
+            drop_whitespace = true,
+            break_on_hyphens = true,
+            tabsize = 8,
+            max_lines = undefined,
+            placeholder=' [...]'
+        } = options
+
+        this.width = width
+        this.initial_indent = initial_indent
+        this.subsequent_indent = subsequent_indent
+        this.expand_tabs = expand_tabs
+        this.replace_whitespace = replace_whitespace
+        this.fix_sentence_endings = fix_sentence_endings
+        this.break_long_words = break_long_words
+        this.drop_whitespace = drop_whitespace
+        this.break_on_hyphens = break_on_hyphens
+        this.tabsize = tabsize
+        this.max_lines = max_lines
+        this.placeholder = placeholder
+    }
+
+
+    // -- Private methods -----------------------------------------------
+    // (possibly useful for subclasses to override)
+
+    _munge_whitespace(text) {
+        /*
+         *  _munge_whitespace(text : string) -> string
+         *
+         *  Munge whitespace in text: expand tabs and convert all other
+         *  whitespace characters to spaces.  Eg. " foo\\tbar\\n\\nbaz"
+         *  becomes " foo    bar  baz".
+         */
+        if (this.expand_tabs) {
+            text = text.replace(/\t/g, ' '.repeat(this.tabsize)) // not strictly correct in js
+        }
+        if (this.replace_whitespace) {
+            text = text.replace(/[\t\n\x0b\x0c\r]/g, ' ')
+        }
+        return text
+    }
+
+    _split(text) {
+        /*
+         *  _split(text : string) -> [string]
+         *
+         *  Split the text to wrap into indivisible chunks.  Chunks are
+         *  not quite the same as words; see _wrap_chunks() for full
+         *  details.  As an example, the text
+         *    Look, goof-ball -- use the -b option!
+         *  breaks into the following chunks:
+         *    'Look,', ' ', 'goof-', 'ball', ' ', '--', ' ',
+         *    'use', ' ', 'the', ' ', '-b', ' ', 'option!'
+         *  if break_on_hyphens is True, or in:
+         *    'Look,', ' ', 'goof-ball', ' ', '--', ' ',
+         *    'use', ' ', 'the', ' ', '-b', ' ', option!'
+         *  otherwise.
+         */
+        let chunks = text.split(wordsep_simple_re)
+        chunks = chunks.filter(Boolean)
+        return chunks
+    }
+
+    _handle_long_word(reversed_chunks, cur_line, cur_len, width) {
+        /*
+         *  _handle_long_word(chunks : [string],
+         *                    cur_line : [string],
+         *                    cur_len : int, width : int)
+         *
+         *  Handle a chunk of text (most likely a word, not whitespace) that
+         *  is too long to fit in any line.
+         */
+        // Figure out when indent is larger than the specified width, and make
+        // sure at least one character is stripped off on every pass
+        let space_left
+        if (width < 1) {
+            space_left = 1
+        } else {
+            space_left = width - cur_len
+        }
+
+        // If we're allowed to break long words, then do so: put as much
+        // of the next chunk onto the current line as will fit.
+        if (this.break_long_words) {
+            cur_line.push(reversed_chunks[reversed_chunks.length - 1].slice(0, space_left))
+            reversed_chunks[reversed_chunks.length - 1] = reversed_chunks[reversed_chunks.length - 1].slice(space_left)
+
+        // Otherwise, we have to preserve the long word intact.  Only add
+        // it to the current line if there's nothing already there --
+        // that minimizes how much we violate the width constraint.
+        } else if (!cur_line) {
+            cur_line.push(...reversed_chunks.pop())
+        }
+
+        // If we're not allowed to break long words, and there's already
+        // text on the current line, do nothing.  Next time through the
+        // main loop of _wrap_chunks(), we'll wind up here again, but
+        // cur_len will be zero, so the next line will be entirely
+        // devoted to the long word that we can't handle right now.
+    }
+
+    _wrap_chunks(chunks) {
+        /*
+         *  _wrap_chunks(chunks : [string]) -> [string]
+         *
+         *  Wrap a sequence of text chunks and return a list of lines of
+         *  length 'self.width' or less.  (If 'break_long_words' is false,
+         *  some lines may be longer than this.)  Chunks correspond roughly
+         *  to words and the whitespace between them: each chunk is
+         *  indivisible (modulo 'break_long_words'), but a line break can
+         *  come between any two chunks.  Chunks should not have internal
+         *  whitespace; ie. a chunk is either all whitespace or a "word".
+         *  Whitespace chunks will be removed from the beginning and end of
+         *  lines, but apart from that whitespace is preserved.
+         */
+        let lines = []
+        let indent
+        if (this.width <= 0) {
+            throw Error(`invalid width ${this.width} (must be > 0)`)
+        }
+        if (this.max_lines !== undefined) {
+            if (this.max_lines > 1) {
+                indent = this.subsequent_indent
+            } else {
+                indent = this.initial_indent
+            }
+            if (indent.length + this.placeholder.trimStart().length > this.width) {
+                throw Error('placeholder too large for max width')
+            }
+        }
+
+        // Arrange in reverse order so items can be efficiently popped
+        // from a stack of chucks.
+        chunks = chunks.reverse()
+
+        while (chunks.length > 0) {
+
+            // Start the list of chunks that will make up the current line.
+            // cur_len is just the length of all the chunks in cur_line.
+            let cur_line = []
+            let cur_len = 0
+
+            // Figure out which static string will prefix this line.
+            let indent
+            if (lines) {
+                indent = this.subsequent_indent
+            } else {
+                indent = this.initial_indent
+            }
+
+            // Maximum width for this line.
+            let width = this.width - indent.length
+
+            // First chunk on line is whitespace -- drop it, unless this
+            // is the very beginning of the text (ie. no lines started yet).
+            if (this.drop_whitespace && chunks[chunks.length - 1].trim() === '' && lines.length > 0) {
+                chunks.pop()
+            }
+
+            while (chunks.length > 0) {
+                let l = chunks[chunks.length - 1].length
+
+                // Can at least squeeze this chunk onto the current line.
+                if (cur_len + l <= width) {
+                    cur_line.push(chunks.pop())
+                    cur_len += l
+
+                // Nope, this line is full.
+                } else {
+                    break
+                }
+            }
+
+            // The current line is full, and the next chunk is too big to
+            // fit on *any* line (not just this one).
+            if (chunks.length && chunks[chunks.length - 1].length > width) {
+                this._handle_long_word(chunks, cur_line, cur_len, width)
+                cur_len = cur_line.map(l => l.length).reduce((a, b) => a + b, 0)
+            }
+
+            // If the last chunk on this line is all whitespace, drop it.
+            if (this.drop_whitespace && cur_line.length > 0 && cur_line[cur_line.length - 1].trim() === '') {
+                cur_len -= cur_line[cur_line.length - 1].length
+                cur_line.pop()
+            }
+
+            if (cur_line) {
+                if (this.max_lines === undefined ||
+                    lines.length + 1 < this.max_lines ||
+                    (chunks.length === 0 ||
+                     this.drop_whitespace &&
+                     chunks.length === 1 &&
+                     !chunks[0].trim()) && cur_len <= width) {
+                    // Convert current line back to a string and store it in
+                    // list of all lines (return value).
+                    lines.push(indent + cur_line.join(''))
+                } else {
+                    let had_break = false
+                    while (cur_line) {
+                        if (cur_line[cur_line.length - 1].trim() &&
+                            cur_len + this.placeholder.length <= width) {
+                            cur_line.push(this.placeholder)
+                            lines.push(indent + cur_line.join(''))
+                            had_break = true
+                            break
+                        }
+                        cur_len -= cur_line[-1].length
+                        cur_line.pop()
+                    }
+                    if (!had_break) {
+                        if (lines) {
+                            let prev_line = lines[lines.length - 1].trimEnd()
+                            if (prev_line.length + this.placeholder.length <=
+                                    this.width) {
+                                lines[lines.length - 1] = prev_line + this.placeholder
+                                break
+                            }
+                        }
+                        lines.push(indent + this.placeholder.lstrip())
+                    }
+                    break
+                }
+            }
+        }
+
+        return lines
+    }
+
+    _split_chunks(text) {
+        text = this._munge_whitespace(text)
+        return this._split(text)
+    }
+
+    // -- Public interface ----------------------------------------------
+
+    wrap(text) {
+        /*
+         *  wrap(text : string) -> [string]
+         *
+         *  Reformat the single paragraph in 'text' so it fits in lines of
+         *  no more than 'self.width' columns, and return a list of wrapped
+         *  lines.  Tabs in 'text' are expanded with string.expandtabs(),
+         *  and all other whitespace characters (including newline) are
+         *  converted to space.
+         */
+        let chunks = this._split_chunks(text)
+        // not implemented in js
+        //if (this.fix_sentence_endings) {
+        //    this._fix_sentence_endings(chunks)
+        //}
+        return this._wrap_chunks(chunks)
+    }
+
+    fill(text) {
+        /*
+         *  fill(text : string) -> string
+         *
+         *  Reformat the single paragraph in 'text' to fit in lines of no
+         *  more than 'self.width' columns, and return a new string
+         *  containing the entire wrapped paragraph.
+         */
+        return this.wrap(text).join('\n')
+    }
+}
+
+
+// -- Convenience interface ---------------------------------------------
+
+function wrap(text, options = {}) {
+    /*
+     *  Wrap a single paragraph of text, returning a list of wrapped lines.
+     *
+     *  Reformat the single paragraph in 'text' so it fits in lines of no
+     *  more than 'width' columns, and return a list of wrapped lines.  By
+     *  default, tabs in 'text' are expanded with string.expandtabs(), and
+     *  all other whitespace characters (including newline) are converted to
+     *  space.  See TextWrapper class for available keyword args to customize
+     *  wrapping behaviour.
+     */
+    let { width = 70, ...kwargs } = options
+    let w = new TextWrapper(Object.assign({ width }, kwargs))
+    return w.wrap(text)
+}
+
+function fill(text, options = {}) {
+    /*
+     *  Fill a single paragraph of text, returning a new string.
+     *
+     *  Reformat the single paragraph in 'text' to fit in lines of no more
+     *  than 'width' columns, and return a new string containing the entire
+     *  wrapped paragraph.  As with wrap(), tabs are expanded and other
+     *  whitespace characters converted to space.  See TextWrapper class for
+     *  available keyword args to customize wrapping behaviour.
+     */
+    let { width = 70, ...kwargs } = options
+    let w = new TextWrapper(Object.assign({ width }, kwargs))
+    return w.fill(text)
+}
+
+// -- Loosely related functionality -------------------------------------
+
+let _whitespace_only_re = /^[ \t]+$/mg
+let _leading_whitespace_re = /(^[ \t]*)(?:[^ \t\n])/mg
+
+function dedent(text) {
+    /*
+     *  Remove any common leading whitespace from every line in `text`.
+     *
+     *  This can be used to make triple-quoted strings line up with the left
+     *  edge of the display, while still presenting them in the source code
+     *  in indented form.
+     *
+     *  Note that tabs and spaces are both treated as whitespace, but they
+     *  are not equal: the lines "  hello" and "\\thello" are
+     *  considered to have no common leading whitespace.
+     *
+     *  Entirely blank lines are normalized to a newline character.
+     */
+    // Look for the longest leading string of spaces and tabs common to
+    // all lines.
+    let margin = undefined
+    text = text.replace(_whitespace_only_re, '')
+    let indents = text.match(_leading_whitespace_re) || []
+    for (let indent of indents) {
+        indent = indent.slice(0, -1)
+
+        if (margin === undefined) {
+            margin = indent
+
+        // Current line more deeply indented than previous winner:
+        // no change (previous winner is still on top).
+        } else if (indent.startsWith(margin)) {
+            // pass
+
+        // Current line consistent with and no deeper than previous winner:
+        // it's the new winner.
+        } else if (margin.startsWith(indent)) {
+            margin = indent
+
+        // Find the largest common whitespace between current line and previous
+        // winner.
+        } else {
+            for (let i = 0; i < margin.length && i < indent.length; i++) {
+                if (margin[i] !== indent[i]) {
+                    margin = margin.slice(0, i)
+                    break
+                }
+            }
+        }
+    }
+
+    if (margin) {
+        text = text.replace(new RegExp('^' + margin, 'mg'), '')
+    }
+    return text
+}
+
+module.exports = { wrap, fill, dedent }

data/packages/webpacker/node_modules/argparse/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "argparse",
+  "description": "CLI arguments parser. Native port of python's argparse.",
+  "version": "2.0.1",
+  "keywords": [
+    "cli",
+    "parser",
+    "argparse",
+    "option",
+    "args"
+  ],
+  "main": "argparse.js",
+  "files": [
+    "argparse.js",
+    "lib/"
+  ],
+  "license": "Python-2.0",
+  "repository": "nodeca/argparse",
+  "scripts": {
+    "lint": "eslint .",
+    "test": "npm run lint && nyc mocha",
+    "coverage": "npm run test && nyc report --reporter html"
+  },
+  "devDependencies": {
+    "@babel/eslint-parser": "^7.11.0",
+    "@babel/plugin-syntax-class-properties": "^7.10.4",
+    "eslint": "^7.5.0",
+    "mocha": "^8.0.1",
+    "nyc": "^15.1.0"
+  }
+}

data/packages/webpacker/node_modules/brace-expansion/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+
+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.

data/packages/webpacker/node_modules/brace-expansion/README.md

@@ -0,0 +1,135 @@
+# brace-expansion
+
+[Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html), 
+as known from sh/bash, in JavaScript.
+
+[![build status](https://secure.travis-ci.org/juliangruber/brace-expansion.svg)](http://travis-ci.org/juliangruber/brace-expansion)
+[![downloads](https://img.shields.io/npm/dm/brace-expansion.svg)](https://www.npmjs.org/package/brace-expansion)
+[![Greenkeeper badge](https://badges.greenkeeper.io/juliangruber/brace-expansion.svg)](https://greenkeeper.io/)
+
+[![testling badge](https://ci.testling.com/juliangruber/brace-expansion.png)](https://ci.testling.com/juliangruber/brace-expansion)
+
+## Example
+
+```js
+var expand = require('brace-expansion');
+
+expand('file-{a,b,c}.jpg')
+// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
+
+expand('-v{,,}')
+// => ['-v', '-v', '-v']
+
+expand('file{0..2}.jpg')
+// => ['file0.jpg', 'file1.jpg', 'file2.jpg']
+
+expand('file-{a..c}.jpg')
+// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
+
+expand('file{2..0}.jpg')
+// => ['file2.jpg', 'file1.jpg', 'file0.jpg']
+
+expand('file{0..4..2}.jpg')
+// => ['file0.jpg', 'file2.jpg', 'file4.jpg']
+
+expand('file-{a..e..2}.jpg')
+// => ['file-a.jpg', 'file-c.jpg', 'file-e.jpg']
+
+expand('file{00..10..5}.jpg')
+// => ['file00.jpg', 'file05.jpg', 'file10.jpg']
+
+expand('{{A..C},{a..c}}')
+// => ['A', 'B', 'C', 'a', 'b', 'c']
+
+expand('ppp{,config,oe{,conf}}')
+// => ['ppp', 'pppconfig', 'pppoe', 'pppoeconf']
+```
+
+## API
+
+```js
+var expand = require('brace-expansion');
+```
+
+### var expanded = expand(str)
+
+Return an array of all possible and valid expansions of `str`. If none are
+found, `[str]` is returned.
+
+Valid expansions are:
+
+```js
+/^(.*,)+(.+)?$/
+// {a,b,...}
+```
+
+A comma separated list of options, like `{a,b}` or `{a,{b,c}}` or `{,a,}`.
+
+```js
+/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
+// {x..y[..incr]}
+```
+
+A numeric sequence from `x` to `y` inclusive, with optional increment.
+If `x` or `y` start with a leading `0`, all the numbers will be padded
+to have equal length. Negative numbers and backwards iteration work too.
+
+```js
+/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
+// {x..y[..incr]}
+```
+
+An alphabetic sequence from `x` to `y` inclusive, with optional increment.
+`x` and `y` must be exactly one character, and if given, `incr` must be a
+number.
+
+For compatibility reasons, the string `${` is not eligible for brace expansion.
+
+## Installation
+
+With [npm](https://npmjs.org) do:
+
+```bash
+npm install brace-expansion
+```
+
+## Contributors
+
+- [Julian Gruber](https://github.com/juliangruber)
+- [Isaac Z. Schlueter](https://github.com/isaacs)
+
+## Sponsors
+
+This module is proudly supported by my [Sponsors](https://github.com/juliangruber/sponsors)!
+
+Do you want to support modules like this to improve their quality, stability and weigh in on new features? Then please consider donating to my [Patreon](https://www.patreon.com/juliangruber). Not sure how much of my modules you're using? Try [feross/thanks](https://github.com/feross/thanks)!
+
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
+## License
+
+(MIT)
+
+Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+
+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.