Report for aasvg_0.3.2-1.dsc — 700 - tarballs not identical

Summary

Source package: https://deb.debian.org/debian/pool/main/a/aasvg/aasvg_0.3.2-1.dsc
DSC SHA256: 56e0b269926a70522ccb1db6d84b82ce48d5d088dc5938773c44b2bd8bd055ba
Timestamp: 2025-12-17 09:24:31
Devscripts version: 2.25.30
Diffoscope version: 309

Available reports for the same source package

2025-12-17 09:24:31 700 - tarballs not identical 2025-12-12 14:41:47 700 - tarballs not identical 2025-12-12 01:38:50 700 - tarballs not identical

dget

log:
command: dget --quiet --download-only --allow-unauthenticated https://deb.debian.org/debian/pool/main/a/aasvg/aasvg_0.3.2-1.dsc
success: True
exit_code: 0
orig_tarball:
- name: aasvg_0.3.2.orig.tar.gz
- size: 20235
- git_commit: 05069ef1a538c4c01fe87159c8efbd703576502c

dscverify

log: Show details (33 lines)

aasvg_0.3.2-1.dsc:
dscverify: aasvg_0.3.2-1.dsc failed signature check:
gpg: Signature made Wed Jan 11 20:33:48 2023 UTC
gpg:                using EDDSA key 2DB5491C9DF0DC8F432863CF3E9D717371DE565C
gpg: Can't check signature: No public key
gpg: can't create `/tmp/.gnupg/random_seed': No such file or directory
Validation FAILED!!
Format: 3.0 (quilt)
Source: aasvg
Binary: aasvg
Architecture: all
Version: 0.3.2-1
Maintainer: Daniel Kahn Gillmor <dkg@fifthhorseman.net>
Homepage: https://github.com/martinthomson/aasvg
Standards-Version: 4.6.1
Vcs-Browser: https://salsa.debian.org/debian/aasvg
Vcs-Git: https://salsa.debian.org/debian/aasvg.git
Testsuite: autopkgtest
Testsuite-Triggers: diffutils
Build-Depends: debhelper-compat (= 13), help2man <!nodoc>, nodejs <!nodoc> <!nocheck>
Package-List:
 aasvg deb text optional arch=all
Checksums-Sha1:
 e32828f0051629db9805a43d99aa058c3a1e1613 20235 aasvg_0.3.2.orig.tar.gz
 99cc048d5ad101a88174e3805f88e9747951e094 3156 aasvg_0.3.2-1.debian.tar.xz
Checksums-Sha256:
 b133731b3b27805c4cc7a485ff2c1c6a8f77698e2af485bee9e9d3e74413abc6 20235 aasvg_0.3.2.orig.tar.gz
 a033098616f731bc1a1fc610cb6824fd3c7ec75e5d912146018884cfb8a94006 3156 aasvg_0.3.2-1.debian.tar.xz
Files:
 17f7eae8999c1670c99cce12d8d30829 20235 aasvg_0.3.2.orig.tar.gz
 4a84a52c3162184e6d429cfd795e0725 3156 aasvg_0.3.2-1.debian.tar.xz

command: dscverify --verbose aasvg_0.3.2-1.dsc
success: False
exit_code: 1

dpkg-source

log: Show details (6 lines)

           No acceptable signatures found
dpkg-source: warning: cannot verify inline signature for ./aasvg_0.3.2-1.dsc: no acceptable signature found
dpkg-source: info: extracting aasvg in aasvg-0.3.2
dpkg-source: info: unpacking aasvg_0.3.2.orig.tar.gz
dpkg-source: info: unpacking aasvg_0.3.2-1.debian.tar.xz

command: dpkg-source -x aasvg_0.3.2-1.dsc
success: True
exit_code: 0

uscan

log: Show details (77 lines)

uscan info: The --dehs option enabled.
        STDOUT = XML output for use by other programs
        STDERR = plain text output for human
        Use the redirection of STDOUT to a file to get the clean XML data
uscan info: Scan watch files in .
uscan info: Check debian/watch and debian/changelog in .
uscan info: package="aasvg" version="0.3.2-1" (as seen in debian/changelog)
uscan info: package="aasvg" version="0.3.2" (no epoch/revision)
uscan info: ./debian/changelog sets package="aasvg" version="0.3.2"
uscan info: Process watch file at: debian/watch
    package = aasvg
    version = 0.3.2
    pkg_dir = .
uscan info: debian/watch isn't formatted in version 5, trying version 4
uscan info: File debian/watch converted into << ==EOF==
Version: 5

Source: https://registry.npmjs.org/aasvg
Matching-Pattern: https://registry.npmjs.org/aasvg/-/aasvg-@ANY_VERSION@@ARCHIVE_EXT@
Searchmode: plain

==EOF==
uscan info: Reset watch_version to 4 because default value may change in version 5
uscan info: Parsing searchmode: plain
uscan info: Last orig.tar.* tarball version (from debian/changelog): 0.3.2
uscan info: Download the --download-current-version specified version: 0.3.2
uscan info: Requesting URL:
   https://registry.npmjs.org/aasvg
uscan info: Found the following matching files on the web page (newest first):
   https://registry.npmjs.org/aasvg/-/aasvg-0.4.2.tgz (0.4.2) index=0.4.2-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.4.1.tgz (0.4.1) index=0.4.1-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.4.0.tgz (0.4.0) index=0.4.0-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.9.tgz (0.3.9) index=0.3.9-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.8.tgz (0.3.8) index=0.3.8-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.7.tgz (0.3.7) index=0.3.7-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.6.tgz (0.3.6) index=0.3.6-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.5.tgz (0.3.5) index=0.3.5-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.4.tgz (0.3.4) index=0.3.4-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.3.tgz (0.3.3) index=0.3.3-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.2.tgz (0.3.2) index=0.3.2-0 matched with the download version
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.1.tgz (0.3.1) index=0.3.1-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.0.tgz (0.3.0) index=0.3.0-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.2.0.tgz (0.2.0) index=0.2.0-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.8.tgz (0.1.8) index=0.1.8-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.7.tgz (0.1.7) index=0.1.7-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.6.tgz (0.1.6) index=0.1.6-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.5.tgz (0.1.5) index=0.1.5-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.4.tgz (0.1.4) index=0.1.4-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.3.tgz (0.1.3) index=0.1.3-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.2.tgz (0.1.2) index=0.1.2-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.1.tgz (0.1.1) index=0.1.1-0 
   https://registry.npmjs.org/aasvg/-/aasvg-0.1.0.tgz (0.1.0) index=0.1.0-0 
