decidim 0.26.2 → 0.26.4

data/packages/webpacker/node_modules/jest-matcher-utils/build/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import chalk = require('chalk');
+import { DiffOptions as ImportDiffOptions } from 'jest-diff';
+declare type MatcherHintColor = (arg: string) => string;
+export declare type MatcherHintOptions = {
+    comment?: string;
+    expectedColor?: MatcherHintColor;
+    isDirectExpectCall?: boolean;
+    isNot?: boolean;
+    promise?: string;
+    receivedColor?: MatcherHintColor;
+    secondArgument?: string;
+    secondArgumentColor?: MatcherHintColor;
+};
+export declare type DiffOptions = ImportDiffOptions;
+export declare const EXPECTED_COLOR: chalk.Chalk;
+export declare const RECEIVED_COLOR: chalk.Chalk;
+export declare const INVERTED_COLOR: chalk.Chalk;
+export declare const BOLD_WEIGHT: chalk.Chalk;
+export declare const DIM_COLOR: chalk.Chalk;
+export declare const SUGGEST_TO_CONTAIN_EQUAL: string;
+export declare const stringify: (object: unknown, maxDepth?: number) => string;
+export declare const highlightTrailingWhitespace: (text: string) => string;
+export declare const printReceived: (object: unknown) => string;
+export declare const printExpected: (value: unknown) => string;
+export declare const printWithType: (name: string, value: unknown, print: (value: unknown) => string) => string;
+export declare const ensureNoExpected: (expected: unknown, matcherName: string, options?: MatcherHintOptions | undefined) => void;
+/**
+ * Ensures that `actual` is of type `number | bigint`
+ */
+export declare const ensureActualIsNumber: (actual: unknown, matcherName: string, options?: MatcherHintOptions | undefined) => void;
+/**
+ * Ensures that `expected` is of type `number | bigint`
+ */
+export declare const ensureExpectedIsNumber: (expected: unknown, matcherName: string, options?: MatcherHintOptions | undefined) => void;
+/**
+ * Ensures that `actual` & `expected` are of type `number | bigint`
+ */
+export declare const ensureNumbers: (actual: unknown, expected: unknown, matcherName: string, options?: MatcherHintOptions | undefined) => void;
+export declare const ensureExpectedIsNonNegativeInteger: (expected: unknown, matcherName: string, options?: MatcherHintOptions | undefined) => void;
+export declare const printDiffOrStringify: (expected: unknown, received: unknown, expectedLabel: string, receivedLabel: string, expand: boolean) => string;
+export declare const diff: (a: unknown, b: unknown, options?: ImportDiffOptions | undefined) => string | null;
+export declare const pluralize: (word: string, count: number) => string;
+declare type PrintLabel = (string: string) => string;
+export declare const getLabelPrinter: (...strings: Array<string>) => PrintLabel;
+export declare const matcherErrorMessage: (hint: string, generic: string, specific?: string | undefined) => string;
+export declare const matcherHint: (matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions) => string;
+export {};

data/packages/webpacker/node_modules/jest-matcher-utils/build/index.js

