dicom-curate 0.23.1 → 0.25.0

package/dist/esm/applyMappingsWorker.js

@@ -79464,6 +79464,12 @@ function collectMappings(inputFilePath, dicomData, mappingOptions) {
     errors: [],
     quarantine: {}
   };
+  if (mappingOptions.curationSpec === "none") {
+    return [
+      dcmjs4.data.DicomMetaDictionary.naturalizeDataset(dicomData.dict),
+      mapResults
+    ];
+  }
   const naturalData = dcmjs4.data.DicomMetaDictionary.naturalizeDataset(
     dicomData.dict
   );
@@ -79891,38 +79897,67 @@ async function curateOne({
   if (canSkip && previousSourceFileInfo) {
     return noMapResult();
   }
-  dcmjs7.log.setLevel(dcmjs7.log.levels.ERROR);
-  dcmjs7.log.getLogger("validation.dcmjs").setLevel(dcmjs7.log.levels.SILENT);
-  let dicomData;
-  try {
-    dicomData = dcmjs7.data.DicomMessage.readFile(fileArrayBuffer, {
-      ignoreErrors: true
-    });
-  } catch (error2) {
-    console.warn(
-      `[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`,
-      error2
-    );
-    const mapResults = {
-      anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-      errors: [
-        `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
-      ],
-      sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+  let mappedDicomData;
+  let clonedMapResults;
+  if (mappingOptions.curationSpec !== "none") {
+    dcmjs7.log.setLevel(dcmjs7.log.levels.ERROR);
+    dcmjs7.log.getLogger("validation.dcmjs").setLevel(dcmjs7.log.levels.SILENT);
+    let dicomData;
+    try {
+      dicomData = dcmjs7.data.DicomMessage.readFile(fileArrayBuffer, {
+        ignoreErrors: true
+      });
+    } catch (error2) {
+      console.warn(
+        `[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`,
+        error2
+      );
+      const mapResults = {
+        anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
+        errors: [
+          `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
+        ],
+        sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+        fileInfo: {
+          name: fileInfo.name,
+          size: fileInfo.size,
+          path: fileInfo.path,
+          mtime,
+          preMappedHash,
+          parseError: error2 instanceof Error ? error2.message : String(error2)
+        },
+        curationTime: performance.now() - startTime
+      };
+      return mapResults;
+    }
+    ;
+    ({ dicomData: mappedDicomData, mapResults: clonedMapResults } = curateDict(
+      `${fileInfo.path}/${fileInfo.name}`,
+      dicomData,
+      mappingOptions
+    ));
+    clonedMapResults.mappingRequired = true;
+  } else {
+    mappedDicomData = {
+      write: (...args) => fileArrayBuffer
+    };
+    clonedMapResults = {
+      sourceInstanceUID: `passthrough_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+      mappings: {},
+      anomalies: [],
+      errors: [],
+      quarantine: {},
       fileInfo: {
         name: fileInfo.name,
         size: fileInfo.size,
         path: fileInfo.path,
         mtime,
-        preMappedHash,
-        parseError: error2 instanceof Error ? error2.message : String(error2)
+        preMappedHash
       },
-      curationTime: performance.now() - startTime
+      outputFilePath: `${fileInfo.path}/${fileInfo.name}`,
+      mappingRequired: false
     };
-    return mapResults;
   }
-  const { dicomData: mappedDicomData, mapResults: clonedMapResults } = curateDict(`${fileInfo.path}/${fileInfo.name}`, dicomData, mappingOptions);
-  clonedMapResults.mappingRequired = true;
   if (!preMappedHash) {
     try {
       preMappedHash = await hash(fileArrayBuffer, hashMethod || "crc64");
@@ -85682,6 +85717,9 @@ var import_acorn_globals = __toESM(require_acorn_globals(), 1);
 // src/serializeMappingOptions.ts
 function deserializeMappingOptions(serializedMappingOptions) {
   const { curationSpecStr, ...rest } = serializedMappingOptions;
+  if (curationSpecStr === "none") {
+    return { ...rest, curationSpec: "none" };
+  }
   const curationSpec = new Function(`return ${curationSpecStr}`)();
   return { ...rest, curationSpec };
 }

package/dist/esm/collectMappings.js

@@ -35458,6 +35458,12 @@ function collectMappings(inputFilePath, dicomData, mappingOptions) {
     errors: [],
     quarantine: {}
   };
+  if (mappingOptions.curationSpec === "none") {
+    return [
+      dcmjs4.data.DicomMetaDictionary.naturalizeDataset(dicomData.dict),
+      mapResults
+    ];
+  }
   const naturalData = dcmjs4.data.DicomMetaDictionary.naturalizeDataset(
     dicomData.dict
   );

package/dist/esm/curateDict.js

@@ -35475,6 +35475,12 @@ function collectMappings(inputFilePath, dicomData, mappingOptions) {
     errors: [],
     quarantine: {}
   };
+  if (mappingOptions.curationSpec === "none") {
+    return [
+      dcmjs4.data.DicomMetaDictionary.naturalizeDataset(dicomData.dict),
+      mapResults
+    ];
+  }
   const naturalData = dcmjs4.data.DicomMetaDictionary.naturalizeDataset(
     dicomData.dict
   );

package/dist/esm/curateOne.js

@@ -73173,6 +73173,12 @@ function collectMappings(inputFilePath, dicomData, mappingOptions) {
     errors: [],
     quarantine: {}
   };
+  if (mappingOptions.curationSpec === "none") {
+    return [
+      dcmjs4.data.DicomMetaDictionary.naturalizeDataset(dicomData.dict),
+      mapResults
+    ];
+  }
   const naturalData = dcmjs4.data.DicomMetaDictionary.naturalizeDataset(
     dicomData.dict
   );
@@ -73600,38 +73606,67 @@ async function curateOne({
   if (canSkip && previousSourceFileInfo) {
     return noMapResult();
   }
-  dcmjs7.log.setLevel(dcmjs7.log.levels.ERROR);
-  dcmjs7.log.getLogger("validation.dcmjs").setLevel(dcmjs7.log.levels.SILENT);
-  let dicomData;
-  try {
-    dicomData = dcmjs7.data.DicomMessage.readFile(fileArrayBuffer, {
-      ignoreErrors: true
-    });
-  } catch (error2) {
-    console.warn(
-      `[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`,
-      error2
-    );
-    const mapResults = {
-      anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-      errors: [
-        `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
-      ],
-      sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+  let mappedDicomData;
+  let clonedMapResults;
+  if (mappingOptions.curationSpec !== "none") {
+    dcmjs7.log.setLevel(dcmjs7.log.levels.ERROR);
+    dcmjs7.log.getLogger("validation.dcmjs").setLevel(dcmjs7.log.levels.SILENT);
+    let dicomData;
+    try {
+      dicomData = dcmjs7.data.DicomMessage.readFile(fileArrayBuffer, {
+        ignoreErrors: true
+      });
+    } catch (error2) {
+      console.warn(
+        `[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`,
+        error2
+      );
+      const mapResults = {
+        anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
+        errors: [
+          `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
+        ],
+        sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+        fileInfo: {
+          name: fileInfo.name,
+          size: fileInfo.size,
+          path: fileInfo.path,
+          mtime,
+          preMappedHash,
+          parseError: error2 instanceof Error ? error2.message : String(error2)
+        },
+        curationTime: performance.now() - startTime
+      };
+      return mapResults;
+    }
+    ;
+    ({ dicomData: mappedDicomData, mapResults: clonedMapResults } = curateDict(
+      `${fileInfo.path}/${fileInfo.name}`,
+      dicomData,
+      mappingOptions
+    ));
+    clonedMapResults.mappingRequired = true;
+  } else {
+    mappedDicomData = {
+      write: (...args) => fileArrayBuffer
+    };
+    clonedMapResults = {
+      sourceInstanceUID: `passthrough_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+      mappings: {},
+      anomalies: [],
+      errors: [],
+      quarantine: {},
       fileInfo: {
         name: fileInfo.name,
         size: fileInfo.size,
         path: fileInfo.path,
         mtime,
-        preMappedHash,
-        parseError: error2 instanceof Error ? error2.message : String(error2)
+        preMappedHash
       },
-      curationTime: performance.now() - startTime
+      outputFilePath: `${fileInfo.path}/${fileInfo.name}`,
+      mappingRequired: false
     };
-    return mapResults;
   }
-  const { dicomData: mappedDicomData, mapResults: clonedMapResults } = curateDict(`${fileInfo.path}/${fileInfo.name}`, dicomData, mappingOptions);
-  clonedMapResults.mappingRequired = true;
   if (!preMappedHash) {
     try {
       preMappedHash = await hash(fileArrayBuffer, hashMethod || "crc64");

package/dist/esm/index.js

@@ -81024,6 +81024,12 @@ function collectMappings(inputFilePath, dicomData, mappingOptions) {
     errors: [],
     quarantine: {}
   };
+  if (mappingOptions.curationSpec === "none") {
+    return [
+      dcmjs4.data.DicomMetaDictionary.naturalizeDataset(dicomData.dict),
+      mapResults
+    ];
+  }
   const naturalData = dcmjs4.data.DicomMetaDictionary.naturalizeDataset(
     dicomData.dict
   );
@@ -81451,38 +81457,67 @@ async function curateOne({
   if (canSkip && previousSourceFileInfo) {
     return noMapResult();
   }
-  dcmjs7.log.setLevel(dcmjs7.log.levels.ERROR);
-  dcmjs7.log.getLogger("validation.dcmjs").setLevel(dcmjs7.log.levels.SILENT);
-  let dicomData;
-  try {
-    dicomData = dcmjs7.data.DicomMessage.readFile(fileArrayBuffer, {
-      ignoreErrors: true
-    });
-  } catch (error2) {
-    console.warn(
-      `[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`,
-      error2
-    );
-    const mapResults = {
-      anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
-      errors: [
-        `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
-      ],
-      sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+  let mappedDicomData;
+  let clonedMapResults;
+  if (mappingOptions.curationSpec !== "none") {
+    dcmjs7.log.setLevel(dcmjs7.log.levels.ERROR);
+    dcmjs7.log.getLogger("validation.dcmjs").setLevel(dcmjs7.log.levels.SILENT);
+    let dicomData;
+    try {
+      dicomData = dcmjs7.data.DicomMessage.readFile(fileArrayBuffer, {
+        ignoreErrors: true
+      });
+    } catch (error2) {
+      console.warn(
+        `[dicom-curate] Could not parse ${fileInfo.name} as DICOM data:`,
+        error2
+      );
+      const mapResults = {
+        anomalies: [`Could not parse ${fileInfo.name} as DICOM data`],
+        errors: [
+          `File ${fileInfo.name} is not a valid DICOM file or is corrupted`
+        ],
+        sourceInstanceUID: `invalid_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+        fileInfo: {
+          name: fileInfo.name,
+          size: fileInfo.size,
+          path: fileInfo.path,
+          mtime,
+          preMappedHash,
+          parseError: error2 instanceof Error ? error2.message : String(error2)
+        },
+        curationTime: performance.now() - startTime
+      };
+      return mapResults;
+    }
+    ;
+    ({ dicomData: mappedDicomData, mapResults: clonedMapResults } = curateDict(
+      `${fileInfo.path}/${fileInfo.name}`,
+      dicomData,
+      mappingOptions
+    ));
+    clonedMapResults.mappingRequired = true;
+  } else {
+    mappedDicomData = {
+      write: (...args) => fileArrayBuffer
+    };
+    clonedMapResults = {
+      sourceInstanceUID: `passthrough_${fileInfo.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+      mappings: {},
+      anomalies: [],
+      errors: [],
+      quarantine: {},
       fileInfo: {
         name: fileInfo.name,
         size: fileInfo.size,
         path: fileInfo.path,
         mtime,
-        preMappedHash,
-        parseError: error2 instanceof Error ? error2.message : String(error2)
+        preMappedHash
       },
-      curationTime: performance.now() - startTime
+      outputFilePath: `${fileInfo.path}/${fileInfo.name}`,
+      mappingRequired: false
     };
-    return mapResults;
   }
-  const { dicomData: mappedDicomData, mapResults: clonedMapResults } = curateDict(`${fileInfo.path}/${fileInfo.name}`, dicomData, mappingOptions);
-  clonedMapResults.mappingRequired = true;
   if (!preMappedHash) {
     try {
       preMappedHash = await hash(fileArrayBuffer, hashMethod || "crc64");
@@ -87284,7 +87319,9 @@ function assertNoClosure(fn) {
 
 // src/serializeMappingOptions.ts
 function serializeMappingOptions(mappingOptions) {
-  assertNoClosure(mappingOptions.curationSpec);
+  if (typeof mappingOptions.curationSpec === "function") {
+    assertNoClosure(mappingOptions.curationSpec);
+  }
   const { curationSpec, ...rest } = mappingOptions;
   const curationSpecStr = curationSpec.toString();
   return { ...rest, curationSpecStr };
@@ -87566,7 +87603,12 @@ async function collectMappingOptions(organizeOptions) {
     outputTarget.directory = organizeOptions.outputDirectory;
   }
   const curationSpec = organizeOptions.curationSpec;
-  const { dicomPS315EOptions: deIdOpts, additionalData } = composeSpecs(curationSpec());
+  let additionalData;
+  let deIdOpts = "Off";
+  if (typeof curationSpec === "function") {
+    ;
+    ({ dicomPS315EOptions: deIdOpts, additionalData } = composeSpecs(curationSpec()));
+  }
   let columnMappings;
   if (organizeOptions.table && additionalData) {
     columnMappings = extractColumnMappings(
@@ -87651,8 +87693,16 @@ async function curateMany(organizeOptions, onProgress) {
       );
       if (organizeOptions.inputType === "directory" || organizeOptions.inputType === "path" || organizeOptions.inputType === "s3") {
         const fileListWorker = await initializeFileListWorker();
-        const curationSpec = composeSpecs(organizeOptions.curationSpec());
-        const specExcludedFiletypes = curationSpec.excludedFiletypes;
+        let specExcludedFiletypes;
+        let noDicomSignatureCheck = false;
+        let noDefaultExclusions = false;
+        if (organizeOptions.curationSpec === "none") {
+          noDicomSignatureCheck = true;
+          noDefaultExclusions = true;
+        } else {
+          const curationSpec = composeSpecs(organizeOptions.curationSpec());
+          specExcludedFiletypes = curationSpec.excludedFiletypes;
+        }
         const excludedPathRegexes = organizeOptions.excludedPathGlobs?.map(
           (glob) => import_picomatch.default.makeRe(glob).source
         );
@@ -87662,6 +87712,8 @@ async function curateMany(organizeOptions, onProgress) {
             directoryHandle: organizeOptions.inputDirectory,
             excludedFiletypes: specExcludedFiletypes,
             excludedPathRegexes,
+            noDicomSignatureCheck,
+            noDefaultExclusions,
             fileInfoIndex: organizeOptions.fileInfoIndex
           });
         } else if (organizeOptions.inputType === "s3") {
@@ -87670,7 +87722,9 @@ async function curateMany(organizeOptions, onProgress) {
             bucketOptions: organizeOptions.inputS3Bucket,
             excludedFiletypes: specExcludedFiletypes,
             excludedPathRegexes,
-            fileInfoIndex: organizeOptions.fileInfoIndex
+            fileInfoIndex: organizeOptions.fileInfoIndex,
+            noDicomSignatureCheck,
+            noDefaultExclusions
           });
         } else {
           fileListWorker.postMessage({
@@ -87678,7 +87732,9 @@ async function curateMany(organizeOptions, onProgress) {
             path: organizeOptions.inputDirectory,
             excludedFiletypes: specExcludedFiletypes,
             excludedPathRegexes,
-            fileInfoIndex: organizeOptions.fileInfoIndex
+            fileInfoIndex: organizeOptions.fileInfoIndex,
+            noDicomSignatureCheck,
+            noDefaultExclusions
           });
         }
       } else if (organizeOptions.inputType === "files") {
@@ -87701,6 +87757,7 @@ export {
   curateMany,
   curateOne,
   extractColumnMappings,
+  hash,
   specVersion
 };
 /*! Bundled license information:

package/dist/esm/scanDirectoryWorker.js

@@ -37139,10 +37139,12 @@ var DEFAULT_EXCLUDED_FILETYPES = [
 var keepScanning = true;
 var excludedFiletypes = [];
 var excludedPathRegexes = [];
+var noDicomSignatureCheck = false;
+var noDefaultExclusions = false;
 var previousIndex;
 async function shouldProcessFile(file, fileAnomalies, filePath) {
   const allExcludedFiletypes = [
-    ...DEFAULT_EXCLUDED_FILETYPES,
+    ...noDefaultExclusions ? [] : DEFAULT_EXCLUDED_FILETYPES,
     ...excludedFiletypes
   ];
   try {
@@ -37155,6 +37157,9 @@ async function shouldProcessFile(file, fileAnomalies, filePath) {
       fileAnomalies.push(`Skipped excluded file: ${file.name}`);
       return false;
     }
+    if (noDicomSignatureCheck) {
+      return true;
+    }
     if (file.size < 132) {
       fileAnomalies.push(
         `Skipped very small file: ${file.name} (${file.size} bytes)`
@@ -37192,6 +37197,9 @@ async function shouldProcessFileItem(s3Item, fileAnomalies) {
       fileAnomalies.push(`Skipped excluded file: ${s3Item.Key}`);
       return false;
     }
+    if (noDicomSignatureCheck) {
+      return true;
+    }
     if (s3Item.Size < 132) {
       fileAnomalies.push(
         `Skipped very small file: ${s3Item.Key} (${s3Item.Size} bytes)`
@@ -37208,7 +37216,7 @@ async function shouldProcessFileItem(s3Item, fileAnomalies) {
 }
 async function shouldProcessFileNode(filePath, fileName, fileSize, fileAnomalies, relativePath) {
   const allExcludedFiletypes = [
-    ...DEFAULT_EXCLUDED_FILETYPES,
+    ...noDefaultExclusions ? [] : DEFAULT_EXCLUDED_FILETYPES,
     ...excludedFiletypes
   ];
   try {
@@ -37221,6 +37229,9 @@ async function shouldProcessFileNode(filePath, fileName, fileSize, fileAnomalies
       fileAnomalies.push(`Skipped excluded file: ${fileName}`);
       return false;
     }
+    if (noDicomSignatureCheck) {
+      return true;
+    }
     if (fileSize < 132) {
       fileAnomalies.push(
         `Skipped very small file: ${fileName} (${fileSize} bytes)`
@@ -37268,6 +37279,8 @@ fixupNodeWorkerEnvironment().then(() => {
         } else {
           excludedPathRegexes = [];
         }
+        noDicomSignatureCheck = event.data.noDicomSignatureCheck ?? false;
+        noDefaultExclusions = event.data.noDefaultExclusions ?? false;
         keepScanning = true;
         if ("path" in eventData) {
           scanDirectoryNode(eventData.path);
@@ -37412,57 +37425,63 @@ async function scanDirectory(dir) {
   }
 }
 async function scanDirectoryNode(dirPath) {
-  const fs = await import("fs/promises");
-  const path = await import("path");
-  async function traverse(currentPath, prefix) {
-    const entries = await fs.readdir(currentPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!keepScanning)
-        return;
-      if (entry.isFile()) {
-        const filePath = path.join(currentPath, entry.name);
-        const stats = await fs.stat(filePath);
-        const fileAnomalies = [];
-        if (await shouldProcessFileNode(
-          filePath,
-          entry.name,
-          stats.size,
-          fileAnomalies,
-          `${prefix}/${entry.name}`
-        )) {
-          globalThis.postMessage({
-            response: "file",
-            fileInfo: {
-              path: prefix,
-              name: entry.name,
-              size: stats.size,
-              kind: "path",
-              fullPath: filePath
-            }
-          });
-        } else if (fileAnomalies.length > 0) {
-          globalThis.postMessage({
-            response: "scanAnomalies",
-            fileInfo: {
-              path: prefix,
-              name: entry.name,
-              size: stats.size,
-              kind: "path",
-              fullPath: filePath
-            },
-            anomalies: fileAnomalies
-          });
+  try {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    async function traverse(currentPath, prefix) {
+      const entries = await fs.readdir(currentPath, { withFileTypes: true });
+      entries.sort((a4, b4) => a4.name.localeCompare(b4.name));
+      for (const entry of entries) {
+        if (!keepScanning)
+          return;
+        if (entry.isFile()) {
+          const filePath = path.join(currentPath, entry.name);
+          const stats = await fs.stat(filePath);
+          const fileAnomalies = [];
+          const key = `${prefix}/${entry.name}`;
+          if (await shouldProcessFileNode(
+            filePath,
+            entry.name,
+            stats.size,
+            fileAnomalies,
+            key
+          )) {
+            const prev = previousIndex ? previousIndex[key] : void 0;
+            globalThis.postMessage({
+              response: "file",
+              fileInfo: {
+                path: prefix,
+                name: entry.name,
+                size: stats.size,
+                kind: "path",
+                fullPath: filePath
+              },
+              previousFileInfo: prev
+            });
+          } else if (fileAnomalies.length > 0) {
+            const prev = previousIndex ? previousIndex[key] : void 0;
+            globalThis.postMessage({
+              response: "scanAnomalies",
+              fileInfo: {
+                path: prefix,
+                name: entry.name,
+                size: stats.size,
+                kind: "path",
+                fullPath: filePath
+              },
+              anomalies: fileAnomalies,
+              previousFileInfo: prev
+            });
+          }
+        } else if (entry.isDirectory()) {
+          await traverse(
+            path.join(currentPath, entry.name),
+            prefix + "/" + entry.name
+          );
         }
-      } else if (entry.isDirectory()) {
-        await traverse(
-          path.join(currentPath, entry.name),
-          prefix + "/" + entry.name
-        );
       }
     }
-  }
-  const dirName = await import("path").then((p4) => p4.basename(dirPath));
-  try {
+    const dirName = await import("path").then((p4) => p4.basename(dirPath));
     await traverse(dirPath, dirName);
     globalThis.postMessage({ response: "done" });
   } catch (error2) {

package/dist/esm/serializeMappingOptions.js

@@ -11968,13 +11968,18 @@ function assertNoClosure(fn) {
 
 // src/serializeMappingOptions.ts
 function serializeMappingOptions(mappingOptions) {
-  assertNoClosure(mappingOptions.curationSpec);
+  if (typeof mappingOptions.curationSpec === "function") {
+    assertNoClosure(mappingOptions.curationSpec);
+  }
   const { curationSpec, ...rest } = mappingOptions;
   const curationSpecStr = curationSpec.toString();
   return { ...rest, curationSpecStr };
 }
 function deserializeMappingOptions(serializedMappingOptions) {
   const { curationSpecStr, ...rest } = serializedMappingOptions;
+  if (curationSpecStr === "none") {
+    return { ...rest, curationSpec: "none" };
+  }
   const curationSpec = new Function(`return ${curationSpecStr}`)();
   return { ...rest, curationSpec };
 }

package/dist/types/index.d.ts

@@ -9,6 +9,7 @@ export { csvTextToRows } from './csvMapping';
 export type { Row } from './csvMapping';
 export { composeSpecs } from './composeSpecs';
 export type { SpecPart } from './composeSpecs';
+export { hash } from './hash';
 declare function curateMany(organizeOptions: OrganizeOptions, onProgress?: ProgressCallback): Promise<TProgressMessageDone>;
 export * from './types';
 export { curateMany, curateOne, extractColumnMappings };

package/dist/types/scanDirectoryWorker.d.ts

@@ -23,24 +23,22 @@ export type FileScanMsg = {
 } | {
     response: 'done';
 };
-export type FileScanRequest = {
-    request: 'scan';
-    directoryHandle: FileSystemDirectoryHandle;
+type CommonFileScanRequestFields = {
     excludedFiletypes?: string[];
     excludedPathRegexes?: string[];
     fileInfoIndex?: TFileInfoIndex;
-} | {
+    noDefaultExclusions?: boolean;
+    noDicomSignatureCheck?: boolean;
+};
+export type FileScanRequest = ({
+    request: 'scan';
+    directoryHandle: FileSystemDirectoryHandle;
+} & CommonFileScanRequestFields) | ({
     request: 'scan';
     path: string;
-    excludedFiletypes?: string[];
-    excludedPathRegexes?: string[];
-    fileInfoIndex?: TFileInfoIndex;
-} | {
+} & CommonFileScanRequestFields) | ({
     request: 'scan';
-    excludedFiletypes?: string[];
-    excludedPathRegexes?: string[];
     bucketOptions: TS3BucketOptions;
-    fileInfoIndex?: TFileInfoIndex;
-} | {
+} & CommonFileScanRequestFields) | {
     request: 'stop';
 };