bids-validator-deno 2.1.0__tar.gz → 2.2.0__tar.gz

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bids-validator-deno
-Version: 2.1.0
+Version: 2.2.0
 Summary: Typescript implementation of the BIDS validator
 Keywords: BIDS,BIDS validator
 Author: bids-standard developers

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@bids/validator",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "exports": {
     ".": "./src/bids-validator.ts",
     "./main": "./src/main.ts",
@@ -27,22 +27,24 @@
     ]
   },
   "imports": {
-    "@ajv": "npm:ajv@8.17.1",
+    "@ajv": "npm:ajv@^8.17.1",
     "@bids/schema": "jsr:@bids/schema@~1.1.0",
     "@cliffy/command": "jsr:@effigies/cliffy-command@1.0.0-dev.8",
     "@cliffy/table": "jsr:@effigies/cliffy-table@1.0.0-dev.5",
-    "@hed/validator": "npm:hed-validator@4.0.1",
-    "@ignore": "npm:ignore@7.0.3",
-    "@libs/xml": "jsr:@libs/xml@6.0.4",
-    "@mango/nifti": "npm:@bids/nifti-reader-js@0.6.9",
-    "@std/assert": "jsr:@std/assert@1.0.12",
-    "@std/fmt": "jsr:@std/fmt@1.0.6",
-    "@std/fs": "jsr:@std/fs@1.0.15",
-    "@std/io": "jsr:@std/io@0.225.2",
-    "@std/log": "jsr:@std/log@0.224.14",
-    "@std/path": "jsr:@std/path@1.0.8",
-    "@std/streams": "jsr:@std/streams@1.0.9",
-    "@std/yaml": "jsr:@std/yaml@^1.0.5"
+    "@hed/validator": "npm:hed-validator@~4.1.4",
+    "@ignore": "npm:ignore@^7.0.5",
+    "@libs/xml": "jsr:@libs/xml@^6.0.8",
+    "@mango/nifti": "npm:@bids/nifti-reader-js@^0.6.9",
+    "@std/assert": "jsr:@std/assert@^1.0.14",
+    "@std/fmt": "jsr:@std/fmt@^1.0.8",
+    "@std/fs": "jsr:@std/fs@^1.0.19",
+    "@std/io": "jsr:@std/io@^0.225.2",
+    "@std/log": "jsr:@std/log@^0.224.14",
+    "@std/path": "jsr:@std/path@^1.1.2",
+    "@std/streams": "jsr:@std/streams@^1.0.12",
+    "@std/yaml": "jsr:@std/yaml@^1.0.9",
+    "isomorphic-git": "npm:isomorphic-git@^1.27.1",
+    "hash-wasm": "npm:hash-wasm@^4.12.0"
   },
   "tasks": {
     "test": "deno test -A src/"
@@ -54,6 +56,9 @@
     "proseWrap": "preserve",
     "include": [
       "src/"
+    ],
+    "exclude": [
+      "src/tests/bom-utf8.json"
     ]
   }
 }

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/pyproject.toml

@@ -18,7 +18,7 @@ keywords = [
     "BIDS validator",
 ]
 dynamic = []
-version = "2.1.0"
+version = "2.2.0"
 
 [project.license]
 text = "MIT"

bids_validator_deno-2.2.0/src/files/access.test.ts

@@ -0,0 +1,40 @@
+import { assert, assertArrayIncludes, assertObjectMatch } from '@std/assert'
+import { basename, dirname } from '@std/path'
+import { BIDSFileDeno } from './deno.ts'
+
+export function testAsyncFileAccess(
+  name: string,
+  fn: (file: BIDSFileDeno, ...args: any[]) => Promise<any>,
+  ...args: any[]
+) {
+  Deno.test({
+    name,
+    ignore: Deno.build.os === 'windows',
+    async fn(t) {
+      await t.step('Dangling symlink', async () => {
+        const file = new BIDSFileDeno('tests/data', '/broken-symlink')
+        try {
+          await fn(file, ...args)
+          assert(false, 'Expected error')
+        } catch (e: any) {
+          assertObjectMatch(e, {
+            code: 'FILE_READ',
+            location: '/broken-symlink',
+          })
+          assertArrayIncludes(['NotFound', 'FilesystemLoop'], [e.subCode])
+        }
+      })
+      await t.step('Insufficient permissions', async () => {
+        const tmpfile = await Deno.makeTempFile()
+        await Deno.chmod(tmpfile, 0o000)
+        const file = new BIDSFileDeno('', tmpfile)
+        try {
+          await fn(file, ...args)
+          assert(false, 'Expected error')
+        } catch (e: any) {
+          assertObjectMatch(e, { code: 'FILE_READ', subCode: 'PermissionDenied' })
+        }
+      })
+    },
+  })
+}