@@ -0,0 +1,590 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.stringify =
+  exports.printWithType =
+  exports.printReceived =
+  exports.printExpected =
+  exports.printDiffOrStringify =
+  exports.pluralize =
+  exports.matcherHint =
+  exports.matcherErrorMessage =
+  exports.highlightTrailingWhitespace =
+  exports.getLabelPrinter =
+  exports.ensureNumbers =
+  exports.ensureNoExpected =
+  exports.ensureExpectedIsNumber =
+  exports.ensureExpectedIsNonNegativeInteger =
+  exports.ensureActualIsNumber =
+  exports.diff =
+  exports.SUGGEST_TO_CONTAIN_EQUAL =
+  exports.RECEIVED_COLOR =
+  exports.INVERTED_COLOR =
+  exports.EXPECTED_COLOR =
+  exports.DIM_COLOR =
+  exports.BOLD_WEIGHT =
+    void 0;
+
+var _chalk = _interopRequireDefault(require('chalk'));
+
+var _jestDiff = require('jest-diff');
+
+var _jestGetType = require('jest-get-type');
+
+var _prettyFormat = require('pretty-format');
+
+var _Replaceable = _interopRequireDefault(require('./Replaceable'));
+
+var _deepCyclicCopyReplaceable = _interopRequireDefault(
+  require('./deepCyclicCopyReplaceable')
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+const {
+  AsymmetricMatcher,
+  DOMCollection,
+  DOMElement,
+  Immutable,
+  ReactElement,
+  ReactTestComponent
+} = _prettyFormat.plugins;
+const PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher
+];
+const EXPECTED_COLOR = _chalk.default.green;
+exports.EXPECTED_COLOR = EXPECTED_COLOR;
+const RECEIVED_COLOR = _chalk.default.red;
+exports.RECEIVED_COLOR = RECEIVED_COLOR;
+const INVERTED_COLOR = _chalk.default.inverse;
+exports.INVERTED_COLOR = INVERTED_COLOR;
+const BOLD_WEIGHT = _chalk.default.bold;
+exports.BOLD_WEIGHT = BOLD_WEIGHT;
+const DIM_COLOR = _chalk.default.dim;
+exports.DIM_COLOR = DIM_COLOR;
+const MULTILINE_REGEXP = /\n/;
+const SPACE_SYMBOL = '\u{00B7}'; // middle dot
+
+const NUMBERS = [
+  'zero',
+  'one',
+  'two',
+  'three',
+  'four',
+  'five',
+  'six',
+  'seven',
+  'eight',
+  'nine',
+  'ten',
+  'eleven',
+  'twelve',
+  'thirteen'
+];
+
+const SUGGEST_TO_CONTAIN_EQUAL = _chalk.default.dim(
+  'Looks like you wanted to test for object/array equality with the stricter `toContain` matcher. You probably need to use `toContainEqual` instead.'
+);
+
+exports.SUGGEST_TO_CONTAIN_EQUAL = SUGGEST_TO_CONTAIN_EQUAL;
+
+const stringify = (object, maxDepth = 10) => {
+  const MAX_LENGTH = 10000;
+  let result;
+
+  try {
+    result = (0, _prettyFormat.format)(object, {
+      maxDepth,
+      min: true,
+      plugins: PLUGINS
+    });
+  } catch {
+    result = (0, _prettyFormat.format)(object, {
+      callToJSON: false,
+      maxDepth,
+      min: true,
+      plugins: PLUGINS
+    });
+  }
+
+  return result.length >= MAX_LENGTH && maxDepth > 1
+    ? stringify(object, Math.floor(maxDepth / 2))
+    : result;
+};
+
+exports.stringify = stringify;
+
+const highlightTrailingWhitespace = text =>
+  text.replace(/\s+$/gm, _chalk.default.inverse('$&')); // Instead of inverse highlight which now implies a change,
+// replace common spaces with middle dot at the end of any line.
+
+exports.highlightTrailingWhitespace = highlightTrailingWhitespace;
+
+const replaceTrailingSpaces = text =>
+  text.replace(/\s+$/gm, spaces => SPACE_SYMBOL.repeat(spaces.length));
+
+const printReceived = object =>
+  RECEIVED_COLOR(replaceTrailingSpaces(stringify(object)));
+
+exports.printReceived = printReceived;
+
+const printExpected = value =>
+  EXPECTED_COLOR(replaceTrailingSpaces(stringify(value)));
+
+exports.printExpected = printExpected;
+
+const printWithType = (
+  name,
+  value,
+  print // printExpected or printReceived
+) => {
+  const type = (0, _jestGetType.getType)(value);
+  const hasType =
+    type !== 'null' && type !== 'undefined'
+      ? `${name} has type:  ${type}\n`
+      : '';
+  const hasValue = `${name} has value: ${print(value)}`;
+  return hasType + hasValue;
+};
+
+exports.printWithType = printWithType;
+
+const ensureNoExpected = (expected, matcherName, options) => {
+  if (typeof expected !== 'undefined') {
+    // Prepend maybe not only for backward compatibility.
+    const matcherString = (options ? '' : '[.not]') + matcherName;
+    throw new Error(
+      matcherErrorMessage(
+        matcherHint(matcherString, undefined, '', options), // Because expected is omitted in hint above,
+        // expected is black instead of green in message below.
+        'this matcher must not have an expected argument',
+        printWithType('Expected', expected, printExpected)
+      )
+    );
+  }
+};
+/**
+ * Ensures that `actual` is of type `number | bigint`
+ */
+
+exports.ensureNoExpected = ensureNoExpected;
+
+const ensureActualIsNumber = (actual, matcherName, options) => {
+  if (typeof actual !== 'number' && typeof actual !== 'bigint') {
+    // Prepend maybe not only for backward compatibility.
+    const matcherString = (options ? '' : '[.not]') + matcherName;
+    throw new Error(
+      matcherErrorMessage(
+        matcherHint(matcherString, undefined, undefined, options),
+        `${RECEIVED_COLOR('received')} value must be a number or bigint`,
+        printWithType('Received', actual, printReceived)
+      )
+    );
+  }
+};
+/**
+ * Ensures that `expected` is of type `number | bigint`
+ */
+
+exports.ensureActualIsNumber = ensureActualIsNumber;
+
+const ensureExpectedIsNumber = (expected, matcherName, options) => {
+  if (typeof expected !== 'number' && typeof expected !== 'bigint') {
+    // Prepend maybe not only for backward compatibility.
+    const matcherString = (options ? '' : '[.not]') + matcherName;
+    throw new Error(
+      matcherErrorMessage(
+        matcherHint(matcherString, undefined, undefined, options),
+        `${EXPECTED_COLOR('expected')} value must be a number or bigint`,
+        printWithType('Expected', expected, printExpected)
+      )
+    );
+  }
+};
+/**
+ * Ensures that `actual` & `expected` are of type `number | bigint`
+ */
+
+exports.ensureExpectedIsNumber = ensureExpectedIsNumber;
+
+const ensureNumbers = (actual, expected, matcherName, options) => {
+  ensureActualIsNumber(actual, matcherName, options);
+  ensureExpectedIsNumber(expected, matcherName, options);
+};
+
+exports.ensureNumbers = ensureNumbers;
+
+const ensureExpectedIsNonNegativeInteger = (expected, matcherName, options) => {
+  if (
+    typeof expected !== 'number' ||
+    !Number.isSafeInteger(expected) ||
+    expected < 0
+  ) {
+    // Prepend maybe not only for backward compatibility.
+    const matcherString = (options ? '' : '[.not]') + matcherName;
+    throw new Error(
+      matcherErrorMessage(
+        matcherHint(matcherString, undefined, undefined, options),
+        `${EXPECTED_COLOR('expected')} value must be a non-negative integer`,
+        printWithType('Expected', expected, printExpected)
+      )
+    );
+  }
+}; // Given array of diffs, return concatenated string:
+// * include common substrings
+// * exclude change substrings which have opposite op
+// * include change substrings which have argument op
+//   with inverse highlight only if there is a common substring
+
+exports.ensureExpectedIsNonNegativeInteger = ensureExpectedIsNonNegativeInteger;
+
+const getCommonAndChangedSubstrings = (diffs, op, hasCommonDiff) =>
+  diffs.reduce(
+    (reduced, diff) =>
+      reduced +
+      (diff[0] === _jestDiff.DIFF_EQUAL
+        ? diff[1]
+        : diff[0] !== op
+        ? ''
+        : hasCommonDiff
+        ? INVERTED_COLOR(diff[1])
+        : diff[1]),
+    ''
+  );
+
+const isLineDiffable = (expected, received) => {
+  const expectedType = (0, _jestGetType.getType)(expected);
+  const receivedType = (0, _jestGetType.getType)(received);
+
+  if (expectedType !== receivedType) {
+    return false;
+  }
+
+  if ((0, _jestGetType.isPrimitive)(expected)) {
+    // Print generic line diff for strings only:
+    // * if neither string is empty
+    // * if either string has more than one line
+    return (
+      typeof expected === 'string' &&
+      typeof received === 'string' &&
+      expected.length !== 0 &&
+      received.length !== 0 &&
+      (MULTILINE_REGEXP.test(expected) || MULTILINE_REGEXP.test(received))
+    );
+  }
+
+  if (
+    expectedType === 'date' ||
+    expectedType === 'function' ||
+    expectedType === 'regexp'
+  ) {
+    return false;
+  }
+
+  if (expected instanceof Error && received instanceof Error) {
+    return false;
+  }
+
+  if (
+    receivedType === 'object' &&
+    typeof received.asymmetricMatch === 'function'
+  ) {
+    return false;
+  }
+
+  return true;
+};
+
+const MAX_DIFF_STRING_LENGTH = 20000;
+
+const printDiffOrStringify = (
+  expected,
+  received,
+  expectedLabel,
+  receivedLabel,
+  expand // CLI options: true if `--expand` or false if `--no-expand`
+) => {
+  if (
+    typeof expected === 'string' &&
+    typeof received === 'string' &&
+    expected.length !== 0 &&
+    received.length !== 0 &&
+    expected.length <= MAX_DIFF_STRING_LENGTH &&
+    received.length <= MAX_DIFF_STRING_LENGTH &&
+    expected !== received
+  ) {
+    if (expected.includes('\n') || received.includes('\n')) {
+      return (0, _jestDiff.diffStringsUnified)(expected, received, {
+        aAnnotation: expectedLabel,
+        bAnnotation: receivedLabel,
+        changeLineTrailingSpaceColor: _chalk.default.bgYellow,
+        commonLineTrailingSpaceColor: _chalk.default.bgYellow,
+        emptyFirstOrLastLinePlaceholder: '↵',
+        // U+21B5
+        expand,
+        includeChangeCounts: true
+      });
+    }
+
+    const diffs = (0, _jestDiff.diffStringsRaw)(expected, received, true);
+    const hasCommonDiff = diffs.some(diff => diff[0] === _jestDiff.DIFF_EQUAL);
+    const printLabel = getLabelPrinter(expectedLabel, receivedLabel);
+    const expectedLine =
+      printLabel(expectedLabel) +
+      printExpected(
+        getCommonAndChangedSubstrings(
+          diffs,
+          _jestDiff.DIFF_DELETE,
+          hasCommonDiff
+        )
+      );
+    const receivedLine =
+      printLabel(receivedLabel) +
+      printReceived(
+        getCommonAndChangedSubstrings(
+          diffs,
+          _jestDiff.DIFF_INSERT,
+          hasCommonDiff
+        )
+      );
+    return expectedLine + '\n' + receivedLine;
+  }
+
+  if (isLineDiffable(expected, received)) {
+    const {replacedExpected, replacedReceived} =
+      replaceMatchedToAsymmetricMatcher(
+        (0, _deepCyclicCopyReplaceable.default)(expected),
+        (0, _deepCyclicCopyReplaceable.default)(received),
+        [],
+        []
+      );
+    const difference = (0, _jestDiff.diff)(replacedExpected, replacedReceived, {
+      aAnnotation: expectedLabel,
+      bAnnotation: receivedLabel,
+      expand,
+      includeChangeCounts: true
+    });
+
+    if (
+      typeof difference === 'string' &&
+      difference.includes('- ' + expectedLabel) &&
+      difference.includes('+ ' + receivedLabel)
+    ) {
+      return difference;
+    }
+  }
+
+  const printLabel = getLabelPrinter(expectedLabel, receivedLabel);
+  const expectedLine = printLabel(expectedLabel) + printExpected(expected);
+  const receivedLine =
+    printLabel(receivedLabel) +
+    (stringify(expected) === stringify(received)
+      ? 'serializes to the same string'
+      : printReceived(received));
+  return expectedLine + '\n' + receivedLine;
+}; // Sometimes, e.g. when comparing two numbers, the output from jest-diff
+// does not contain more information than the `Expected:` / `Received:` already gives.
+// In those cases, we do not print a diff to make the output shorter and not redundant.
+
+exports.printDiffOrStringify = printDiffOrStringify;
+
+const shouldPrintDiff = (actual, expected) => {
+  if (typeof actual === 'number' && typeof expected === 'number') {
+    return false;
+  }
+
+  if (typeof actual === 'bigint' && typeof expected === 'bigint') {
+    return false;
+  }
+
+  if (typeof actual === 'boolean' && typeof expected === 'boolean') {
+    return false;
+  }
+
+  return true;
+};
+
+function replaceMatchedToAsymmetricMatcher(
+  replacedExpected,
+  replacedReceived,
+  expectedCycles,
+  receivedCycles
+) {
+  if (!_Replaceable.default.isReplaceable(replacedExpected, replacedReceived)) {
+    return {
+      replacedExpected,
+      replacedReceived
+    };
+  }
+
+  if (
+    expectedCycles.includes(replacedExpected) ||
+    receivedCycles.includes(replacedReceived)
+  ) {
+    return {
+      replacedExpected,
+      replacedReceived
+    };
+  }
+
+  expectedCycles.push(replacedExpected);
+  receivedCycles.push(replacedReceived);
+  const expectedReplaceable = new _Replaceable.default(replacedExpected);
+  const receivedReplaceable = new _Replaceable.default(replacedReceived);
+  expectedReplaceable.forEach((expectedValue, key) => {
+    const receivedValue = receivedReplaceable.get(key);
+
+    if (isAsymmetricMatcher(expectedValue)) {
+      if (expectedValue.asymmetricMatch(receivedValue)) {
+        receivedReplaceable.set(key, expectedValue);
+      }
+    } else if (isAsymmetricMatcher(receivedValue)) {
+      if (receivedValue.asymmetricMatch(expectedValue)) {
+        expectedReplaceable.set(key, receivedValue);
+      }
+    } else if (
+      _Replaceable.default.isReplaceable(expectedValue, receivedValue)
+    ) {
+      const replaced = replaceMatchedToAsymmetricMatcher(
+        expectedValue,
+        receivedValue,
+        expectedCycles,
+        receivedCycles
+      );
+      expectedReplaceable.set(key, replaced.replacedExpected);
+      receivedReplaceable.set(key, replaced.replacedReceived);
+    }
+  });
+  return {
+    replacedExpected: expectedReplaceable.object,
+    replacedReceived: receivedReplaceable.object
+  };
+}
+
+function isAsymmetricMatcher(data) {
+  const type = (0, _jestGetType.getType)(data);
+  return type === 'object' && typeof data.asymmetricMatch === 'function';
+}
+
+const diff = (a, b, options) =>
+  shouldPrintDiff(a, b) ? (0, _jestDiff.diff)(a, b, options) : null;
+
+exports.diff = diff;
+
+const pluralize = (word, count) =>
+  (NUMBERS[count] || count) + ' ' + word + (count === 1 ? '' : 's'); // To display lines of labeled values as two columns with monospace alignment:
+// given the strings which will describe the values,
+// return function which given each string, returns the label:
+// string, colon, space, and enough padding spaces to align the value.
+
+exports.pluralize = pluralize;
+
+const getLabelPrinter = (...strings) => {
+  const maxLength = strings.reduce(
+    (max, string) => (string.length > max ? string.length : max),
+    0
+  );
+  return string => `${string}: ${' '.repeat(maxLength - string.length)}`;
+};
+
+exports.getLabelPrinter = getLabelPrinter;
+
+const matcherErrorMessage = (
+  hint,
+  generic,
+  specific // incorrect value returned from call to printWithType
+) =>
+  `${hint}\n\n${_chalk.default.bold('Matcher error')}: ${generic}${
+    typeof specific === 'string' ? '\n\n' + specific : ''
+  }`; // Display assertion for the report when a test fails.
+// New format: rejects/resolves, not, and matcher name have black color
+// Old format: matcher name has dim color
+
+exports.matcherErrorMessage = matcherErrorMessage;
+
+const matcherHint = (
+  matcherName,
+  received = 'received',
+  expected = 'expected',
+  options = {}
+) => {
+  const {
+    comment = '',
+    expectedColor = EXPECTED_COLOR,
+    isDirectExpectCall = false,
+    // seems redundant with received === ''
+    isNot = false,
+    promise = '',
+    receivedColor = RECEIVED_COLOR,
+    secondArgument = '',
+    secondArgumentColor = EXPECTED_COLOR
+  } = options;
+  let hint = '';
+  let dimString = 'expect'; // concatenate adjacent dim substrings
+
+  if (!isDirectExpectCall && received !== '') {
+    hint += DIM_COLOR(dimString + '(') + receivedColor(received);
+    dimString = ')';
+  }
+
+  if (promise !== '') {
+    hint += DIM_COLOR(dimString + '.') + promise;
+    dimString = '';
+  }
+
+  if (isNot) {
+    hint += DIM_COLOR(dimString + '.') + 'not';
+    dimString = '';
+  }
+
+  if (matcherName.includes('.')) {
+    // Old format: for backward compatibility,
+    // especially without promise or isNot options
+    dimString += matcherName;
+  } else {
+    // New format: omit period from matcherName arg
+    hint += DIM_COLOR(dimString + '.') + matcherName;
+    dimString = '';
+  }
+
+  if (expected === '') {
+    dimString += '()';
+  } else {
+    hint += DIM_COLOR(dimString + '(') + expectedColor(expected);
+
+    if (secondArgument) {
+      hint += DIM_COLOR(', ') + secondArgumentColor(secondArgument);
+    }
+
+    dimString = ')';
+  }
+
+  if (comment !== '') {
+    dimString += ' // ' + comment;
+  }
+
+  if (dimString !== '') {
+    hint += DIM_COLOR(dimString);
+  }
+
+  return hint;
+};
+
+exports.matcherHint = matcherHint;

data/packages/webpacker/node_modules/jest-matcher-utils/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "jest-matcher-utils",
+  "description": "A set of utility functions for expect and related packages",
+  "version": "27.5.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/jest.git",
+    "directory": "packages/jest-matcher-utils"
+  },
+  "engines": {
+    "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+  },
+  "license": "MIT",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "chalk": "^4.0.0",
+    "jest-diff": "^27.5.1",
+    "jest-get-type": "^27.5.1",
+    "pretty-format": "^27.5.1"
+  },
+  "devDependencies": {
+    "@jest/test-utils": "^27.5.1",
+    "@types/node": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "67c1aa20c5fec31366d733e901fee2b981cb1850"
+}

data/packages/webpacker/node_modules/jest-message-util/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+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.