@volter/tabnode 0.2.14-volter.88

package/src/node-lib/internal/assert/myers_diff.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const {
+  ArrayPrototypePush,
+  Int32Array,
+  StringPrototypeEndsWith,
+} = primordials;
+
+const colors = require('internal/util/colors');
+
+const kNopLinesToCollapse = 5;
+const kOperations = {
+  DELETE: -1,
+  NOP: 0,
+  INSERT: 1,
+};
+
+function areLinesEqual(actual, expected, checkCommaDisparity) {
+  if (actual === expected) {
+    return true;
+  }
+  if (checkCommaDisparity) {
+    return (actual + ',') === expected || actual === (expected + ',');
+  }
+  return false;
+}
+
+function myersDiff(actual, expected, checkCommaDisparity = false) {
+  const actualLength = actual.length;
+  const expectedLength = expected.length;
+  const max = actualLength + expectedLength;
+  // TODO(BridgeAR): Cap the input in case the values go beyond the limit of 2^31 - 1.
+  const v = new Int32Array(2 * max + 1);
+  const trace = [];
+
+  for (let diffLevel = 0; diffLevel <= max; diffLevel++) {
+    ArrayPrototypePush(trace, new Int32Array(v)); // Clone the current state of `v`
+
+    for (let diagonalIndex = -diffLevel; diagonalIndex <= diffLevel; diagonalIndex += 2) {
+      const offset = diagonalIndex + max;
+      const previousOffset = v[offset - 1];
+      const nextOffset = v[offset + 1];
+      let x = diagonalIndex === -diffLevel || (diagonalIndex !== diffLevel && previousOffset < nextOffset) ?
+        nextOffset :
+        previousOffset + 1;
+      let y = x - diagonalIndex;
+
+      while (
+        x < actualLength &&
+        y < expectedLength &&
+        areLinesEqual(actual[x], expected[y], checkCommaDisparity)
+      ) {
+        x++;
+        y++;
+      }
+
+      v[offset] = x;
+
+      if (x >= actualLength && y >= expectedLength) {
+        return backtrack(trace, actual, expected, checkCommaDisparity);
+      }
+    }
+  }
+}
+
+function backtrack(trace, actual, expected, checkCommaDisparity) {
+  const actualLength = actual.length;
+  const expectedLength = expected.length;
+  const max = actualLength + expectedLength;
+
+  let x = actualLength;
+  let y = expectedLength;
+  const result = [];
+
+  for (let diffLevel = trace.length - 1; diffLevel >= 0; diffLevel--) {
+    const v = trace[diffLevel];
+    const diagonalIndex = x - y;
+    const offset = diagonalIndex + max;
+
+    let prevDiagonalIndex;
+    if (
+      diagonalIndex === -diffLevel ||
+      (diagonalIndex !== diffLevel && v[offset - 1] < v[offset + 1])
+    ) {
+      prevDiagonalIndex = diagonalIndex + 1;
+    } else {
+      prevDiagonalIndex = diagonalIndex - 1;
+    }
+
+    const prevX = v[prevDiagonalIndex + max];
+    const prevY = prevX - prevDiagonalIndex;
+
+    while (x > prevX && y > prevY) {
+      const actualItem = actual[x - 1];
+      const value = checkCommaDisparity && !StringPrototypeEndsWith(actualItem, ',') ? expected[y - 1] : actualItem;
+      ArrayPrototypePush(result, [ kOperations.NOP, value ]);
+      x--;
+      y--;
+    }
+
+    if (diffLevel > 0) {
+      if (x > prevX) {
+        ArrayPrototypePush(result, [ kOperations.INSERT, actual[--x] ]);
+      } else {
+        ArrayPrototypePush(result, [ kOperations.DELETE, expected[--y] ]);
+      }
+    }
+  }
+
+  return result;
+}
+
+function printSimpleMyersDiff(diff) {
+  let message = '';
+
+  for (let diffIdx = diff.length - 1; diffIdx >= 0; diffIdx--) {
+    const { 0: operation, 1: value } = diff[diffIdx];
+    let color = colors.white;
+
+    if (operation === kOperations.INSERT) {
+      color = colors.green;
+    } else if (operation === kOperations.DELETE) {
+      color = colors.red;
+    }
+
+    message += `${color}${value}${colors.white}`;
+  }
+
+  return `\n${message}`;
+}
+
+function printMyersDiff(diff, operator) {
+  let message = '';
+  let skipped = false;
+  let nopCount = 0;
+
+  for (let diffIdx = diff.length - 1; diffIdx >= 0; diffIdx--) {
+    const { 0: operation, 1: value } = diff[diffIdx];
+    const previousOperation = diffIdx < diff.length - 1 ? diff[diffIdx + 1][0] : null;
+
+    // Avoid grouping if only one line would have been grouped otherwise
+    if (previousOperation === kOperations.NOP && operation !== previousOperation) {
+      if (nopCount === kNopLinesToCollapse + 1) {
+        message += `${colors.white}  ${diff[diffIdx + 1][1]}\n`;
+      } else if (nopCount === kNopLinesToCollapse + 2) {
+        message += `${colors.white}  ${diff[diffIdx + 2][1]}\n`;
+        message += `${colors.white}  ${diff[diffIdx + 1][1]}\n`;
+      } else if (nopCount >= kNopLinesToCollapse + 3) {
+        message += `${colors.blue}...${colors.white}\n`;
+        message += `${colors.white}  ${diff[diffIdx + 1][1]}\n`;
+        skipped = true;
+      }
+      nopCount = 0;
+    }
+
+    if (operation === kOperations.INSERT) {
+      if (operator === 'partialDeepStrictEqual') {
+        message += `${colors.gray}${colors.hasColors ? ' ' : '+'} ${value}${colors.white}\n`;
+      } else {
+        message += `${colors.green}+${colors.white} ${value}\n`;
+      }
+    } else if (operation === kOperations.DELETE) {
+      message += `${colors.red}-${colors.white} ${value}\n`;
+    } else if (operation === kOperations.NOP) {
+      if (nopCount < kNopLinesToCollapse) {
+        message += `${colors.white}  ${value}\n`;
+      }
+      nopCount++;
+    }
+  }
+
+  message = message.trimEnd();
+
+  return { message: `\n${message}`, skipped };
+}
+
+module.exports = { myersDiff, printMyersDiff, printSimpleMyersDiff };