bids_validator_deno-2.2.0/src/files/access.ts

@@ -0,0 +1,35 @@
+import { type BIDSFile } from '../types/filetree.ts'
+import { type Issue } from '../types/issues.ts'
+
+function IOErrorToIssue(err: { code: string; name: string }): Issue {
+  const subcode = err.name
+  let issueMessage: string | undefined = undefined
+  if (err.code === 'ENOENT' || err.code === 'ELOOP') {
+    issueMessage = 'Possible dangling symbolic link'
+  }
+  return { code: 'FILE_READ', subCode: err.name, issueMessage }
+}
+
+export async function openStream(
+  file: BIDSFile,
+): Promise<ReadableStream<Uint8Array<ArrayBuffer>>> {
+  return file.stream().catch((err: any) => {
+    throw { location: file.path, ...IOErrorToIssue(err) }
+  })
+}
+
+export async function readBytes(
+  file: BIDSFile,
+  size: number,
+  offset = 0,
+): Promise<Uint8Array<ArrayBuffer>> {
+  return file.readBytes(size, offset).catch((err: any) => {
+    throw { location: file.path, ...IOErrorToIssue(err) }
+  })
+}
+
+export async function readText(file: BIDSFile): Promise<string> {
+  return file.text().catch((err: any) => {
+    throw { location: file.path, ...IOErrorToIssue(err) }
+  })
+}

bids_validator_deno-2.2.0/src/files/browser.ts

@@ -0,0 +1,34 @@
+import { BIDSFile, FileTree } from '../types/filetree.ts'
+import { filesToTree } from './filetree.ts'
+import { FileIgnoreRules, readBidsIgnore } from './ignore.ts'
+import { BrowserFileOpener } from './openers.ts'
+
+/**
+ * Browser implement of BIDSFile wrapping native File/FileList types
+ */
+export class BIDSFileBrowser extends BIDSFile {
+  constructor(file: File, ignore: FileIgnoreRules, parent?: FileTree) {
+    const relativePath = file.webkitRelativePath
+    const prefixLength = relativePath.indexOf('/')
+    const opener = new BrowserFileOpener(file)
+    super(relativePath.substring(prefixLength), opener, ignore, parent)
+  }
+}
+
+/**
+ * Convert from FileList (created with webkitDirectory: true) to FileTree for validator use
+ */
+export async function fileListToTree(files: File[]): Promise<FileTree> {
+  const ignore = new FileIgnoreRules([])
+  const root = new FileTree('/', '/', undefined)
+  const tree = filesToTree(files.map((f) => new BIDSFileBrowser(f, ignore, root)), ignore)
+  const bidsignore = tree.get('.bidsignore')
+  if (bidsignore) {
+    try {
+      ignore.add(await readBidsIgnore(bidsignore as BIDSFile))
+    } catch (err) {
+      console.log(`Failed to read '.bidsignore' file with the following error:\n${err}`)
+    }
+  }
+  return tree
+}

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/deno.test.ts

