支持 mac

npm-packages/mac-v3.4.+/ag-psd/dist/abr.d.ts

@@ -0,0 +1,132 @@
+import { BlendMode, PatternInfo } from './psd';
+export interface Abr {
+    brushes: Brush[];
+    samples: SampleInfo[];
+    patterns: PatternInfo[];
+}
+export interface SampleInfo {
+    id: string;
+    bounds: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    alpha: Uint8Array;
+}
+export interface BrushDynamics {
+    control: 'off' | 'fade' | 'pen pressure' | 'pen tilt' | 'stylus wheel' | 'initial direction' | 'direction' | 'initial rotation' | 'rotation';
+    steps: number;
+    jitter: number;
+    minimum: number;
+}
+export interface BrushShape {
+    name?: string;
+    size: number;
+    angle: number;
+    roundness: number;
+    hardness?: number;
+    spacingOn: boolean;
+    spacing: number;
+    flipX: boolean;
+    flipY: boolean;
+    sampledData?: string;
+}
+export interface Brush {
+    name: string;
+    shape: BrushShape;
+    shapeDynamics?: {
+        sizeDynamics: BrushDynamics;
+        minimumDiameter: number;
+        tiltScale: number;
+        angleDynamics: BrushDynamics;
+        roundnessDynamics: BrushDynamics;
+        minimumRoundness: number;
+        flipX: boolean;
+        flipY: boolean;
+        brushProjection: boolean;
+    };
+    scatter?: {
+        bothAxes: boolean;
+        scatterDynamics: BrushDynamics;
+        countDynamics: BrushDynamics;
+        count: number;
+    };
+    texture?: {
+        id: string;
+        name: string;
+        invert: boolean;
+        scale: number;
+        brightness: number;
+        contrast: number;
+        blendMode: BlendMode;
+        depth: number;
+        depthMinimum: number;
+        depthDynamics: BrushDynamics;
+    };
+    dualBrush?: {
+        flip: boolean;
+        shape: BrushShape;
+        blendMode: BlendMode;
+        useScatter: boolean;
+        spacing: number;
+        count: number;
+        bothAxes: boolean;
+        countDynamics: BrushDynamics;
+        scatterDynamics: BrushDynamics;
+    };
+    colorDynamics?: {
+        foregroundBackground: BrushDynamics;
+        hue: number;
+        saturation: number;
+        brightness: number;
+        purity: number;
+        perTip: boolean;
+    };
+    transfer?: {
+        flowDynamics: BrushDynamics;
+        opacityDynamics: BrushDynamics;
+        wetnessDynamics: BrushDynamics;
+        mixDynamics: BrushDynamics;
+    };
+    brushPose?: {
+        overrideAngle: boolean;
+        overrideTiltX: boolean;
+        overrideTiltY: boolean;
+        overridePressure: boolean;
+        pressure: number;
+        tiltX: number;
+        tiltY: number;
+        angle: number;
+    };
+    noise: boolean;
+    wetEdges: boolean;
+    protectTexture?: boolean;
+    spacing: number;
+    brushGroup?: undefined;
+    interpretation?: boolean;
+    useBrushSize: boolean;
+    toolOptions?: {
+        brushPreset: boolean;
+        flow: number;
+        smooth: number;
+        mode: BlendMode;
+        opacity: number;
+        smoothing: boolean;
+        smoothingValue: number;
+        smoothingRadiusMode: boolean;
+        smoothingCatchup: boolean;
+        smoothingCatchupAtEnd: boolean;
+        smoothingZoomCompensation: boolean;
+        pressureSmoothing: boolean;
+        usePressureOverridesSize: boolean;
+        usePressureOverridesOpacity: boolean;
+        useLegacy: boolean;
+        flowDynamics?: BrushDynamics;
+        opacityDynamics?: BrushDynamics;
+        sizeDynamics?: BrushDynamics;
+    };
+}
+export declare function readAbr(buffer: ArrayBufferView, options?: {
+    logMissingFeatures?: boolean;
+}): Abr;

npm-packages/mac-v3.4.+/ag-psd/dist/additionalInfo.d.ts

@@ -0,0 +1,25 @@
+import { LayerAdditionalInfo, BezierPath, Psd, ReadOptions, WriteOptions, BooleanOperation, LayerEffectsInfo, LayerVectorMask } from './psd';
+import { PsdReader } from './psdReader';
+import { PsdWriter } from './psdWriter';
+export interface ExtendedWriteOptions extends WriteOptions {
+    layerIds: Set<number>;
+    layerToId: Map<any, number>;
+}
+declare type HasMethod = (target: LayerAdditionalInfo) => boolean;
+declare type ReadMethod = (reader: PsdReader, target: LayerAdditionalInfo, left: () => number, psd: Psd, options: ReadOptions) => void;
+declare type WriteMethod = (writer: PsdWriter, target: LayerAdditionalInfo, psd: Psd, options: ExtendedWriteOptions) => void;
+export interface InfoHandler {
+    key: string;
+    has: HasMethod;
+    read: ReadMethod;
+    write: WriteMethod;
+}
+export declare const infoHandlers: InfoHandler[];
+export declare const infoHandlersMap: {
+    [key: string]: InfoHandler;
+};
+export declare function readBezierKnot(reader: PsdReader, width: number, height: number): number[];
+export declare const booleanOperations: BooleanOperation[];
+export declare function readVectorMask(reader: PsdReader, vectorMask: LayerVectorMask, width: number, height: number, size: number): BezierPath[];
+export declare function hasMultiEffects(effects: LayerEffectsInfo): boolean;
+export {};

