@ubercode/dcmtk 0.8.2 → 0.9.1

package/dist/index.js

@@ -6,12 +6,13 @@ import { spawn, execSync } from 'child_process';
 import kill from 'tree-kill';
 import { EventEmitter } from 'events';
 import { stderr, tryCatch } from 'stderr-lib';
-import { XMLParser } from 'fast-xml-parser';
 import * as fs from 'fs/promises';
-import { copyFile, unlink, stat, mkdtemp, rm, readdir } from 'fs/promises';
-import * as net from 'net';
+import { mkdir, stat, rm, copyFile, unlink, mkdtemp, readdir } from 'fs/promises';
 import * as os from 'os';
 import { tmpdir } from 'os';
+import { XMLParser } from 'fast-xml-parser';
+import * as net from 'net';
+import { randomUUID } from 'crypto';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -31476,13 +31477,26 @@ async function tryDirectPath(inputPath, timeoutMs, signal, verbosity) {
   if (!jsonBinary.ok) {
     return err(jsonBinary.error);
   }
-  const directArgs = [...buildVerbosityArgs(verbosity), "+b", inputPath];
-  const result = await execCommand(jsonBinary.value, directArgs, { timeoutMs, signal });
+  const bulkDir = await createBulkTempDir();
+  const directArgs = [...buildVerbosityArgs(verbosity), "+b", "+bd", bulkDir, inputPath];
+  try {
+    const execOpts = signal !== void 0 ? { timeoutMs, signal } : { timeoutMs };
+    return await execAndParse(jsonBinary.value, directArgs, inputPath, execOpts);
+  } finally {
+    rm(bulkDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function createBulkTempDir() {
+  return mkdtemp(join(tmpdir(), "dcm2json-bulk-"));
+}
+async function execAndParse(binary, args, inputPath, execOpts) {
+  const result = await execCommand(binary, args, execOpts);
   if (!result.ok) {
     return err(result.error);
   }
   if (result.value.exitCode !== 0) {
-    return err(createToolError("dcm2json", directArgs, result.value.exitCode, result.value.stderr));
+    return err(createToolError("dcm2json", args, result.value.exitCode, result.value.stderr));
   }
   try {
     const repaired = repairJson(result.value.stdout);
@@ -36576,7 +36590,7 @@ var DicomReceiver = class _DicomReceiver extends EventEmitter {
       acseTimeout: this.options.acseTimeout,
       dimseTimeout: this.options.dimseTimeout,
       maxPdu: this.options.maxPdu,
-      filenameMode: this.options.filenameMode,
+      filenameMode: this.options.filenameMode ?? "unique",
       filenameExtension: this.options.filenameExtension,
       storageMode: this.options.storageMode
     });
@@ -36691,8 +36705,9 @@ var DicomReceiver = class _DicomReceiver extends EventEmitter {
     const assocDir = worker.associationDir;
     const moveResult = await moveFile(srcPath, destPath);
     const finalPath = moveResult.ok ? destPath : srcPath;
+    const fileSize = await statFileSafe(finalPath);
     worker.files.push(finalPath);
-    worker.fileSizes.push(await statFileSafe(finalPath));
+    worker.fileSizes.push(fileSize);
     const openResult = await DicomInstance.open(finalPath);
     if (!openResult.ok) {
       this.emit("error", {
@@ -36708,6 +36723,7 @@ var DicomReceiver = class _DicomReceiver extends EventEmitter {
     }
     this.emit("FILE_RECEIVED", {
       filePath: finalPath,
+      fileSize,
       associationId: assocId,
       associationDir: assocDir,
       callingAE: data.callingAE,
@@ -36856,8 +36872,8 @@ async function moveFile(src, dest) {
 }
 async function statFileSafe(filePath) {
   try {
-    const stat3 = await fs.stat(filePath);
-    return stat3.size;
+    const stat4 = await fs.stat(filePath);
+    return stat4.size;
   } catch {
     return 0;
   }
@@ -38268,6 +38284,341 @@ async function batch(items, operation, options) {
   return { results: state.results, succeeded: state.succeeded, failed: state.failed };
 }
 
+// src/testing/types.ts
+var HammerPhase = {
+  /** File generation phase (copy + modify). */
+  GENERATE: "generate",
+  /** File sending phase (dcmsend). */
+  SEND: "send"
+};
+
+// src/testing/DicomHammer.ts
+var DEFAULT_FILE_COUNT = 100;
+var MAX_FILE_COUNT = 1e5;
+var DEFAULT_CONCURRENCY2 = 4;
+var MAX_CONCURRENCY2 = 64;
+var DEFAULT_CALLING_AE = "HAMMER";
+var DEFAULT_CALLED_AE = "ANY-SCP";
+var DICOM_UID_ROOT = "2.25.";
+var DicomHammerOptionsSchema = z.object({
+  sourceFile: z.string().min(1),
+  host: z.string().min(1),
+  port: z.number().int().min(1).max(65535),
+  callingAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  fileCount: z.number().int().min(1).max(MAX_FILE_COUNT).optional(),
+  concurrency: z.number().int().min(1).max(MAX_CONCURRENCY2).optional(),
+  delayMs: z.number().int().min(0).optional(),
+  institution: z.string().min(1).optional(),
+  erasePrivateTags: z.boolean().optional(),
+  modifications: z.array(z.object({ tag: z.string().min(1), value: z.string() })).optional(),
+  timeoutMs: z.number().int().positive().optional(),
+  signal: z.instanceof(AbortSignal).optional(),
+  outputDir: z.string().min(1).optional(),
+  noHalt: z.boolean().optional()
+}).strict();
+function resolveNetworkOptions(options) {
+  return {
+    host: options.host,
+    port: options.port,
+    callingAETitle: options.callingAETitle ?? DEFAULT_CALLING_AE,
+    calledAETitle: options.calledAETitle ?? DEFAULT_CALLED_AE,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    noHalt: options.noHalt ?? true
+  };
+}
+function resolveOptions(options) {
+  return {
+    sourceFile: options.sourceFile,
+    ...resolveNetworkOptions(options),
+    fileCount: options.fileCount ?? DEFAULT_FILE_COUNT,
+    concurrency: options.concurrency ?? DEFAULT_CONCURRENCY2,
+    delayMs: options.delayMs ?? 0,
+    institution: options.institution,
+    erasePrivateTags: options.erasePrivateTags ?? false,
+    modifications: options.modifications ?? [],
+    signal: options.signal,
+    outputDir: options.outputDir ?? tmpdir()
+  };
+}
+function generateUid() {
+  const hex = randomUUID().replace(/-/g, "");
+  const decimal = BigInt("0x" + hex).toString(10);
+  return DICOM_UID_ROOT + decimal;
+}
+function formatDate() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = String(d.getFullYear());
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return yyyy + mm + dd;
+}
+function buildModifications(index, opts) {
+  const mods = [
+    { tag: "(0020,000D)", value: generateUid() },
+    { tag: "(0020,000E)", value: generateUid() },
+    { tag: "(0008,0018)", value: generateUid() },
+    { tag: "(0008,0020)", value: formatDate() },
+    { tag: "(0008,0050)", value: `HAMMER-${String(index + 1).padStart(6, "0")}` }
+  ];
+  if (opts.institution !== void 0) {
+    mods.push({ tag: "(0008,0080)", value: opts.institution });
+  }
+  for (const mod of opts.modifications) {
+    mods.push({ tag: mod.tag, value: mod.value });
+  }
+  return mods;
+}
+function computeThroughput(succeeded, totalBytes, durationMs) {
+  const durationSec = durationMs / 1e3;
+  return {
+    filesPerSec: durationSec > 0 ? succeeded / durationSec : 0,
+    bytesPerSec: durationSec > 0 ? totalBytes / durationSec : 0
+  };
+}
+function delay3(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var DicomHammer = class _DicomHammer extends EventEmitter {
+  constructor(options) {
+    super();
+    __publicField(this, "opts");
+    __publicField(this, "generatedDir");
+    __publicField(this, "generatedFiles", []);
+    this.opts = options;
+    this.setMaxListeners(20);
+  }
+  // -----------------------------------------------------------------------
+  // Factory
+  // -----------------------------------------------------------------------
+  /**
+   * Creates a DicomHammer instance.
+   *
+   * @param options - Configuration for file generation and sending
+   * @returns A Result containing the DicomHammer or a validation error
+   */
+  static create(options) {
+    const validation = DicomHammerOptionsSchema.safeParse(options);
+    if (!validation.success) {
+      return err(createValidationError("DicomHammer", validation.error));
+    }
+    return ok(new _DicomHammer(resolveOptions(options)));
+  }
+  // -----------------------------------------------------------------------
+  // Generate phase
+  // -----------------------------------------------------------------------
+  /**
+   * Generates modified copies of the source DICOM file.
+   *
+   * Each copy receives unique Study/Series/SOP Instance UIDs, a unique
+   * accession number, and any custom modifications.
+   */
+  async generate() {
+    const start = Date.now();
+    const dir = join(this.opts.outputDir, `dcmtk-hammer-${Date.now()}`);
+    try {
+      await mkdir(dir, { recursive: true });
+    } catch {
+      return err(new Error(`Failed to create output directory: ${dir}`));
+    }
+    this.generatedDir = dir;
+    const indices = Array.from({ length: this.opts.fileCount }, (_, i) => i);
+    const total = this.opts.fileCount;
+    let completedCount = 0;
+    const result = await batch(
+      indices,
+      async (index) => {
+        return this.generateOneFile(index, dir);
+      },
+      {
+        concurrency: this.opts.concurrency,
+        signal: this.opts.signal,
+        onProgress: (_completed, _total, fileResult) => {
+          completedCount++;
+          if (fileResult.ok) {
+            this.emit("FILE_GENERATED", { index: completedCount - 1, total, filePath: fileResult.value });
+          }
+          this.emitProgress(HammerPhase.GENERATE, completedCount, total);
+        }
+      }
+    );
+    const files = result.results.filter((r) => r.ok).map((r) => r.value);
+    this.generatedFiles = files;
+    if (files.length === 0) {
+      return err(new Error(`All ${total} file generations failed`));
+    }
+    return ok({ files, durationMs: Date.now() - start, outputDir: dir });
+  }
+  /** Generates a single modified copy. Extracted for function size compliance. */
+  async generateOneFile(index, dir) {
+    const padded = String(index + 1).padStart(6, "0");
+    const dest = join(dir, `hammer_${padded}.dcm`);
+    const copyResult = await copyFileSafe(this.opts.sourceFile, dest);
+    if (!copyResult.ok) return err(copyResult.error);
+    const modResult = await dcmodify(dest, {
+      modifications: buildModifications(index, this.opts),
+      erasePrivateTags: this.opts.erasePrivateTags || void 0,
+      insertIfMissing: true,
+      noBackup: true,
+      timeoutMs: this.opts.timeoutMs,
+      signal: this.opts.signal
+    });
+    if (!modResult.ok) return err(modResult.error);
+    return ok(dest);
+  }
+  // -----------------------------------------------------------------------
+  // Send phase
+  // -----------------------------------------------------------------------
+  /**
+   * Sends files to the target SCP.
+   *
+   * @param files - Files to send. Defaults to previously generated files.
+   */
+  async send(files) {
+    const filesToSend = files ?? this.generatedFiles;
+    if (filesToSend.length === 0) {
+      return err(new Error("No files to send. Call generate() first or provide files."));
+    }
+    const fileSize = await this.getFileSize(filesToSend[0]);
+    const start = Date.now();
+    const total = filesToSend.length;
+    const tracker = { errors: [], completedCount: 0, succeeded: 0 };
+    await batch([...filesToSend], async (file) => this.sendOneFile(file), {
+      concurrency: this.opts.concurrency,
+      signal: this.opts.signal,
+      onProgress: (_c, _t, sendResult) => this.trackSendProgress(sendResult, filesToSend, total, tracker)
+    });
+    return ok(this.buildSendResult(tracker, total, fileSize, Date.now() - start));
+  }
+  /** Tracks a single send result for progress reporting. */
+  trackSendProgress(sendResult, files, total, tracker) {
+    tracker.completedCount++;
+    const file = files[tracker.completedCount - 1];
+    if (sendResult.ok) {
+      tracker.succeeded++;
+      this.emit("SEND_COMPLETE", { index: tracker.completedCount - 1, total, file, durationMs: 0 });
+    } else {
+      tracker.errors.push({ file, error: sendResult.error });
+      this.emit("SEND_FAILED", { index: tracker.completedCount - 1, total, file, error: sendResult.error });
+    }
+    this.emitProgress(HammerPhase.SEND, tracker.completedCount, total);
+  }
+  /** Assembles the final HammerSendResult. */
+  buildSendResult(tracker, total, fileSize, durationMs) {
+    const totalBytes = tracker.succeeded * fileSize;
+    const throughput = computeThroughput(tracker.succeeded, totalBytes, durationMs);
+    return {
+      succeeded: tracker.succeeded,
+      failed: tracker.errors.length,
+      totalFiles: total,
+      durationMs,
+      filesPerSec: throughput.filesPerSec,
+      bytesPerSec: throughput.bytesPerSec,
+      totalBytes,
+      errors: tracker.errors
+    };
+  }
+  /** Sends a single file, with optional delay. */
+  async sendOneFile(file) {
+    if (this.opts.delayMs > 0) {
+      await delay3(this.opts.delayMs);
+    }
+    const result = await dcmsend({
+      host: this.opts.host,
+      port: this.opts.port,
+      files: [file],
+      callingAETitle: this.opts.callingAETitle,
+      calledAETitle: this.opts.calledAETitle,
+      noHalt: this.opts.noHalt || void 0,
+      timeoutMs: this.opts.timeoutMs,
+      signal: this.opts.signal
+    });
+    if (!result.ok) return err(result.error);
+    return ok(void 0);
+  }
+  /** Gets the file size in bytes, returning 0 on error. */
+  async getFileSize(filePath) {
+    try {
+      const s = await stat(filePath);
+      return s.size;
+    } catch {
+      return 0;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Combined run
+  // -----------------------------------------------------------------------
+  /**
+   * Generates files and sends them in one call.
+   *
+   * @returns Combined result with timing for both phases
+   */
+  async run() {
+    const genResult = await this.generate();
+    if (!genResult.ok) return err(genResult.error);
+    const sendResult = await this.send(genResult.value.files);
+    if (!sendResult.ok) return err(sendResult.error);
+    const result = {
+      succeeded: sendResult.value.succeeded,
+      failed: sendResult.value.failed,
+      totalFiles: sendResult.value.totalFiles,
+      durationMs: genResult.value.durationMs + sendResult.value.durationMs,
+      generateDurationMs: genResult.value.durationMs,
+      sendDurationMs: sendResult.value.durationMs,
+      filesPerSec: sendResult.value.filesPerSec,
+      bytesPerSec: sendResult.value.bytesPerSec,
+      totalBytes: sendResult.value.totalBytes,
+      errors: sendResult.value.errors
+    };
+    this.emit("RUN_COMPLETE", result);
+    return ok(result);
+  }
+  // -----------------------------------------------------------------------
+  // Cleanup
+  // -----------------------------------------------------------------------
+  /** Removes all generated files and the output directory. */
+  async cleanup() {
+    if (this.generatedDir === void 0) return ok(void 0);
+    try {
+      await rm(this.generatedDir, { recursive: true, force: true });
+      this.generatedDir = void 0;
+      this.generatedFiles = [];
+      return ok(void 0);
+    } catch {
+      return err(new Error(`Failed to cleanup: ${this.generatedDir}`));
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Event helpers
+  // -----------------------------------------------------------------------
+  /** Emits a PROGRESS event. */
+  emitProgress(phase, completed, total) {
+    this.emit("PROGRESS", { phase, completed, total, percent: Math.round(completed / total * 100) });
+  }
+  /** Registers a listener for FILE_GENERATED events. */
+  onFileGenerated(listener) {
+    return this.on("FILE_GENERATED", listener);
+  }
+  /** Registers a listener for SEND_COMPLETE events. */
+  onSendComplete(listener) {
+    return this.on("SEND_COMPLETE", listener);
+  }
+  /** Registers a listener for SEND_FAILED events. */
+  onSendFailed(listener) {
+    return this.on("SEND_FAILED", listener);
+  }
+  /** Registers a listener for PROGRESS events. */
+  onProgress(listener) {
+    return this.on("PROGRESS", listener);
+  }
+  /** Registers a listener for RUN_COMPLETE events. */
+  onRunComplete(listener) {
+    return this.on("RUN_COMPLETE", listener);
+  }
+};
+
 // src/utils/retry.ts
 var DEFAULT_MAX_ATTEMPTS = 3;
 var DEFAULT_INITIAL_DELAY_MS = 1e3;
@@ -38342,6 +38693,6 @@ async function retry(operation, options) {
   return lastResult;
 }
 
-export { AETitleSchema, AssociationTracker, ChangeSet, ColorConversion, DCMPRSCP_FATAL_EVENTS, DCMPRSCP_PATTERNS, DCMPSRCV_FATAL_EVENTS, DCMPSRCV_PATTERNS, DCMQRSCP_FATAL_EVENTS, DCMQRSCP_PATTERNS, DCMRECV_FATAL_EVENTS, DCMRECV_PATTERNS, DEFAULT_BLOCK_TIMEOUT_MS, DEFAULT_DICOM_PORT, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_PARSE_CONCURRENCY, DEFAULT_START_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, Dcm2pnmOutputFormat, Dcm2xmlCharset, DcmQRSCP, DcmdumpFormat, Dcmj2pnmOutputFormat, DcmprsCP, DcmprscpEvent, Dcmpsrcv, DcmpsrcvEvent, DcmqrscpEvent, Dcmrecv, DcmrecvEvent, DcmtkProcess, DicomDataset, DicomInstance, DicomReceiver, DicomSend, DicomSender, DicomTagPathSchema, DicomTagSchema, FilenameMode, GetQueryModel, Img2dcmInputFormat, JplsColorConversion, LineParser, LutType, MAX_BLOCK_LINES, MAX_CHANGESET_OPERATIONS, MAX_EVENT_PATTERNS, MAX_TRAVERSAL_DEPTH, MoveQueryModel, PDU_SIZE, PacsClient, PortSchema, PreferredTransferSyntax, ProcessState, ProposedTransferSyntax, QueryLevel, QueryModel, REQUIRED_BINARIES, RetrieveMode, SOP_CLASSES, STORESCP_FATAL_EVENTS, STORESCP_PATTERNS, SenderHealth, SenderMode, StorageMode, StoreSCP, StoreSCPPreset, StorescpEvent, SubdirectoryMode, TransferSyntax, UIDSchema, UNIX_SEARCH_PATHS, VR, VR_CATEGORY, VR_CATEGORY_NAME, VR_META, WINDOWS_SEARCH_PATHS, WLMSCPFS_FATAL_EVENTS, WLMSCPFS_PATTERNS, Wlmscpfs, WlmscpfsEvent, assertUnreachable, batch, cda2dcm, clearDcmtkPathCache, createAETitle, createDicomFilePath, createDicomTag, createDicomTagPath, createPort, createSOPClassUID, createTransferSyntaxUID, dcm2cda, dcm2json, dcm2pdf, dcm2pnm, dcm2xml, dcmcjpeg, dcmcjpls, dcmconv, dcmcrle, dcmdecap, dcmdjpeg, dcmdjpls, dcmdrle, dcmdspfn, dcmdump, dcmencap, dcmftest, dcmgpdir, dcmj2pnm, dcmmkcrv, dcmmkdir, dcmmklut, dcmodify, dcmp2pgm, dcmprscu, dcmpschk, dcmpsmk, dcmpsprt, dcmqridx, dcmquant, dcmscale, dcmsend, dcod2lum, dconvlum, drtdump, dsr2xml, dsrdump, dump2dcm, echoscu, err, execCommand, findDcmtkPath, findscu, getVRCategory, getscu, img2dcm, isBinaryVR, isNumericVR, isStringVR, json2dcm, lookupTag, lookupTagByKeyword, lookupTagByName, mapResult, movescu, ok, parseAETitle, parseDicomTag, parseDicomTagPath, parsePort, parseSOPClassUID, parseTransferSyntaxUID, pdf2dcm, retry, segmentsToModifyPath, segmentsToString, sopClassNameFromUID, spawnCommand, stl2dcm, storescu, tag, tagPathToSegments, termscu, walkTags, xml2dcm, xml2dsr, xmlToJson };
+export { AETitleSchema, AssociationTracker, ChangeSet, ColorConversion, DCMPRSCP_FATAL_EVENTS, DCMPRSCP_PATTERNS, DCMPSRCV_FATAL_EVENTS, DCMPSRCV_PATTERNS, DCMQRSCP_FATAL_EVENTS, DCMQRSCP_PATTERNS, DCMRECV_FATAL_EVENTS, DCMRECV_PATTERNS, DEFAULT_BLOCK_TIMEOUT_MS, DEFAULT_DICOM_PORT, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_PARSE_CONCURRENCY, DEFAULT_START_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, Dcm2pnmOutputFormat, Dcm2xmlCharset, DcmQRSCP, DcmdumpFormat, Dcmj2pnmOutputFormat, DcmprsCP, DcmprscpEvent, Dcmpsrcv, DcmpsrcvEvent, DcmqrscpEvent, Dcmrecv, DcmrecvEvent, DcmtkProcess, DicomDataset, DicomHammer, DicomInstance, DicomReceiver, DicomSend, DicomSender, DicomTagPathSchema, DicomTagSchema, FilenameMode, GetQueryModel, HammerPhase, Img2dcmInputFormat, JplsColorConversion, LineParser, LutType, MAX_BLOCK_LINES, MAX_CHANGESET_OPERATIONS, MAX_EVENT_PATTERNS, MAX_TRAVERSAL_DEPTH, MoveQueryModel, PDU_SIZE, PacsClient, PortSchema, PreferredTransferSyntax, ProcessState, ProposedTransferSyntax, QueryLevel, QueryModel, REQUIRED_BINARIES, RetrieveMode, SOP_CLASSES, STORESCP_FATAL_EVENTS, STORESCP_PATTERNS, SenderHealth, SenderMode, StorageMode, StoreSCP, StoreSCPPreset, StorescpEvent, SubdirectoryMode, TransferSyntax, UIDSchema, UNIX_SEARCH_PATHS, VR, VR_CATEGORY, VR_CATEGORY_NAME, VR_META, WINDOWS_SEARCH_PATHS, WLMSCPFS_FATAL_EVENTS, WLMSCPFS_PATTERNS, Wlmscpfs, WlmscpfsEvent, assertUnreachable, batch, cda2dcm, clearDcmtkPathCache, createAETitle, createDicomFilePath, createDicomTag, createDicomTagPath, createPort, createSOPClassUID, createTransferSyntaxUID, dcm2cda, dcm2json, dcm2pdf, dcm2pnm, dcm2xml, dcmcjpeg, dcmcjpls, dcmconv, dcmcrle, dcmdecap, dcmdjpeg, dcmdjpls, dcmdrle, dcmdspfn, dcmdump, dcmencap, dcmftest, dcmgpdir, dcmj2pnm, dcmmkcrv, dcmmkdir, dcmmklut, dcmodify, dcmp2pgm, dcmprscu, dcmpschk, dcmpsmk, dcmpsprt, dcmqridx, dcmquant, dcmscale, dcmsend, dcod2lum, dconvlum, drtdump, dsr2xml, dsrdump, dump2dcm, echoscu, err, execCommand, findDcmtkPath, findscu, getVRCategory, getscu, img2dcm, isBinaryVR, isNumericVR, isStringVR, json2dcm, lookupTag, lookupTagByKeyword, lookupTagByName, mapResult, movescu, ok, parseAETitle, parseDicomTag, parseDicomTagPath, parsePort, parseSOPClassUID, parseTransferSyntaxUID, pdf2dcm, retry, segmentsToModifyPath, segmentsToString, sopClassNameFromUID, spawnCommand, stl2dcm, storescu, tag, tagPathToSegments, termscu, walkTags, xml2dcm, xml2dsr, xmlToJson };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map