package/src/node-lib/internal/assert/utils.js

@@ -0,0 +1,278 @@
+'use strict';
+
+const {
+  ArrayPrototypeShift,
+  Error,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  RegExpPrototypeSymbolReplace,
+  SafeMap,
+  StringPrototypeCharCodeAt,
+  StringPrototypeIncludes,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+} = primordials;
+
+const { Buffer } = require('buffer');
+const {
+  isErrorStackTraceLimitWritable,
+  overrideStackTrace,
+} = require('internal/errors');
+const AssertionError = require('internal/assert/assertion_error');
+const { openSync, closeSync, readSync } = require('fs');
+const { EOL } = require('internal/constants');
+const { BuiltinModule } = require('internal/bootstrap/realm');
+const { isError } = require('internal/util');
+
+const errorCache = new SafeMap();
+const { fileURLToPath } = require('internal/url');
+
+let parseExpressionAt;
+let findNodeAround;
+let tokenizer;
+let decoder;
+
+// Escape control characters but not \n and \t to keep the line breaks and
+// indentation intact.
+// eslint-disable-next-line no-control-regex
+const escapeSequencesRegExp = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
+const meta = [
+  '\\u0000', '\\u0001', '\\u0002', '\\u0003', '\\u0004',
+  '\\u0005', '\\u0006', '\\u0007', '\\b', '',
+  '', '\\u000b', '\\f', '', '\\u000e',
+  '\\u000f', '\\u0010', '\\u0011', '\\u0012', '\\u0013',
+  '\\u0014', '\\u0015', '\\u0016', '\\u0017', '\\u0018',
+  '\\u0019', '\\u001a', '\\u001b', '\\u001c', '\\u001d',
+  '\\u001e', '\\u001f',
+];
+
+const escapeFn = (str) => meta[StringPrototypeCharCodeAt(str, 0)];
+
+function findColumn(fd, column, code) {
+  if (code.length > column + 100) {
+    try {
+      return parseCode(code, column);
+    } catch {
+      // End recursion in case no code could be parsed. The expression should
+      // have been found after 2500 characters, so stop trying.
+      if (code.length - column > 2500) {
+        // eslint-disable-next-line no-throw-literal
+        throw null;
+      }
+    }
+  }
+  // Read up to 2500 bytes more than necessary in columns. That way we address
+  // multi byte characters and read enough data to parse the code.
+  const bytesToRead = column - code.length + 2500;
+  const buffer = Buffer.allocUnsafe(bytesToRead);
+  const bytesRead = readSync(fd, buffer, 0, bytesToRead);
+  code += decoder.write(buffer.slice(0, bytesRead));
+  // EOF: fast path.
+  if (bytesRead < bytesToRead) {
+    return parseCode(code, column);
+  }
+  // Read potentially missing code.
+  return findColumn(fd, column, code);
+}
+
+function getCode(fd, line, column) {
+  let bytesRead = 0;
+  if (line === 0) {
+    // Special handle line number one. This is more efficient and simplifies the
+    // rest of the algorithm. Read more than the regular column number in bytes
+    // to prevent multiple reads in case multi byte characters are used.
+    return findColumn(fd, column, '');
+  }
+  let lines = 0;
+  // Prevent blocking the event loop by limiting the maximum amount of
+  // data that may be read.
+  let maxReads = 32; // bytesPerRead * maxReads = 512 KiB
+  const bytesPerRead = 16384;
+  // Use a single buffer up front that is reused until the call site is found.
+  let buffer = Buffer.allocUnsafe(bytesPerRead);
+  while (maxReads-- !== 0) {
+    // Only allocate a new buffer in case the needed line is found. All data
+    // before that can be discarded.
+    buffer = lines < line ? buffer : Buffer.allocUnsafe(bytesPerRead);
+    bytesRead = readSync(fd, buffer, 0, bytesPerRead);
+    // Read the buffer until the required code line is found.
+    for (let i = 0; i < bytesRead; i++) {
+      if (buffer[i] === 10 && ++lines === line) {
+        // If the end of file is reached, directly parse the code and return.
+        if (bytesRead < bytesPerRead) {
+          return parseCode(buffer.toString('utf8', i + 1, bytesRead), column);
+        }
+        // Check if the read code is sufficient or read more until the whole
+        // expression is read. Make sure multi byte characters are preserved
+        // properly by using the decoder.
+        const code = decoder.write(buffer.slice(i + 1, bytesRead));
+        return findColumn(fd, column, code);
+      }
+    }
+  }
+}
+
+function parseCode(code, offset) {
+  // Lazy load acorn.
+  if (parseExpressionAt === undefined) {
+    const Parser = require('internal/deps/acorn/acorn/dist/acorn').Parser;
+    ({ findNodeAround } = require('internal/deps/acorn/acorn-walk/dist/walk'));
+
+    parseExpressionAt = FunctionPrototypeBind(Parser.parseExpressionAt, Parser);
+    tokenizer = FunctionPrototypeBind(Parser.tokenizer, Parser);
+  }
+  let node;
+  let start;
+  // Parse the read code until the correct expression is found.
+  for (const token of tokenizer(code, { ecmaVersion: 'latest' })) {
+    start = token.start;
+    if (start > offset) {
+      // No matching expression found. This could happen if the assert
+      // expression is bigger than the provided buffer.
+      break;
+    }
+    try {
+      node = parseExpressionAt(code, start, { ecmaVersion: 'latest' });
+      // Find the CallExpression in the tree.
+      node = findNodeAround(node, offset, 'CallExpression');
+      if (node?.node.end >= offset) {
+        return [
+          node.node.start,
+          StringPrototypeReplace(StringPrototypeSlice(code,
+                                                      node.node.start, node.node.end),
+                                 escapeSequencesRegExp, escapeFn),
+        ];
+      }
+    // eslint-disable-next-line no-unused-vars
+    } catch (err) {
+      continue;
+    }
+  }
+  // eslint-disable-next-line no-throw-literal
+  throw null;
+}
+
+function getErrMessage(message, fn) {
+  const tmpLimit = Error.stackTraceLimit;
+  const errorStackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+  // Make sure the limit is set to 1. Otherwise it could fail (<= 0) or it
+  // does to much work.
+  if (errorStackTraceLimitIsWritable) Error.stackTraceLimit = 1;
+  // We only need the stack trace. To minimize the overhead use an object
+  // instead of an error.
+  const err = {};
+  ErrorCaptureStackTrace(err, fn);
+  if (errorStackTraceLimitIsWritable) Error.stackTraceLimit = tmpLimit;
+
+  overrideStackTrace.set(err, (_, stack) => stack);
+  const call = err.stack[0];
+
+  let filename = call.getFileName();
+  const line = call.getLineNumber() - 1;
+  let column = call.getColumnNumber() - 1;
+  let identifier;
+
+  if (filename) {
+    identifier = `${filename}${line}${column}`;
+
+    // Skip Node.js modules!
+    if (StringPrototypeStartsWith(filename, 'node:') &&
+        BuiltinModule.exists(StringPrototypeSlice(filename, 5))) {
+      errorCache.set(identifier, undefined);
+      return;
+    }
+  } else {
+    return message;
+  }
+
+  if (errorCache.has(identifier)) {
+    return errorCache.get(identifier);
+  }
+
+  let fd;
+  try {
+    // Set the stack trace limit to zero. This makes sure unexpected token
+    // errors are handled faster.
+    if (errorStackTraceLimitIsWritable) Error.stackTraceLimit = 0;
+
+    if (decoder === undefined) {
+      const { StringDecoder } = require('string_decoder');
+      decoder = new StringDecoder('utf8');
+    }
+
+    // ESM file prop is a file proto. Convert that to path.
+    // This ensure opensync will not throw ENOENT for ESM files.
+    const fileProtoPrefix = 'file://';
+    if (StringPrototypeStartsWith(filename, fileProtoPrefix)) {
+      filename = fileURLToPath(filename);
+    }
+
+    fd = openSync(filename, 'r', 0o666);
+    // Reset column and message.
+    ({ 0: column, 1: message } = getCode(fd, line, column));
+    // Flush unfinished multi byte characters.
+    decoder.end();
+
+    // Always normalize indentation, otherwise the message could look weird.
+    if (StringPrototypeIncludes(message, '\n')) {
+      if (EOL === '\r\n') {
+        message = RegExpPrototypeSymbolReplace(/\r\n/g, message, '\n');
+      }
+      const frames = StringPrototypeSplit(message, '\n');
+      message = ArrayPrototypeShift(frames);
+      for (const frame of frames) {
+        let pos = 0;
+        while (pos < column && (frame[pos] === ' ' || frame[pos] === '\t')) {
+          pos++;
+        }
+        message += `\n  ${StringPrototypeSlice(frame, pos)}`;
+      }
+    }
+    message = `The expression evaluated to a falsy value:\n\n  ${message}\n`;
+    // Make sure to always set the cache! No matter if the message is
+    // undefined or not
+    errorCache.set(identifier, message);
+
+    return message;
+  } catch {
+    // Invalidate cache to prevent trying to read this part again.
+    errorCache.set(identifier, undefined);
+  } finally {
+    // Reset limit.
+    if (errorStackTraceLimitIsWritable) Error.stackTraceLimit = tmpLimit;
+    if (fd !== undefined)
+      closeSync(fd);
+  }
+}
+
+function innerOk(fn, argLen, value, message) {
+  if (!value) {
+    let generatedMessage = false;
+
+    if (argLen === 0) {
+      generatedMessage = true;
+      message = 'No value argument passed to `assert.ok()`';
+    } else if (message == null) {
+      generatedMessage = true;
+      message = getErrMessage(message, fn);
+    } else if (isError(message)) {
+      throw message;
+    }
+
+    const err = new AssertionError({
+      actual: value,
+      expected: true,
+      message,
+      operator: '==',
+      stackStartFn: fn,
+    });
+    err.generatedMessage = generatedMessage;
+    throw err;
+  }
+}
+
+module.exports = {
+  innerOk,
+};