@@ -31,7 +31,7 @@ Deno.test('Deno implementation of BIDSFile', async (t) => {
   })
   await t.step('can be read as ReadableStream', async () => {
     const file = new BIDSFileDeno(testDir, testFilename, ignore)
-    const stream = file.stream
+    const stream = await file.stream()
     const streamReader = stream.getReader()
     const denoReader = readerFromStreamReader(streamReader)
     const fileBuffer = await readAll(denoReader)

bids_validator_deno-2.2.0/src/files/deno.ts

@@ -0,0 +1,99 @@
+/**
+ * Deno specific implementation for reading files
+ */
+import { basename, join } from '@std/path'
+import * as posix from '@std/path/posix'
+import { BIDSFile, type FileOpener, FileTree } from '../types/filetree.ts'
+import { requestReadPermission } from '../setup/requestPermissions.ts'
+import { FileIgnoreRules, readBidsIgnore } from './ignore.ts'
+import { FsFileOpener, HTTPOpener } from './openers.ts'
+import { resolveAnnexedFile } from './repo.ts'
+import fs from 'node:fs'
+
+export class BIDSFileDeno extends BIDSFile {
+  constructor(datasetPath: string, path: string, ignore?: FileIgnoreRules, parent?: FileTree) {
+    super(path, new FsFileOpener(datasetPath, path), ignore, parent)
+  }
+}
+
+type ReadFileTreeOptions = {
+  rootPath: string
+  relativePath: string
+  ignore: FileIgnoreRules
+  prune: FileIgnoreRules
+  parent?: FileTree
+  preferredRemote?: string
+}
+
+async function _readFileTree({
+  rootPath,
+  relativePath,
+  ignore,
+  prune,
+  parent,
+  preferredRemote,
+}: ReadFileTreeOptions): Promise<FileTree> {
+  await requestReadPermission()
+  const name = basename(relativePath)
+  const tree = new FileTree(relativePath, name, parent, ignore)
+
+  // Opaque cache for passing to git operations
+  const cache = {}
+
+  for await (const dirEntry of Deno.readDir(join(rootPath, relativePath))) {
+    const thisPath = posix.join(relativePath, dirEntry.name)
+    if (prune.test(thisPath)) {
+      continue
+    }
+    if (dirEntry.isFile || dirEntry.isSymlink) {
+      let opener: FileOpener
+      const fullPath = join(rootPath, thisPath)
+      try {
+        const fileInfo = await Deno.stat(fullPath)
+        opener = new FsFileOpener(rootPath, thisPath, fileInfo)
+      } catch (error) {
+        try {
+          const { url, size } = await resolveAnnexedFile(fullPath, preferredRemote, { cache, fs })
+          opener = new HTTPOpener(url, size)
+        } catch (_) {
+          throw error
+        }
+      }
+      tree.files.push(new BIDSFile(thisPath, opener, ignore, tree))
+    }
+    if (dirEntry.isDirectory) {
+      const dirTree = await _readFileTree({
+        rootPath,
+        relativePath: thisPath,
+        ignore,
+        prune,
+        parent: tree,
+        preferredRemote,
+      })
+      tree.directories.push(dirTree)
+    }
+  }
+  return tree
+}
+
+/**
+ * Read in the target directory structure and return a FileTree
+ */
+export async function readFileTree(
+  rootPath: string,
+  prune?: FileIgnoreRules,
+  preferredRemote?: string,
+): Promise<FileTree> {
+  prune ??= new FileIgnoreRules([], false)
+  const ignore = new FileIgnoreRules([])
+  const tree = await _readFileTree({rootPath, relativePath: '/', ignore, prune, preferredRemote})
+  const bidsignore = tree.get('.bidsignore')
+  if (bidsignore) {
+    try {
+      ignore.add(await readBidsIgnore(bidsignore as BIDSFile))
+    } catch (err) {
+      console.log(`Failed to read '.bidsignore' file with the following error:\n${err}`)
+    }
+  }
+  return tree
+}

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/filetree.test.ts

@@ -1,7 +1,25 @@
 import { assert, assertEquals } from '@std/assert'
-import type { FileIgnoreRules } from './ignore.ts'
-import type { BIDSFile, FileTree } from '../types/filetree.ts'
-import { filesToTree, pathsToTree } from './filetree.ts'
+import { FileIgnoreRules } from './ignore.ts'
+import { BIDSFile, type FileOpener, type FileTree } from '../types/filetree.ts'
+import { filesToTree } from './filetree.ts'
+import { asyncStreamFromString } from '../tests/utils.ts'
+
+class NullFileOpener implements FileOpener {
+  size = 0
+  stream = () => asyncStreamFromString('')
+  text = () => Promise.resolve('')
+  readBytes = async (size: number, offset?: number) => new Uint8Array()
+}
+
+export function pathToFile(path: string, ignored: boolean = false): BIDSFile {
+  const name = path.split('/').pop() as string
+  return new BIDSFile(path, new NullFileOpener(), ignored)
+}
+
+export function pathsToTree(paths: string[], ignore?: string[]): FileTree {
+  const ignoreRules = new FileIgnoreRules(ignore ?? [])
+  return filesToTree(paths.map((path) => pathToFile(path, ignoreRules.test(path))))
+}
 
 Deno.test('FileTree generation', async (t) => {
   await t.step('converts a basic list', async () => {

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/filetree.ts

@@ -1,31 +1,8 @@
 import { parse, SEPARATOR_PATTERN } from '@std/path'
 import * as posix from '@std/path/posix'
-import { type BIDSFile, FileTree } from '../types/filetree.ts'
+import { BIDSFile, FileTree } from '../types/filetree.ts'
 import { FileIgnoreRules } from './ignore.ts'
 
-const nullFile = {
-  size: 0,
-  stream: new ReadableStream({
-    start(controller) {
-      controller.close()
-    },
-  }),
-  text: () => Promise.resolve(''),
-  readBytes: async (size: number, offset?: number) => new Uint8Array(),
-  parent: new FileTree('', '/'),
-  viewed: false,
-}
-
-export function pathToFile(path: string, ignored: boolean = false): BIDSFile {
-  const name = path.split('/').pop() as string
-  return { name, path, ignored, ...nullFile }
-}
-
-export function pathsToTree(paths: string[], ignore?: string[]): FileTree {
-  const ignoreRules = new FileIgnoreRules(ignore ?? [])
-  return filesToTree(paths.map((path) => pathToFile(path, ignoreRules.test(path))))
-}
-
 export function filesToTree(fileList: BIDSFile[], ignore?: FileIgnoreRules): FileTree {
   ignore = ignore ?? new FileIgnoreRules([])
   const tree: FileTree = new FileTree('/', '/')

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/gzip.test.ts

@@ -1,6 +1,7 @@
 import { assert, assertObjectMatch } from '@std/assert'
 import { parseGzip } from './gzip.ts'
 import { BIDSFileDeno } from './deno.ts'
+import { testAsyncFileAccess } from './access.test.ts'
 
 Deno.test('parseGzip', async (t) => {
   await t.step('parses anonymized file', async () => {
@@ -40,3 +41,5 @@ Deno.test('parseGzip', async (t) => {
     assert(!gzip)
   })
 })
+
+testAsyncFileAccess('Test file access errors for parseGzip', parseGzip)

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/gzip.ts

@@ -4,6 +4,7 @@
  */
 import type { Gzip } from '@bids/schema/context'
 import type { BIDSFile } from '../types/filetree.ts'
+import { readBytes } from './access.ts'
 
 /**
  * Parse a gzip header from a file
@@ -19,7 +20,7 @@ export async function parseGzip(
   file: BIDSFile,
   maxBytes: number = 512,
 ): Promise<Gzip | undefined> {
-  const buf = await file.readBytes(maxBytes)
+  const buf = await readBytes(file, maxBytes)
   const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
   if (view.byteLength < 2 || view.getUint16(0, false) !== 0x1f8b) return undefined
 

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/inheritance.test.ts

@@ -1,6 +1,6 @@
 import { assert, assertEquals, assertThrows } from '@std/assert'
 import type { BIDSFile } from '../types/filetree.ts'
-import { pathsToTree } from './filetree.ts'
+import { pathsToTree } from './filetree.test.ts'
 import { walkBack } from './inheritance.ts'
 
 Deno.test('walkback inheritance tests', async (t) => {
@@ -72,4 +72,22 @@ Deno.test('walkback inheritance tests', async (t) => {
       assertEquals(rootElectrodes.path, '/space-talairach_electrodes.tsv')
     },
   )
+  await t.step(
+    'The presence of target entities does not trigger exact match logic',
+    async () => {
+      const rootFileTree = pathsToTree([
+        '/sub-01/ieeg/sub-01_task-rest_ieeg.edf',
+        '/sub-01/ieeg/sub-01_task-rest_space-anat_electrodes.tsv',
+        '/sub-01/ieeg/sub-01_task-rest_space-MNI_electrodes.tsv',
+      ])
+      const dataFile = rootFileTree.get('sub-01/ieeg/sub-01_task-rest_ieeg.edf') as BIDSFile
+      const electrodes = walkBack(dataFile, true, ['.tsv'], 'electrodes', ['space'])
+      const localElectrodes: BIDSFile[] = electrodes.next().value
+      assert(Array.isArray(localElectrodes))
+      assertEquals(localElectrodes.map((f) => f.path), [
+        '/sub-01/ieeg/sub-01_task-rest_space-anat_electrodes.tsv',
+        '/sub-01/ieeg/sub-01_task-rest_space-MNI_electrodes.tsv',
+      ])
+    },
+  )
 })

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/inheritance.ts

@@ -50,7 +50,7 @@ export function* walkBack<T extends string[]>(
     if (candidates.length > 1) {
       const exactMatch = candidates.find((file) => {
         const { entities } = readEntities(file.name)
-        return Object.keys(sourceParts.entities).every((entity) =>
+        return [...Object.keys(sourceParts.entities), ...(targetEntities ?? [])].every((entity) =>
           entities[entity] === sourceParts.entities[entity]
         )
       })

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/json.test.ts

@@ -1,7 +1,9 @@
 import { type assert, assertObjectMatch } from '@std/assert'
 import type { BIDSFile } from '../types/filetree.ts'
 import type { FileIgnoreRules } from './ignore.ts'
+import { testAsyncFileAccess } from './access.test.ts'
 
+import { pathsToTree } from '../files/filetree.test.ts'
 import { loadJSON } from './json.ts'
 
 function encodeUTF16(text: string) {
@@ -17,9 +19,12 @@ function encodeUTF16(text: string) {
   return buffer
 }
 
-function makeFile(text: string, encoding: string): BIDSFile {
+function makeFile(path: string, text: string, encoding: string): BIDSFile {
   const bytes = encoding === 'utf-8' ? new TextEncoder().encode(text) : encodeUTF16(text)
+  const file = pathsToTree([path]).get(path) as BIDSFile
   return {
+    path: file.path,
+    parent: file.parent,
     readBytes: async (size: number) => {
       return new Uint8Array(bytes)
     },
@@ -29,13 +34,13 @@ function makeFile(text: string, encoding: string): BIDSFile {
 
 Deno.test('Test JSON error conditions', async (t) => {
   await t.step('Load valid JSON', async () => {
-    const JSONfile = makeFile('{"a": 1}', 'utf-8')
+    const JSONfile = makeFile('/valid-contents.json', '{"a": 1}', 'utf-8')
     const result = await loadJSON(JSONfile)
     assertObjectMatch(result, { a: 1 })
   })
 
   await t.step('Error on BOM', async () => {
-    const BOMfile = makeFile('\uFEFF{"a": 1}', 'utf-8')
+    const BOMfile = makeFile('/BOM.json', '\uFEFF{"a": 1}', 'utf-8')
     let error: any = undefined
     await loadJSON(BOMfile).catch((e) => {
       error = e
@@ -44,7 +49,7 @@ Deno.test('Test JSON error conditions', async (t) => {
   })
 
   await t.step('Error on UTF-16', async () => {
-    const UTF16file = makeFile('{"a": 1}', 'utf-16')
+    const UTF16file = makeFile('/utf16.json', '{"a": 1}', 'utf-16')
     let error: any = undefined
     await loadJSON(UTF16file).catch((e) => {
       error = e
@@ -53,11 +58,14 @@ Deno.test('Test JSON error conditions', async (t) => {
   })
 
   await t.step('Error on invalid JSON syntax', async () => {
-    const badJSON = makeFile('{"a": 1]', 'utf-8')
+    const badJSON = makeFile('/bad-syntax.json', '{"a": 1]', 'utf-8')
     let error: any = undefined
     await loadJSON(badJSON).catch((e) => {
       error = e
     })
     assertObjectMatch(error, { code: 'JSON_INVALID' })
   })
+  loadJSON.cache.clear()
 })
+
+testAsyncFileAccess('Test file access errors for loadJSON', loadJSON)

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/json.ts

@@ -1,4 +1,6 @@
+import { filememoizeAsync } from '../utils/memoize.ts'
 import type { BIDSFile } from '../types/filetree.ts'
+import { readBytes } from './access.ts'
 
 async function readJSONText(file: BIDSFile): Promise<string> {
   // Read JSON text from a file
@@ -6,7 +8,7 @@ async function readJSONText(file: BIDSFile): Promise<string> {
   const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })
   // Streaming TextDecoders are buggy in Deno and Chrome, so read the
   // entire file into memory before decoding and parsing
-  const data = await file.readBytes(file.size)
+  const data = await readBytes(file, file.size)
   try {
     const text = decoder.decode(data)
     if (text.startsWith('\uFEFF')) {
@@ -20,7 +22,7 @@ async function readJSONText(file: BIDSFile): Promise<string> {
   }
 }
 
-export async function loadJSON(file: BIDSFile): Promise<Record<string, unknown>> {
+async function _loadJSON(file: BIDSFile): Promise<Record<string, unknown>> {
   const text = await readJSONText(file) // Raise encoding errors
   let parsedText
   try {
@@ -36,3 +38,5 @@ export async function loadJSON(file: BIDSFile): Promise<Record<string, unknown>>
   }
   return parsedText
 }
+
+export const loadJSON = filememoizeAsync(_loadJSON)

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/nifti.test.ts

@@ -1,8 +1,9 @@
 import { assert, assertEquals, assertObjectMatch } from '@std/assert'
 import { FileIgnoreRules } from './ignore.ts'
 import { BIDSFileDeno } from './deno.ts'
+import { testAsyncFileAccess } from './access.test.ts'
 
-import { loadHeader, axisCodes } from './nifti.ts'
+import { axisCodes, loadHeader } from './nifti.ts'
 
 Deno.test('Test loading nifti header', async (t) => {
   const ignore = new FileIgnoreRules([])
@@ -96,3 +97,5 @@ Deno.test('Test extracting axis codes', async (t) => {
     assertEquals(axisCodes(affine), ['A', 'S', 'R'])
   })
 })
+
+testAsyncFileAccess('Test file access errors for loadHeader', loadHeader)

{bids_validator_deno-2.1.0 → bids_validator_deno-2.2.0}/src/files/nifti.ts

@@ -2,6 +2,7 @@ import { isCompressed, isNIFTI1, isNIFTI2, NIFTI1, NIFTI2 } from '@mango/nifti'
 import type { BIDSFile } from '../types/filetree.ts'
 import { logger } from '../utils/logger.ts'
 import type { NiftiHeader } from '@bids/schema/context'
+import { readBytes } from './access.ts'
 
 async function extract(buffer: Uint8Array, nbytes: number): Promise<Uint8Array<ArrayBuffer>> {
   // The fflate decompression that is used in nifti-reader does not like
@@ -32,8 +33,8 @@ async function extract(buffer: Uint8Array, nbytes: number): Promise<Uint8Array<A
 }
 
 export async function loadHeader(file: BIDSFile): Promise<NiftiHeader> {
+  const buf = await readBytes(file, 1024)
   try {
-    const buf = await file.readBytes(1024)
     const data = isCompressed(buf.buffer) ? await extract(buf, 540) : buf.slice(0, 540)
     let header
     if (isNIFTI1(data.buffer)) {
@@ -138,7 +139,8 @@ export function axisCodes(affine: number[][]): string[] {
 
   // Orthogonalize cosZ with respect to cosX and orthY
   const orthZ = sub(
-    cosZ, add(scale(cosX, dot(cosX, cosZ)), scale(orthY, dot(orthY, cosZ)))
+    cosZ,
+    add(scale(cosX, dot(cosX, cosZ)), scale(orthY, dot(orthY, cosZ))),
   )
 
   const basis = [cosX, orthY, orthZ]