ag-psd 32.0.0 → 33.0.0

package/dist/abr.d.ts

@@ -85,6 +85,7 @@ interface DynamicBrushShape {
 }
 export interface Brush {
     name: string;
+    group?: string[];
     shape: BrushShape;
     shapeDynamics?: {
         sizeDynamics: BrushDynamics;
@@ -138,8 +139,8 @@ export interface Brush {
     transfer?: {
         flowDynamics: BrushDynamics;
         opacityDynamics: BrushDynamics;
-        wetnessDynamics: BrushDynamics;
-        mixDynamics: BrushDynamics;
+        wetnessDynamics?: BrushDynamics;
+        mixDynamics?: BrushDynamics;
     };
     brushPose?: {
         overrideAngle: boolean;
@@ -153,6 +154,7 @@ export interface Brush {
     };
     noise: boolean;
     wetEdges: boolean;
+    buildUp: boolean;
     protectTexture?: boolean;
     spacing: number;
     brushGroup?: undefined;
@@ -190,7 +192,12 @@ export interface Brush {
         strength?: number;
     };
 }
-export declare function readAbr(buffer: ArrayBufferView, options?: {
+export interface ReadAbrOptions {
     logMissingFeatures?: boolean;
-}): Abr;
+    /** Throw on unsupported or invalid parts of the file instead of skipping them */
+    throwForMissingFeatures?: boolean;
+    /** Memory limit for decoded data in bytes (2GB by default), set to `undefined` explicitly to disable */
+    totalMemoryLimit?: number;
+}
+export declare function readAbr(buffer: ArrayBufferView, options?: ReadAbrOptions): Abr;
 export {};

package/dist/abr.js

@@ -98,261 +98,92 @@ function parseHeightmap(array) {
     // return result;
 }
 function readAbr(buffer, options = {}) {
-    var _a, _b, _c, _d;
     const reader = (0, psdReader_1.createReader)(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    reader.logMissingFeatures = options.logMissingFeatures;
+    reader.throwForMissingFeatures = options.throwForMissingFeatures;
+    reader.totalMemoryLimit = 'totalMemoryLimit' in options ? options.totalMemoryLimit : 2 * 1024 * 1024 * 1024;
+    // skips invalid or unsupported part of the file
+    const skip = (e, what) => {
+        if (options.throwForMissingFeatures)
+            throw e;
+        options.logMissingFeatures && reader.log(`Skipped ${what}: ${e.message}`);
+    };
+    if (reader.view.byteLength < 4)
+        throw new Error('Invalid ABR file');
     const version = (0, psdReader_1.readInt16)(reader);
     const samples = [];
     const brushes = [];
     const patterns = [];
+    const brushByPreset = []; // brush for each preset in 'desc' section (brushes that fail to parse are skipped)
+    let hierarchy;
     if (version === 1 || version === 2) {
-        throw new Error(`Unsupported ABR version (${version})`); // TODO: ...
+        readLegacyBrushes(reader, version, samples, brushes, skip);
     }
     else if (version === 6 || version === 7 || version === 9 || version === 10) {
         const minorVersion = (0, psdReader_1.readInt16)(reader);
         if (minorVersion !== 1 && minorVersion !== 2)
             throw new Error('Unsupported ABR minor version');
-        while (reader.offset < reader.view.byteLength) {
+        // section header is 12 bytes, ignore any shorter trailing data
+        while (reader.offset + 12 <= reader.view.byteLength) {
             (0, psdReader_1.checkSignature)(reader, '8BIM');
             const type = (0, psdReader_1.readSignature)(reader);
             const size = (0, psdReader_1.readUint32)(reader);
-            const end = reader.offset + size;
-            switch (type) {
-                case 'samp': {
-                    while (reader.offset < end) {
-                        let brushLength = (0, psdReader_1.readUint32)(reader);
-                        while (brushLength & 0b11)
-                            brushLength++; // pad to 4 byte alignment
-                        const brushEnd = reader.offset + brushLength;
-                        const id = (0, psdReader_1.readPascalString)(reader, 1);
-                        // v1 - Skip the Int16 bounds rectangle and the unknown Int16.
-                        // v2 - Skip the unknown bytes.
-                        (0, psdReader_1.skipBytes)(reader, minorVersion === 1 ? 10 : 264);
-                        const y = (0, psdReader_1.readInt32)(reader);
-                        const x = (0, psdReader_1.readInt32)(reader);
-                        const h = (0, psdReader_1.readInt32)(reader) - y;
-                        const w = (0, psdReader_1.readInt32)(reader) - x;
-                        if (w <= 0 || h <= 0)
-                            throw new Error('Invalid bounds');
-                        if (w > MAX_BRUSH_SIZE || h > MAX_BRUSH_SIZE) {
-                            throw new Error(`Brush sample too large (${w}x${h})`);
-                        }
-                        const bithDepth = (0, psdReader_1.readInt16)(reader);
-                        const compression = (0, psdReader_1.readUint8)(reader); // 0 - raw, 1 - RLE
-                        if (compression === 0 && w * h * (bithDepth === 16 ? 2 : 1) > brushEnd - reader.offset) {
-                            throw new Error('Brush sample data out of bounds');
-                        }
-                        const alpha = new Uint8Array(w * h);
-                        if (bithDepth === 8) {
-                            if (compression === 0) {
-                                alpha.set((0, psdReader_1.readBytes)(reader, alpha.byteLength));
-                            }
-                            else if (compression === 1) {
-                                (0, psdReader_1.readDataRLE)(reader, { width: w, height: h, data: alpha }, w, h, bithDepth, 1, [0], false);
+            const end = Math.min(reader.offset + size, reader.view.byteLength);
+            try {
+                switch (type) {
+                    case 'samp': {
+                        while (reader.offset + 4 <= end) {
+                            let brushLength = (0, psdReader_1.readUint32)(reader);
+                            while (brushLength & 0b11)
+                                brushLength++; // pad to 4 byte alignment
+                            const brushEnd = Math.min(reader.offset + brushLength, end);
+                            try {
+                                const sample = readSample(reader, brushEnd, minorVersion);
+                                samples.push(sample);
                             }
-                            else {
-                                throw new Error('Invalid compression');
+                            catch (e) {
+                                skip(e, 'brush sample');
                             }
+                            reader.offset = brushEnd;
                         }
-                        else if (bithDepth === 16) {
-                            if (compression === 0) {
-                                for (let i = 0; i < alpha.byteLength; i++) {
-                                    alpha[i] = (0, psdReader_1.readUint16)(reader) >> 8; // convert to 8bit values
-                                }
-                            }
-                            else if (compression === 1) {
-                                throw new Error('not implemented (16bit RLE)'); // TODO: ...
+                        break;
+                    }
+                    case 'desc': {
+                        const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
+                        for (const [index, brush] of (desc.Brsh || []).entries()) {
+                            try {
+                                const parsed = parseBrush(brush);
+                                brushes.push(parsed);
+                                brushByPreset[index] = parsed;
                             }
-                            else {
-                                throw new Error('Invalid compression');
+                            catch (e) {
+                                skip(e, `brush "${brush['Nm  ']}"`);
                             }
                         }
-                        else {
-                            throw new Error('Invalid depth');
-                        }
-                        samples.push({ id, bounds: { x, y, w, h }, alpha });
-                        reader.offset = brushEnd;
+                        break;
                     }
-                    break;
-                }
-                case 'desc': {
-                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
-                    // console.log(require('util').inspect(desc, false, 99, true));
-                    // require('fs').writeFileSync('test.log', require('util').inspect(desc, false, 99, false), 'utf8');
-                    for (const brush of desc.Brsh) {
-                        const b = {
-                            name: brush['Nm  '],
-                            shape: parseBrushShape(brush.Brsh),
-                            spacing: (0, descriptor_1.parsePercent)(brush.Spcn),
-                            // TODO: brushGroup ???
-                            wetEdges: brush.Wtdg,
-                            noise: brush.Nose,
-                            // TODO: TxtC ??? smoothing / build-up ?
-                            // TODO: 'Rpt ' ???
-                            useBrushSize: brush.useBrushSize, // ???
-                        };
-                        if (brush.interpretation != null)
-                            b.interpretation = brush.interpretation;
-                        if (brush.protectTexture != null)
-                            b.protectTexture = brush.protectTexture;
-                        if (brush.useTipDynamics) {
-                            b.shapeDynamics = {
-                                tiltScale: (0, descriptor_1.parsePercent)(brush.tiltScale),
-                                sizeDynamics: parseDynamics(brush.szVr),
-                                angleDynamics: parseDynamics(brush.angleDynamics),
-                                roundnessDynamics: parseDynamics(brush.roundnessDynamics),
-                                flipX: brush.flipX,
-                                flipY: brush.flipY,
-                                brushProjection: brush.brushProjection,
-                                minimumDiameter: (0, descriptor_1.parsePercent)(brush.minimumDiameter),
-                                minimumRoundness: (0, descriptor_1.parsePercent)(brush.minimumRoundness),
-                            };
-                        }
-                        if (brush.useScatter) {
-                            b.scatter = {
-                                count: brush['Cnt '],
-                                bothAxes: brush.bothAxes,
-                                countDynamics: parseDynamics(brush.countDynamics),
-                                scatterDynamics: parseDynamics(brush.scatterDynamics),
-                            };
-                        }
-                        if (brush.useTexture && brush.Txtr) {
-                            b.texture = {
-                                id: brush.Txtr.Idnt,
-                                name: brush.Txtr['Nm  '],
-                                blendMode: descriptor_1.BlnM.decode(brush.textureBlendMode),
-                                depth: (0, descriptor_1.parsePercent)(brush.textureDepth),
-                                depthMinimum: (0, descriptor_1.parsePercent)(brush.minimumDepth),
-                                depthDynamics: parseDynamics(brush.textureDepthDynamics),
-                                scale: (0, descriptor_1.parsePercent)(brush.textureScale),
-                                invert: brush.InvT,
-                                brightness: brush.textureBrightness,
-                                contrast: brush.textureContrast,
-                                textureEachTip: !!brush.TxtC,
-                            };
-                        }
-                        const db = brush.dualBrush;
-                        if (db && db.useDualBrush) {
-                            b.dualBrush = {
-                                flip: db.Flip,
-                                shape: parseBrushShape(db.Brsh),
-                                blendMode: descriptor_1.BlnM.decode(db.BlnM),
-                                useScatter: db.useScatter,
-                                spacing: (0, descriptor_1.parsePercent)(db.Spcn),
-                                count: db['Cnt '],
-                                bothAxes: db.bothAxes,
-                                countDynamics: parseDynamics(db.countDynamics),
-                                scatterDynamics: parseDynamics(db.scatterDynamics),
-                            };
-                        }
-                        if (brush.useColorDynamics) {
-                            b.colorDynamics = {
-                                foregroundBackground: parseDynamics(brush.clVr),
-                                hue: (0, descriptor_1.parsePercent)(brush['H   ']),
-                                saturation: (0, descriptor_1.parsePercent)(brush.Strt),
-                                brightness: (0, descriptor_1.parsePercent)(brush.Brgh),
-                                purity: (0, descriptor_1.parsePercent)(brush.purity),
-                                perTip: brush.colorDynamicsPerTip,
-                            };
-                        }
-                        if (brush.usePaintDynamics) {
-                            b.transfer = {
-                                flowDynamics: parseDynamics(brush.prVr),
-                                opacityDynamics: parseDynamics(brush.opVr),
-                                wetnessDynamics: parseDynamics(brush.wtVr),
-                                mixDynamics: parseDynamics(brush.mxVr),
-                            };
-                        }
-                        if (brush.useBrushPose) {
-                            b.brushPose = {
-                                overrideAngle: brush.overridePoseAngle,
-                                overrideTiltX: brush.overridePoseTiltX,
-                                overrideTiltY: brush.overridePoseTiltY,
-                                overridePressure: brush.overridePosePressure,
-                                pressure: (0, descriptor_1.parsePercent)(brush.brushPosePressure),
-                                tiltX: brush.brushPoseTiltX,
-                                tiltY: brush.brushPoseTiltY,
-                                angle: brush.brushPoseAngle,
-                            };
-                        }
-                        const to = brush.toolOptions;
-                        if (to) {
-                            b.toolOptions = {
-                                type: toBrushType[to._classID] || 'brush',
-                                brushPreset: to.brushPreset,
-                                flow: (_a = to.flow) !== null && _a !== void 0 ? _a : 100,
-                                smooth: (_b = to.Smoo) !== null && _b !== void 0 ? _b : 0,
-                                mode: descriptor_1.BlnM.decode(to['Md  '] || 'BlnM.Nrml'), // sometimes mode is missing
-                                opacity: (_c = to.Opct) !== null && _c !== void 0 ? _c : 100,
-                                smoothing: !!to.smoothing,
-                                smoothingValue: to.smoothingValue || 0,
-                                smoothingRadiusMode: !!to.smoothingRadiusMode,
-                                smoothingCatchup: !!to.smoothingCatchup,
-                                smoothingCatchupAtEnd: !!to.smoothingCatchupAtEnd,
-                                smoothingZoomCompensation: !!to.smoothingZoomCompensation,
-                                pressureSmoothing: !!to.pressureSmoothing,
-                                usePressureOverridesSize: !!to.usePressureOverridesSize,
-                                usePressureOverridesOpacity: !!to.usePressureOverridesOpacity,
-                                useLegacy: !!to.useLegacy,
-                            };
-                            if (to.prVr)
-                                b.toolOptions.flowDynamics = parseDynamics(to.prVr);
-                            if (to.opVr)
-                                b.toolOptions.opacityDynamics = parseDynamics(to.opVr);
-                            if (to.szVr)
-                                b.toolOptions.sizeDynamics = parseDynamics(to.szVr);
-                            if ('wetness' in to)
-                                b.toolOptions.wetness = to.wetness;
-                            if ('dryness' in to)
-                                b.toolOptions.dryness = to.dryness;
-                            if ('mix' in to)
-                                b.toolOptions.mix = to.mix;
-                            if ('autoFill' in to)
-                                b.toolOptions.autoFill = to.autoFill;
-                            if ('autoClean' in to)
-                                b.toolOptions.autoClean = to.autoClean;
-                            if ('loadSolidColorOnly' in to)
-                                b.toolOptions.loadSolidColorOnly = to.loadSolidColorOnly;
-                            if ('sampleAllLayers' in to)
-                                b.toolOptions.sampleAllLayers = to.sampleAllLayers;
-                            if ('SmdF' in to)
-                                b.toolOptions.smudgeFingerPainting = to.SmdF;
-                            if ('SmdS' in to)
-                                b.toolOptions.smudgeSampleAllLayers = to.SmdS;
-                            if ('Prs ' in to)
-                                b.toolOptions.strength = to['Prs '];
+                    case 'patt': {
+                        while (reader.offset + 4 <= end) {
+                            const pattern = (0, psdReader_1.readPatternSafe)(reader);
+                            if (pattern)
+                                patterns.push(pattern);
                         }
-                        brushes.push(b);
+                        break;
                     }
-                    break;
-                }
-                case 'patt': {
-                    while (reader.offset < end) {
-                        patterns.push((0, psdReader_1.readPattern)(reader));
-                    }
-                    reader.offset = end;
-                    break;
-                }
-                case 'phry': {
-                    // TODO: what is this ?
-                    const desc = (0, descriptor_1.readVersionAndDescriptor)(reader);
-                    // example:
-                    // hierarchy: [
-                    // 	{
-                    // 		'Nm  ': 'PRE_EXPORT ',
-                    // 		zuid: '965209f2-6f35-9a40-aa43-485684382172'
-                    // 	},
-                    // 	{},
-                    //  ...
-                    // ]
-                    if (options.logMissingFeatures) {
-                        if ((_d = desc.hierarchy) === null || _d === void 0 ? void 0 : _d.length) {
-                            // console.log('unhandled phry section', desc);
-                        }
+                    case 'phry': { // brush groups (folders in brushes panel)
+                        // flat list of group starts, presets (in the same order as in 'desc' section) and group ends
+                        const desc = (0, descriptor_1.readVersionAndDescriptor)(reader, true);
+                        hierarchy = desc.hierarchy;
+                        break;
                     }
-                    break;
+                    default:
+                        // 'lPdc' (tool presets) and other unknown sections
+                        options.logMissingFeatures && reader.log(`Unhandled brush section: ${type}`);
+                        break;
                 }
-                default:
-                    throw new Error(`Invalid brush type: ${type}`);
+            }
+            catch (e) {
+                skip(e, `brush section ${type}`);
             }
             // skip any unread data in the section and align to 4 bytes
             reader.offset = end;
@@ -363,6 +194,302 @@ function readAbr(buffer, options = {}) {
     else {
         throw new Error(`Unsupported ABR version (${version})`);
     }
+    if (hierarchy) {
+        const groups = [];
+        let presetIndex = 0;
+        for (const item of hierarchy) {
+            if (item._classID === 'Grup') {
+                groups.push(item['Nm  ']);
+            }
+            else if (item._classID === 'groupEnd') {
+                groups.pop();
+            }
+            else if (item._classID === 'preset') {
+                const brush = brushByPreset[presetIndex];
+                if (brush && groups.length)
+                    brush.group = groups.slice();
+                presetIndex++;
+            }
+        }
+    }
     return { samples, patterns, brushes };
 }
+function readSample(reader, brushEnd, minorVersion) {
+    const id = (0, psdReader_1.readPascalString)(reader, 1);
+    // v1 - Skip the Int16 bounds rectangle and the unknown Int16.
+    // v2 - Skip the unknown bytes.
+    (0, psdReader_1.skipBytes)(reader, minorVersion === 1 ? 10 : 264);
+    return readSampleBitmap(reader, brushEnd, id);
+}
+// bounds, bit depth, compression and image data of brush sample
+function readSampleBitmap(reader, brushEnd, id) {
+    const y = (0, psdReader_1.readInt32)(reader);
+    const x = (0, psdReader_1.readInt32)(reader);
+    const h = (0, psdReader_1.readInt32)(reader) - y;
+    const w = (0, psdReader_1.readInt32)(reader) - x;
+    if (w <= 0 || h <= 0)
+        throw new Error('Invalid bounds');
+    if (w > MAX_BRUSH_SIZE || h > MAX_BRUSH_SIZE) {
+        throw new Error(`Brush sample too large (${w}x${h})`);
+    }
+    const bithDepth = (0, psdReader_1.readInt16)(reader);
+    const compression = (0, psdReader_1.readUint8)(reader); // 0 - raw, 1 - RLE
+    if (bithDepth !== 8 && bithDepth !== 16)
+        throw new Error('Invalid depth');
+    if (compression !== 0 && compression !== 1)
+        throw new Error('Invalid compression');
+    const rowSize = w * (bithDepth === 16 ? 2 : 1);
+    // RLE needs at least 2 bytes for row length and 2 bytes per each 128 byte run
+    const minDataSize = compression === 0 ? h * rowSize : h * (2 + Math.ceil(rowSize / 128) * 2);
+    if (minDataSize > brushEnd - reader.offset) {
+        throw new Error('Brush sample data out of bounds');
+    }
+    (0, psdReader_1.consumeMemory)(reader, w * h * (compression === 1 && bithDepth === 16 ? 3 : 1));
+    const alpha = new Uint8Array(w * h);
+    if (bithDepth === 8) {
+        if (compression === 0) {
+            alpha.set((0, psdReader_1.readBytes)(reader, alpha.byteLength));
+        }
+        else if (compression === 1) {
+            (0, psdReader_1.readDataRLE)(reader, { width: w, height: h, data: alpha }, w, h, bithDepth, 1, [0], false);
+        }
+        else {
+            throw new Error('Invalid compression');
+        }
+    }
+    else if (bithDepth === 16) {
+        if (compression === 0) {
+            for (let i = 0; i < alpha.byteLength; i++) {
+                alpha[i] = (0, psdReader_1.readUint16)(reader) >> 8; // convert to 8bit values
+            }
+        }
+        else if (compression === 1) {
+            const data = new Uint16Array(w * h);
+            (0, psdReader_1.readDataRLE)(reader, { width: w, height: h, data }, w, h, bithDepth, 1, [0], false);
+            for (let i = 0; i < alpha.byteLength; i++) {
+                alpha[i] = data[i] >> 8; // convert to 8bit values
+            }
+        }
+        else {
+            throw new Error('Invalid compression');
+        }
+    }
+    else {
+        throw new Error('Invalid depth');
+    }
+    return { id, bounds: { x, y, w, h }, alpha };
+}
+// ABR versions 1 and 2 (Photoshop 6 and earlier) contain a list of brushes with brush tips in them
+function readLegacyBrushes(reader, version, samples, brushes, skip) {
+    const count = (0, psdReader_1.readUint16)(reader);
+    for (let i = 0; i < count; i++) {
+        const type = (0, psdReader_1.readUint16)(reader);
+        const size = (0, psdReader_1.readUint32)(reader);
+        const end = reader.offset + size;
+        if (end > reader.view.byteLength) { // truncated file
+            skip(new Error('Brush data out of bounds'), `brush ${i + 1}`);
+            break;
+        }
+        try {
+            if (type === 1) { // computed brush
+                (0, psdReader_1.skipBytes)(reader, 4); // misc
+                const spacing = (0, psdReader_1.readUint16)(reader);
+                const diameter = (0, psdReader_1.readUint16)(reader);
+                const roundness = (0, psdReader_1.readUint16)(reader);
+                const angle = (0, psdReader_1.readInt16)(reader);
+                const hardness = (0, psdReader_1.readUint16)(reader);
+                if (reader.offset > end)
+                    throw new Error('Brush data out of bounds');
+                brushes.push(createLegacyBrush('', {
+                    type: 'computed',
+                    size: diameter,
+                    angle,
+                    roundness: roundness / 100,
+                    spacingOn: spacing !== 0,
+                    spacing: spacing / 100,
+                    flipX: false,
+                    flipY: false,
+                    hardness: hardness / 100,
+                }));
+            }
+            else if (type === 2) { // sampled brush
+                (0, psdReader_1.skipBytes)(reader, 4); // misc
+                const spacing = (0, psdReader_1.readUint16)(reader);
+                const name = version === 2 ? (0, psdReader_1.readUnicodeString)(reader) : '';
+                (0, psdReader_1.skipBytes)(reader, 1 + 8); // antialiasing, Int16 bounds rectangle (same as Int32 one)
+                // legacy brushes don't have sample ids
+                const sample = readSampleBitmap(reader, end, `brush-${i + 1}`);
+                samples.push(sample);
+                brushes.push(createLegacyBrush(name, {
+                    type: 'sampled',
+                    size: Math.max(sample.bounds.w, sample.bounds.h),
+                    angle: 0,
+                    roundness: 1,
+                    spacingOn: spacing !== 0,
+                    spacing: spacing / 100,
+                    flipX: false,
+                    flipY: false,
+                    name,
+                    sampledData: sample.id,
+                }));
+            }
+            else {
+                throw new Error(`Unknown brush type: ${type}`);
+            }
+        }
+        catch (e) {
+            skip(e, `brush ${i + 1}`);
+        }
+        reader.offset = end;
+    }
+}
+function createLegacyBrush(name, shape) {
+    return { name, shape, spacing: 1, wetEdges: false, noise: false, buildUp: false, useBrushSize: true };
+}
+function parseBrush(brush) {
+    var _a, _b, _c;
+    const b = {
+        name: brush['Nm  '],
+        shape: parseBrushShape(brush.Brsh),
+        spacing: (0, descriptor_1.parsePercent)(brush.Spcn),
+        wetEdges: brush.Wtdg,
+        noise: brush.Nose,
+        buildUp: !!brush['Rpt '],
+        useBrushSize: brush.useBrushSize, // ???
+    };
+    if (brush.interpretation != null)
+        b.interpretation = brush.interpretation;
+    if (brush.protectTexture != null)
+        b.protectTexture = brush.protectTexture;
+    if (brush.useTipDynamics) {
+        b.shapeDynamics = {
+            tiltScale: (0, descriptor_1.parsePercent)(brush.tiltScale),
+            sizeDynamics: parseDynamics(brush.szVr),
+            angleDynamics: parseDynamics(brush.angleDynamics),
+            roundnessDynamics: parseDynamics(brush.roundnessDynamics),
+            flipX: brush.flipX,
+            flipY: brush.flipY,
+            brushProjection: brush.brushProjection,
+            minimumDiameter: (0, descriptor_1.parsePercent)(brush.minimumDiameter),
+            minimumRoundness: (0, descriptor_1.parsePercent)(brush.minimumRoundness),
+        };
+    }
+    if (brush.useScatter) {
+        b.scatter = {
+            count: brush['Cnt '],
+            bothAxes: brush.bothAxes,
+            countDynamics: parseDynamics(brush.countDynamics),
+            scatterDynamics: parseDynamics(brush.scatterDynamics),
+        };
+    }
+    if (brush.useTexture && brush.Txtr) {
+        b.texture = {
+            id: brush.Txtr.Idnt,
+            name: brush.Txtr['Nm  '],
+            blendMode: descriptor_1.BlnM.decode(brush.textureBlendMode),
+            depth: (0, descriptor_1.parsePercent)(brush.textureDepth),
+            depthMinimum: (0, descriptor_1.parsePercent)(brush.minimumDepth),
+            depthDynamics: parseDynamics(brush.textureDepthDynamics),
+            scale: (0, descriptor_1.parsePercent)(brush.textureScale),
+            invert: brush.InvT,
+            brightness: brush.textureBrightness,
+            contrast: brush.textureContrast,
+            textureEachTip: !!brush.TxtC,
+        };
+    }
+    const db = brush.dualBrush;
+    if (db && db.useDualBrush) {
+        b.dualBrush = {
+            flip: db.Flip,
+            shape: parseBrushShape(db.Brsh),
+            blendMode: descriptor_1.BlnM.decode(db.BlnM),
+            useScatter: db.useScatter,
+            spacing: (0, descriptor_1.parsePercent)(db.Spcn),
+            count: db['Cnt '],
+            bothAxes: db.bothAxes,
+            countDynamics: parseDynamics(db.countDynamics),
+            scatterDynamics: parseDynamics(db.scatterDynamics),
+        };
+    }
+    if (brush.useColorDynamics) {
+        b.colorDynamics = {
+            foregroundBackground: parseDynamics(brush.clVr),
+            hue: (0, descriptor_1.parsePercent)(brush['H   ']),
+            saturation: (0, descriptor_1.parsePercent)(brush.Strt),
+            brightness: (0, descriptor_1.parsePercent)(brush.Brgh),
+            purity: (0, descriptor_1.parsePercent)(brush.purity),
+            perTip: brush.colorDynamicsPerTip,
+        };
+    }
+    if (brush.usePaintDynamics) {
+        b.transfer = {
+            flowDynamics: parseDynamics(brush.prVr),
+            opacityDynamics: parseDynamics(brush.opVr),
+        };
+        if (brush.wtVr)
+            b.transfer.wetnessDynamics = parseDynamics(brush.wtVr);
+        if (brush.mxVr)
+            b.transfer.mixDynamics = parseDynamics(brush.mxVr);
+    }
+    if (brush.useBrushPose) {
+        b.brushPose = {
+            overrideAngle: brush.overridePoseAngle,
+            overrideTiltX: brush.overridePoseTiltX,
+            overrideTiltY: brush.overridePoseTiltY,
+            overridePressure: brush.overridePosePressure,
+            pressure: (0, descriptor_1.parsePercent)(brush.brushPosePressure),
+            tiltX: brush.brushPoseTiltX,
+            tiltY: brush.brushPoseTiltY,
+            angle: brush.brushPoseAngle,
+        };
+    }
+    const to = brush.toolOptions;
+    if (to) {
+        b.toolOptions = {
+            type: toBrushType[to._classID] || 'brush',
+            brushPreset: to.brushPreset,
+            flow: (_a = to.flow) !== null && _a !== void 0 ? _a : 100,
+            smooth: (_b = to.Smoo) !== null && _b !== void 0 ? _b : 0,
+            mode: descriptor_1.BlnM.decode(to['Md  '] || 'BlnM.Nrml'), // sometimes mode is missing
+            opacity: (_c = to.Opct) !== null && _c !== void 0 ? _c : 100,
+            smoothing: !!to.smoothing,
+            smoothingValue: to.smoothingValue || 0,
+            smoothingRadiusMode: !!to.smoothingRadiusMode,
+            smoothingCatchup: !!to.smoothingCatchup,
+            smoothingCatchupAtEnd: !!to.smoothingCatchupAtEnd,
+            smoothingZoomCompensation: !!to.smoothingZoomCompensation,
+            pressureSmoothing: !!to.pressureSmoothing,
+            usePressureOverridesSize: !!to.usePressureOverridesSize,
+            usePressureOverridesOpacity: !!to.usePressureOverridesOpacity,
+            useLegacy: !!to.useLegacy,
+        };
+        if (to.prVr)
+            b.toolOptions.flowDynamics = parseDynamics(to.prVr);
+        if (to.opVr)
+            b.toolOptions.opacityDynamics = parseDynamics(to.opVr);
+        if (to.szVr)
+            b.toolOptions.sizeDynamics = parseDynamics(to.szVr);
+        if ('wetness' in to)
+            b.toolOptions.wetness = to.wetness;
+        if ('dryness' in to)
+            b.toolOptions.dryness = to.dryness;
+        if ('mix' in to)
+            b.toolOptions.mix = to.mix;
+        if ('autoFill' in to)
+            b.toolOptions.autoFill = to.autoFill;
+        if ('autoClean' in to)
+            b.toolOptions.autoClean = to.autoClean;
+        if ('loadSolidColorOnly' in to)
+            b.toolOptions.loadSolidColorOnly = to.loadSolidColorOnly;
+        if ('sampleAllLayers' in to)
+            b.toolOptions.sampleAllLayers = to.sampleAllLayers;
+        if ('SmdF' in to)
+            b.toolOptions.smudgeFingerPainting = to.SmdF;
+        if ('SmdS' in to)
+            b.toolOptions.smudgeSampleAllLayers = to.SmdS;
+        if ('Prs ' in to)
+            b.toolOptions.strength = to['Prs '];
+    }
+    return b;
+}
 //# sourceMappingURL=abr.js.map