npm-packages/mac-v3.4.+/ag-psd/dist/csh.d.ts

@@ -0,0 +1,10 @@
+import { LayerVectorMask } from './psd';
+export interface Csh {
+    shapes: (LayerVectorMask & {
+        name: string;
+        id: string;
+        width: number;
+        height: number;
+    })[];
+}
+export declare function readCsh(buffer: ArrayBufferView): Csh;

npm-packages/mac-v3.4.+/ag-psd/dist/csh.js

@@ -0,0 +1,49 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCsh = void 0;
+var additionalInfo_1 = require("./additionalInfo");
+var psdReader_1 = require("./psdReader");
+function readCsh(buffer) {
+    var reader = (0, psdReader_1.createReader)(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    var csh = { shapes: [] };
+    (0, psdReader_1.checkSignature)(reader, 'cush');
+    if ((0, psdReader_1.readUint32)(reader) !== 2)
+        throw new Error('Invalid version');
+    var count = (0, psdReader_1.readUint32)(reader);
+    for (var i = 0; i < count; i++) {
+        var name_1 = (0, psdReader_1.readUnicodeString)(reader);
+        while (reader.offset % 4)
+            reader.offset++; // pad to 4byte bounds
+        if ((0, psdReader_1.readUint32)(reader) !== 1)
+            throw new Error('Invalid shape version');
+        var size = (0, psdReader_1.readUint32)(reader);
+        var end = reader.offset + size;
+        var id = (0, psdReader_1.readPascalString)(reader, 1);
+        // this might not be correct ???
+        var y1 = (0, psdReader_1.readUint32)(reader);
+        var x1 = (0, psdReader_1.readUint32)(reader);
+        var y2 = (0, psdReader_1.readUint32)(reader);
+        var x2 = (0, psdReader_1.readUint32)(reader);
+        var width = x2 - x1;
+        var height = y2 - y1;
+        var mask = { paths: [] };
+        (0, additionalInfo_1.readVectorMask)(reader, mask, width, height, end - reader.offset);
+        csh.shapes.push(__assign({ name: name_1, id: id, width: width, height: height }, mask));
+        reader.offset = end;
+    }
+    return csh;
+}
+exports.readCsh = readCsh;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

npm-packages/mac-v3.4.+/ag-psd/dist/descriptor.d.ts

@@ -0,0 +1,390 @@
+import { AntiAlias, BevelDirection, BevelStyle, BevelTechnique, BlendMode, Color, GlowSource, GlowTechnique, GradientStyle, InterpolationMethod, LayerEffectsInfo, LineAlignment, LineCapType, LineJoinType, Orientation, TextGridding, TimelineKeyInterpolation, TimelineTrack, TimelineTrackType, Units, UnitsValue, VectorContent, WarpStyle } from './psd';
+import { PsdReader } from './psdReader';
+import { PsdWriter } from './psdWriter';
+export declare function setLogErrors(value: boolean): void;
+export declare function readAsciiStringOrClassId(reader: PsdReader): string;
+export declare function readDescriptorStructure(reader: PsdReader): any;
+export declare function writeDescriptorStructure(writer: PsdWriter, name: string, classId: string, value: any, root: string): void;
+export declare function readVersionAndDescriptor(reader: PsdReader): any;
+export declare function writeVersionAndDescriptor(writer: PsdWriter, name: string, classID: string, descriptor: any, root?: string): void;
+export declare type DescriptorUnits = 'Angle' | 'Density' | 'Distance' | 'None' | 'Percent' | 'Pixels' | 'Millimeters' | 'Points' | 'Picas' | 'Inches' | 'Centimeters';
+export interface DescriptorUnitsValue {
+    units: DescriptorUnits;
+    value: number;
+}
+export declare type DescriptorColor = {
+    'Rd  ': number;
+    'Grn ': number;
+    'Bl  ': number;
+} | {
+    'H   ': DescriptorUnitsValue;
+    Strt: number;
+    Brgh: number;
+} | {
+    'Cyn ': number;
+    Mgnt: number;
+    'Ylw ': number;
+    Blck: number;
+} | {
+    'Gry ': number;
+} | {
+    Lmnc: number;
+    'A   ': number;
+    'B   ': number;
+};
+export interface DesciptorPattern {
+    'Nm  ': string;
+    Idnt: string;
+}
+export declare type DesciptorGradient = {
+    'Nm  ': string;
+    GrdF: 'GrdF.CstS';
+    Intr: number;
+    Clrs: {
+        'Clr ': DescriptorColor;
+        Type: 'Clry.UsrS';
+        Lctn: number;
+        Mdpn: number;
+    }[];
+    Trns: {
+        Opct: DescriptorUnitsValue;
+        Lctn: number;
+        Mdpn: number;
+    }[];
+} | {
+    GrdF: 'GrdF.ClNs';
+    Smth: number;
+    'Nm  ': string;
+    ClrS: string;
+    RndS: number;
+    VctC?: boolean;
+    ShTr?: boolean;
+    'Mnm ': number[];
+    'Mxm ': number[];
+};
+export interface DescriptorColorContent {
+    'Clr ': DescriptorColor;
+}
+export interface DescriptorGradientContent {
+    Grad: DesciptorGradient;
+    Type: string;
+    Dthr?: boolean;
+    Rvrs?: boolean;
+    Angl?: DescriptorUnitsValue;
+    'Scl '?: DescriptorUnitsValue;
+    Algn?: boolean;
+    Ofst?: {
+        Hrzn: DescriptorUnitsValue;
+        Vrtc: DescriptorUnitsValue;
+    };
+}
+export interface DescriptorPatternContent {
+    Ptrn: DesciptorPattern;
+    Lnkd?: boolean;
+    phase?: {
+        Hrzn: number;
+        Vrtc: number;
+    };
+}
+export declare type DescriptorVectorContent = DescriptorColorContent | DescriptorGradientContent | DescriptorPatternContent;
+export interface StrokeDescriptor {
+    strokeStyleVersion: number;
+    strokeEnabled: boolean;
+    fillEnabled: boolean;
+    strokeStyleLineWidth: DescriptorUnitsValue;
+    strokeStyleLineDashOffset: DescriptorUnitsValue;
+    strokeStyleMiterLimit: number;
+    strokeStyleLineCapType: string;
+    strokeStyleLineJoinType: string;
+    strokeStyleLineAlignment: string;
+    strokeStyleScaleLock: boolean;
+    strokeStyleStrokeAdjust: boolean;
+    strokeStyleLineDashSet: DescriptorUnitsValue[];
+    strokeStyleBlendMode: string;
+    strokeStyleOpacity: DescriptorUnitsValue;
+    strokeStyleContent: DescriptorVectorContent;
+    strokeStyleResolution: number;
+}
+export interface TextDescriptor {
+    'Txt ': string;
+    textGridding: string;
+    Ornt: string;
+    AntA: string;
+    TextIndex: number;
+    EngineData?: Uint8Array;
+}
+export interface WarpDescriptor {
+    warpStyle: string;
+    warpValue: number;
+    warpPerspective: number;
+    warpPerspectiveOther: number;
+    warpRotate: string;
+    bounds?: {
+        'Top ': DescriptorUnitsValue;
+        Left: DescriptorUnitsValue;
+        Btom: DescriptorUnitsValue;
+        Rght: DescriptorUnitsValue;
+    };
+    uOrder: number;
+    vOrder: number;
+    customEnvelopeWarp?: {
+        meshPoints: {
+            type: 'Hrzn' | 'Vrtc';
+            values: number[];
+        }[];
+    };
+}
+export interface QuiltWarpDescriptor extends WarpDescriptor {
+    deformNumRows: number;
+    deformNumCols: number;
+    customEnvelopeWarp: {
+        quiltSliceX: {
+            type: 'quiltSliceX';
+            values: number[];
+        }[];
+        quiltSliceY: {
+            type: 'quiltSliceY';
+            values: number[];
+        }[];
+        meshPoints: {
+            type: 'Hrzn' | 'Vrtc';
+            values: number[];
+        }[];
+    };
+}
+export interface FractionDescriptor {
+    numerator: number;
+    denominator: number;
+}
+export interface HrznVrtcDescriptor {
+    Hrzn: number;
+    Vrtc: number;
+}
+export interface FrameDescriptor {
+    FrLs: number[];
+    enab?: boolean;
+    IMsk?: {
+        Ofst: HrznVrtcDescriptor;
+    };
+    VMsk?: {
+        Ofst: HrznVrtcDescriptor;
+    };
+    Ofst?: HrznVrtcDescriptor;
+    FXRf?: HrznVrtcDescriptor;
+    Lefx?: Lfx2Descriptor;
+    blendOptions?: {
+        Opct: DescriptorUnitsValue;
+    };
+}
+export interface FrameListDescriptor {
+    LaID: number;
+    LaSt: FrameDescriptor[];
+}
+export declare function horzVrtcToXY(hv: HrznVrtcDescriptor): {
+    x: number;
+    y: number;
+};
+export declare function xyToHorzVrtc(xy: {
+    x: number;
+    y: number;
+}): HrznVrtcDescriptor;
+export declare type TimelineAnimKeyDescriptor = {
+    Type: 'keyType.Opct';
+    Opct: DescriptorUnitsValue;
+} | {
+    Type: 'keyType.Trnf';
+    'Scl ': HrznVrtcDescriptor;
+    Skew: HrznVrtcDescriptor;
+    rotation: number;
+    translation: HrznVrtcDescriptor;
+} | {
+    Type: 'keyType.Pstn';
+    Hrzn: number;
+    Vrtc: number;
+} | {
+    Type: 'keyType.sheetStyle';
+    sheetStyle: {
+        Vrsn: number;
+        Lefx?: Lfx2Descriptor;
+        blendOptions: {};
+    };
+} | {
+    Type: 'keyType.globalLighting';
+    gblA: number;
+    globalAltitude: number;
+};
+export interface TimelineKeyDescriptor {
+    Vrsn: 1;
+    animInterpStyle: 'animInterpStyle.Lnr ' | 'animInterpStyle.hold';
+    time: FractionDescriptor;
+    animKey: TimelineAnimKeyDescriptor;
+    selected: boolean;
+}
+export interface TimelineTrackDescriptor {
+    trackID: 'stdTrackID.globalLightingTrack' | 'stdTrackID.opacityTrack' | 'stdTrackID.styleTrack' | 'stdTrackID.sheetTransformTrack' | 'stdTrackID.sheetPositionTrack';
+    Vrsn: 1;
+    enab: boolean;
+    Effc: boolean;
+    effectParams?: {
+        keyList: TimelineKeyDescriptor[];
+        fillCanvas: boolean;
+        zoomOrigin: number;
+    };
+    keyList: TimelineKeyDescriptor[];
+}
+export interface TimeScopeDescriptor {
+    Vrsn: 1;
+    Strt: FractionDescriptor;
+    duration: FractionDescriptor;
+    inTime: FractionDescriptor;
+    outTime: FractionDescriptor;
+}
+export interface TimelineDescriptor {
+    Vrsn: 1;
+    timeScope: TimeScopeDescriptor;
+    autoScope: boolean;
+    audioLevel: number;
+    LyrI: number;
+    trackList?: TimelineTrackDescriptor[];
+}
+export interface EffectDescriptor extends Partial<DescriptorGradientContent>, Partial<DescriptorPatternContent> {
+    enab?: boolean;
+    Styl: string;
+    PntT?: string;
+    'Md  '?: string;
+    Opct?: DescriptorUnitsValue;
+    'Sz  '?: DescriptorUnitsValue;
+    'Clr '?: DescriptorColor;
+    present?: boolean;
+    showInDialog?: boolean;
+    overprint?: boolean;
+}
+export interface Lfx2Descriptor {
+    'Scl '?: DescriptorUnitsValue;
+    masterFXSwitch?: boolean;
+    DrSh?: EffectDescriptor;
+    IrSh?: EffectDescriptor;
+    OrGl?: EffectDescriptor;
+    IrGl?: EffectDescriptor;
+    ebbl?: EffectDescriptor;
+    SoFi?: EffectDescriptor;
+    patternFill?: EffectDescriptor;
+    GrFl?: EffectDescriptor;
+    ChFX?: EffectDescriptor;
+    FrFX?: EffectDescriptor;
+}
+export interface LmfxDescriptor {
+    'Scl '?: DescriptorUnitsValue;
+    masterFXSwitch?: boolean;
+    numModifyingFX?: number;
+    OrGl?: EffectDescriptor;
+    IrGl?: EffectDescriptor;
+    ebbl?: EffectDescriptor;
+    ChFX?: EffectDescriptor;
+    dropShadowMulti?: EffectDescriptor[];
+    innerShadowMulti?: EffectDescriptor[];
+    solidFillMulti?: EffectDescriptor[];
+    gradientFillMulti?: EffectDescriptor[];
+    frameFXMulti?: EffectDescriptor[];
+    patternFill?: EffectDescriptor;
+}
+export declare function serializeEffects(e: LayerEffectsInfo, log: boolean, multi: boolean): Lfx2Descriptor & LmfxDescriptor;
+export declare function parseEffects(info: Lfx2Descriptor & LmfxDescriptor, log: boolean): LayerEffectsInfo;
+export declare function parseTrackList(trackList: TimelineTrackDescriptor[], logMissingFeatures: boolean): TimelineTrack[];
+export declare function serializeTrackList(tracks: TimelineTrack[]): TimelineTrackDescriptor[];
+export declare function parseVectorContent(descriptor: DescriptorVectorContent): VectorContent;
+export declare function serializeVectorContent(content: VectorContent): {
+    descriptor: DescriptorVectorContent;
+    key: string;
+};
+export declare function parseColor(color: DescriptorColor): Color;
+export declare function serializeColor(color: Color | undefined): DescriptorColor;
+export declare function parseAngle(x: DescriptorUnitsValue): number;
+export declare function parsePercent(x: DescriptorUnitsValue | undefined): number;
+export declare function parsePercentOrAngle(x: DescriptorUnitsValue | undefined): number;
+export declare function parseUnits({ units, value }: DescriptorUnitsValue): UnitsValue;
+export declare function parseUnitsOrNumber(value: DescriptorUnitsValue | number, units?: Units): UnitsValue;
+export declare function parseUnitsToNumber({ units, value }: DescriptorUnitsValue, expectedUnits: string): number;
+export declare function unitsAngle(value: number | undefined): DescriptorUnitsValue;
+export declare function unitsPercent(value: number | undefined): DescriptorUnitsValue;
+export declare function unitsValue(x: UnitsValue | undefined, key: string): DescriptorUnitsValue;
+export declare const textGridding: {
+    decode: (val: string) => TextGridding;
+    encode: (val: TextGridding | undefined) => string;
+};
+export declare const Ornt: {
+    decode: (val: string) => Orientation;
+    encode: (val: Orientation | undefined) => string;
+};
+export declare const Annt: {
+    decode: (val: string) => AntiAlias;
+    encode: (val: AntiAlias | undefined) => string;
+};
+export declare const warpStyle: {
+    decode: (val: string) => WarpStyle;
+    encode: (val: WarpStyle | undefined) => string;
+};
+export declare const BlnM: {
+    decode: (val: string) => BlendMode;
+    encode: (val: BlendMode | undefined) => string;
+};
+export declare const BESl: {
+    decode: (val: string) => BevelStyle;
+    encode: (val: BevelStyle | undefined) => string;
+};
+export declare const bvlT: {
+    decode: (val: string) => BevelTechnique;
+    encode: (val: BevelTechnique | undefined) => string;
+};
+export declare const BESs: {
+    decode: (val: string) => BevelDirection;
+    encode: (val: BevelDirection | undefined) => string;
+};
+export declare const BETE: {
+    decode: (val: string) => GlowTechnique;
+    encode: (val: GlowTechnique | undefined) => string;
+};
+export declare const IGSr: {
+    decode: (val: string) => GlowSource;
+    encode: (val: GlowSource | undefined) => string;
+};
+export declare const GrdT: {
+    decode: (val: string) => GradientStyle;
+    encode: (val: GradientStyle | undefined) => string;
+};
+export declare const animInterpStyleEnum: {
+    decode: (val: string) => TimelineKeyInterpolation;
+    encode: (val: TimelineKeyInterpolation | undefined) => string;
+};
+export declare const stdTrackID: {
+    decode: (val: string) => TimelineTrackType;
+    encode: (val: TimelineTrackType | undefined) => string;
+};
+export declare const gradientInterpolationMethodType: {
+    decode: (val: string) => InterpolationMethod;
+    encode: (val: InterpolationMethod | undefined) => string;
+};
+export declare const ClrS: {
+    decode: (val: string) => "rgb" | "hsb" | "lab";
+    encode: (val: "rgb" | "hsb" | "lab" | undefined) => string;
+};
+export declare const FStl: {
+    decode: (val: string) => "center" | "inside" | "outside";
+    encode: (val: "center" | "inside" | "outside" | undefined) => string;
+};
+export declare const FrFl: {
+    decode: (val: string) => "color" | "pattern" | "gradient";
+    encode: (val: "color" | "pattern" | "gradient" | undefined) => string;
+};
+export declare const strokeStyleLineCapType: {
+    decode: (val: string) => LineCapType;
+    encode: (val: LineCapType | undefined) => string;
+};
+export declare const strokeStyleLineJoinType: {
+    decode: (val: string) => LineJoinType;
+    encode: (val: LineJoinType | undefined) => string;
+};
+export declare const strokeStyleLineAlignment: {
+    decode: (val: string) => LineAlignment;
+    encode: (val: LineAlignment | undefined) => string;
+};

npm-packages/mac-v3.4.+/ag-psd/dist/effectsHelpers.d.ts

@@ -0,0 +1,5 @@
+import { LayerEffectsInfo } from './psd';
+import { PsdReader } from './psdReader';
+import { PsdWriter } from './psdWriter';
+export declare function readEffects(reader: PsdReader): LayerEffectsInfo;
+export declare function writeEffects(writer: PsdWriter, effects: LayerEffectsInfo): void;

npm-packages/mac-v3.4.+/ag-psd/dist/engineData.d.ts

@@ -0,0 +1,2 @@
+export declare function parseEngineData(data: number[] | Uint8Array): any;
+export declare function serializeEngineData(data: any, condensed?: boolean): Uint8Array;

npm-packages/mac-v3.4.+/ag-psd/dist/helpers.d.ts

@@ -0,0 +1,93 @@
+import { Layer, BlendMode, LayerColor } from './psd';
+export declare const MOCK_HANDLERS = false;
+export declare const RAW_IMAGE_DATA = false;
+export declare const fromBlendMode: {
+    [key: string]: string;
+};
+export declare const toBlendMode: {
+    [key: string]: BlendMode;
+};
+export declare const layerColors: LayerColor[];
+export declare const largeAdditionalInfoKeys: string[];
+export interface Dict {
+    [key: string]: string;
+}
+export declare function revMap(map: Dict): Dict;
+export declare function createEnum<T>(prefix: string, def: string, map: Dict): {
+    decode: (val: string) => T;
+    encode: (val: T | undefined) => string;
+};
+export declare const enum ColorSpace {
+    RGB = 0,
+    HSB = 1,
+    CMYK = 2,
+    Lab = 7,
+    Grayscale = 8
+}
+export declare const enum LayerMaskFlags {
+    PositionRelativeToLayer = 1,
+    LayerMaskDisabled = 2,
+    InvertLayerMaskWhenBlending = 4,
+    LayerMaskFromRenderingOtherData = 8,
+    MaskHasParametersAppliedToIt = 16
+}
+export declare const enum MaskParams {
+    UserMaskDensity = 1,
+    UserMaskFeather = 2,
+    VectorMaskDensity = 4,
+    VectorMaskFeather = 8
+}
+export declare const enum ChannelID {
+    Color0 = 0,
+    Color1 = 1,
+    Color2 = 2,
+    Color3 = 3,
+    Transparency = -1,
+    UserMask = -2,
+    RealUserMask = -3
+}
+export declare const enum Compression {
+    RawData = 0,
+    RleCompressed = 1,
+    ZipWithoutPrediction = 2,
+    ZipWithPrediction = 3
+}
+export interface ChannelData {
+    channelId: ChannelID;
+    compression: Compression;
+    buffer: Uint8Array | undefined;
+    length: number;
+}
+export interface Bounds {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+}
+export interface LayerChannelData {
+    layer: Layer;
+    channels: ChannelData[];
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+    mask?: Bounds;
+}
+export declare type PixelArray = Uint8ClampedArray | Uint8Array;
+export interface PixelData {
+    data: PixelArray;
+    width: number;
+    height: number;
+}
+export declare function offsetForChannel(channelId: ChannelID, cmyk: boolean): number;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function hasAlpha(data: PixelData): boolean;
+export declare function resetImageData({ data }: PixelData): void;
+export declare function decodeBitmap(input: PixelArray, output: PixelArray, width: number, height: number): void;
+export declare function writeDataRaw(data: PixelData, offset: number, width: number, height: number): Uint8Array | undefined;
+export declare function writeDataRLE(buffer: Uint8Array, { data, width, height }: PixelData, offsets: number[], large: boolean): Uint8Array | undefined;
+export declare function writeDataZipWithoutPrediction({ data, width, height }: PixelData, offsets: number[]): Uint8Array;
+export declare let createCanvas: (width: number, height: number) => HTMLCanvasElement;
+export declare let createCanvasFromData: (data: Uint8Array) => HTMLCanvasElement;
+export declare let createImageData: (width: number, height: number) => ImageData;
+export declare function initializeCanvas(createCanvasMethod: (width: number, height: number) => HTMLCanvasElement, createCanvasFromDataMethod?: (data: Uint8Array) => HTMLCanvasElement, createImageDataMethod?: (width: number, height: number) => ImageData): void;

npm-packages/mac-v3.4.+/ag-psd/dist/imageResources.d.ts

@@ -0,0 +1,13 @@
+import { ImageResources, ReadOptions } from './psd';
+import { PsdReader } from './psdReader';
+import { PsdWriter } from './psdWriter';
+export interface ResourceHandler {
+    key: number;
+    has: (target: ImageResources) => boolean;
+    read: (reader: PsdReader, target: ImageResources, left: () => number, options: ReadOptions) => void;
+    write: (writer: PsdWriter, target: ImageResources) => void;
+}
+export declare const resourceHandlers: ResourceHandler[];
+export declare const resourceHandlersMap: {
+    [key: number]: ResourceHandler;
+};

npm-packages/mac-v3.4.+/ag-psd/dist/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { Psd, ReadOptions, WriteOptions } from './psd';
+import { PsdWriter } from './psdWriter';
+import { PsdReader } from './psdReader';
+export * from './abr';
+export * from './csh';
+export { initializeCanvas } from './helpers';
+export * from './psd';
+import { fromByteArray } from 'base64-js';
+export { PsdReader, PsdWriter };
+interface BufferLike {
+    buffer: ArrayBuffer;
+    byteOffset: number;
+    byteLength: number;
+}
+export declare const byteArrayToBase64: typeof fromByteArray;
+export declare function readPsd(buffer: ArrayBuffer | BufferLike, options?: ReadOptions): Psd;
+export declare function writePsd(psd: Psd, options?: WriteOptions): ArrayBuffer;
+export declare function writePsdUint8Array(psd: Psd, options?: WriteOptions): Uint8Array;
+export declare function writePsdBuffer(psd: Psd, options?: WriteOptions): Buffer;

npm-packages/mac-v3.4.+/ag-psd/dist/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePsdBuffer = exports.writePsdUint8Array = exports.writePsd = exports.readPsd = exports.byteArrayToBase64 = exports.initializeCanvas = void 0;
+var psdWriter_1 = require("./psdWriter");
+var psdReader_1 = require("./psdReader");
+__exportStar(require("./abr"), exports);
+__exportStar(require("./csh"), exports);
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "initializeCanvas", { enumerable: true, get: function () { return helpers_1.initializeCanvas; } });
+__exportStar(require("./psd"), exports);
+var base64_js_1 = require("base64-js");
+exports.byteArrayToBase64 = base64_js_1.fromByteArray;
+function readPsd(buffer, options) {
+    var reader = 'buffer' in buffer ?
+        (0, psdReader_1.createReader)(buffer.buffer, buffer.byteOffset, buffer.byteLength) :
+        (0, psdReader_1.createReader)(buffer);
+    return (0, psdReader_1.readPsd)(reader, options);
+}
+exports.readPsd = readPsd;
+function writePsd(psd, options) {
+    var writer = (0, psdWriter_1.createWriter)();
+    (0, psdWriter_1.writePsd)(writer, psd, options);
+    return (0, psdWriter_1.getWriterBuffer)(writer);
+}
+exports.writePsd = writePsd;
+function writePsdUint8Array(psd, options) {
+    var writer = (0, psdWriter_1.createWriter)();
+    (0, psdWriter_1.writePsd)(writer, psd, options);
+    return (0, psdWriter_1.getWriterBufferNoCopy)(writer);
+}
+exports.writePsdUint8Array = writePsdUint8Array;
+function writePsdBuffer(psd, options) {
+    if (typeof Buffer === 'undefined') {
+        throw new Error('Buffer not supported on this platform');
+    }
+    return Buffer.from(writePsdUint8Array(psd, options));
+}
+exports.writePsdBuffer = writePsdBuffer;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

