dicom-synth 1.18.0 → 1.19.0

package/dist/esm/nonStandardDicom/dicomdir.js

@@ -1,30 +1,29 @@
+// src/platform/bytes.ts
+function utf8Bytes(text) {
+  return new TextEncoder().encode(text);
+}
+
 // src/nonStandardDicom/dicomdir.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
 var DICOMDIR_SOP_CLASS_UID = "1.2.840.10008.1.3.10";
 function buildDicomdirBuffer() {
   const uid = DICOMDIR_SOP_CLASS_UID;
-  const buf = Buffer.alloc(256, 0);
-  buf.write("DICM", 128, 4, "ascii");
+  const buf = new Uint8Array(256);
+  const view = new DataView(buf.buffer);
+  buf.set(utf8Bytes("DICM"), 128);
   let off = 132;
-  buf.writeUInt16LE(2, off);
+  view.setUint16(off, 2, true);
   off += 2;
-  buf.writeUInt16LE(2, off);
+  view.setUint16(off, 2, true);
   off += 2;
-  buf.write("UI", off, 2, "ascii");
+  buf.set(utf8Bytes("UI"), off);
   off += 2;
-  buf.writeUInt16LE(uid.length, off);
+  view.setUint16(off, uid.length, true);
   off += 2;
-  buf.write(uid, off, uid.length, "ascii");
+  buf.set(utf8Bytes(uid), off);
   off += uid.length;
   return buf.subarray(0, off);
 }
-function writeDicomdirFile(filePath) {
-  mkdirSync(resolve(filePath, ".."), { recursive: true });
-  writeFileSync(filePath, buildDicomdirBuffer());
-}
 export {
   DICOMDIR_SOP_CLASS_UID,
-  buildDicomdirBuffer,
-  writeDicomdirFile
+  buildDicomdirBuffer
 };

package/dist/esm/platform/bytes.js