uscan info: uscan parser results:
    $base               = https://registry.npmjs.org/aasvg
    $filepattern        = https://registry.npmjs.org/aasvg/-/aasvg-(?:[-_]?[Vv]?(\d[\-+\.:\~\da-zA-Z]*))(?i)(?:\.(?:tar\.xz|tar\.bz2|tar\.gz|tar\.zstd?|zip|tgz|tbz|txz))
    $newfile            = https://registry.npmjs.org/aasvg/-/aasvg-0.3.2.tgz
    $mangled_newversion = 0.3.2
    $newversion         = 0.3.2
    $lastversion        = 0.3.2
uscan info: Matching target for downloadurlmangle: https://registry.npmjs.org/aasvg/-/aasvg-0.3.2.tgz
uscan info: Upstream URL(+tag) to download is identified as    https://registry.npmjs.org/aasvg/-/aasvg-0.3.2.tgz
uscan info: Filename (filenamemangled) for downloaded file: aasvg-0.3.2.tgz
Newest version of aasvg on remote site is 0.3.2, specified download version is 0.3.2
uscan info: Downloading upstream package: aasvg-0.3.2.tgz
uscan info: Requesting URL:
   https://registry.npmjs.org/aasvg/-/aasvg-0.3.2.tgz
uscan info: Successfully downloaded upstream package: aasvg-0.3.2.tgz
uscan info: Start checking for common possible upstream OpenPGP signature files
uscan info: End checking for common possible upstream OpenPGP signature files
uscan info: Missing OpenPGP signature.
uscan info: New orig.tar.* tarball version (oversionmangled): 0.3.2
uscan info: Launch mk-origtargz with options:
   --package aasvg --version 0.3.2 --compression default --directory /var/tmp/oc.2790owe5/uscan --copyright-file debian/copyright /var/tmp/oc.2790owe5/uscan/aasvg-0.3.2.tgz
Successfully symlinked /var/tmp/oc.2790owe5/uscan/aasvg-0.3.2.tgz to /var/tmp/oc.2790owe5/uscan/aasvg_0.3.2.orig.tar.gz.
uscan info: New orig.tar.* tarball version (after mk-origtargz): 0.3.2
uscan info: Scan finished

dehs: Show details

{
  "debian-mangled-uversion": "0.3.2",
  "debian-uversion": "0.3.2",
  "messages": "Successfully downloaded upstream package: aasvg-0.3.2.tgz",
  "package": "aasvg",
  "target": "aasvg_0.3.2.orig.tar.gz",
  "target-path": "/var/tmp/oc.2790owe5/uscan/aasvg_0.3.2.orig.tar.gz",
  "upstream-url": "https://registry.npmjs.org/aasvg/-/aasvg-0.3.2.tgz",
  "upstream-version": "0.3.2"
}

command: uscan -v --download-current-version --dehs --destdir=/var/tmp/oc.2790owe5/uscan
exit_code: 0

watch_file: Show details (5 lines)

version=4
opts="searchmode=plain" \
  https://registry.npmjs.org/aasvg \
  https://registry.npmjs.org/aasvg/-/aasvg-@ANY_VERSION@@ARCHIVE_EXT@

upstream_url: https://registry.npmjs.org/aasvg/-/aasvg-0.3.2.tgz
upstream_sha256: f8cc0e6ad81e7c4683157fcbe216691b4bf9ca4f6f6ad5caac6cc7f0da86e9e9
upstream_filename: aasvg-0.3.2.tgz

compare

tarballs:

name: aasvg_0.3.2.orig.tar.gz

diffoscope:

log: Show details (258 lines)