npm-packages/mac-v3.4.+/ag-psd/dist/initializeCanvas.d.ts

@@ -0,0 +1 @@
+export declare function initialize(): void;

npm-packages/mac-v3.4.+/ag-psd/dist/initializeCanvas.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = void 0;
+var canvas_1 = require("canvas");
+var index_1 = require("./index");
+var jpeg_1 = require("./jpeg");
+function createCanvasFromData(data) {
+    var canvas = (0, canvas_1.createCanvas)(100, 100);
+    try {
+        var context_1 = canvas.getContext('2d');
+        var imageData = (0, jpeg_1.decodeJpeg)(data, function (w, h) { return context_1.createImageData(w, h); });
+        canvas.width = imageData.width;
+        canvas.height = imageData.height;
+        context_1.putImageData(imageData, 0, 0);
+    }
+    catch (e) {
+        console.error('JPEG decompression error', e.message);
+    }
+    return canvas;
+}
+(0, index_1.initializeCanvas)(canvas_1.createCanvas, createCanvasFromData);
+function initialize() {
+    (0, index_1.initializeCanvas)(canvas_1.createCanvas, createCanvasFromData);
+}
+exports.initialize = initialize;
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

npm-packages/mac-v3.4.+/ag-psd/dist/jpeg.d.ts

