ag-psd
Version:
Library for reading and writing PSD files
1,025 lines • 164 kB
JavaScript
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
import { fromByteArray, toByteArray } from 'base64-js';
import { readEffects, writeEffects } from './effectsHelpers';
import { clamp, createEnum, layerColors, MOCK_HANDLERS } from './helpers';
import { readSignature, readUnicodeString, skipBytes, readUint32, readUint8, readFloat64, readUint16, readBytes, readInt16, checkSignature, readFloat32, readFixedPointPath32, readSection, readColor, readInt32, readPascalString, readUnicodeStringWithLength, readAsciiString, readPattern, readLayerInfo } from './psdReader';
import { writeZeros, writeSignature, writeBytes, writeUint32, writeUint16, writeFloat64, writeUint8, writeInt16, writeFloat32, writeFixedPointPath32, writeUnicodeString, writeSection, writeUnicodeStringWithPadding, writeColor, writePascalString, writeInt32 } from './psdWriter';
import { Annt, BlnM, parsePercent, parseUnits, parseUnitsOrNumber, strokeStyleLineAlignment, strokeStyleLineCapType, strokeStyleLineJoinType, textGridding, unitsPercent, unitsValue, warpStyle, writeVersionAndDescriptor, readVersionAndDescriptor, Ornt, horzVrtcToXY, xyToHorzVrtc, serializeEffects, parseEffects, parseColor, serializeColor, serializeVectorContent, parseVectorContent, parseTrackList, serializeTrackList, BlrM, BlrQ, SmBQ, SmBM, DspM, UndA, Cnvr, RplS, SphM, Wvtp, ZZTy, Dstr, Chnl, MztT, Lns, blurType, DfsM, ExtT, ExtR, FlCl, CntE, WndM, Drct, IntE, IntC, FlMd, unitsPercentF, frac, ClrS, descBoundsToBounds, boundsToDescBounds, presetKindType, gradientInterpolationMethodType } from './descriptor';
import { serializeEngineData, parseEngineData } from './engineData';
import { encodeEngineData, decodeEngineData } from './text';
import { decodeEngineData2 } from './engineData2';
var fromAtoZ = 'abcdefghijklmnopqrstuvwxyz';
export var infoHandlers = [];
export var infoHandlersMap = {};
function addHandler(key, has, read, write) {
var handler = { key: key, has: has, read: read, write: write };
infoHandlers.push(handler);
infoHandlersMap[handler.key] = handler;
}
function addHandlerAlias(key, target) {
infoHandlersMap[key] = infoHandlersMap[target];
}
function hasKey(key) {
return function (target) { return target[key] !== undefined; };
}
function readLength64(reader) {
if (readUint32(reader))
throw new Error("Resource size above 4 GB limit at ".concat(reader.offset.toString(16)));
return readUint32(reader);
}
function writeLength64(writer, length) {
writeUint32(writer, 0);
writeUint32(writer, length);
}
addHandler('TySh', hasKey('text'), function (reader, target, leftBytes) {
if (readInt16(reader) !== 1)
throw new Error("Invalid TySh version");
var transform = [];
for (var i = 0; i < 6; i++)
transform.push(readFloat64(reader));
if (readInt16(reader) !== 50)
throw new Error("Invalid TySh text version");
var text = readVersionAndDescriptor(reader);
// console.log(require('util').inspect(text, false, 99, false), 'utf8');
if (readInt16(reader) !== 1)
throw new Error("Invalid TySh warp version");
var warp = readVersionAndDescriptor(reader);
// console.log(require('util').inspect(warp, false, 99, false), 'utf8');
target.text = {
transform: transform,
left: readFloat32(reader),
top: readFloat32(reader),
right: readFloat32(reader),
bottom: readFloat32(reader),
text: text['Txt '].replace(/\r/g, '\n'),
index: text.TextIndex || 0,
gridding: textGridding.decode(text.textGridding),
antiAlias: Annt.decode(text.AntA),
orientation: Ornt.decode(text.Ornt),
warp: {
style: warpStyle.decode(warp.warpStyle),
value: warp.warpValue || 0,
perspective: warp.warpPerspective || 0,
perspectiveOther: warp.warpPerspectiveOther || 0,
rotate: Ornt.decode(warp.warpRotate),
},
};
if (text.bounds)
target.text.bounds = descBoundsToBounds(text.bounds);
if (text.boundingBox)
target.text.boundingBox = descBoundsToBounds(text.boundingBox);
if (text.EngineData) {
var engineData = parseEngineData(text.EngineData);
var textData = decodeEngineData(engineData);
// console.log(require('util').inspect(engineData, false, 99, false), 'utf8');
// require('fs').writeFileSync(`layer-${target.name}.txt`, require('util').inspect(engineData, false, 99, false), 'utf8');
// const before = parseEngineData(text.EngineData);
// const after = encodeEngineData(engineData);
// require('fs').writeFileSync('before.txt', require('util').inspect(before, false, 99, false), 'utf8');
// require('fs').writeFileSync('after.txt', require('util').inspect(after, false, 99, false), 'utf8');
// console.log(require('util').inspect(parseEngineData(text.EngineData), false, 99, true));
target.text = __assign(__assign({}, target.text), textData);
// console.log(require('util').inspect(target.text, false, 99, true));
}
skipBytes(reader, leftBytes());
}, function (writer, target) {
var text = target.text;
var warp = text.warp || {};
var transform = text.transform || [1, 0, 0, 1, 0, 0];
var textDescriptor = __assign(__assign(__assign({ 'Txt ': (text.text || '').replace(/\r?\n/g, '\r'), textGridding: textGridding.encode(text.gridding), Ornt: Ornt.encode(text.orientation), AntA: Annt.encode(text.antiAlias) }, (text.bounds ? { bounds: boundsToDescBounds(text.bounds) } : {})), (text.boundingBox ? { boundingBox: boundsToDescBounds(text.boundingBox) } : {})), { TextIndex: text.index || 0, EngineData: serializeEngineData(encodeEngineData(text)) });
writeInt16(writer, 1); // version
for (var i = 0; i < 6; i++) {
writeFloat64(writer, transform[i]);
}
writeInt16(writer, 50); // text version
writeVersionAndDescriptor(writer, '', 'TxLr', textDescriptor, 'text');
writeInt16(writer, 1); // warp version
writeVersionAndDescriptor(writer, '', 'warp', encodeWarp(warp));
writeFloat32(writer, text.left);
writeFloat32(writer, text.top);
writeFloat32(writer, text.right);
writeFloat32(writer, text.bottom);
// writeZeros(writer, 2);
});
// vector fills
addHandler('SoCo', function (target) { return target.vectorFill !== undefined && target.vectorStroke === undefined &&
target.vectorFill.type === 'color'; }, function (reader, target) {
var descriptor = readVersionAndDescriptor(reader);
target.vectorFill = parseVectorContent(descriptor);
}, function (writer, target) {
var descriptor = serializeVectorContent(target.vectorFill).descriptor;
writeVersionAndDescriptor(writer, '', 'null', descriptor);
});
addHandler('GdFl', function (target) { return target.vectorFill !== undefined && target.vectorStroke === undefined &&
(target.vectorFill.type === 'solid' || target.vectorFill.type === 'noise'); }, function (reader, target, left) {
var descriptor = readVersionAndDescriptor(reader);
target.vectorFill = parseVectorContent(descriptor);
skipBytes(reader, left());
}, function (writer, target) {
var descriptor = serializeVectorContent(target.vectorFill).descriptor;
writeVersionAndDescriptor(writer, '', 'null', descriptor);
});
addHandler('PtFl', function (target) { return target.vectorFill !== undefined && target.vectorStroke === undefined &&
target.vectorFill.type === 'pattern'; }, function (reader, target) {
var descriptor = readVersionAndDescriptor(reader);
target.vectorFill = parseVectorContent(descriptor);
}, function (writer, target) {
var descriptor = serializeVectorContent(target.vectorFill).descriptor;
writeVersionAndDescriptor(writer, '', 'null', descriptor);
});
addHandler('vscg', function (target) { return target.vectorFill !== undefined && target.vectorStroke !== undefined; }, function (reader, target, left) {
readSignature(reader); // key
var desc = readVersionAndDescriptor(reader);
target.vectorFill = parseVectorContent(desc);
skipBytes(reader, left());
}, function (writer, target) {
var _a = serializeVectorContent(target.vectorFill), descriptor = _a.descriptor, key = _a.key;
writeSignature(writer, key);
writeVersionAndDescriptor(writer, '', 'null', descriptor);
});
export function readBezierKnot(reader, width, height) {
var y0 = readFixedPointPath32(reader) * height;
var x0 = readFixedPointPath32(reader) * width;
var y1 = readFixedPointPath32(reader) * height;
var x1 = readFixedPointPath32(reader) * width;
var y2 = readFixedPointPath32(reader) * height;
var x2 = readFixedPointPath32(reader) * width;
return [x0, y0, x1, y1, x2, y2];
}
function writeBezierKnot(writer, points, width, height) {
writeFixedPointPath32(writer, points[1] / height); // y0
writeFixedPointPath32(writer, points[0] / width); // x0
writeFixedPointPath32(writer, points[3] / height); // y1
writeFixedPointPath32(writer, points[2] / width); // x1
writeFixedPointPath32(writer, points[5] / height); // y2
writeFixedPointPath32(writer, points[4] / width); // x2
}
export var booleanOperations = ['exclude', 'combine', 'subtract', 'intersect'];
export function readVectorMask(reader, vectorMask, width, height, size) {
var end = reader.offset + size;
var paths = vectorMask.paths;
var path = undefined;
while ((end - reader.offset) >= 26) {
var selector = readUint16(reader);
switch (selector) {
case 0: // Closed subpath length record
case 3: { // Open subpath length record
readUint16(reader); // count
var boolOp = readInt16(reader);
var flags = readUint16(reader); // bit 1 always 1 ?
skipBytes(reader, 18);
path = {
open: selector === 3,
knots: [],
fillRule: flags === 2 ? 'non-zero' : 'even-odd',
};
if (boolOp !== -1)
path.operation = booleanOperations[boolOp];
paths.push(path);
break;
}
case 1: // Closed subpath Bezier knot, linked
case 2: // Closed subpath Bezier knot, unlinked
case 4: // Open subpath Bezier knot, linked
case 5: // Open subpath Bezier knot, unlinked
path.knots.push({ linked: (selector === 1 || selector === 4), points: readBezierKnot(reader, width, height) });
break;
case 6: // Path fill rule record
skipBytes(reader, 24);
break;
case 7: { // Clipboard record
// TODO: check if these need to be multiplied by document size
var top_1 = readFixedPointPath32(reader);
var left = readFixedPointPath32(reader);
var bottom = readFixedPointPath32(reader);
var right = readFixedPointPath32(reader);
var resolution = readFixedPointPath32(reader);
skipBytes(reader, 4);
vectorMask.clipboard = { top: top_1, left: left, bottom: bottom, right: right, resolution: resolution };
break;
}
case 8: // Initial fill rule record
vectorMask.fillStartsWithAllPixels = !!readUint16(reader);
skipBytes(reader, 22);
break;
default: throw new Error('Invalid vmsk section');
}
}
return paths;
}
addHandler('vmsk', hasKey('vectorMask'), function (reader, target, left, _a) {
var width = _a.width, height = _a.height;
if (readUint32(reader) !== 3)
throw new Error('Invalid vmsk version');
target.vectorMask = { paths: [] };
var vectorMask = target.vectorMask;
var flags = readUint32(reader);
vectorMask.invert = (flags & 1) !== 0;
vectorMask.notLink = (flags & 2) !== 0;
vectorMask.disable = (flags & 4) !== 0;
readVectorMask(reader, vectorMask, width, height, left());
// drawBezierPaths(vectorMask.paths, width, height, 'out.png');
skipBytes(reader, left());
}, function (writer, target, _a) {
var width = _a.width, height = _a.height;
var vectorMask = target.vectorMask;
var flags = (vectorMask.invert ? 1 : 0) |
(vectorMask.notLink ? 2 : 0) |
(vectorMask.disable ? 4 : 0);
writeUint32(writer, 3); // version
writeUint32(writer, flags);
// initial entry
writeUint16(writer, 6);
writeZeros(writer, 24);
var clipboard = vectorMask.clipboard;
if (clipboard) {
writeUint16(writer, 7);
writeFixedPointPath32(writer, clipboard.top);
writeFixedPointPath32(writer, clipboard.left);
writeFixedPointPath32(writer, clipboard.bottom);
writeFixedPointPath32(writer, clipboard.right);
writeFixedPointPath32(writer, clipboard.resolution);
writeZeros(writer, 4);
}
writeUint16(writer, 8);
writeUint16(writer, vectorMask.fillStartsWithAllPixels ? 1 : 0);
writeZeros(writer, 22);
for (var _i = 0, _b = vectorMask.paths; _i < _b.length; _i++) {
var path = _b[_i];
writeUint16(writer, path.open ? 3 : 0);
writeUint16(writer, path.knots.length);
writeUint16(writer, path.operation ? booleanOperations.indexOf(path.operation) : -1); // -1 for undefined
writeUint16(writer, path.fillRule === 'non-zero' ? 2 : 1);
writeZeros(writer, 18); // TODO: these are sometimes non-zero
var linkedKnot = path.open ? 4 : 1;
var unlinkedKnot = path.open ? 5 : 2;
for (var _c = 0, _d = path.knots; _c < _d.length; _c++) {
var _e = _d[_c], linked = _e.linked, points = _e.points;
writeUint16(writer, linked ? linkedKnot : unlinkedKnot);
writeBezierKnot(writer, points, width, height);
}
}
});
// TODO: need to write vmsk if has outline ?
addHandlerAlias('vsms', 'vmsk');
// addHandlerAlias('vmsk', 'vsms');
addHandler('vowv', // something with vectors?
hasKey('vowv'), function (reader, target) {
target.vowv = readUint32(reader); // always 2 ????
}, function (writer, target) {
writeUint32(writer, target.vowv);
});
addHandler('vogk', hasKey('vectorOrigination'), function (reader, target, left) {
if (readInt32(reader) !== 1)
throw new Error("Invalid vogk version");
var desc = readVersionAndDescriptor(reader);
// console.log(require('util').inspect(desc, false, 99, true));
target.vectorOrigination = { keyDescriptorList: [] };
for (var _i = 0, _a = desc.keyDescriptorList; _i < _a.length; _i++) {
var i = _a[_i];
var item = {};
if (i.keyShapeInvalidated != null)
item.keyShapeInvalidated = i.keyShapeInvalidated;
if (i.keyOriginType != null)
item.keyOriginType = i.keyOriginType;
if (i.keyOriginResolution != null)
item.keyOriginResolution = i.keyOriginResolution;
if (i.keyOriginShapeBBox) {
item.keyOriginShapeBoundingBox = {
top: parseUnitsOrNumber(i.keyOriginShapeBBox['Top ']),
left: parseUnitsOrNumber(i.keyOriginShapeBBox.Left),
bottom: parseUnitsOrNumber(i.keyOriginShapeBBox.Btom),
right: parseUnitsOrNumber(i.keyOriginShapeBBox.Rght),
};
}
var rectRadii = i.keyOriginRRectRadii;
if (rectRadii) {
item.keyOriginRRectRadii = {
topRight: parseUnits(rectRadii.topRight),
topLeft: parseUnits(rectRadii.topLeft),
bottomLeft: parseUnits(rectRadii.bottomLeft),
bottomRight: parseUnits(rectRadii.bottomRight),
};
}
var corners = i.keyOriginBoxCorners;
if (corners) {
item.keyOriginBoxCorners = [
{ x: corners.rectangleCornerA.Hrzn, y: corners.rectangleCornerA.Vrtc },
{ x: corners.rectangleCornerB.Hrzn, y: corners.rectangleCornerB.Vrtc },
{ x: corners.rectangleCornerC.Hrzn, y: corners.rectangleCornerC.Vrtc },
{ x: corners.rectangleCornerD.Hrzn, y: corners.rectangleCornerD.Vrtc },
];
}
var trnf = i.Trnf;
if (trnf) {
item.transform = [trnf.xx, trnf.xy, trnf.yx, trnf.yy, trnf.tx, trnf.ty];
}
target.vectorOrigination.keyDescriptorList.push(item);
}
skipBytes(reader, left());
}, function (writer, target) {
target;
var orig = target.vectorOrigination;
var desc = { keyDescriptorList: [] };
for (var i = 0; i < orig.keyDescriptorList.length; i++) {
var item = orig.keyDescriptorList[i];
desc.keyDescriptorList.push({}); // we're adding keyOriginIndex at the end
var out = desc.keyDescriptorList[desc.keyDescriptorList.length - 1];
if (item.keyOriginType != null)
out.keyOriginType = item.keyOriginType;
if (item.keyOriginResolution != null)
out.keyOriginResolution = item.keyOriginResolution;
var radii = item.keyOriginRRectRadii;
if (radii) {
out.keyOriginRRectRadii = {
unitValueQuadVersion: 1,
topRight: unitsValue(radii.topRight, 'topRight'),
topLeft: unitsValue(radii.topLeft, 'topLeft'),
bottomLeft: unitsValue(radii.bottomLeft, 'bottomLeft'),
bottomRight: unitsValue(radii.bottomRight, 'bottomRight'),
};
}
var box = item.keyOriginShapeBoundingBox;
if (box) {
out.keyOriginShapeBBox = {
unitValueQuadVersion: 1,
'Top ': unitsValue(box.top, 'top'),
Left: unitsValue(box.left, 'left'),
Btom: unitsValue(box.bottom, 'bottom'),
Rght: unitsValue(box.right, 'right'),
};
}
var corners = item.keyOriginBoxCorners;
if (corners && corners.length === 4) {
out.keyOriginBoxCorners = {
rectangleCornerA: { Hrzn: corners[0].x, Vrtc: corners[0].y },
rectangleCornerB: { Hrzn: corners[1].x, Vrtc: corners[1].y },
rectangleCornerC: { Hrzn: corners[2].x, Vrtc: corners[2].y },
rectangleCornerD: { Hrzn: corners[3].x, Vrtc: corners[3].y },
};
}
var transform = item.transform;
if (transform && transform.length === 6) {
out.Trnf = {
xx: transform[0],
xy: transform[1],
yx: transform[2],
yy: transform[3],
tx: transform[4],
ty: transform[5],
};
}
if (item.keyShapeInvalidated != null)
out.keyShapeInvalidated = item.keyShapeInvalidated;
out.keyOriginIndex = i;
}
writeInt32(writer, 1); // version
writeVersionAndDescriptor(writer, '', 'null', desc);
});
addHandler('lmfx', function (target) { return target.effects !== undefined && hasMultiEffects(target.effects); }, function (reader, target, left) {
var version = readUint32(reader);
if (version !== 0)
throw new Error('Invalid lmfx version');
var desc = readVersionAndDescriptor(reader);
// console.log('READ', require('util').inspect(desc, false, 99, true));
// discard if read in 'lrFX' or 'lfx2' section
target.effects = parseEffects(desc, !!reader.logMissingFeatures);
skipBytes(reader, left());
}, function (writer, target, _, options) {
var desc = serializeEffects(target.effects, !!options.logMissingFeatures, true);
// console.log('WRITE', require('util').inspect(desc, false, 99, true));
writeUint32(writer, 0); // version
writeVersionAndDescriptor(writer, '', 'null', desc);
});
addHandler('lrFX', hasKey('effects'), function (reader, target, left) {
if (!target.effects)
target.effects = readEffects(reader);
skipBytes(reader, left());
}, function (writer, target) {
writeEffects(writer, target.effects);
});
addHandler('luni', hasKey('name'), function (reader, target, left) {
if (left() > 4) {
var length_1 = readUint32(reader);
if (left() >= (length_1 * 2)) {
target.name = readUnicodeStringWithLength(reader, length_1);
}
else {
if (reader.logDevFeatures)
reader.log('name in luni section is too long');
}
}
else {
if (reader.logDevFeatures)
reader.log('empty luni section');
}
skipBytes(reader, left());
}, function (writer, target) {
writeUnicodeString(writer, target.name);
// writeUint16(writer, 0); // padding (but not extending string length)
});
addHandler('lnsr', hasKey('nameSource'), function (reader, target) { return target.nameSource = readSignature(reader); }, function (writer, target) { return writeSignature(writer, target.nameSource); });
addHandler('lyid', hasKey('id'), function (reader, target) {
target.id = readUint32(reader);
}, function (writer, target, _psd, options) {
var id = target.id;
while (options.layerIds.has(id))
id += 100; // make sure we don't have duplicate layer ids
writeUint32(writer, id);
options.layerIds.add(id);
options.layerToId.set(target, id);
});
addHandler('lsct', hasKey('sectionDivider'), function (reader, target, left) {
target.sectionDivider = { type: readUint32(reader) };
if (left()) {
checkSignature(reader, '8BIM');
target.sectionDivider.key = readSignature(reader);
}
if (left()) {
target.sectionDivider.subType = readUint32(reader);
}
}, function (writer, target) {
writeUint32(writer, target.sectionDivider.type);
if (target.sectionDivider.key) {
writeSignature(writer, '8BIM');
writeSignature(writer, target.sectionDivider.key);
if (target.sectionDivider.subType !== undefined) {
writeUint32(writer, target.sectionDivider.subType);
}
}
});
// it seems lsdk is used when there's a layer is nested more than 6 levels, but I don't know why?
// maybe some limitation of old version of PS?
addHandlerAlias('lsdk', 'lsct');
addHandler('clbl', hasKey('blendClippendElements'), function (reader, target) {
target.blendClippendElements = !!readUint8(reader);
skipBytes(reader, 3);
}, function (writer, target) {
writeUint8(writer, target.blendClippendElements ? 1 : 0);
writeZeros(writer, 3);
});
addHandler('infx', hasKey('blendInteriorElements'), function (reader, target) {
target.blendInteriorElements = !!readUint8(reader);
skipBytes(reader, 3);
}, function (writer, target) {
writeUint8(writer, target.blendInteriorElements ? 1 : 0);
writeZeros(writer, 3);
});
addHandler('knko', hasKey('knockout'), function (reader, target) {
target.knockout = !!readUint8(reader);
skipBytes(reader, 3);
}, function (writer, target) {
writeUint8(writer, target.knockout ? 1 : 0);
writeZeros(writer, 3);
});
addHandler('lmgm', hasKey('layerMaskAsGlobalMask'), function (reader, target) {
target.layerMaskAsGlobalMask = !!readUint8(reader);
skipBytes(reader, 3);
}, function (writer, target) {
writeUint8(writer, target.layerMaskAsGlobalMask ? 1 : 0);
writeZeros(writer, 3);
});
addHandler('lspf', hasKey('protected'), function (reader, target) {
var flags = readUint32(reader);
target.protected = {
transparency: (flags & 0x01) !== 0,
composite: (flags & 0x02) !== 0,
position: (flags & 0x04) !== 0,
};
if (flags & 0x08)
target.protected.artboards = true;
}, function (writer, target) {
var flags = (target.protected.transparency ? 0x01 : 0) |
(target.protected.composite ? 0x02 : 0) |
(target.protected.position ? 0x04 : 0) |
(target.protected.artboards ? 0x08 : 0);
writeUint32(writer, flags);
});
addHandler('lclr', hasKey('layerColor'), function (reader, target) {
var color = readUint16(reader);
skipBytes(reader, 6);
target.layerColor = layerColors[color];
}, function (writer, target) {
var index = layerColors.indexOf(target.layerColor);
writeUint16(writer, index === -1 ? 0 : index);
writeZeros(writer, 6);
});
addHandler('shmd', // Metadata setting
function (// Metadata setting
target) { return target.timestamp !== undefined || target.animationFrames !== undefined || target.animationFrameFlags !== undefined || target.timeline !== undefined || target.comps !== undefined; }, function (reader, target, left) {
var count = readUint32(reader);
var _loop_1 = function (i) {
checkSignature(reader, '8BIM');
var key = readSignature(reader);
readUint8(reader); // copy
skipBytes(reader, 3);
readSection(reader, 1, function (left) {
if (key === 'cust') {
var desc = readVersionAndDescriptor(reader);
// console.log('cust', target.name, require('util').inspect(desc, false, 99, true));
if (desc.layerTime !== undefined)
target.timestamp = desc.layerTime;
}
else if (key === 'mlst') {
var desc = readVersionAndDescriptor(reader);
// console.log('mlst', target.name, require('util').inspect(desc, false, 99, true));
target.animationFrames = [];
for (var i_1 = 0; i_1 < desc.LaSt.length; i_1++) {
var f = desc.LaSt[i_1];
var frame = { frames: f.FrLs };
if (f.enab !== undefined)
frame.enable = f.enab;
if (f.Ofst)
frame.offset = horzVrtcToXY(f.Ofst);
if (f.FXRf)
frame.referencePoint = horzVrtcToXY(f.FXRf);
if (f.Lefx)
frame.effects = parseEffects(f.Lefx, !!reader.logMissingFeatures);
if (f.blendOptions && f.blendOptions.Opct)
frame.opacity = parsePercent(f.blendOptions.Opct);
target.animationFrames.push(frame);
}
}
else if (key === 'mdyn') {
// frame flags
readUint16(reader); // unknown
var propagate = readUint8(reader);
var flags = readUint8(reader);
target.animationFrameFlags = {
propagateFrameOne: !propagate,
unifyLayerPosition: (flags & 1) !== 0,
unifyLayerStyle: (flags & 2) !== 0,
unifyLayerVisibility: (flags & 4) !== 0,
};
}
else if (key === 'tmln') {
var desc = readVersionAndDescriptor(reader);
var timeScope = desc.timeScope;
// console.log('tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
var timeline = {
start: frac(timeScope.Strt),
duration: frac(timeScope.duration),
inTime: frac(timeScope.inTime),
outTime: frac(timeScope.outTime),
autoScope: desc.autoScope,
audioLevel: desc.audioLevel,
};
if (desc.trackList) {
timeline.tracks = parseTrackList(desc.trackList, !!reader.logMissingFeatures);
}
target.timeline = timeline;
// console.log('tmln:result', target.name, target.id, require('util').inspect(timeline, false, 99, true));
}
else if (key === 'cmls') {
var desc = readVersionAndDescriptor(reader);
// console.log('cmls', require('util').inspect(desc, false, 99, true));
target.comps = {
settings: [],
};
if (desc.origFXRefPoint)
target.comps.originalEffectsReferencePoint = { x: desc.origFXRefPoint.Hrzn, y: desc.origFXRefPoint.Vrtc };
for (var _i = 0, _a = desc.layerSettings; _i < _a.length; _i++) {
var item = _a[_i];
target.comps.settings.push({ compList: item.compList });
var t = target.comps.settings[target.comps.settings.length - 1];
if ('enab' in item)
t.enabled = item.enab;
if (item.Ofst)
t.offset = { x: item.Ofst.Hrzn, y: item.Ofst.Vrtc };
if (item.FXRefPoint)
t.effectsReferencePoint = { x: item.FXRefPoint.Hrzn, y: item.FXRefPoint.Vrtc };
}
}
else if (key === 'extn') {
var desc = readVersionAndDescriptor(reader);
// console.log(require('util').inspect(desc, false, 99, true));
desc; // TODO: save this
reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
}
else {
reader.logMissingFeatures && reader.log('Unhandled "shmd" section key', key);
}
skipBytes(reader, left());
});
};
for (var i = 0; i < count; i++) {
_loop_1(i);
}
skipBytes(reader, left());
}, function (writer, target, _, options) {
var animationFrames = target.animationFrames, animationFrameFlags = target.animationFrameFlags, timestamp = target.timestamp, timeline = target.timeline, comps = target.comps;
var count = 0;
if (animationFrames)
count++;
if (animationFrameFlags)
count++;
if (timeline)
count++;
if (timestamp !== undefined)
count++;
if (comps)
count++;
writeUint32(writer, count);
if (animationFrames) {
writeSignature(writer, '8BIM');
writeSignature(writer, 'mlst');
writeUint8(writer, 0); // copy (always false)
writeZeros(writer, 3);
writeSection(writer, 2, function () {
var _a;
var desc = {
LaID: (_a = target.id) !== null && _a !== void 0 ? _a : 0,
LaSt: [],
};
for (var i = 0; i < animationFrames.length; i++) {
var f = animationFrames[i];
var frame = {};
if (f.enable !== undefined)
frame.enab = f.enable;
frame.FrLs = f.frames;
if (f.offset)
frame.Ofst = xyToHorzVrtc(f.offset);
if (f.referencePoint)
frame.FXRf = xyToHorzVrtc(f.referencePoint);
if (f.effects)
frame.Lefx = serializeEffects(f.effects, false, false);
if (f.opacity !== undefined)
frame.blendOptions = { Opct: unitsPercent(f.opacity) };
desc.LaSt.push(frame);
}
writeVersionAndDescriptor(writer, '', 'null', desc);
}, true);
}
if (animationFrameFlags) {
writeSignature(writer, '8BIM');
writeSignature(writer, 'mdyn');
writeUint8(writer, 0); // copy (always false)
writeZeros(writer, 3);
writeSection(writer, 2, function () {
writeUint16(writer, 0); // unknown
writeUint8(writer, animationFrameFlags.propagateFrameOne ? 0x0 : 0xf);
writeUint8(writer, (animationFrameFlags.unifyLayerPosition ? 1 : 0) |
(animationFrameFlags.unifyLayerStyle ? 2 : 0) |
(animationFrameFlags.unifyLayerVisibility ? 4 : 0));
});
}
if (timeline) {
writeSignature(writer, '8BIM');
writeSignature(writer, 'tmln');
writeUint8(writer, 0); // copy (always false)
writeZeros(writer, 3);
writeSection(writer, 2, function () {
var desc = {
Vrsn: 1,
timeScope: {
Vrsn: 1,
Strt: timeline.start,
duration: timeline.duration,
inTime: timeline.inTime,
outTime: timeline.outTime,
},
autoScope: timeline.autoScope,
audioLevel: timeline.audioLevel,
};
if (timeline.tracks) {
desc.trackList = serializeTrackList(timeline.tracks);
}
var id = options.layerToId.get(target) || target.id;
if (!id)
throw new Error('You need to provide layer.id value whan writing document with animations');
desc.LyrI = id;
// console.log('WRITE:tmln', target.name, target.id, require('util').inspect(desc, false, 99, true));
writeVersionAndDescriptor(writer, '', 'null', desc, 'anim');
}, true);
}
if (timestamp !== undefined) {
writeSignature(writer, '8BIM');
writeSignature(writer, 'cust');
writeUint8(writer, 0); // copy (always false)
writeZeros(writer, 3);
writeSection(writer, 2, function () {
var desc = {
layerTime: timestamp,
};
writeVersionAndDescriptor(writer, '', 'metadata', desc);
}, true);
}
if (comps) {
writeSignature(writer, '8BIM');
writeSignature(writer, 'cmls');
writeUint8(writer, 0); // copy (always false)
writeZeros(writer, 3);
writeSection(writer, 2, function () {
var id = options.layerToId.get(target) || target.id;
if (!id)
throw new Error('You need to provide layer.id value whan writing document with layer comps');
var desc = {};
if (comps.originalEffectsReferencePoint) {
desc.origFXRefPoint = { Hrzn: comps.originalEffectsReferencePoint.x, Vrtc: comps.originalEffectsReferencePoint.y };
}
desc.LyrI = id;
desc.layerSettings = [];
for (var _i = 0, _a = comps.settings; _i < _a.length; _i++) {
var item = _a[_i];
var t = {};
if (item.enabled !== undefined)
t.enab = item.enabled;
if (item.offset)
t.Ofst = { Hrzn: item.offset.x, Vrtc: item.offset.y };
if (item.effectsReferencePoint)
t.FXRefPoint = { Hrzn: item.effectsReferencePoint.x, Vrtc: item.effectsReferencePoint.y };
t.compList = item.compList;
desc.layerSettings.push(t);
}
// console.log('cmls', require('util').inspect(desc, false, 99, true));
writeVersionAndDescriptor(writer, '', 'null', desc);
}, true);
}
});
addHandler('PxSc', function () { return false; }, function (reader, target) {
var desc = readVersionAndDescriptor(reader, true);
// console.log('PxSc', require('util').inspect(desc, false, 99, true));
if (desc.pixelSourceType === 1986285651) {
target.pixelSource = {
type: 'vdPS',
origin: { x: desc.origin.Hrzn, y: desc.origin.Vrtc },
interpretation: {
interpretAlpha: desc.interpretation.interpretAlpha.split('.')[1],
profile: desc.interpretation.profile,
},
frameReader: {
type: 'QTFR',
link: {
name: desc.frameReader['Lnk ']['Nm '],
fullPath: desc.frameReader['Lnk '].fullPath,
originalPath: desc.frameReader['Lnk '].originalPath,
relativePath: desc.frameReader['Lnk '].relPath,
alias: desc.frameReader['Lnk '].alis,
},
mediaDescriptor: desc.frameReader.mediaDescriptor,
},
showAlteredVideo: desc.showAlteredVideo,
};
}
else {
reader.log("Unknown pixelSourceType");
}
}, function (writer, target) {
var source = target.pixelSource;
var desc = {
_name: '',
_classID: 'PixelSource',
pixelSourceType: 1986285651,
descVersion: 1,
origin: { Hrzn: source.origin.x, Vrtc: source.origin.y },
interpretation: {
_name: '',
_classID: 'footageInterpretation',
Vrsn: 1,
interpretAlpha: "alphaInterpretation.".concat(source.interpretation.interpretAlpha),
profile: source.interpretation.profile,
},
frameReader: {
_name: '',
_classID: 'FrameReader',
frameReaderType: 1364477522,
descVersion: 1,
'Lnk ': {
_name: '',
_classID: 'ExternalFileLink',
descVersion: 2,
'Nm ': source.frameReader.link.name,
fullPath: source.frameReader.link.fullPath,
originalPath: source.frameReader.link.originalPath,
alis: source.frameReader.link.alias,
relPath: source.frameReader.link.relativePath,
},
mediaDescriptor: source.frameReader.mediaDescriptor,
},
showAlteredVideo: source.showAlteredVideo,
};
writeVersionAndDescriptor(writer, '', 'PixelSource', desc);
});
addHandler('vstk', hasKey('vectorStroke'), function (reader, target, left) {
var desc = readVersionAndDescriptor(reader);
// console.log(require('util').inspect(desc, false, 99, true));
target.vectorStroke = {
strokeEnabled: desc.strokeEnabled,
fillEnabled: desc.fillEnabled,
lineWidth: parseUnits(desc.strokeStyleLineWidth),
lineDashOffset: parseUnits(desc.strokeStyleLineDashOffset),
miterLimit: desc.strokeStyleMiterLimit,
lineCapType: strokeStyleLineCapType.decode(desc.strokeStyleLineCapType),
lineJoinType: strokeStyleLineJoinType.decode(desc.strokeStyleLineJoinType),
lineAlignment: strokeStyleLineAlignment.decode(desc.strokeStyleLineAlignment),
scaleLock: desc.strokeStyleScaleLock,
strokeAdjust: desc.strokeStyleStrokeAdjust,
lineDashSet: desc.strokeStyleLineDashSet.map(parseUnits),
blendMode: BlnM.decode(desc.strokeStyleBlendMode),
opacity: parsePercent(desc.strokeStyleOpacity),
content: parseVectorContent(desc.strokeStyleContent),
resolution: desc.strokeStyleResolution,
};
skipBytes(reader, left());
}, function (writer, target) {
var _a, _b, _c;
var stroke = target.vectorStroke;
var desc = {
strokeStyleVersion: 2,
strokeEnabled: !!stroke.strokeEnabled,
fillEnabled: !!stroke.fillEnabled,
strokeStyleLineWidth: stroke.lineWidth || { value: 3, units: 'Points' },
strokeStyleLineDashOffset: stroke.lineDashOffset || { value: 0, units: 'Points' },
strokeStyleMiterLimit: (_a = stroke.miterLimit) !== null && _a !== void 0 ? _a : 100,
strokeStyleLineCapType: strokeStyleLineCapType.encode(stroke.lineCapType),
strokeStyleLineJoinType: strokeStyleLineJoinType.encode(stroke.lineJoinType),
strokeStyleLineAlignment: strokeStyleLineAlignment.encode(stroke.lineAlignment),
strokeStyleScaleLock: !!stroke.scaleLock,
strokeStyleStrokeAdjust: !!stroke.strokeAdjust,
strokeStyleLineDashSet: stroke.lineDashSet || [],
strokeStyleBlendMode: BlnM.encode(stroke.blendMode),
strokeStyleOpacity: unitsPercent((_b = stroke.opacity) !== null && _b !== void 0 ? _b : 1),
strokeStyleContent: serializeVectorContent(stroke.content || { type: 'color', color: { r: 0, g: 0, b: 0 } }).descriptor,
strokeStyleResolution: (_c = stroke.resolution) !== null && _c !== void 0 ? _c : 72,
};
writeVersionAndDescriptor(writer, '', 'strokeStyle', desc);
});
addHandler('artb', // per-layer arboard info
hasKey('artboard'), function (reader, target, left) {
var desc = readVersionAndDescriptor(reader);
var rect = desc.artboardRect;
target.artboard = {
rect: { top: rect['Top '], left: rect.Left, bottom: rect.Btom, right: rect.Rght },
guideIndices: desc.guideIndeces,
presetName: desc.artboardPresetName,
color: parseColor(desc['Clr ']),
backgroundType: desc.artboardBackgroundType,
};
skipBytes(reader, left());
}, function (writer, target) {
var _a;
var artboard = target.artboard;
var rect = artboard.rect;
var desc = {
artboardRect: { 'Top ': rect.top, Left: rect.left, Btom: rect.bottom, Rght: rect.right },
guideIndeces: artboard.guideIndices || [],
artboardPresetName: artboard.presetName || '',
'Clr ': serializeColor(artboard.color),
artboardBackgroundType: (_a = artboard.backgroundType) !== null && _a !== void 0 ? _a : 1,
};
writeVersionAndDescriptor(writer, '', 'artboard', desc);
});
addHandler('sn2P', hasKey('usingAlignedRendering'), function (reader, target) { return target.usingAlignedRendering = !!readUint32(reader); }, function (writer, target) { return writeUint32(writer, target.usingAlignedRendering ? 1 : 0); });
var placedLayerTypes = ['unknown', 'vector', 'raster', 'image stack'];
function parseWarp(warp) {
var _a, _b, _c, _d, _e, _f;
var result = __assign(__assign({ style: warpStyle.decode(warp.warpStyle) }, (warp.warpValues ? { values: warp.warpValues } : { value: warp.warpValue || 0 })), { perspective: warp.warpPerspective || 0, perspectiveOther: warp.warpPerspectiveOther || 0, rotate: Ornt.decode(warp.warpRotate), bounds: warp.bounds && {
top: parseUnitsOrNumber(warp.bounds['Top ']),
left: parseUnitsOrNumber(warp.bounds.Left),
bottom: parseUnitsOrNumber(warp.bounds.Btom),
right: parseUnitsOrNumber(warp.bounds.Rght),
}, uOrder: warp.uOrder, vOrder: warp.vOrder });
if (warp.deformNumRows != null || warp.deformNumCols != null) {
result.deformNumRows = warp.deformNumRows;
result.deformNumCols = warp.deformNumCols;
}
var envelopeWarp = warp.customEnvelopeWarp;
if (envelopeWarp) {
result.customEnvelopeWarp = {
meshPoints: [],
};
var xs = ((_a = envelopeWarp.meshPoints.find(function (i) { return i.type === 'Hrzn'; })) === null || _a === void 0 ? void 0 : _a.values) || [];
var ys = ((_b = envelopeWarp.meshPoints.find(function (i) { return i.type === 'Vrtc'; })) === null || _b === void 0 ? void 0 : _b.values) || [];
for (var i = 0; i < xs.length; i++) {
result.customEnvelopeWarp.meshPoints.push({ x: xs[i], y: ys[i] });
}
if (envelopeWarp.quiltSliceX || envelopeWarp.quiltSliceY) {
result.customEnvelopeWarp.quiltSliceX = ((_d = (_c = envelopeWarp.quiltSliceX) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.values) || [];
result.customEnvelopeWarp.quiltSliceY = ((_f = (_e = envelopeWarp.quiltSliceY) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.values) || [];
}
}
return result;
}
function isQuiltWarp(warp) {
var _a, _b;
return warp.deformNumCols != null || warp.deformNumRows != null ||
((_a = warp.customEnvelopeWarp) === null || _a === void 0 ? void 0 : _a.quiltSliceX) || ((_b = warp.customEnvelopeWarp) === null || _b === void 0 ? void 0 : _b.quiltSliceY);
}
function encodeWarp(warp) {
var bounds = warp.bounds;
var desc = __assign(__assign({ warpStyle: warpStyle.encode(warp.style) }, (warp.values ? { warpValues: warp.values } : { warpValue: warp.value || 0 })), { warpPerspective: warp.perspective || 0, warpPerspectiveOther: warp.perspectiveOther || 0, warpRotate: Ornt.encode(warp.rotate), bounds: /*1 ? { // testing
_classID: 'classFloatRect',
'Top ': bounds && bounds.top && bounds.top.value || 0,
Left: bounds && bounds.left && bounds.left.value || 0,
Btom: bounds && bounds.bottom && bounds.bottom.value || 0,
Rght: bounds && bounds.right && bounds.right.value || 0,
} :*/ {
'Top ': unitsValue(bounds && bounds.top || { units: 'Pixels', value: 0 }, 'bounds.top'),
Left: unitsValue(bounds && bounds.left || { units: 'Pixels', value: 0 }, 'bounds.left'),
Btom: unitsValue(bounds && bounds.bottom || { units: 'Pixels', value: 0 }, 'bounds.bottom'),
Rght: unitsValue(bounds && bounds.right || { units: 'Pixels', value: 0 }, 'bounds.right'),
}, uOrder: warp.uOrder || 0, vOrder: warp.vOrder || 0 });
var isQuilt = isQuiltWarp(warp);
if (isQuilt) {
var desc2 = desc;
desc2.deformNumRows = warp.deformNumRows || 0;
desc2.deformNumCols = warp.deformNumCols || 0;
}
var customEnvelopeWarp = warp.customEnvelopeWarp;
if (customEnvelopeWarp) {
var meshPoints = customEnvelopeWarp.meshPoints || [];
if (isQuilt) {
var desc2 = desc;
desc2.customEnvelopeWarp = {
_name: '',
_classID: 'customEnvelopeWarp',
quiltSliceX: [{
type: 'quiltSliceX',
values: customEnvelopeWarp.quiltSliceX || [],
}],
quiltSliceY: [{
type: 'quiltSliceY',
values: customEnvelopeWarp.quiltSliceY || [],
}],
meshPoints: [
{ type: 'Hrzn', values: meshPoints.map(function (p) { return p.x; }) },
{ type: 'Vrtc', values: meshPoints.map(function (p) { return p.y; }) },
],
};
}
else {
desc.customEnvelopeWarp = {
_name: '',
_classID: 'customEnvelopeWarp',
meshPoints: [
{ type: 'Hrzn', values: meshPoints.map(function (p) { return p.x; }) },
{ type: 'Vrtc', values: meshPoints.map(function (p) { return p.y; }) },
],
};
}
}
return desc;
}
addHandler('PlLd', hasKey('placedLayer'), function (reader, target, left) {
if (readSignature(reader) !== 'plcL')
throw new Error("Invalid PlLd signature");
if (readInt32(reader) !== 3)
throw new Error("Invalid PlLd version");
var id = readPascalString(reader, 1);
var pageNumber = readInt32(reader);
var totalPages = readInt32(reader); // TODO: check how this works ?
readInt32(reader); // anitAliasPolicy 16
var placedLayerType = readInt32(reader); // 0 = unknown, 1 = vector, 2 = raster, 3 = image stack
if (!placedLayerTypes[placedLayerType])
throw new Error('Invalid PlLd type');
var transform = [];
for (var i = 0; i < 8; i++)
transform.push(readFloat64(reader)); // x, y of 4 corners of the transform
var warpVersion = readInt32(reader);
if (warpVersion !== 0)
throw new Error("Invalid Warp version ".concat(warpVersion));
var warp = readVersionAndDescriptor(reader);
target.placedLayer = target.placedLayer || {
id: id,
type: placedLayerTypes[placedLayerType],
pageNumber: pageNumber,
totalPages: totalPages,
transform: transform,
warp: parseWarp(warp),
};
// console.log('PlLd warp', require('util').inspect(warp, false, 99, true));
// console.log('PlLd', require('util').inspect(target.placedLayer, false, 99, true));
skipBytes(reader, left());
}, function (writer, target) {
var placed = target.placedLayer;
writeSignature(writer, 'plcL');
writeInt32(writer, 3); // version
if (!placed.id || typeof placed.id !== 'string' || !/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(placed.id)) {
throw new Error('Placed layer ID must be in a GUID format (example: 20953ddb-9391-11ec-b4f1-c15674f50bc4)');
}
writePascalString(writer, placed.id, 1);
writeInt32(writer, 1); // pageNumber
writeInt32(writer, 1); // totalPages
writeInt32(writer, 16); // anitAliasPolicy
if (placedLayerTypes.indexOf(placed.type) === -1)
throw new Error('Invalid placedLayer type');
writeInt32(writer, placedLayerTypes.indexOf(placed.type));
for (var i = 0; i < 8; i++)
writeFloat64(writer, placed.transform[i]);
writeInt32(writer, 0); // warp version
var warp = getWarpFromPlacedLayer(placed);
var isQuilt = isQuiltWarp(warp);
var type = isQuilt ? 'quiltWarp' : 'warp';
writeVersionAndDescriptor(writer, '', type, encodeWarp(warp), type);
});
function u