ag-psd 32.0.0 → 33.0.0

package/src/ase.ts

@@ -1,4 +1,4 @@
-import { createReader, readFloat32, readSignature, readUint16, readUint32, readUnicodeStringWithLength } from './psdReader';
+import { createReader, PsdReader, readFloat32, readSignature, readUint16, readUint32, readUnicodeStringWithLength } from './psdReader';
 
 export type AseColorType = 'global' | 'spot' | 'normal';
 
@@ -35,79 +35,58 @@ export interface Ase {
   colors: (AseGroup | AseColor)[];
 }
 
-export function readAse(buffer: ArrayBufferView): Ase {
+export interface ReadAseOptions {
+  logMissingFeatures?: boolean;
+  /** Throw on unsupported or invalid blocks instead of skipping them */
+  throwForMissingFeatures?: boolean;
+}
+
+export function readAse(buffer: ArrayBufferView, options: ReadAseOptions = {}): Ase {
   const reader = createReader(buffer.buffer, buffer.byteOffset, buffer.byteLength);
   const signature = readSignature(reader); // ASEF
   if (signature !== 'ASEF') throw new Error('Invalid signature');
   const versionMajor = readUint16(reader); // 1
-  const versionMinor = readUint16(reader); // 0
-  if (versionMajor !== 1 || versionMinor !== 0) throw new Error('Invalid version');
+  readUint16(reader); // minor version: 0
+  if (versionMajor !== 1) throw new Error('Invalid version');
   const blocksCount = readUint32(reader);
-  const colorTypes: AseColorType[] = ['global', 'spot', 'normal'];
   const ase: Ase = { colors: [] };
   let group: Ase | AseGroup = ase;
 
-  for (let i = 0; i < blocksCount; i++) {
+  for (let i = 0; i < blocksCount && reader.offset + 6 <= reader.view.byteLength; i++) {
     const type = readUint16(reader);
     const length = readUint32(reader);
-    const end = reader.offset + length;
+    const end = Math.min(reader.offset + length, reader.view.byteLength);
+    // block reader, so invalid lengths can't make us read data of following blocks
+    const block = createReader(reader.view.buffer, reader.view.byteOffset + reader.offset, end - reader.offset);
 
-    switch (type) {
-      case 0x0001: { // color
-        const nameLength = readUint16(reader);
-        const name = readUnicodeStringWithLength(reader, nameLength);
-        const colorMode = readSignature(reader);
-        let color: AseColor['color'];
-        switch (colorMode) {
-          case 'RGB ':
-            color = {
-              r: readFloat32(reader),
-              g: readFloat32(reader),
-              b: readFloat32(reader),
-              type: colorTypes[readUint16(reader)],
-            };
-            break;
-          case 'CMYK':
-            color = {
-              c: readFloat32(reader),
-              m: readFloat32(reader),
-              y: readFloat32(reader),
-              k: readFloat32(reader),
-              type: colorTypes[readUint16(reader)],
-            };
-            break;
-          case 'Gray':
-            color = {
-              k: readFloat32(reader),
-              type: colorTypes[readUint16(reader)],
-            };
-            break;
-          case 'LAB ':
-            color = {
-              l: readFloat32(reader),
-              a: readFloat32(reader),
-              b: readFloat32(reader),
-              type: colorTypes[readUint16(reader)],
-            };
-            break;
-          default:
-            throw new Error('Invalid color mode');
+    try {
+      switch (type) {
+        case 0x0001: { // color
+          const color = readAseColor(block);
+          if (color) {
+            group.colors.push(color);
+          } else {
+            if (options.throwForMissingFeatures) throw new Error('Unsupported color mode');
+            options.logMissingFeatures && reader.log('Skipped color with unsupported color mode');
+          }
+          break;
         }
-        if (!color.type) throw new Error('Invalid color type');
-        group.colors.push({ name, color });
-        break;
-      }
-      case 0xC001: { // group start
-        const nameLength = readUint16(reader);
-        const name = readUnicodeStringWithLength(reader, nameLength);
-        ase.colors.push(group = { name, colors: [] });
-        break;
+        case 0xC001: { // group start
+          const nameLength = readUint16(block);
+          const name = readUnicodeStringWithLength(block, nameLength);
+          ase.colors.push(group = { name, colors: [] });
+          break;
+        }
+        case 0xC002: // group end
+          group = ase;
+          break;
+        default:
+          if (options.throwForMissingFeatures) throw new Error(`Invalid block type: ${type}`);
+          options.logMissingFeatures && reader.log(`Skipped unknown block type: ${type}`);
       }
-      case 0xC002: // group end
-        group = ase;
-        break;
-      default:
-        throw new Error('Invalid block type');
+    } catch (e) {
+      if (options.throwForMissingFeatures) throw e;
+      options.logMissingFeatures && reader.log(`Skipped invalid block: ${(e as Error).message}`);
     }
 
     reader.offset = end;
@@ -115,3 +94,29 @@ export function readAse(buffer: ArrayBufferView): Ase {
 
   return ase;
 }
+
+function readAseColor(reader: PsdReader): AseColor | undefined {
+  const nameLength = readUint16(reader);
+  const name = readUnicodeStringWithLength(reader, nameLength);
+  const colorMode = readSignature(reader);
+  // NaN and infinite values are replaced with 0
+  const value = () => {
+    const v = readFloat32(reader);
+    return isFinite(v) ? v : 0;
+  };
+  // color type is sometimes missing, unknown types are treated as process (normal) colors
+  const colorType = () => {
+    const index = reader.offset + 2 <= reader.view.byteLength ? readUint16(reader) : 2;
+    return colorTypes[index] || 'normal';
+  };
+
+  switch (colorMode) {
+    case 'RGB ': return { name, color: { r: value(), g: value(), b: value(), type: colorType() } };
+    case 'CMYK': return { name, color: { c: value(), m: value(), y: value(), k: value(), type: colorType() } };
+    case 'Gray': return { name, color: { k: value(), type: colorType() } };
+    case 'LAB ': return { name, color: { l: value(), a: value(), b: value(), type: colorType() } };
+    default: return undefined;
+  }
+}
+
+const colorTypes: AseColorType[] = ['global', 'spot', 'normal'];