@@ -0,0 +1 @@
+export declare function decodeJpeg(encoded: Uint8Array, createImageData: (width: number, height: number) => ImageData): ImageData;

npm-packages/mac-v3.4.+/ag-psd/dist/psdReader.d.ts

@@ -0,0 +1,36 @@
+import { Psd, ColorMode, ReadOptions, Color, PatternInfo } from './psd';
+import { PixelData } from './helpers';
+export declare const supportedColorModes: ColorMode[];
+export interface PsdReader {
+    offset: number;
+    view: DataView;
+    strict: boolean;
+    debug: boolean;
+}
+export declare function createReader(buffer: ArrayBuffer, offset?: number, length?: number): PsdReader;
+export declare function warnOrThrow(reader: PsdReader, message: string): void;
+export declare function readUint8(reader: PsdReader): number;
+export declare function peekUint8(reader: PsdReader): number;
+export declare function readInt16(reader: PsdReader): number;
+export declare function readUint16(reader: PsdReader): number;
+export declare function readInt32(reader: PsdReader): number;
+export declare function readInt32LE(reader: PsdReader): number;
+export declare function readUint32(reader: PsdReader): number;
+export declare function readFloat32(reader: PsdReader): number;
+export declare function readFloat64(reader: PsdReader): number;
+export declare function readFixedPoint32(reader: PsdReader): number;
+export declare function readFixedPointPath32(reader: PsdReader): number;
+export declare function readBytes(reader: PsdReader, length: number): Uint8Array;
+export declare function readSignature(reader: PsdReader): string;
+export declare function readPascalString(reader: PsdReader, padTo: number): string;
+export declare function readUnicodeString(reader: PsdReader): string;
+export declare function readUnicodeStringWithLength(reader: PsdReader, length: number): string;
+export declare function readAsciiString(reader: PsdReader, length: number): string;
+export declare function skipBytes(reader: PsdReader, count: number): void;
+export declare function checkSignature(reader: PsdReader, a: string, b?: string): void;
+export declare function readPsd(reader: PsdReader, options?: ReadOptions): Psd;
+export declare function readDataZipWithoutPrediction(reader: PsdReader, length: number, pixelData: PixelData | undefined, width: number, height: number, step: number, offset: number): void;
+export declare function readDataRLE(reader: PsdReader, pixelData: PixelData | undefined, _width: number, height: number, step: number, offsets: number[], large: boolean): void;
+export declare function readSection<T>(reader: PsdReader, round: number, func: (left: () => number) => T, skipEmpty?: boolean, eightBytes?: boolean): T | undefined;
+export declare function readColor(reader: PsdReader): Color;
+export declare function readPattern(reader: PsdReader): PatternInfo;