--- debian/aasvg_0.3.2.orig.tar.gz
+++ uscan/aasvg-0.3.2.tgz
├── filetype from file(1)
│ @@ -1 +1 @@
│ -gzip compressed data, from Unix
│ +gzip compressed data, max compression
│   --- aasvg_0.3.2.orig.tar
├── +++ aasvg-0.3.2.tgz-content
│ ├── file list
│ │ @@ -1,11 +1,5 @@
│ │ -drwxrwxr-x   0 root         (0) root         (0)        0 2022-10-24 01:05:32.000000 aasvg-0.3.2/
│ │ --rw-rw-r--   0 root         (0) root         (0)        9 2022-10-24 01:05:32.000000 aasvg-0.3.2/.gitignore
│ │ --rw-rw-r--   0 root         (0) root         (0)     1304 2022-10-24 01:05:32.000000 aasvg-0.3.2/LICENSE
│ │ --rw-rw-r--   0 root         (0) root         (0)     1868 2022-10-24 01:05:32.000000 aasvg-0.3.2/README.md
│ │ --rw-rw-r--   0 root         (0) root         (0)    14953 2022-10-24 01:05:32.000000 aasvg-0.3.2/example.svg
│ │ --rw-rw-r--   0 root         (0) root         (0)     2080 2022-10-24 01:05:32.000000 aasvg-0.3.2/example.txt
│ │ --rwxrwxr-x   0 root         (0) root         (0)     3303 2022-10-24 01:05:32.000000 aasvg-0.3.2/main.js
│ │ --rw-rw-r--   0 root         (0) root         (0)    64693 2022-10-24 01:05:32.000000 aasvg-0.3.2/markdeep-diagram.js
│ │ --rw-rw-r--   0 root         (0) root         (0)       68 2022-10-24 01:05:32.000000 aasvg-0.3.2/package-lock.json
│ │ --rw-rw-r--   0 root         (0) root         (0)      943 2022-10-24 01:05:32.000000 aasvg-0.3.2/package.json
│ │ --rwxrwxr-x   0 root         (0) root         (0)      327 2022-10-24 01:05:32.000000 aasvg-0.3.2/pre-commit
│ │ +-rw-r--r--   0        0        0     1304 1985-10-26 08:15:00.000000 package/LICENSE
│ │ +-rwxr-xr-x   0        0        0     3303 1985-10-26 08:15:00.000000 package/main.js
│ │ +-rw-r--r--   0        0        0    63480 1985-10-26 08:15:00.000000 package/markdeep-diagram.js
│ │ +-rw-r--r--   0        0        0      943 1985-10-26 08:15:00.000000 package/package.json
│ │ +-rw-r--r--   0        0        0     1868 1985-10-26 08:15:00.000000 package/README.md
│ │   --- aasvg-0.3.2/LICENSE
│ ├── +++ package/LICENSE
│ │┄ Files identical despite different names
│ │   --- aasvg-0.3.2/README.md
│ ├── +++ package/README.md
│ │┄ Files identical despite different names
│ │   --- aasvg-0.3.2/main.js
│ ├── +++ package/main.js
│ │┄ Files identical despite different names
│ │   --- aasvg-0.3.2/markdeep-diagram.js
│ ├── +++ package/markdeep-diagram.js
│ │┄ Files 99% similar despite different names
│ │ ├── js-beautify {}
│ │ │ @@ -167,15 +167,15 @@
│ │ │      var DIAGONAL_ANGLE = Math.atan(1.0 / ASPECT) * 180 / Math.PI;
│ │ │  
│ │ │      var EPSILON = 1e-6;
│ │ │  
│ │ │      // The order of the following is based on rotation angles
│ │ │      // and is used for ArrowSet.toSVG
│ │ │      var ARROW_HEAD_CHARACTERS = '>v<^';
│ │ │ -    var POINT_CHARACTERS = 'o*◌○◍●⊕';
│ │ │ +    var POINT_CHARACTERS = 'o*◌○◍●';
│ │ │      var JUMP_CHARACTERS = '()';
│ │ │      var UNDIRECTED_VERTEX_CHARACTERS = "+";
│ │ │      var VERTEX_CHARACTERS = UNDIRECTED_VERTEX_CHARACTERS + ".',`";
│ │ │  
│ │ │      // GRAY[i] is the Unicode block character for (i+1)/4 level gray
│ │ │      var GRAY_CHARACTERS = '\u2591\u2592\u2593\u2588';
│ │ │  
│ │ │ @@ -857,14 +857,15 @@
│ │ │              C: Vec2(x, y),
│ │ │              type: type,
│ │ │              angle: angle || 0
│ │ │          };
│ │ │  
│ │ │          // Put arrows at the front and points at the back so that
│ │ │          // arrows always draw under points
│ │ │ +
│ │ │          if (isPoint(type)) {
│ │ │              this._decorationArray.push(d);
│ │ │          } else {
│ │ │              this._decorationArray.unshift(d);
│ │ │          }
│ │ │      };
│ │ │  
│ │ │ @@ -888,47 +889,32 @@
│ │ │              } else if (isPoint(decoration.type)) {
│ │ │                  const CLASSES = {
│ │ │                      '*': 'closed',
│ │ │                      'o': 'open',
│ │ │                      '◌': 'dotted',
│ │ │                      '○': 'open',
│ │ │                      '◍': 'shaded',
│ │ │ -                    '●': 'closed',
│ │ │ -                    '⊕': 'xor'
│ │ │ +                    '●': 'closed'
│ │ │                  };
│ │ │                  const FILL = {
│ │ │                      'closed': 'black',
│ │ │                      'open': 'white',
│ │ │                      'dotted': 'white',
│ │ │ -                    'shaded': '#666',
│ │ │ -                    'xor': 'white'
│ │ │ +                    'shaded': '#666'
│ │ │                  };
│ │ │                  const STROKE = {
│ │ │                      'closed': '',
│ │ │                      'open': ' stroke="black"',
│ │ │                      'dotted': ' stroke="black" stroke-dasharray="1,1"',
│ │ │ -                    'shaded': ' stroke="black"',
│ │ │ -                    'xor': ' stroke="black"',
│ │ │ +                    'shaded': ' stroke="black"'
│ │ │                  };
│ │ │                  var cls = CLASSES[decoration.type];
│ │ │                  svg += '<circle cx="' + ((C.x + 1) * SCALE) + '" cy="' + ((C.y + 1) * SCALE * ASPECT) +
│ │ │                      '" r="' + (SCALE - STROKE_WIDTH) + '" class="' + cls + 'dot"' +
│ │ │                      ' fill="' + FILL[cls] + '"' + STROKE[cls] + '/>\n';
│ │ │ -                if (decoration.type === '⊕') {
│ │ │ -                    svg += '<line x1="' + ((C.x) * SCALE + STROKE_WIDTH) +
│ │ │ -                        '" y1="' + ((C.y + 1) * SCALE * ASPECT) +
│ │ │ -                        '" x2="' + ((C.x + 2) * SCALE - STROKE_WIDTH) +
│ │ │ -                        '" y2="' + ((C.y + 1) * SCALE * ASPECT) +
│ │ │ -                        '" stroke="black"/>';
│ │ │ -                    svg += '<line x1="' + ((C.x + 1) * SCALE) +
│ │ │ -                        '" y1="' + ((C.y + 1) * SCALE * ASPECT - SCALE + STROKE_WIDTH) +
│ │ │ -                        '" x2="' + ((C.x + 1) * SCALE) +
│ │ │ -                        '" y2="' + ((C.y + 1) * SCALE * ASPECT + SCALE - STROKE_WIDTH) +
│ │ │ -                        '" stroke="black"/>';
│ │ │ -                }
│ │ │              } else if (isGray(decoration.type)) {
│ │ │                  var shade = Math.round((3 - GRAY_CHARACTERS.indexOf(decoration.type)) * 63.75);
│ │ │                  svg += '<rect class="gray" x="' + ((C.x + 0.5) * SCALE) + '" y="' + ((C.y + 0.5) * SCALE * ASPECT) +
│ │ │                      '" width="' + SCALE + '" height="' + (SCALE * ASPECT) +
│ │ │                      '" fill="rgb(' + shade + ',' + shade + ',' + shade + ')"/>\n';
│ │ │              } else if (isTri(decoration.type)) {
│ │ │                  // 30-60-90 triangle
│ │ │ @@ -1058,15 +1044,15 @@
│ │ │  
│ │ │              } // y
│ │ │          } // x
│ │ │  
│ │ │  
│ │ │          // Find all solid horizontal lines
│ │ │          for (var y = 0; y < grid.height; ++y) {
│ │ │ -            for (var x = 0; x < grid.width; ++x) {
│ │ │ +            for (var x = 0; x < grid.width;) {
│ │ │                  function hline(p, boxl, boxr, style) {
│ │ │                      if (grid[p](x, y)) {
│ │ │                          // Begins a line...find the end
│ │ │                          var A = Vec2(x, y);
│ │ │                          do {
│ │ │                              grid.setUsed(x, y);
│ │ │                              ++x;
│ │ │ @@ -1101,16 +1087,18 @@
│ │ │                          }
│ │ │  
│ │ │                          // Continue the search from the end x+1
│ │ │                      }
│ │ │                      return false;
│ │ │                  }
│ │ │  
│ │ │ -                hline("isSolidHLineAt", '\u2523', '\u252b', null) ||
│ │ │ -                    hline("isDoubleHLineAt", '\u255E', '\u2561', "double");
│ │ │ +                if (!hline("isSolidHLineAt", '\u2523', '\u252b', null) &&
│ │ │ +                    !hline("isDoubleHLineAt", '\u255E', '\u2561', "double")) {
│ │ │ +                    ++x;
│ │ │ +                }
│ │ │              }
│ │ │          } // y
│ │ │  
│ │ │          // Find all solid left-to-right downward diagonal lines (BACK DIAGONAL)
│ │ │          for (var i = -grid.height; i < grid.width; ++i) {
│ │ │              for (var x = i, y = 0; y < grid.height; ++y, ++x) {
│ │ │                  if (grid.isSolidBLineAt(x, y)) {
│ │ │ @@ -1473,14 +1461,16 @@
│ │ │                      }
│ │ │  
│ │ │                  } else if (isPoint(c)) {
│ │ │                      var up = grid(x, y - 1);
│ │ │                      var dn = grid(x, y + 1);
│ │ │                      var lt = grid(x - 1, y);
│ │ │                      var rt = grid(x + 1, y);
│ │ │ +                    var llt = grid(x - 2, y);
│ │ │ +                    var rrt = grid(x + 2, y);
│ │ │  
│ │ │                      if (pathSet.rightEndsAt(x - 1, y) || // Must be at the end of a line...
│ │ │                          pathSet.leftEndsAt(x + 1, y) || // or completely isolated NSEW
│ │ │                          pathSet.downEndsAt(x, y - 1) ||
│ │ │                          pathSet.upEndsAt(x, y + 1) ||
│ │ │  
│ │ │                          pathSet.upEndsAt(x, y) || // For points on vertical lines
│ │ │ @@ -1498,33 +1488,30 @@
│ │ │                      decorationSet.insert(x, y, c);
│ │ │                      grid.setUsed(x, y);
│ │ │                  } else { // Arrow heads
│ │ │  
│ │ │                      // If we find one, ensure that it is really an
│ │ │                      // arrow head and not a stray character by looking
│ │ │                      // for a connecting line.
│ │ │ -                    const BACKOFF_X = 0.5;
│ │ │ -                    const BACKOFF_Y = 0.5 / ASPECT;
│ │ │                      var dx = 0;
│ │ │ -                    var dy = 0;
│ │ │                      if ((c === '>') && (pathSet.rightEndsAt(x, y) ||
│ │ │                              pathSet.horizontalPassesThrough(x, y))) {
│ │ │                          if (isPoint(grid(x + 1, y))) {
│ │ │                              // Back up if connecting to a point so as to not
│ │ │                              // overlap it
│ │ │ -                            dx = -BACKOFF_X;
│ │ │ +                            dx = -0.5;
│ │ │                          }
│ │ │                          decorationSet.insert(x + dx, y, '>', 0);
│ │ │                          grid.setUsed(x, y);
│ │ │                      } else if ((c === '<') && (pathSet.leftEndsAt(x, y) ||
│ │ │                              pathSet.horizontalPassesThrough(x, y))) {
│ │ │                          if (isPoint(grid(x - 1, y))) {
│ │ │                              // Back up if connecting to a point so as to not
│ │ │                              // overlap it
│ │ │ -                            dx = BACKOFF_X;
│ │ │ +                            dx = 0.5;
│ │ │                          }
│ │ │                          decorationSet.insert(x + dx, y, '>', 180);
│ │ │                          grid.setUsed(x, y);
│ │ │                      } else if (c === '^') {
│ │ │                          // Because of the aspect ratio, we need to look
│ │ │                          // in two slots for the end of the previous line
│ │ │                          if (pathSet.upEndsAt(x, y - 0.5)) {
│ │ │ @@ -1549,18 +1536,15 @@
│ │ │                              decorationSet.insert(x - 0.5, y - 0.5, c, 270 - DIAGONAL_ANGLE);
│ │ │                              grid.setUsed(x, y);
│ │ │                          } else if (pathSet.backDiagonalUpEndsAt(x - 0.25, y - 0.25)) {
│ │ │                              decorationSet.insert(x - 0.25, y - 0.25, c, 270 - DIAGONAL_ANGLE);
│ │ │                              grid.setUsed(x, y);
│ │ │                          } else if (pathSet.verticalPassesThrough(x, y)) {
│ │ │                              // Only try this if all others failed
│ │ │ -                            if (isPoint(grid(x, y - 1))) {
│ │ │ -                                dy = BACKOFF_Y; // Back up if connecting to a point
│ │ │ -                            }
│ │ │ -                            decorationSet.insert(x, y - 0.5 + dy, '>', 270);
│ │ │ +                            decorationSet.insert(x, y - 0.5, '>', 270);
│ │ │                              grid.setUsed(x, y);
│ │ │                          }
│ │ │                      } else if (c === 'v' || c === 'V') {
│ │ │                          if (pathSet.downEndsAt(x, y + 0.5)) {
│ │ │                              decorationSet.insert(x, y + 0.5, '>', 90);
│ │ │                              grid.setUsed(x, y);
│ │ │                          } else if (pathSet.downEndsAt(x, y)) {
│ │ │ @@ -1582,18 +1566,15 @@
│ │ │                              decorationSet.insert(x + 0.5, y + 0.5, '>', 90 - DIAGONAL_ANGLE);
│ │ │                              grid.setUsed(x, y);
│ │ │                          } else if (pathSet.backDiagonalDownEndsAt(x + 0.25, y + 0.25)) {
│ │ │                              decorationSet.insert(x + 0.25, y + 0.25, '>', 90 - DIAGONAL_ANGLE);
│ │ │                              grid.setUsed(x, y);
│ │ │                          } else if (pathSet.verticalPassesThrough(x, y)) {
│ │ │                              // Only try this if all others failed
│ │ │ -                            if (isPoint(grid(x, y + 1))) {
│ │ │ -                                dy = -BACKOFF_Y; // Back up if connecting to a point
│ │ │ -                            }
│ │ │ -                            decorationSet.insert(x, y + 0.5 + dy, '>', 90);
│ │ │ +                            decorationSet.insert(x, y + 0.5, '>', 90);
│ │ │                              grid.setUsed(x, y);
│ │ │                          }
│ │ │                      } // arrow heads
│ │ │                  } // decoration type
│ │ │              } // y
│ │ │          } // x
│ │ │      } // findArrowHeads
│ │   --- aasvg-0.3.2/package.json
│ ├── +++ package/package.json
│ │┄ Files identical despite different names