@@ -0,0 +1,39 @@
+// src/platform/bytes.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function utf8Bytes(text) {
+  return new TextEncoder().encode(text);
+}
+function concatBytes(...parts) {
+  const out = new Uint8Array(parts.reduce((sum, p) => sum + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function patternBytes(length, pattern) {
+  const out = new Uint8Array(length);
+  const seed = utf8Bytes(pattern);
+  if (length === 0 || seed.length === 0) return out;
+  out.set(seed.subarray(0, Math.min(seed.length, length)));
+  let filled = Math.min(seed.length, length);
+  while (filled < length) {
+    const chunk = Math.min(filled, length - filled);
+    out.copyWithin(filled, 0, chunk);
+    filled += chunk;
+  }
+  return out;
+}
+export {
+  bytesToHex,
+  concatBytes,
+  patternBytes,
+  utf8Bytes
+};

package/dist/esm/platform/random.js

@@ -0,0 +1,22 @@
+// src/platform/bytes.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+// src/platform/random.ts
+function randomUint32() {
+  return globalThis.crypto.getRandomValues(new Uint32Array(1))[0];
+}
+function randomHex(byteLength) {
+  return bytesToHex(
+    globalThis.crypto.getRandomValues(new Uint8Array(byteLength))
+  );
+}
+export {
+  randomHex,
+  randomUint32
+};

package/dist/esm/platform/sha256.js

@@ -0,0 +1,131 @@
+// src/platform/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256(input) {
+  const data = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const padded = new Uint8Array((data.length + 8 >> 6) + 1 << 6);
+  padded.set(data);
+  padded[data.length] = 128;
+  new DataView(padded.buffer).setBigUint64(
+    padded.length - 8,
+    BigInt(data.length * 8),
+    false
+  );
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  const view = new DataView(padded.buffer);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(offset + t * 4, false);
+    for (let t = 16; t < 64; t++) {
+      const s0 = rotr(w[t - 15], 7) ^ rotr(w[t - 15], 18) ^ w[t - 15] >>> 3;
+      const s1 = rotr(w[t - 2], 17) ^ rotr(w[t - 2], 19) ^ w[t - 2] >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[t] + w[t] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) outView.setUint32(i * 4, h[i], false);
+  return out;
+}
+export {
+  sha256
+};

package/dist/esm/schema/parametric.js

@@ -1,8 +1,77 @@
-// src/schema/parametric.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
+// src/platform/random.ts
+function randomUint32() {
+  return globalThis.crypto.getRandomValues(new Uint32Array(1))[0];
+}
+
+// src/platform/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
 
 // src/syntheticFixtures/uid.ts
-import { createHash, randomBytes } from "node:crypto";
 function lcg(seed) {
   let s = seed >>> 0;
   return () => {
@@ -548,7 +617,7 @@ function fraction(next) {
 }
 function resolveParametricSpec(spec) {
   const validated = validateParametricSpec(spec);
-  const seed = validated.seed ?? randomBytes2(4).readUInt32BE(0);
+  const seed = validated.seed ?? randomUint32();
   const next = seededStream(seed, PARAMETRIC_STREAM_OFFSET, 0, 0);
   const params = validated.studies;
   const studies = [];

package/dist/esm/syntheticFixtures/generator.js

@@ -17,24 +17,41 @@ function loadDcmjs() {
 }
 var dcmjs = loadDcmjs();
 
+// src/platform/bytes.ts
+function utf8Bytes(text) {
+  return new TextEncoder().encode(text);
+}
+function patternBytes(length, pattern) {
+  const out = new Uint8Array(length);
+  const seed = utf8Bytes(pattern);
+  if (length === 0 || seed.length === 0) return out;
+  out.set(seed.subarray(0, Math.min(seed.length, length)));
+  let filled = Math.min(seed.length, length);
+  while (filled < length) {
+    const chunk = Math.min(filled, length - filled);
+    out.copyWithin(filled, 0, chunk);
+    filled += chunk;
+  }
+  return out;
+}
+
 // src/nonStandardDicom/dicomdir.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
 var DICOMDIR_SOP_CLASS_UID = "1.2.840.10008.1.3.10";
 function buildDicomdirBuffer() {
   const uid = DICOMDIR_SOP_CLASS_UID;
-  const buf = Buffer.alloc(256, 0);
-  buf.write("DICM", 128, 4, "ascii");
+  const buf = new Uint8Array(256);
+  const view = new DataView(buf.buffer);
+  buf.set(utf8Bytes("DICM"), 128);
   let off = 132;
-  buf.writeUInt16LE(2, off);
+  view.setUint16(off, 2, true);
   off += 2;
-  buf.writeUInt16LE(2, off);
+  view.setUint16(off, 2, true);
   off += 2;
-  buf.write("UI", off, 2, "ascii");
+  buf.set(utf8Bytes("UI"), off);
   off += 2;
-  buf.writeUInt16LE(uid.length, off);
+  view.setUint16(off, uid.length, true);
   off += 2;
-  buf.write(uid, off, uid.length, "ascii");
+  buf.set(utf8Bytes(uid), off);
   off += uid.length;
   return buf.subarray(0, off);
 }
@@ -191,7 +208,7 @@ function serializeDict(meta, dataset, rawElements) {
   if (rawElements) {
     Object.assign(dicomDict.dict, rawElements);
   }
-  return Buffer.from(dicomDict.write({ allowInvalidVRLength: true }));
+  return new Uint8Array(dicomDict.write({ allowInvalidVRLength: true }));
 }
 var MAX_DIMENSION = 65535;
 function applySizing(dataset, meta, spec, rawElements) {
@@ -236,8 +253,8 @@ function buildImageBuffer(spec, uid) {
   return { buffer: serializeDict(meta, dataset, rawElements), rawElements };
 }
 function buildFakeSignatureBuffer() {
-  const buf = Buffer.alloc(200, 0);
-  buf.write("XXXX", 128, 4, "ascii");
+  const buf = new Uint8Array(200);
+  buf.set(utf8Bytes("XXXX"), 128);
   return buf;
 }
 function sizedNonDicomBytes(spec) {
@@ -245,8 +262,8 @@ function sizedNonDicomBytes(spec) {
 }
 function buildNonDicomBuffer(spec) {
   const bytes = sizedNonDicomBytes(spec);
-  if (bytes !== void 0) return Buffer.alloc(bytes, "not dicom ");
-  return Buffer.from(spec.content ?? "not dicom", "utf8");
+  if (bytes !== void 0) return patternBytes(bytes, "not dicom ");
+  return utf8Bytes(spec.content ?? "not dicom");
 }
 function buildBufferForSpec(spec, uid) {
   switch (spec.type) {

package/dist/esm/syntheticFixtures/streamWrite.js

@@ -1,6 +1,6 @@
 // src/syntheticFixtures/streamWrite.ts
-import { closeSync, mkdirSync as mkdirSync2, openSync, writeSync } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+import { closeSync, mkdirSync, openSync, writeSync } from "node:fs";
+import { resolve } from "node:path";
 
 // src/schema/limits.ts
 var MAX_PIXEL_BYTES = 512 * 1024 * 1024;
@@ -25,9 +25,14 @@ function loadDcmjs() {
 }
 var dcmjs = loadDcmjs();
 
-// src/nonStandardDicom/dicomdir.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
+// src/platform/bytes.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
 
 // src/schema/validate.ts
 var HEX_TAG_RE = /^[0-9a-fA-F]{8}$/;
@@ -177,18 +182,153 @@ function serializeDict(meta, dataset, rawElements) {
   if (rawElements) {
     Object.assign(dicomDict.dict, rawElements);
   }
-  return Buffer.from(dicomDict.write({ allowInvalidVRLength: true }));
+  return new Uint8Array(dicomDict.write({ allowInvalidVRLength: true }));
+}
+
+// src/platform/random.ts
+function randomHex(byteLength) {
+  return bytesToHex(
+    globalThis.crypto.getRandomValues(new Uint8Array(byteLength))
+  );
+}
+
+// src/platform/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256(input) {
+  const data2 = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const padded = new Uint8Array((data2.length + 8 >> 6) + 1 << 6);
+  padded.set(data2);
+  padded[data2.length] = 128;
+  new DataView(padded.buffer).setBigUint64(
+    padded.length - 8,
+    BigInt(data2.length * 8),
+    false
+  );
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  const view = new DataView(padded.buffer);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(offset + t * 4, false);
+    for (let t = 16; t < 64; t++) {
+      const s0 = rotr(w[t - 15], 7) ^ rotr(w[t - 15], 18) ^ w[t - 15] >>> 3;
+      const s1 = rotr(w[t - 2], 17) ^ rotr(w[t - 2], 19) ^ w[t - 2] >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[t] + w[t] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) outView.setUint32(i * 4, h[i], false);
+  return out;
 }
 
 // src/syntheticFixtures/uid.ts
-import { createHash, randomBytes } from "node:crypto";
 function hashUid(salt, key) {
-  const digest = createHash("sha256").update(salt).update(" ").update(key).digest();
-  const n = BigInt(`0x${digest.subarray(0, 16).toString("hex")}`);
+  const digest = sha256(`${salt} ${key}`);
+  const n = BigInt(`0x${bytesToHex(digest.subarray(0, 16))}`);
   return `2.25.${n.toString()}`;
 }
 function randomUid() {
-  const n = BigInt(`0x${randomBytes(16).toString("hex")}`);
+  const n = BigInt(`0x${randomHex(16)}`);
   return `2.25.${n.toString()}`;
 }
 function seedToSalt(seed) {
@@ -215,6 +355,9 @@ var PIXEL_DATA_OB_HEADER = Buffer.from([224, 127, 16, 0, 79, 66]);
 var ITEM_TAG_GROUP = 65534;
 var ITEM_TAG_ELEMENT = 57344;
 var SEQUENCE_DELIMITER_ELEMENT = 57565;
+function asBuffer(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
 function itemTag(element, byteLength = 0) {
   const b = Buffer.alloc(8);
   b.writeUInt16LE(ITEM_TAG_GROUP, 0);
@@ -245,7 +388,7 @@ function writeNative(outPath, params, dims, zeroChunk) {
   dataset.Rows = dims.rows;
   dataset.Columns = dims.columns;
   const minimalPixelBytes = dataset.PixelData.byteLength;
-  const probe = serializeDict(meta, dataset, rawElements);
+  const probe = asBuffer(serializeDict(meta, dataset, rawElements));
   const pixelElement = Buffer.alloc(12);
   PIXEL_DATA_OW_HEADER.copy(pixelElement);
   pixelElement.writeUInt32LE(minimalPixelBytes, 8);
@@ -278,7 +421,7 @@ function writeEncapsulated(outPath, params, pixelBytes, fragmentBytes, zeroChunk
   syncMetaWithDataset(meta, dataset, rawElements);
   dataset.PixelData = [new Uint8Array([]).buffer, new Uint8Array([0, 0]).buffer];
   dataset._vrMap = { PixelData: "OB" };
-  const probe = serializeDict(meta, dataset, rawElements);
+  const probe = asBuffer(serializeDict(meta, dataset, rawElements));
   const idx = probe.indexOf(PIXEL_DATA_OB_HEADER);
   if (idx < 0 || probe.readUInt32LE(idx + 8) !== 4294967295) {
     throw new Error("failed to locate encapsulated PixelData element header");
@@ -319,7 +462,7 @@ function streamLargeImage(outPath, options) {
   const modality = options.modality ?? "CT";
   const uid = options.uid ?? makeUidGenerator(options.uidSalt ?? seedToSalt(options.seed))(0);
   const identity = { modality, uid, tags: options.tags };
-  mkdirSync2(resolve2(outPath, ".."), { recursive: true });
+  mkdirSync(resolve(outPath, ".."), { recursive: true });
   const zeroChunk = Buffer.alloc(Math.max(1, chunkBytes));
   const probe = serializeDict(
     buildMeta(uid, modality),