npm-packages/mac-v3.4.+/ag-psd/dist/psdWriter.d.ts

@@ -0,0 +1,27 @@
+import { Psd, WriteOptions, Color } from './psd';
+export interface PsdWriter {
+    offset: number;
+    buffer: ArrayBuffer;
+    view: DataView;
+}
+export declare function createWriter(size?: number): PsdWriter;
+export declare function getWriterBuffer(writer: PsdWriter): ArrayBuffer;
+export declare function getWriterBufferNoCopy(writer: PsdWriter): Uint8Array;
+export declare function writeUint8(writer: PsdWriter, value: number): void;
+export declare function writeInt16(writer: PsdWriter, value: number): void;
+export declare function writeUint16(writer: PsdWriter, value: number): void;
+export declare function writeInt32(writer: PsdWriter, value: number): void;
+export declare function writeUint32(writer: PsdWriter, value: number): void;
+export declare function writeFloat32(writer: PsdWriter, value: number): void;
+export declare function writeFloat64(writer: PsdWriter, value: number): void;
+export declare function writeFixedPoint32(writer: PsdWriter, value: number): void;
+export declare function writeFixedPointPath32(writer: PsdWriter, value: number): void;
+export declare function writeBytes(writer: PsdWriter, buffer: Uint8Array | undefined): void;
+export declare function writeZeros(writer: PsdWriter, count: number): void;
+export declare function writeSignature(writer: PsdWriter, signature: string): void;
+export declare function writePascalString(writer: PsdWriter, text: string, padTo: number): void;
+export declare function writeUnicodeString(writer: PsdWriter, text: string): void;
+export declare function writeUnicodeStringWithPadding(writer: PsdWriter, text: string): void;
+export declare function writeSection(writer: PsdWriter, round: number, func: () => void, writeTotalLength?: boolean, large?: boolean): void;
+export declare function writePsd(writer: PsdWriter, psd: Psd, options?: WriteOptions): void;
+export declare function writeColor(writer: PsdWriter, color: Color | undefined): void;