command: diffoscope debian/aasvg_0.3.2.orig.tar.gz uscan/aasvg-0.3.2.tgz
success: True
exit_code: 1

normalized:

diffoscope:

log: Show details (233 lines)

--- debian/normalized/aasvg_0.3.2.orig.tar
+++ uscan/normalized/aasvg-0.3.2.tgz
├── file list
│ @@ -1,10 +1,5 @@
│ --rw-------   0 root         (0) root         (0)        9 1970-01-01 00:00:00.000000 .gitignore
│  -rw-------   0 root         (0) root         (0)     1304 1970-01-01 00:00:00.000000 LICENSE
│  -rw-------   0 root         (0) root         (0)     1868 1970-01-01 00:00:00.000000 README.md
│ --rw-------   0 root         (0) root         (0)    14953 1970-01-01 00:00:00.000000 example.svg
│ --rw-------   0 root         (0) root         (0)     2080 1970-01-01 00:00:00.000000 example.txt
│  -rwx------   0 root         (0) root         (0)     3303 1970-01-01 00:00:00.000000 main.js
│ --rw-------   0 root         (0) root         (0)    64693 1970-01-01 00:00:00.000000 markdeep-diagram.js
│ --rw-------   0 root         (0) root         (0)       68 1970-01-01 00:00:00.000000 package-lock.json
│ +-rw-------   0 root         (0) root         (0)    63480 1970-01-01 00:00:00.000000 markdeep-diagram.js
│  -rw-------   0 root         (0) root         (0)      943 1970-01-01 00:00:00.000000 package.json
│ --rwx------   0 root         (0) root         (0)      327 1970-01-01 00:00:00.000000 pre-commit
├── markdeep-diagram.js
│ ├── js-beautify {}
│ │ @@ -167,15 +167,15 @@
│ │      var DIAGONAL_ANGLE = Math.atan(1.0 / ASPECT) * 180 / Math.PI;
│ │  
│ │      var EPSILON = 1e-6;
│ │  
│ │      // The order of the following is based on rotation angles
│ │      // and is used for ArrowSet.toSVG
│ │      var ARROW_HEAD_CHARACTERS = '>v<^';
│ │ -    var POINT_CHARACTERS = 'o*◌○◍●⊕';
│ │ +    var POINT_CHARACTERS = 'o*◌○◍●';
│ │      var JUMP_CHARACTERS = '()';
│ │      var UNDIRECTED_VERTEX_CHARACTERS = "+";
│ │      var VERTEX_CHARACTERS = UNDIRECTED_VERTEX_CHARACTERS + ".',`";
│ │  
│ │      // GRAY[i] is the Unicode block character for (i+1)/4 level gray
│ │      var GRAY_CHARACTERS = '\u2591\u2592\u2593\u2588';
│ │  
│ │ @@ -857,14 +857,15 @@
│ │              C: Vec2(x, y),
│ │              type: type,
│ │              angle: angle || 0
│ │          };
│ │  
│ │          // Put arrows at the front and points at the back so that
│ │          // arrows always draw under points
│ │ +
│ │          if (isPoint(type)) {
│ │              this._decorationArray.push(d);
│ │          } else {
│ │              this._decorationArray.unshift(d);
│ │          }
│ │      };
│ │  
│ │ @@ -888,47 +889,32 @@
│ │              } else if (isPoint(decoration.type)) {
│ │                  const CLASSES = {
│ │                      '*': 'closed',
│ │                      'o': 'open',
│ │                      '◌': 'dotted',
│ │                      '○': 'open',
│ │                      '◍': 'shaded',
│ │ -                    '●': 'closed',
│ │ -                    '⊕': 'xor'
│ │ +                    '●': 'closed'
│ │                  };
│ │                  const FILL = {
│ │                      'closed': 'black',
│ │                      'open': 'white',
│ │                      'dotted': 'white',
│ │ -                    'shaded': '#666',
│ │ -                    'xor': 'white'
│ │ +                    'shaded': '#666'
│ │                  };
│ │                  const STROKE = {
│ │                      'closed': '',
│ │                      'open': ' stroke="black"',
│ │                      'dotted': ' stroke="black" stroke-dasharray="1,1"',
│ │ -                    'shaded': ' stroke="black"',
│ │ -                    'xor': ' stroke="black"',
│ │ +                    'shaded': ' stroke="black"'
│ │                  };
│ │                  var cls = CLASSES[decoration.type];
│ │                  svg += '<circle cx="' + ((C.x + 1) * SCALE) + '" cy="' + ((C.y + 1) * SCALE * ASPECT) +
│ │                      '" r="' + (SCALE - STROKE_WIDTH) + '" class="' + cls + 'dot"' +
│ │                      ' fill="' + FILL[cls] + '"' + STROKE[cls] + '/>\n';
│ │ -                if (decoration.type === '⊕') {
│ │ -                    svg += '<line x1="' + ((C.x) * SCALE + STROKE_WIDTH) +
│ │ -                        '" y1="' + ((C.y + 1) * SCALE * ASPECT) +
│ │ -                        '" x2="' + ((C.x + 2) * SCALE - STROKE_WIDTH) +
│ │ -                        '" y2="' + ((C.y + 1) * SCALE * ASPECT) +
│ │ -                        '" stroke="black"/>';
│ │ -                    svg += '<line x1="' + ((C.x + 1) * SCALE) +
│ │ -                        '" y1="' + ((C.y + 1) * SCALE * ASPECT - SCALE + STROKE_WIDTH) +
│ │ -                        '" x2="' + ((C.x + 1) * SCALE) +
│ │ -                        '" y2="' + ((C.y + 1) * SCALE * ASPECT + SCALE - STROKE_WIDTH) +
│ │ -                        '" stroke="black"/>';
│ │ -                }
│ │              } else if (isGray(decoration.type)) {
│ │                  var shade = Math.round((3 - GRAY_CHARACTERS.indexOf(decoration.type)) * 63.75);
│ │                  svg += '<rect class="gray" x="' + ((C.x + 0.5) * SCALE) + '" y="' + ((C.y + 0.5) * SCALE * ASPECT) +
│ │                      '" width="' + SCALE + '" height="' + (SCALE * ASPECT) +
│ │                      '" fill="rgb(' + shade + ',' + shade + ',' + shade + ')"/>\n';
│ │              } else if (isTri(decoration.type)) {
│ │                  // 30-60-90 triangle
│ │ @@ -1058,15 +1044,15 @@
│ │  
│ │              } // y
│ │          } // x
│ │  
│ │  
│ │          // Find all solid horizontal lines
│ │          for (var y = 0; y < grid.height; ++y) {
│ │ -            for (var x = 0; x < grid.width; ++x) {
│ │ +            for (var x = 0; x < grid.width;) {
│ │                  function hline(p, boxl, boxr, style) {
│ │                      if (grid[p](x, y)) {
│ │                          // Begins a line...find the end
│ │                          var A = Vec2(x, y);
│ │                          do {
│ │                              grid.setUsed(x, y);
│ │                              ++x;
│ │ @@ -1101,16 +1087,18 @@
│ │                          }
│ │  
│ │                          // Continue the search from the end x+1
│ │                      }
│ │                      return false;
│ │                  }
│ │  
│ │ -                hline("isSolidHLineAt", '\u2523', '\u252b', null) ||
│ │ -                    hline("isDoubleHLineAt", '\u255E', '\u2561', "double");
│ │ +                if (!hline("isSolidHLineAt", '\u2523', '\u252b', null) &&
│ │ +                    !hline("isDoubleHLineAt", '\u255E', '\u2561', "double")) {
│ │ +                    ++x;
│ │ +                }
│ │              }
│ │          } // y
│ │  
│ │          // Find all solid left-to-right downward diagonal lines (BACK DIAGONAL)
│ │          for (var i = -grid.height; i < grid.width; ++i) {
│ │              for (var x = i, y = 0; y < grid.height; ++y, ++x) {
│ │                  if (grid.isSolidBLineAt(x, y)) {
│ │ @@ -1473,14 +1461,16 @@
│ │                      }
│ │  
│ │                  } else if (isPoint(c)) {
│ │                      var up = grid(x, y - 1);
│ │                      var dn = grid(x, y + 1);
│ │                      var lt = grid(x - 1, y);
│ │                      var rt = grid(x + 1, y);
│ │ +                    var llt = grid(x - 2, y);
│ │ +                    var rrt = grid(x + 2, y);
│ │  
│ │                      if (pathSet.rightEndsAt(x - 1, y) || // Must be at the end of a line...
│ │                          pathSet.leftEndsAt(x + 1, y) || // or completely isolated NSEW
│ │                          pathSet.downEndsAt(x, y - 1) ||
│ │                          pathSet.upEndsAt(x, y + 1) ||
│ │  
│ │                          pathSet.upEndsAt(x, y) || // For points on vertical lines
│ │ @@ -1498,33 +1488,30 @@
│ │                      decorationSet.insert(x, y, c);
│ │                      grid.setUsed(x, y);
│ │                  } else { // Arrow heads
│ │  
│ │                      // If we find one, ensure that it is really an
│ │                      // arrow head and not a stray character by looking
│ │                      // for a connecting line.
│ │ -                    const BACKOFF_X = 0.5;
│ │ -                    const BACKOFF_Y = 0.5 / ASPECT;
│ │                      var dx = 0;
│ │ -                    var dy = 0;
│ │                      if ((c === '>') && (pathSet.rightEndsAt(x, y) ||
│ │                              pathSet.horizontalPassesThrough(x, y))) {
│ │                          if (isPoint(grid(x + 1, y))) {
│ │                              // Back up if connecting to a point so as to not
│ │                              // overlap it
│ │ -                            dx = -BACKOFF_X;
│ │ +                            dx = -0.5;
│ │                          }
│ │                          decorationSet.insert(x + dx, y, '>', 0);
│ │                          grid.setUsed(x, y);
│ │                      } else if ((c === '<') && (pathSet.leftEndsAt(x, y) ||
│ │                              pathSet.horizontalPassesThrough(x, y))) {
│ │                          if (isPoint(grid(x - 1, y))) {
│ │                              // Back up if connecting to a point so as to not
│ │                              // overlap it
│ │ -                            dx = BACKOFF_X;
│ │ +                            dx = 0.5;
│ │                          }
│ │                          decorationSet.insert(x + dx, y, '>', 180);
│ │                          grid.setUsed(x, y);
│ │                      } else if (c === '^') {
│ │                          // Because of the aspect ratio, we need to look
│ │                          // in two slots for the end of the previous line
│ │                          if (pathSet.upEndsAt(x, y - 0.5)) {
│ │ @@ -1549,18 +1536,15 @@
│ │                              decorationSet.insert(x - 0.5, y - 0.5, c, 270 - DIAGONAL_ANGLE);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.backDiagonalUpEndsAt(x - 0.25, y - 0.25)) {
│ │                              decorationSet.insert(x - 0.25, y - 0.25, c, 270 - DIAGONAL_ANGLE);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.verticalPassesThrough(x, y)) {
│ │                              // Only try this if all others failed
│ │ -                            if (isPoint(grid(x, y - 1))) {
│ │ -                                dy = BACKOFF_Y; // Back up if connecting to a point
│ │ -                            }
│ │ -                            decorationSet.insert(x, y - 0.5 + dy, '>', 270);
│ │ +                            decorationSet.insert(x, y - 0.5, '>', 270);
│ │                              grid.setUsed(x, y);
│ │                          }
│ │                      } else if (c === 'v' || c === 'V') {
│ │                          if (pathSet.downEndsAt(x, y + 0.5)) {
│ │                              decorationSet.insert(x, y + 0.5, '>', 90);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.downEndsAt(x, y)) {
│ │ @@ -1582,18 +1566,15 @@
│ │                              decorationSet.insert(x + 0.5, y + 0.5, '>', 90 - DIAGONAL_ANGLE);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.backDiagonalDownEndsAt(x + 0.25, y + 0.25)) {
│ │                              decorationSet.insert(x + 0.25, y + 0.25, '>', 90 - DIAGONAL_ANGLE);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.verticalPassesThrough(x, y)) {
│ │                              // Only try this if all others failed
│ │ -                            if (isPoint(grid(x, y + 1))) {
│ │ -                                dy = -BACKOFF_Y; // Back up if connecting to a point
│ │ -                            }
│ │ -                            decorationSet.insert(x, y + 0.5 + dy, '>', 90);
│ │ +                            decorationSet.insert(x, y + 0.5, '>', 90);
│ │                              grid.setUsed(x, y);
│ │                          }
│ │                      } // arrow heads
│ │                  } // decoration type
│ │              } // y
│ │          } // x
│ │      } // findArrowHeads

