Izmjenjena struktura, dodan backand

web/node_modules/pretty-format/build/index.js

@@ -0,0 +1,970 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const style = require('ansi-styles'); /**
+                                       * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                       *
+                                       * This source code is licensed under the BSD-style license found in the
+                                       * LICENSE file in the root directory of this source tree. An additional grant
+                                       * of patent rights can be found in the PATENTS file in the same directory.
+                                       *
+                                       * 
+                                       */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const toString = Object.prototype.toString;
+const toISOString = Date.prototype.toISOString;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+const symbolToString = Symbol.prototype.toString;
+
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+const NEWLINE_REGEXP = /\n/gi;
+
+const getSymbols = Object.getOwnPropertySymbols || (obj => []);
+
+function isToStringedArrayType(toStringed) {
+  return (
+    toStringed === '[object Array]' ||
+    toStringed === '[object ArrayBuffer]' ||
+    toStringed === '[object DataView]' ||
+    toStringed === '[object Float32Array]' ||
+    toStringed === '[object Float64Array]' ||
+    toStringed === '[object Int8Array]' ||
+    toStringed === '[object Int16Array]' ||
+    toStringed === '[object Int32Array]' ||
+    toStringed === '[object Uint8Array]' ||
+    toStringed === '[object Uint8ClampedArray]' ||
+    toStringed === '[object Uint16Array]' ||
+    toStringed === '[object Uint32Array]');
+
+}
+
+function printNumber(val) {
+  if (val != +val) {
+    return 'NaN';
+  }
+  const isNegativeZero = val === 0 && 1 / val < 0;
+  return isNegativeZero ? '-0' : '' + val;
+}
+
+function printFunction(val, printFunctionName) {
+  if (!printFunctionName) {
+    return '[Function]';
+  } else if (val.name === '') {
+    return '[Function anonymous]';
+  } else {
+    return '[Function ' + val.name + ']';
+  }
+}
+
+function printSymbol(val) {
+  return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+}
+
+function printError(val) {
+  return '[' + errorToString.call(val) + ']';
+}
+
+function printBasicValue(
+val,
+printFunctionName,
+escapeRegex)
+{
+  if (val === true || val === false) {
+    return '' + val;
+  }
+  if (val === undefined) {
+    return 'undefined';
+  }
+  if (val === null) {
+    return 'null';
+  }
+
+  const typeOf = typeof val;
+
+  if (typeOf === 'number') {
+    return printNumber(val);
+  }
+  if (typeOf === 'string') {
+    return '"' + val.replace(/"|\\/g, '\\$&') + '"';
+  }
+  if (typeOf === 'function') {
+    return printFunction(val, printFunctionName);
+  }
+  if (typeOf === 'symbol') {
+    return printSymbol(val);
+  }
+
+  const toStringed = toString.call(val);
+
+  if (toStringed === '[object WeakMap]') {
+    return 'WeakMap {}';
+  }
+  if (toStringed === '[object WeakSet]') {
+    return 'WeakSet {}';
+  }
+  if (
+  toStringed === '[object Function]' ||
+  toStringed === '[object GeneratorFunction]')
+  {
+    return printFunction(val, printFunctionName);
+  }
+  if (toStringed === '[object Symbol]') {
+    return printSymbol(val);
+  }
+  if (toStringed === '[object Date]') {
+    return toISOString.call(val);
+  }
+  if (toStringed === '[object Error]') {
+    return printError(val);
+  }
+  if (toStringed === '[object RegExp]') {
+    if (escapeRegex) {
+      // https://github.com/benjamingr/RegExp.escape/blob/master/polyfill.js
+      return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+    return regExpToString.call(val);
+  }
+  if (toStringed === '[object Arguments]' && val.length === 0) {
+    return 'Arguments []';
+  }
+  if (isToStringedArrayType(toStringed) && val.length === 0) {
+    return val.constructor.name + ' []';
+  }
+
+  if (val instanceof Error) {
+    return printError(val);
+  }
+
+  return null;
+}
+
+function printList(
+list,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  let body = '';
+
+  if (list.length) {
+    body += edgeSpacing;
+
+    const innerIndent = prevIndent + indent;
+
+    for (let i = 0; i < list.length; i++) {
+      body +=
+      innerIndent +
+      print(
+      list[i],
+      indent,
+      innerIndent,
+      spacing,
+      edgeSpacing,
+      refs,
+      maxDepth,
+      currentDepth,
+      plugins,
+      min,
+      callToJSON,
+      printFunctionName,
+      escapeRegex,
+      colors);
+
+
+      if (i < list.length - 1) {
+        body += ',' + spacing;
+      }
+    }
+
+    body += (min ? '' : ',') + edgeSpacing + prevIndent;
+  }
+
+  return '[' + body + ']';
+}
+
+function printArguments(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  return (
+    (min ? '' : 'Arguments ') +
+    printList(
+    val,
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    maxDepth,
+    currentDepth,
+    plugins,
+    min,
+    callToJSON,
+    printFunctionName,
+    escapeRegex,
+    colors));
+
+
+}
+
+function printArray(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  return (
+    (min ? '' : val.constructor.name + ' ') +
+    printList(
+    val,
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    maxDepth,
+    currentDepth,
+    plugins,
+    min,
+    callToJSON,
+    printFunctionName,
+    escapeRegex,
+    colors));
+
+
+}
+
+function printMap(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  let result = 'Map {';
+  const iterator = val.entries();
+  let current = iterator.next();
+
+  if (!current.done) {
+    result += edgeSpacing;
+
+    const innerIndent = prevIndent + indent;
+
+    while (!current.done) {
+      const key = print(
+      current.value[0],
+      indent,
+      innerIndent,
+      spacing,
+      edgeSpacing,
+      refs,
+      maxDepth,
+      currentDepth,
+      plugins,
+      min,
+      callToJSON,
+      printFunctionName,
+      escapeRegex,
+      colors);
+
+      const value = print(
+      current.value[1],
+      indent,
+      innerIndent,
+      spacing,
+      edgeSpacing,
+      refs,
+      maxDepth,
+      currentDepth,
+      plugins,
+      min,
+      callToJSON,
+      printFunctionName,
+      escapeRegex,
+      colors);
+
+
+      result += innerIndent + key + ' => ' + value;
+
+      current = iterator.next();
+
+      if (!current.done) {
+        result += ',' + spacing;
+      }
+    }
+
+    result += (min ? '' : ',') + edgeSpacing + prevIndent;
+  }
+
+  return result + '}';
+}
+
+function printObject(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  const constructor = min ?
+  '' :
+  val.constructor ? val.constructor.name + ' ' : 'Object ';
+  let result = constructor + '{';
+  let keys = Object.keys(val).sort();
+  const symbols = getSymbols(val);
+
+  if (symbols.length) {
+    keys = keys.
+    filter(
+    key =>
+    // $FlowFixMe string literal `symbol`. This value is not a valid `typeof` return value
+    !(typeof key === 'symbol' ||
+    toString.call(key) === '[object Symbol]')).
+
+    concat(symbols);
+  }
+
+  if (keys.length) {
+    result += edgeSpacing;
+
+    const innerIndent = prevIndent + indent;
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const name = print(
+      key,
+      indent,
+      innerIndent,
+      spacing,
+      edgeSpacing,
+      refs,
+      maxDepth,
+      currentDepth,
+      plugins,
+      min,
+      callToJSON,
+      printFunctionName,
+      escapeRegex,
+      colors);
+
+      const value = print(
+      val[key],
+      indent,
+      innerIndent,
+      spacing,
+      edgeSpacing,
+      refs,
+      maxDepth,
+      currentDepth,
+      plugins,
+      min,
+      callToJSON,
+      printFunctionName,
+      escapeRegex,
+      colors);
+
+
+      result += innerIndent + name + ': ' + value;
+
+      if (i < keys.length - 1) {
+        result += ',' + spacing;
+      }
+    }
+
+    result += (min ? '' : ',') + edgeSpacing + prevIndent;
+  }
+
+  return result + '}';
+}
+
+function printSet(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  let result = 'Set {';
+  const iterator = val.entries();
+  let current = iterator.next();
+
+  if (!current.done) {
+    result += edgeSpacing;
+
+    const innerIndent = prevIndent + indent;
+
+    while (!current.done) {
+      result +=
+      innerIndent +
+      print(
+      current.value[1],
+      indent,
+      innerIndent,
+      spacing,
+      edgeSpacing,
+      refs,
+      maxDepth,
+      currentDepth,
+      plugins,
+      min,
+      callToJSON,
+      printFunctionName,
+      escapeRegex,
+      colors);
+
+
+      current = iterator.next();
+
+      if (!current.done) {
+        result += ',' + spacing;
+      }
+    }
+
+    result += (min ? '' : ',') + edgeSpacing + prevIndent;
+  }
+
+  return result + '}';
+}
+
+function printComplexValue(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  refs = refs.slice();
+  if (refs.indexOf(val) > -1) {
+    return '[Circular]';
+  } else {
+    refs.push(val);
+  }
+
+  currentDepth++;
+
+  const hitMaxDepth = currentDepth > maxDepth;
+
+  if (
+  callToJSON &&
+  !hitMaxDepth &&
+  val.toJSON &&
+  typeof val.toJSON === 'function')
+  {
+    return print(
+    val.toJSON(),
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    maxDepth,
+    currentDepth,
+    plugins,
+    min,
+    callToJSON,
+    printFunctionName,
+    escapeRegex,
+    colors);
+
+  }
+
+  const toStringed = toString.call(val);
+  if (toStringed === '[object Arguments]') {
+    return hitMaxDepth ?
+    '[Arguments]' :
+    printArguments(
+    val,
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    maxDepth,
+    currentDepth,
+    plugins,
+    min,
+    callToJSON,
+    printFunctionName,
+    escapeRegex,
+    colors);
+
+  } else if (isToStringedArrayType(toStringed)) {
+    return hitMaxDepth ?
+    '[Array]' :
+    printArray(
+    val,
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    maxDepth,
+    currentDepth,
+    plugins,
+    min,
+    callToJSON,
+    printFunctionName,
+    escapeRegex,
+    colors);
+
+  } else if (toStringed === '[object Map]') {
+    return hitMaxDepth ?
+    '[Map]' :
+    printMap(
+    val,
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    maxDepth,
+    currentDepth,
+    plugins,
+    min,
+    callToJSON,
+    printFunctionName,
+    escapeRegex,
+    colors);
+
+  } else if (toStringed === '[object Set]') {
+    return hitMaxDepth ?
+    '[Set]' :
+    printSet(
+    val,
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    maxDepth,
+    currentDepth,
+    plugins,
+    min,
+    callToJSON,
+    printFunctionName,
+    escapeRegex,
+    colors);
+
+  }
+
+  return hitMaxDepth ?
+  '[Object]' :
+  printObject(
+  val,
+  indent,
+  prevIndent,
+  spacing,
+  edgeSpacing,
+  refs,
+  maxDepth,
+  currentDepth,
+  plugins,
+  min,
+  callToJSON,
+  printFunctionName,
+  escapeRegex,
+  colors);
+
+}
+
+function printPlugin(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  let plugin;
+
+  for (let p = 0; p < plugins.length; p++) {
+    if (plugins[p].test(val)) {
+      plugin = plugins[p];
+      break;
+    }
+  }
+
+  if (!plugin) {
+    return null;
+  }
+
+  function boundPrint(val) {
+    return print(
+    val,
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    maxDepth,
+    currentDepth,
+    plugins,
+    min,
+    callToJSON,
+    printFunctionName,
+    escapeRegex,
+    colors);
+
+  }
+
+  function boundIndent(str) {
+    const indentation = prevIndent + indent;
+    return indentation + str.replace(NEWLINE_REGEXP, '\n' + indentation);
+  }
+
+  const opts = {
+    edgeSpacing,
+    min,
+    spacing };
+
+  return plugin.print(val, boundPrint, boundIndent, opts, colors);
+}
+
+function print(
+val,
+indent,
+prevIndent,
+spacing,
+edgeSpacing,
+refs,
+maxDepth,
+currentDepth,
+plugins,
+min,
+callToJSON,
+printFunctionName,
+escapeRegex,
+colors)
+{
+  const pluginsResult = printPlugin(
+  val,
+  indent,
+  prevIndent,
+  spacing,
+  edgeSpacing,
+  refs,
+  maxDepth,
+  currentDepth,
+  plugins,
+  min,
+  callToJSON,
+  printFunctionName,
+  escapeRegex,
+  colors);
+
+  if (typeof pluginsResult === 'string') {
+    return pluginsResult;
+  }
+
+  const basicResult = printBasicValue(val, printFunctionName, escapeRegex);
+  if (basicResult !== null) {
+    return basicResult;
+  }
+
+  return printComplexValue(
+  val,
+  indent,
+  prevIndent,
+  spacing,
+  edgeSpacing,
+  refs,
+  maxDepth,
+  currentDepth,
+  plugins,
+  min,
+  callToJSON,
+  printFunctionName,
+  escapeRegex,
+  colors);
+
+}
+
+const DEFAULTS = {
+  callToJSON: true,
+  edgeSpacing: '\n',
+  escapeRegex: false,
+  highlight: false,
+  indent: 2,
+  maxDepth: Infinity,
+  min: false,
+  plugins: [],
+  printFunctionName: true,
+  spacing: '\n',
+  theme: {
+    comment: 'gray',
+    content: 'reset',
+    prop: 'yellow',
+    tag: 'cyan',
+    value: 'green' } };
+
+
+
+function validateOptions(opts) {
+  Object.keys(opts).forEach(key => {
+    if (!DEFAULTS.hasOwnProperty(key)) {
+      throw new Error(`pretty-format: Unknown option "${key}".`);
+    }
+  });
+
+  if (opts.min && opts.indent !== undefined && opts.indent !== 0) {
+    throw new Error(
+    'pretty-format: Options "min" and "indent" cannot be used together.');
+
+  }
+}
+
+function normalizeOptions(opts) {
+  const result = {};
+
+  Object.keys(DEFAULTS).forEach(
+  key =>
+  result[key] = opts.hasOwnProperty(key) ?
+  key === 'theme' ? normalizeTheme(opts.theme) : opts[key] :
+  DEFAULTS[key]);
+
+
+  if (result.min) {
+    result.indent = 0;
+  }
+
+  // $FlowFixMe the type cast below means YOU are responsible to verify the code above.
+  return result;
+}
+
+function normalizeTheme(themeOption) {
+  if (!themeOption) {
+    throw new Error(`pretty-format: Option "theme" must not be null.`);
+  }
+
+  if (typeof themeOption !== 'object') {
+    throw new Error(
+    `pretty-format: Option "theme" must be of type "object" but instead received "${typeof themeOption}".`);
+
+  }
+
+  // Silently ignore any keys in `theme` that are not in defaults.
+  const themeRefined = themeOption;
+  const themeDefaults = DEFAULTS.theme;
+  return Object.keys(themeDefaults).reduce((theme, key) => {
+    theme[key] = Object.prototype.hasOwnProperty.call(themeOption, key) ?
+    themeRefined[key] :
+    themeDefaults[key];
+    return theme;
+  }, {});
+}
+
+function createIndent(indent) {
+  return new Array(indent + 1).join(' ');
+}
+
+function prettyFormat(val, initialOptions) {
+  let opts;
+  if (!initialOptions) {
+    opts = DEFAULTS;
+  } else {
+    validateOptions(initialOptions);
+    opts = normalizeOptions(initialOptions);
+  }
+
+  const colors = {
+    comment: { close: '', open: '' },
+    content: { close: '', open: '' },
+    prop: { close: '', open: '' },
+    tag: { close: '', open: '' },
+    value: { close: '', open: '' } };
+
+  Object.keys(opts.theme).forEach(key => {
+    if (opts.highlight) {
+      const color = colors[key] = style[opts.theme[key]];
+      if (
+      !color ||
+      typeof color.close !== 'string' ||
+      typeof color.open !== 'string')
+      {
+        throw new Error(
+        `pretty-format: Option "theme" has a key "${key}" whose value "${opts.theme[key]}" is undefined in ansi-styles.`);
+
+      }
+    }
+  });
+
+  let indent;
+  let refs;
+  const prevIndent = '';
+  const currentDepth = 0;
+  const spacing = opts.min ? ' ' : '\n';
+  const edgeSpacing = opts.min ? '' : '\n';
+
+  if (opts && opts.plugins.length) {
+    indent = createIndent(opts.indent);
+    refs = [];
+    const pluginsResult = printPlugin(
+    val,
+    indent,
+    prevIndent,
+    spacing,
+    edgeSpacing,
+    refs,
+    opts.maxDepth,
+    currentDepth,
+    opts.plugins,
+    opts.min,
+    opts.callToJSON,
+    opts.printFunctionName,
+    opts.escapeRegex,
+    colors);
+
+    if (typeof pluginsResult === 'string') {
+      return pluginsResult;
+    }
+  }
+
+  const basicResult = printBasicValue(
+  val,
+  opts.printFunctionName,
+  opts.escapeRegex);
+
+  if (basicResult !== null) {
+    return basicResult;
+  }
+
+  if (!indent) {
+    indent = createIndent(opts.indent);
+  }
+  if (!refs) {
+    refs = [];
+  }
+  return printComplexValue(
+  val,
+  indent,
+  prevIndent,
+  spacing,
+  edgeSpacing,
+  refs,
+  opts.maxDepth,
+  currentDepth,
+  opts.plugins,
+  opts.min,
+  opts.callToJSON,
+  opts.printFunctionName,
+  opts.escapeRegex,
+  colors);
+
+}
+
+prettyFormat.plugins = {
+  AsymmetricMatcher: require('./plugins/AsymmetricMatcher'),
+  ConvertAnsi: require('./plugins/ConvertAnsi'),
+  HTMLElement: require('./plugins/HTMLElement'),
+  Immutable: require('./plugins/ImmutablePlugins'),
+  ReactElement: require('./plugins/ReactElement'),
+  ReactTestComponent: require('./plugins/ReactTestComponent') };
+
+
+module.exports = prettyFormat;

web/node_modules/pretty-format/build/plugins/AsymmetricMatcher.js

@@ -0,0 +1,55 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const asymmetricMatcher = Symbol.for('jest.asymmetricMatcher'); /**
+                                                                 * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                                 *
+                                                                 * This source code is licensed under the BSD-style license found in the
+                                                                 * LICENSE file in the root directory of this source tree. An additional grant
+                                                                 * of patent rights can be found in the PATENTS file in the same directory.
+                                                                 *
+                                                                 * 
+                                                                 */const SPACE = ' ';class ArrayContaining extends Array {}class ObjectContaining extends Object {}const print = (val, print,
+indent,
+opts,
+colors) =>
+{
+  const stringedValue = val.toString();
+
+  if (stringedValue === 'ArrayContaining') {
+    const array = ArrayContaining.from(val.sample);
+    return opts.spacing === SPACE ?
+    stringedValue + SPACE + print(array) :
+    print(array);
+  }
+
+  if (stringedValue === 'ObjectContaining') {
+    const object = Object.assign(new ObjectContaining(), val.sample);
+    return opts.spacing === SPACE ?
+    stringedValue + SPACE + print(object) :
+    print(object);
+  }
+
+  if (stringedValue === 'StringMatching') {
+    return stringedValue + SPACE + print(val.sample);
+  }
+
+  if (stringedValue === 'StringContaining') {
+    return stringedValue + SPACE + print(val.sample);
+  }
+
+  return val.toAsymmetricMatcher();
+};
+
+const test = object => object && object.$$typeof === asymmetricMatcher;
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ConvertAnsi.js

@@ -0,0 +1,49 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const ansiRegex = require('ansi-regex'); /**
+                                          * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                          *
+                                          * This source code is licensed under the BSD-style license found in the
+                                          * LICENSE file in the root directory of this source tree. An additional grant
+                                          * of patent rights can be found in the PATENTS file in the same directory.
+                                          *
+                                          * 
+                                          */const toHumanReadableAnsi = text => {const style = require('ansi-styles');return text.replace(ansiRegex(), (match, offset, string) => {switch (match) {case style.red.close:case style.green.close:case style.reset.open:
+      case style.reset.close:
+        return '</>';
+      case style.red.open:
+        return '<red>';
+      case style.green.open:
+        return '<green>';
+      case style.dim.open:
+        return '<dim>';
+      case style.bold.open:
+        return '<bold>';
+      default:
+        return '';}
+
+  });
+};
+
+const test = value =>
+typeof value === 'string' && value.match(ansiRegex());
+
+const print = (
+val,
+print,
+indent,
+opts,
+colors) =>
+print(toHumanReadableAnsi(val));
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/HTMLElement.js

@@ -0,0 +1,143 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const escapeHTML = require('./lib/escapeHTML'); /**
+                                                 * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                 *
+                                                 * This source code is licensed under the BSD-style license found in the
+                                                 * LICENSE file in the root directory of this source tree. An additional grant
+                                                 * of patent rights can be found in the PATENTS file in the same directory.
+                                                 *
+                                                 * 
+                                                 */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const HTML_ELEMENT_REGEXP = /(HTML\w*?Element)|Text|Comment/;
+const test = isHTMLElement;
+
+function isHTMLElement(value) {
+  return (
+    value !== undefined &&
+    value !== null && (
+    value.nodeType === 1 || value.nodeType === 3 || value.nodeType === 8) &&
+    value.constructor !== undefined &&
+    value.constructor.name !== undefined &&
+    HTML_ELEMENT_REGEXP.test(value.constructor.name));
+
+}
+
+function printChildren(flatChildren, print, indent, colors, opts) {
+  return flatChildren.
+  map(node => {
+    if (typeof node === 'object') {
+      return print(node, print, indent, colors, opts);
+    } else if (typeof node === 'string') {
+      return colors.content.open + escapeHTML(node) + colors.content.close;
+    } else {
+      return print(node);
+    }
+  }).
+  filter(value => value.trim().length).
+  join(opts.edgeSpacing);
+}
+
+function printAttributes(attributes, indent, colors, opts) {
+  return attributes.
+  sort().
+  map(attribute => {
+    return (
+      opts.spacing +
+      indent(colors.prop.open + attribute.name + colors.prop.close + '=') +
+      colors.value.open +
+      `"${attribute.value}"` +
+      colors.value.close);
+
+  }).
+  join('');
+}
+
+const print = (
+element,
+print,
+indent,
+opts,
+colors) =>
+{
+  if (element.nodeType === 3) {
+    return element.data.
+    split('\n').
+    map(text => text.trimLeft()).
+    filter(text => text.length).
+    join(' ');
+  } else if (element.nodeType === 8) {
+    return (
+      colors.comment.open +
+      '<!-- ' +
+      element.data.trim() +
+      ' -->' +
+      colors.comment.close);
+
+  }
+
+  let result = colors.tag.open + '<';
+  const elementName = element.tagName.toLowerCase();
+  result += elementName + colors.tag.close;
+
+  const hasAttributes = element.attributes && element.attributes.length;
+  if (hasAttributes) {
+    const attributes = Array.prototype.slice.call(element.attributes);
+    result += printAttributes(attributes, indent, colors, opts);
+  }
+
+  const flatChildren = Array.prototype.slice.call(element.childNodes);
+  if (!flatChildren.length && element.textContent) {
+    flatChildren.push(element.textContent);
+  }
+
+  const closeInNewLine = hasAttributes && !opts.min;
+  if (flatChildren.length) {
+    const children = printChildren(flatChildren, print, indent, colors, opts);
+    result +=
+    colors.tag.open + (
+    closeInNewLine ? '\n' : '') +
+    '>' +
+    colors.tag.close +
+    opts.edgeSpacing +
+    indent(children) +
+    opts.edgeSpacing +
+    colors.tag.open +
+    '</' +
+    elementName +
+    '>' +
+    colors.tag.close;
+  } else {
+    result +=
+    colors.tag.open + (closeInNewLine ? '\n' : ' ') + '/>' + colors.tag.close;
+  }
+
+  return result;
+};
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ImmutableList.js

@@ -0,0 +1,26 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const printImmutable = require('./lib/printImmutable'); /**
+                                                         * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                         *
+                                                         * This source code is licensed under the BSD-style license found in the
+                                                         * LICENSE file in the root directory of this source tree. An additional grant
+                                                         * of patent rights can be found in the PATENTS file in the same directory.
+                                                         *
+                                                         * 
+                                                         */const IS_LIST = '@@__IMMUTABLE_LIST__@@';const test = maybeList => !!(maybeList && maybeList[IS_LIST]);const print = (val, print, indent,
+opts,
+colors) =>
+printImmutable(val, print, indent, opts, colors, 'List', false);
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ImmutableMap.js

@@ -0,0 +1,28 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const printImmutable = require('./lib/printImmutable'); /**
+                                                         * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                         *
+                                                         * This source code is licensed under the BSD-style license found in the
+                                                         * LICENSE file in the root directory of this source tree. An additional grant
+                                                         * of patent rights can be found in the PATENTS file in the same directory.
+                                                         *
+                                                         * 
+                                                         */const IS_MAP = '@@__IMMUTABLE_MAP__@@';const IS_ORDERED = '@@__IMMUTABLE_ORDERED__@@';const test = maybeMap => !!(maybeMap && maybeMap[IS_MAP] && !maybeMap[IS_ORDERED]);const print = (val,
+print,
+indent,
+opts,
+colors) =>
+printImmutable(val, print, indent, opts, colors, 'Map', true);
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ImmutableOrderedMap.js

@@ -0,0 +1,28 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const printImmutable = require('./lib/printImmutable'); /**
+                                                         * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                         *
+                                                         * This source code is licensed under the BSD-style license found in the
+                                                         * LICENSE file in the root directory of this source tree. An additional grant
+                                                         * of patent rights can be found in the PATENTS file in the same directory.
+                                                         *
+                                                         * 
+                                                         */const IS_MAP = '@@__IMMUTABLE_MAP__@@';const IS_ORDERED = '@@__IMMUTABLE_ORDERED__@@';const test = maybeOrderedMap => maybeOrderedMap && maybeOrderedMap[IS_MAP] && maybeOrderedMap[IS_ORDERED];const print = (val,
+print,
+indent,
+opts,
+colors) =>
+printImmutable(val, print, indent, opts, colors, 'OrderedMap', true);
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ImmutableOrderedSet.js

@@ -0,0 +1,28 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const printImmutable = require('./lib/printImmutable'); /**
+                                                         * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                         *
+                                                         * This source code is licensed under the BSD-style license found in the
+                                                         * LICENSE file in the root directory of this source tree. An additional grant
+                                                         * of patent rights can be found in the PATENTS file in the same directory.
+                                                         *
+                                                         * 
+                                                         */const IS_SET = '@@__IMMUTABLE_SET__@@';const IS_ORDERED = '@@__IMMUTABLE_ORDERED__@@';const test = maybeOrderedSet => maybeOrderedSet && maybeOrderedSet[IS_SET] && maybeOrderedSet[IS_ORDERED];const print = (val,
+print,
+indent,
+opts,
+colors) =>
+printImmutable(val, print, indent, opts, colors, 'OrderedSet', false);
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ImmutablePlugins.js

@@ -0,0 +1,17 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               * 
+               */
+
+module.exports = [
+require('./ImmutableList'),
+require('./ImmutableSet'),
+require('./ImmutableMap'),
+require('./ImmutableStack'),
+require('./ImmutableOrderedSet'),
+require('./ImmutableOrderedMap')];

web/node_modules/pretty-format/build/plugins/ImmutableSet.js

@@ -0,0 +1,28 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const printImmutable = require('./lib/printImmutable'); /**
+                                                         * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                         *
+                                                         * This source code is licensed under the BSD-style license found in the
+                                                         * LICENSE file in the root directory of this source tree. An additional grant
+                                                         * of patent rights can be found in the PATENTS file in the same directory.
+                                                         *
+                                                         * 
+                                                         */const IS_SET = '@@__IMMUTABLE_SET__@@';const IS_ORDERED = '@@__IMMUTABLE_ORDERED__@@';const test = maybeSet => !!(maybeSet && maybeSet[IS_SET] && !maybeSet[IS_ORDERED]);const print = (val,
+print,
+indent,
+opts,
+colors) =>
+printImmutable(val, print, indent, opts, colors, 'Set', false);
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ImmutableStack.js

@@ -0,0 +1,26 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const printImmutable = require('./lib/printImmutable'); /**
+                                                         * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                         *
+                                                         * This source code is licensed under the BSD-style license found in the
+                                                         * LICENSE file in the root directory of this source tree. An additional grant
+                                                         * of patent rights can be found in the PATENTS file in the same directory.
+                                                         *
+                                                         * 
+                                                         */const IS_STACK = '@@__IMMUTABLE_STACK__@@';const test = maybeStack => !!(maybeStack && maybeStack[IS_STACK]);const print = (val, print, indent,
+opts,
+colors) =>
+printImmutable(val, print, indent, opts, colors, 'Stack', false);
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ReactElement.js

@@ -0,0 +1,126 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+const escapeHTML = require('./lib/escapeHTML'); /**
+                                                 * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                 *
+                                                 * This source code is licensed under the BSD-style license found in the
+                                                 * LICENSE file in the root directory of this source tree. An additional grant
+                                                 * of patent rights can be found in the PATENTS file in the same directory.
+                                                 *
+                                                 * 
+                                                 */const reactElement = Symbol.for('react.element');function traverseChildren(opaqueChildren, cb) {if (Array.isArray(opaqueChildren)) {opaqueChildren.forEach(child => traverseChildren(child, cb));} else if (opaqueChildren != null && opaqueChildren !== false) {cb(opaqueChildren);
+  }
+}
+
+function printChildren(flatChildren, print, indent, colors, opts) {
+  return flatChildren.
+  map(node => {
+    if (typeof node === 'object') {
+      return print(node, print, indent, colors, opts);
+    } else if (typeof node === 'string') {
+      return colors.content.open + escapeHTML(node) + colors.content.close;
+    } else {
+      return print(node);
+    }
+  }).
+  join(opts.edgeSpacing);
+}
+
+function printProps(props, print, indent, colors, opts) {
+  return Object.keys(props).
+  sort().
+  map(name => {
+    if (name === 'children') {
+      return '';
+    }
+
+    const prop = props[name];
+    let printed = print(prop);
+
+    if (typeof prop !== 'string') {
+      if (printed.indexOf('\n') !== -1) {
+        printed =
+        '{' +
+        opts.edgeSpacing +
+        indent(indent(printed) + opts.edgeSpacing + '}');
+      } else {
+        printed = '{' + printed + '}';
+      }
+    }
+
+    return (
+      opts.spacing +
+      indent(colors.prop.open + name + colors.prop.close + '=') +
+      colors.value.open +
+      printed +
+      colors.value.close);
+
+  }).
+  join('');
+}
+
+const print = (
+element,
+print,
+indent,
+opts,
+colors) =>
+{
+  let result = colors.tag.open + '<';
+  let elementName;
+  if (typeof element.type === 'string') {
+    elementName = element.type;
+  } else if (typeof element.type === 'function') {
+    elementName = element.type.displayName || element.type.name || 'Unknown';
+  } else {
+    elementName = 'Unknown';
+  }
+  result += elementName + colors.tag.close;
+  result += printProps(element.props, print, indent, colors, opts);
+
+  const opaqueChildren = element.props.children;
+  const hasProps = !!Object.keys(element.props).filter(
+  propName => propName !== 'children').
+  length;
+  const closeInNewLine = hasProps && !opts.min;
+
+  if (opaqueChildren) {
+    const flatChildren = [];
+    traverseChildren(opaqueChildren, child => {
+      flatChildren.push(child);
+    });
+    const children = printChildren(flatChildren, print, indent, colors, opts);
+    result +=
+    colors.tag.open + (
+    closeInNewLine ? '\n' : '') +
+    '>' +
+    colors.tag.close +
+    opts.edgeSpacing +
+    indent(children) +
+    opts.edgeSpacing +
+    colors.tag.open +
+    '</' +
+    elementName +
+    '>' +
+    colors.tag.close;
+  } else {
+    result +=
+    colors.tag.open + (closeInNewLine ? '\n' : ' ') + '/>' + colors.tag.close;
+  }
+
+  return result;
+};
+
+const test = object => object && object.$$typeof === reactElement;
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/ReactTestComponent.js

@@ -0,0 +1,121 @@
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const escapeHTML = require('./lib/escapeHTML'); /**
+                                                 * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                                 *
+                                                 * This source code is licensed under the BSD-style license found in the
+                                                 * LICENSE file in the root directory of this source tree. An additional grant
+                                                 * of patent rights can be found in the PATENTS file in the same directory.
+                                                 *
+                                                 * 
+                                                 */const reactTestInstance = Symbol.for('react.test.json');function printChildren(children, print, indent, colors,
+opts)
+{
+  return children.
+  map(child => printInstance(child, print, indent, colors, opts)).
+  join(opts.edgeSpacing);
+}
+
+function printProps(props, print, indent, colors, opts) {
+  return Object.keys(props).
+  sort().
+  map(name => {
+    const prop = props[name];
+    let printed = print(prop);
+
+    if (typeof prop !== 'string') {
+      if (printed.indexOf('\n') !== -1) {
+        printed =
+        '{' +
+        opts.edgeSpacing +
+        indent(indent(printed) + opts.edgeSpacing + '}');
+      } else {
+        printed = '{' + printed + '}';
+      }
+    }
+
+    return (
+      opts.spacing +
+      indent(colors.prop.open + name + colors.prop.close + '=') +
+      colors.value.open +
+      printed +
+      colors.value.close);
+
+  }).
+  join('');
+}
+
+function printInstance(instance, print, indent, colors, opts) {
+  if (typeof instance == 'number') {
+    return print(instance);
+  } else if (typeof instance === 'string') {
+    return colors.content.open + escapeHTML(instance) + colors.content.close;
+  }
+
+  let closeInNewLine = false;
+  let result = colors.tag.open + '<' + instance.type + colors.tag.close;
+
+  if (instance.props) {
+    closeInNewLine = !!Object.keys(instance.props).length && !opts.min;
+    result += printProps(instance.props, print, indent, colors, opts);
+  }
+
+  if (instance.children) {
+    const children = printChildren(
+    instance.children,
+    print,
+    indent,
+    colors,
+    opts);
+
+    result +=
+    colors.tag.open + (
+    closeInNewLine ? '\n' : '') +
+    '>' +
+    colors.tag.close +
+    opts.edgeSpacing +
+    indent(children) +
+    opts.edgeSpacing +
+    colors.tag.open +
+    '</' +
+    instance.type +
+    '>' +
+    colors.tag.close;
+  } else {
+    result +=
+    colors.tag.open + (closeInNewLine ? '\n' : ' ') + '/>' + colors.tag.close;
+  }
+
+  return result;
+}
+
+const print = (
+val,
+print,
+indent,
+opts,
+colors) =>
+printInstance(val, print, indent, colors, opts);
+
+const test = object =>
+object && object.$$typeof === reactTestInstance;
+
+module.exports = { print, test };

web/node_modules/pretty-format/build/plugins/lib/escapeHTML.js

@@ -0,0 +1,15 @@
+'use strict'; /**
+               * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+               *
+               * This source code is licensed under the BSD-style license found in the
+               * LICENSE file in the root directory of this source tree. An additional grant
+               * of patent rights can be found in the PATENTS file in the same directory.
+               *
+               * 
+               */
+
+function escapeHTML(str) {
+  return str.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+module.exports = escapeHTML;

web/node_modules/pretty-format/build/plugins/lib/printImmutable.js

@@ -0,0 +1,57 @@
+'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();
+
+
+
+
+
+
+
+
+
+
+
+const IMMUTABLE_NAMESPACE = 'Immutable.'; /**
+                                           * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+                                           *
+                                           * This source code is licensed under the BSD-style license found in the
+                                           * LICENSE file in the root directory of this source tree. An additional grant
+                                           * of patent rights can be found in the PATENTS file in the same directory.
+                                           *
+                                           * 
+                                           */const SPACE = ' ';const addKey = (isMap, key) => isMap ? key + ': ' : '';const addFinalEdgeSpacing = (length, edgeSpacing) => length > 0 ? edgeSpacing : '';const printImmutable = (
+val,
+print,
+indent,
+opts,
+colors,
+immutableDataStructureName,
+isMap) =>
+{var _ref =
+  isMap ? ['{', '}'] : ['[', ']'],_ref2 = _slicedToArray(_ref, 2);const openTag = _ref2[0],closeTag = _ref2[1];
+  let result =
+  IMMUTABLE_NAMESPACE +
+  immutableDataStructureName +
+  SPACE +
+  openTag +
+  opts.edgeSpacing;
+
+  const immutableArray = [];
+  val.forEach((item, key) =>
+  immutableArray.push(
+  indent(addKey(isMap, key) + print(item, print, indent, opts, colors))));
+
+
+
+  result += immutableArray.join(',' + opts.spacing);
+  if (!opts.min && immutableArray.length > 0) {
+    result += ',';
+  }
+
+  return (
+    result +
+    addFinalEdgeSpacing(immutableArray.length, opts.edgeSpacing) +
+    closeTag);
+
+};
+
+module.exports = printImmutable;