npm-packages/mac-v3.4.+/ag-psd/dist/text.d.ts

@@ -0,0 +1,168 @@
+import { LayerTextData } from './psd';
+interface Adjustments {
+    Axis: number[];
+    XY: number[];
+}
+interface TypeValues {
+    Type: number;
+    Values: number[];
+}
+interface ParagraphProperties {
+    Justification?: number;
+    FirstLineIndent?: number;
+    StartIndent?: number;
+    EndIndent?: number;
+    SpaceBefore?: number;
+    SpaceAfter?: number;
+    AutoHyphenate?: boolean;
+    HyphenatedWordSize?: number;
+    PreHyphen?: number;
+    PostHyphen?: number;
+    ConsecutiveHyphens?: number;
+    Zone?: number;
+    WordSpacing?: number[];
+    LetterSpacing?: number[];
+    GlyphSpacing?: number[];
+    AutoLeading?: number;
+    LeadingType?: number;
+    Hanging?: boolean;
+    Burasagari?: boolean;
+    KinsokuOrder?: number;
+    EveryLineComposer?: boolean;
+}
+interface ParagraphSheet {
+    Name?: string;
+    DefaultStyleSheet: number;
+    Properties: ParagraphProperties;
+}
+interface StyleSheetData {
+    Font?: number;
+    FontSize?: number;
+    FauxBold?: boolean;
+    FauxItalic?: boolean;
+    AutoLeading?: boolean;
+    Leading?: number;
+    HorizontalScale?: number;
+    VerticalScale?: number;
+    Tracking?: number;
+    AutoKerning?: boolean;
+    Kerning?: number;
+    BaselineShift?: number;
+    FontCaps?: number;
+    FontBaseline?: number;
+    Underline?: boolean;
+    Strikethrough?: boolean;
+    Ligatures?: boolean;
+    DLigatures?: boolean;
+    BaselineDirection?: number;
+    Tsume?: number;
+    StyleRunAlignment?: number;
+    Language?: number;
+    NoBreak?: boolean;
+    FillColor?: TypeValues;
+    StrokeColor?: TypeValues;
+    FillFlag?: boolean;
+    StrokeFlag?: boolean;
+    FillFirst?: boolean;
+    YUnderline?: number;
+    OutlineWidth?: number;
+    CharacterDirection?: number;
+    HindiNumbers?: boolean;
+    Kashida?: number;
+    DiacriticPos?: number;
+}
+interface FontSet {
+    Name: string;
+    Script: number;
+    FontType: number;
+    Synthetic: number;
+}
+interface ResourceDict {
+    KinsokuSet: any[];
+    MojiKumiSet: any[];
+    TheNormalStyleSheet: number;
+    TheNormalParagraphSheet: number;
+    ParagraphSheetSet: ParagraphSheet[];
+    StyleSheetSet: {
+        Name: string;
+        StyleSheetData: StyleSheetData;
+    }[];
+    FontSet: FontSet[];
+    SuperscriptSize: number;
+    SuperscriptPosition: number;
+    SubscriptSize: number;
+    SubscriptPosition: number;
+    SmallCapSize: number;
+}
+interface ParagraphRun {
+    ParagraphSheet: ParagraphSheet;
+    Adjustments: Adjustments;
+}
+interface StyleRun {
+    StyleSheet: {
+        StyleSheetData: StyleSheetData;
+    };
+}
+interface PhotoshopNode {
+    ShapeType?: number;
+    PointBase?: number[];
+    BoxBounds?: number[];
+    Base?: {
+        ShapeType: number;
+        TransformPoint0: number[];
+        TransformPoint1: number[];
+        TransformPoint2: number[];
+    };
+}
+interface EngineData {
+    EngineDict: {
+        Editor: {
+            Text: string;
+        };
+        ParagraphRun: {
+            DefaultRunData: ParagraphRun;
+            RunArray: ParagraphRun[];
+            RunLengthArray: number[];
+            IsJoinable: number;
+        };
+        StyleRun: {
+            DefaultRunData: StyleRun;
+            RunArray: StyleRun[];
+            RunLengthArray: number[];
+            IsJoinable: number;
+        };
+        GridInfo: {
+            GridIsOn: boolean;
+            ShowGrid: boolean;
+            GridSize: number;
+            GridLeading: number;
+            GridColor: TypeValues;
+            GridLeadingFillColor: TypeValues;
+            AlignLineHeightToGridFlags: boolean;
+        };
+        AntiAlias: number;
+        UseFractionalGlyphWidths: boolean;
+        Rendered?: {
+            Version: number;
+            Shapes?: {
+                WritingDirection: number;
+                Children?: {
+                    ShapeType?: number;
+                    Procession: number;
+                    Lines: {
+                        WritingDirection: number;
+                        Children: any[];
+                    };
+                    Cookie?: {
+                        Photoshop?: PhotoshopNode;
+                    };
+                }[];
+            };
+        };
+    };
+    ResourceDict: ResourceDict;
+    DocumentResources: ResourceDict;
+}
+export declare function decodeEngineData(engineData: EngineData): LayerTextData;
+export declare function encodeEngineData(data: LayerTextData): EngineData;
+export {};

npm-packages/mac-v3.4.+/ag-psd/dist/utf8.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export declare function stringLengthInBytes(value: string): number;
+export declare function encodeStringTo(buffer: Uint8Array | Buffer, offset: number, value: string): number;
+export declare function encodeString(value: string): Uint8Array;
+export declare function decodeString(value: Uint8Array): string;