command: diffoscope debian/normalized/aasvg_0.3.2.orig.tar uscan/normalized/aasvg-0.3.2.tgz
success: True
exit_code: 1

diffoscope_no_metadata:

log: Show details (232 lines)

--- debian/normalized/aasvg_0.3.2.orig.tar
+++ uscan/normalized/aasvg-0.3.2.tgz
├── file list
│ @@ -1,10 +1,5 @@
│ -.gitignore
│  LICENSE
│  README.md
│ -example.svg
│ -example.txt
│  main.js
│  markdeep-diagram.js
│ -package-lock.json
│  package.json
│ -pre-commit
├── markdeep-diagram.js
│ ├── js-beautify {}
│ │ @@ -167,15 +167,15 @@
│ │      var DIAGONAL_ANGLE = Math.atan(1.0 / ASPECT) * 180 / Math.PI;
│ │  
│ │      var EPSILON = 1e-6;
│ │  
│ │      // The order of the following is based on rotation angles
│ │      // and is used for ArrowSet.toSVG
│ │      var ARROW_HEAD_CHARACTERS = '>v<^';
│ │ -    var POINT_CHARACTERS = 'o*◌○◍●⊕';
│ │ +    var POINT_CHARACTERS = 'o*◌○◍●';
│ │      var JUMP_CHARACTERS = '()';
│ │      var UNDIRECTED_VERTEX_CHARACTERS = "+";
│ │      var VERTEX_CHARACTERS = UNDIRECTED_VERTEX_CHARACTERS + ".',`";
│ │  
│ │      // GRAY[i] is the Unicode block character for (i+1)/4 level gray
│ │      var GRAY_CHARACTERS = '\u2591\u2592\u2593\u2588';
│ │  
│ │ @@ -857,14 +857,15 @@
│ │              C: Vec2(x, y),
│ │              type: type,
│ │              angle: angle || 0
│ │          };
│ │  
│ │          // Put arrows at the front and points at the back so that
│ │          // arrows always draw under points
│ │ +
│ │          if (isPoint(type)) {
│ │              this._decorationArray.push(d);
│ │          } else {
│ │              this._decorationArray.unshift(d);
│ │          }
│ │      };
│ │  
│ │ @@ -888,47 +889,32 @@
│ │              } else if (isPoint(decoration.type)) {
│ │                  const CLASSES = {
│ │                      '*': 'closed',
│ │                      'o': 'open',
│ │                      '◌': 'dotted',
│ │                      '○': 'open',
│ │                      '◍': 'shaded',
│ │ -                    '●': 'closed',
│ │ -                    '⊕': 'xor'
│ │ +                    '●': 'closed'
│ │                  };
│ │                  const FILL = {
│ │                      'closed': 'black',
│ │                      'open': 'white',
│ │                      'dotted': 'white',
│ │ -                    'shaded': '#666',
│ │ -                    'xor': 'white'
│ │ +                    'shaded': '#666'
│ │                  };
│ │                  const STROKE = {
│ │                      'closed': '',
│ │                      'open': ' stroke="black"',
│ │                      'dotted': ' stroke="black" stroke-dasharray="1,1"',
│ │ -                    'shaded': ' stroke="black"',
│ │ -                    'xor': ' stroke="black"',
│ │ +                    'shaded': ' stroke="black"'
│ │                  };
│ │                  var cls = CLASSES[decoration.type];
│ │                  svg += '<circle cx="' + ((C.x + 1) * SCALE) + '" cy="' + ((C.y + 1) * SCALE * ASPECT) +
│ │                      '" r="' + (SCALE - STROKE_WIDTH) + '" class="' + cls + 'dot"' +
│ │                      ' fill="' + FILL[cls] + '"' + STROKE[cls] + '/>\n';
│ │ -                if (decoration.type === '⊕') {
│ │ -                    svg += '<line x1="' + ((C.x) * SCALE + STROKE_WIDTH) +
│ │ -                        '" y1="' + ((C.y + 1) * SCALE * ASPECT) +
│ │ -                        '" x2="' + ((C.x + 2) * SCALE - STROKE_WIDTH) +
│ │ -                        '" y2="' + ((C.y + 1) * SCALE * ASPECT) +
│ │ -                        '" stroke="black"/>';
│ │ -                    svg += '<line x1="' + ((C.x + 1) * SCALE) +
│ │ -                        '" y1="' + ((C.y + 1) * SCALE * ASPECT - SCALE + STROKE_WIDTH) +
│ │ -                        '" x2="' + ((C.x + 1) * SCALE) +
│ │ -                        '" y2="' + ((C.y + 1) * SCALE * ASPECT + SCALE - STROKE_WIDTH) +
│ │ -                        '" stroke="black"/>';
│ │ -                }
│ │              } else if (isGray(decoration.type)) {
│ │                  var shade = Math.round((3 - GRAY_CHARACTERS.indexOf(decoration.type)) * 63.75);
│ │                  svg += '<rect class="gray" x="' + ((C.x + 0.5) * SCALE) + '" y="' + ((C.y + 0.5) * SCALE * ASPECT) +
│ │                      '" width="' + SCALE + '" height="' + (SCALE * ASPECT) +
│ │                      '" fill="rgb(' + shade + ',' + shade + ',' + shade + ')"/>\n';
│ │              } else if (isTri(decoration.type)) {
│ │                  // 30-60-90 triangle
│ │ @@ -1058,15 +1044,15 @@
│ │  
│ │              } // y
│ │          } // x
│ │  
│ │  
│ │          // Find all solid horizontal lines
│ │          for (var y = 0; y < grid.height; ++y) {
│ │ -            for (var x = 0; x < grid.width; ++x) {
│ │ +            for (var x = 0; x < grid.width;) {
│ │                  function hline(p, boxl, boxr, style) {
│ │                      if (grid[p](x, y)) {
│ │                          // Begins a line...find the end
│ │                          var A = Vec2(x, y);
│ │                          do {
│ │                              grid.setUsed(x, y);
│ │                              ++x;
│ │ @@ -1101,16 +1087,18 @@
│ │                          }
│ │  
│ │                          // Continue the search from the end x+1
│ │                      }
│ │                      return false;
│ │                  }
│ │  
│ │ -                hline("isSolidHLineAt", '\u2523', '\u252b', null) ||
│ │ -                    hline("isDoubleHLineAt", '\u255E', '\u2561', "double");
│ │ +                if (!hline("isSolidHLineAt", '\u2523', '\u252b', null) &&
│ │ +                    !hline("isDoubleHLineAt", '\u255E', '\u2561', "double")) {
│ │ +                    ++x;
│ │ +                }
│ │              }
│ │          } // y
│ │  
│ │          // Find all solid left-to-right downward diagonal lines (BACK DIAGONAL)
│ │          for (var i = -grid.height; i < grid.width; ++i) {
│ │              for (var x = i, y = 0; y < grid.height; ++y, ++x) {
│ │                  if (grid.isSolidBLineAt(x, y)) {
│ │ @@ -1473,14 +1461,16 @@
│ │                      }
│ │  
│ │                  } else if (isPoint(c)) {
│ │                      var up = grid(x, y - 1);
│ │                      var dn = grid(x, y + 1);
│ │                      var lt = grid(x - 1, y);
│ │                      var rt = grid(x + 1, y);
│ │ +                    var llt = grid(x - 2, y);
│ │ +                    var rrt = grid(x + 2, y);
│ │  
│ │                      if (pathSet.rightEndsAt(x - 1, y) || // Must be at the end of a line...
│ │                          pathSet.leftEndsAt(x + 1, y) || // or completely isolated NSEW
│ │                          pathSet.downEndsAt(x, y - 1) ||
│ │                          pathSet.upEndsAt(x, y + 1) ||
│ │  
│ │                          pathSet.upEndsAt(x, y) || // For points on vertical lines
│ │ @@ -1498,33 +1488,30 @@
│ │                      decorationSet.insert(x, y, c);
│ │                      grid.setUsed(x, y);
│ │                  } else { // Arrow heads
│ │  
│ │                      // If we find one, ensure that it is really an
│ │                      // arrow head and not a stray character by looking
│ │                      // for a connecting line.
│ │ -                    const BACKOFF_X = 0.5;
│ │ -                    const BACKOFF_Y = 0.5 / ASPECT;
│ │                      var dx = 0;
│ │ -                    var dy = 0;
│ │                      if ((c === '>') && (pathSet.rightEndsAt(x, y) ||
│ │                              pathSet.horizontalPassesThrough(x, y))) {
│ │                          if (isPoint(grid(x + 1, y))) {
│ │                              // Back up if connecting to a point so as to not
│ │                              // overlap it
│ │ -                            dx = -BACKOFF_X;
│ │ +                            dx = -0.5;
│ │                          }
│ │                          decorationSet.insert(x + dx, y, '>', 0);
│ │                          grid.setUsed(x, y);
│ │                      } else if ((c === '<') && (pathSet.leftEndsAt(x, y) ||
│ │                              pathSet.horizontalPassesThrough(x, y))) {
│ │                          if (isPoint(grid(x - 1, y))) {
│ │                              // Back up if connecting to a point so as to not
│ │                              // overlap it
│ │ -                            dx = BACKOFF_X;
│ │ +                            dx = 0.5;
│ │                          }
│ │                          decorationSet.insert(x + dx, y, '>', 180);
│ │                          grid.setUsed(x, y);
│ │                      } else if (c === '^') {
│ │                          // Because of the aspect ratio, we need to look
│ │                          // in two slots for the end of the previous line
│ │                          if (pathSet.upEndsAt(x, y - 0.5)) {
│ │ @@ -1549,18 +1536,15 @@
│ │                              decorationSet.insert(x - 0.5, y - 0.5, c, 270 - DIAGONAL_ANGLE);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.backDiagonalUpEndsAt(x - 0.25, y - 0.25)) {
│ │                              decorationSet.insert(x - 0.25, y - 0.25, c, 270 - DIAGONAL_ANGLE);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.verticalPassesThrough(x, y)) {
│ │                              // Only try this if all others failed
│ │ -                            if (isPoint(grid(x, y - 1))) {
│ │ -                                dy = BACKOFF_Y; // Back up if connecting to a point
│ │ -                            }
│ │ -                            decorationSet.insert(x, y - 0.5 + dy, '>', 270);
│ │ +                            decorationSet.insert(x, y - 0.5, '>', 270);
│ │                              grid.setUsed(x, y);
│ │                          }
│ │                      } else if (c === 'v' || c === 'V') {
│ │                          if (pathSet.downEndsAt(x, y + 0.5)) {
│ │                              decorationSet.insert(x, y + 0.5, '>', 90);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.downEndsAt(x, y)) {
│ │ @@ -1582,18 +1566,15 @@
│ │                              decorationSet.insert(x + 0.5, y + 0.5, '>', 90 - DIAGONAL_ANGLE);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.backDiagonalDownEndsAt(x + 0.25, y + 0.25)) {
│ │                              decorationSet.insert(x + 0.25, y + 0.25, '>', 90 - DIAGONAL_ANGLE);
│ │                              grid.setUsed(x, y);
│ │                          } else if (pathSet.verticalPassesThrough(x, y)) {
│ │                              // Only try this if all others failed
│ │ -                            if (isPoint(grid(x, y + 1))) {
│ │ -                                dy = -BACKOFF_Y; // Back up if connecting to a point
│ │ -                            }
│ │ -                            decorationSet.insert(x, y + 0.5 + dy, '>', 90);
│ │ +                            decorationSet.insert(x, y + 0.5, '>', 90);
│ │                              grid.setUsed(x, y);
│ │                          }
│ │                      } // arrow heads
│ │                  } // decoration type
│ │              } // y
│ │          } // x
│ │      } // findArrowHeads

command: diffoscope --exclude-directory-metadata=recursive debian/normalized/aasvg_0.3.2.orig.tar uscan/normalized/aasvg-0.3.2.tgz
success: True
exit_code: 1

normalization_successful: True

sha256_orig: b133731b3b27805c4cc7a485ff2c1c6a8f77698e2af485bee9e9d3e74413abc6
sha256_uscan: f8cc0e6ad81e7c4683157fcbe216691b4bf9ca4f6f6ad5caac6cc7f0da86e9e9
sha256_compare: False