How to get text transform box boundary?

As a result, I wrote such code to get the rectangle of the transformation of the text layer. It works fine, but only for layers with a simple transformation (xx yy):

#target photoshop;

s2t = stringIDToTypeID;
(r = new ActionReference()).putProperty(s2t('property'), p = s2t('resolution'));
r.putEnumerated(s2t('document'), s2t('ordinal'), s2t('targetEnum'));
var docRes = executeActionGet(r).getUnitDoubleValue(p);

(r = new ActionReference()).putProperty(s2t('property'), p = s2t('unitsPrefs'));
r.putEnumerated(s2t("application"), s2t("ordinal"), s2t("targetEnum"));
var exactPoints = executeActionGet(r).getObjectValue(p).getBoolean(s2t('exactPoints')) ? 72.27 : 72;

(d = new ActionDescriptor()).putUnitDouble(s2t('resolution'), s2t('densityUnit'), exactPoints);
executeAction(s2t("imageSize"), d, DialogModes.NO);

(r = new ActionReference()).putProperty(s2t('property'), p = s2t('height'))
r.putEnumerated(s2t('document'), s2t('ordinal'), s2t('targetEnum'));
var docHeight = executeActionGet(r).getUnitDoubleValue(p);

(r = new ActionReference()).putProperty(s2t('property'), p = s2t('width'))
r.putEnumerated(s2t('document'), s2t('ordinal'), s2t('targetEnum'));
var docWidth = executeActionGet(r).getUnitDoubleValue(p);

(r = new ActionReference()).putProperty(s2t('property'), p = s2t('textKey'))
r.putEnumerated(s2t('layer'), s2t('ordinal'), s2t('targetEnum'));
var textKey = executeActionGet(r).getObjectValue(p);

var clickPointH = textKey.getObjectValue(s2t('textClickPoint')).getUnitDoubleValue(s2t('horizontal')),
    clickPointV = textKey.getObjectValue(s2t('textClickPoint')).getUnitDoubleValue(s2t('vertical')),
    clickPointHPx = Math.round(clickPointH / 100 * docWidth),
    clickPointVPx = Math.round(clickPointV / 100 * docHeight);

makeGuide(clickPointHPx, 'vertical')
makeGuide(clickPointVPx, 'horizontal')

if (typeIDToStringID(textKey.getList(s2t('textShape')).getObjectValue(0).getEnumerationValue(s2t('textType'))) != 'box') {
    var bounds = textKey.getObjectValue(s2t('bounds')),
        left = bounds.getUnitDoubleValue(s2t('left')),
        top = bounds.getUnitDoubleValue(s2t('top')),
        right = bounds.getUnitDoubleValue(s2t('right')),
        bottom = bounds.getUnitDoubleValue(s2t('bottom')),
        transform = textKey.hasKey(s2t('transform')) ? textKey.getObjectValue(s2t('transform')) : null,
        xx = transform != null ? transform.getDouble(s2t('xx')) : 1,
        yy = transform != null ? transform.getDouble(s2t('yy')) : 1,
        xy = transform != null ? transform.getDouble(s2t('xy')) : 1,
        yx = transform != null ? transform.getDouble(s2t('xy')) : 1;

    makeGuide(left * xx + clickPointHPx, 'vertical');
    makeGuide(top * yy + clickPointVPx, 'horizontal');
    makeGuide(right * xx + clickPointHPx, 'vertical');
    makeGuide(bottom * yy + clickPointVPx, 'horizontal');
}

(d = new ActionDescriptor()).putUnitDouble(s2t('resolution'), s2t('densityUnit'), docRes);
executeAction(s2t("imageSize"), d, DialogModes.NO);

function makeGuide(position, orientation) {
    (d1 = new ActionDescriptor()).putUnitDouble(s2t("position"), s2t("pixelsUnit"), position);
    d1.putEnumerated(s2t("orientation"), s2t("orientation"), s2t(orientation));
    d1.putEnumerated(s2t("kind"), s2t("kind"), s2t("document"));
    (d = new ActionDescriptor()).putObject(s2t("new"), s2t("guide"), d1);
    (r = new ActionReference()).putClass(s2t("guide"));
    d.putReference(s2t("null"), r);
    executeAction(s2t("make"), d, DialogModes.NO);
}

For more complex transformations, as I understand it, displacements along each axis are additionally indicated (by the way, I could not make such a transformation so that tx and ty change - what is it?):

xx = 0.35280340604376
xy = -0.26049157198293
yx = 0.09027891302419
yy = 0.47847952594196
tx = 0
ty = 0

I approximately understood the principle and even was able to process these displacements for simple cases such as a 90-degree turn, but so far I can’t get any further: I need to somehow take into account all the displacements so that in the end they give the correct transformation box. If someone can help, i would be grateful.

»by the way, they are points, I could not adequately convert them to pixels«

You can just have the Script save the resolution, resize the image to 72ppi resolution without resampling, do whatever and at the end resize the image to its original resolution without resampling again. 

In the meantime I think pt and px should be interchangable. 

Hi,

I have a script that I found long days ago. May be this scipt will help you to find out the correct values. 

// Copyright 2012 Adobe Systems Incorporated.  All Rights reserved.

// IMPORTANT: This file MUST be written out from ESTK with the option to write the UTF-8
// signature turned ON (Edit > Preferences > Documents > UTF-8 Signature).  Otherwise,
// the script fails when run from Photoshop with "JavaScript code was missing" on
// non-English Windows systems.

//
// Extract CSS from the current layer selection and copy it to the clipboard.
//

/*
@@@BUILDINFO@@@ CopyCSSToClipboard.jsx 1.0.0.0
*/

if (typeof COPYCSS !== 'object') {
    COPYCSS = {};
}

$.localize = true;

// Constants for accessing PS event functionality.  In the interests of speed
// we're defining just the ones used here, rather than sucking in a general defs file.
const classApplication = app.charIDToTypeID('capp');
const classDocument = charIDToTypeID('Dcmn');
const classLayer = app.charIDToTypeID('Lyr ');
const classLayerEffects = app.charIDToTypeID('Lefx');
const classProperty = app.charIDToTypeID('Prpr');
const enumTarget = app.charIDToTypeID('Trgt');
const eventGet = app.charIDToTypeID('getd');
const eventHide = app.charIDToTypeID('Hd  ');
const eventSelect = app.charIDToTypeID('slct');
const eventShow = app.charIDToTypeID('Shw ');
const keyItemIndex = app.charIDToTypeID('ItmI');
const keyLayerID = app.charIDToTypeID('LyrI');
const keyTarget = app.charIDToTypeID('null');
const keyTextData = app.charIDToTypeID('TxtD');
const typeNULL = app.charIDToTypeID('null');
const typeOrdinal = app.charIDToTypeID('Ordn');

const ktextToClipboardStr = app.stringIDToTypeID("textToClipboard");

const unitAngle = app.charIDToTypeID('#Ang');
const unitDensity = app.charIDToTypeID('#Rsl');
const unitDistance = app.charIDToTypeID('#Rlt');
const unitNone = app.charIDToTypeID('#Nne');
const unitPercent = app.charIDToTypeID('#Prc');
const unitPixels = app.charIDToTypeID('#Pxl');
const unitMillimeters = app.charIDToTypeID('#Mlm');
const unitPoints = app.charIDToTypeID('#Pnt');

const enumRulerCm = app.charIDToTypeID('RrCm');
const enumRulerInches = app.charIDToTypeID('RrIn');
const enumRulerPercent = app.charIDToTypeID('RrPr');
const enumRulerPicas = app.charIDToTypeID('RrPi');
const enumRulerPixels = app.charIDToTypeID('RrPx');
const enumRulerPoints = app.charIDToTypeID('RrPt');

// SheetKind definitions from USheet.h
const kAnySheet = 0;
const kPixelSheet = 1;
const kAdjustmentSheet = 2;
const kTextSheet = 3;
const kVectorSheet = 4;
const kSmartObjectSheet = 5;
const kVideoSheet = 6;
const kLayerGroupSheet = 7;
const k3DSheet = 8;
const kGradientSheet = 9;
const kPatternSheet = 10;
const kSolidColorSheet = 11;
const kBackgroundSheet = 12;
const kHiddenSectionBounder = 13;

// Tables to convert Photoshop UnitTypes into CSS types
var unitIDToCSS = {};
unitIDToCSS[unitAngle] = "deg";
unitIDToCSS[unitDensity] = "DEN	"; // Not supported in CSS
unitIDToCSS[unitDistance] = "DIST"; // Not supported in CSS
unitIDToCSS[unitNone] = ""; // Not supported in CSS
unitIDToCSS[unitPercent] = "%";
unitIDToCSS[unitPixels] = "px";
unitIDToCSS[unitMillimeters] = "mm";
unitIDToCSS[unitPoints] = "pt";

unitIDToCSS[enumRulerCm] = "cm";
unitIDToCSS[enumRulerInches] = "in";
unitIDToCSS[enumRulerPercent] = "%";
unitIDToCSS[enumRulerPicas] = "pc";
unitIDToCSS[enumRulerPixels] = "px";
unitIDToCSS[enumRulerPoints] = "pt";

// Pixel units in Photoshop are hardwired to 72 DPI (points),
// regardless of the doc resolution.
var unitIDToPt = {};
unitIDToPt[unitPixels] = 1;
unitIDToPt[enumRulerPixels] = 1;
unitIDToPt[Units.PIXELS] = 1;
unitIDToPt[unitPoints] = 1;
unitIDToPt[enumRulerPoints] = 1;
unitIDToPt[Units.POINTS] = 1;

unitIDToPt[unitMillimeters] = UnitValue(1, "mm").as('pt');
unitIDToPt[Units.MM] = UnitValue(1, "mm").as('pt');
unitIDToPt[enumRulerCm] = UnitValue(1, "cm").as('pt');
unitIDToPt[Units.CM] = UnitValue(1, "cm").as('pt');
unitIDToPt[enumRulerInches] = UnitValue(1, "in").as('pt');
unitIDToPt[Units.INCHES] = UnitValue(1, "in").as('pt');
unitIDToPt[stringIDToTypeID("inchesUnit")] = UnitValue(1, "in").as('pt');
unitIDToPt[enumRulerPicas] = UnitValue(1, "pc").as('pt');
unitIDToPt[Units.PICAS] = UnitValue(1, "pc").as('pt');

unitIDToPt[unitDistance] = 1;
unitIDToPt[unitDensity] = 1;

// Fortunately, both CSS and the DOM unit values use the same
// unit abbreviations.
var DOMunitToCSS = {};
DOMunitToCSS[Units.CM] = "cm";
DOMunitToCSS[Units.INCHES] = "in";
DOMunitToCSS[Units.MM] = "mm";
DOMunitToCSS[Units.PERCENT] = "%";
DOMunitToCSS[Units.PICAS] = "pc";
DOMunitToCSS[Units.PIXELS] = "px";
DOMunitToCSS[Units.POINTS] = "pt";
DOMunitToCSS[TypeUnits.MM] = "mm";
DOMunitToCSS[TypeUnits.PIXELS] = "px";
DOMunitToCSS[TypeUnits.POINTS] = "pt";


// A sample object descriptor path looks like:
// AGMStrokeStyleInfo.strokeStyleContent.'Clr '.'Rd  '
// This converts either OSType or string IDs.
makeID = function (keyStr) {
    if (keyStr[0] == "'") // Keys with single quotes 'ABCD' are charIDs.
        return app.charIDToTypeID(eval(keyStr));
    else
        return app.stringIDToTypeID(keyStr);
}

// Clean up some pretty noisy FP numbers...
function round1k(x) {
    return Math.round(x * 1000) / 1000;
}

// Strip off the unit string and return UnitValue as an actual number
function stripUnits(x) {
    return Number(x.replace(/[^0-9.-]+/g, ""));
}

// Convert a "3.0pt" style string or number to a DOM UnitValue
function makeUnitVal(v) {
    if (typeof v == "string")
        return UnitValue(stripUnits(v), v.replace(/[0-9.-]+/g, ""));
    if (typeof v == "number")
        return UnitValue(v, DOMunitToCSS[app.preferences.rulerUnits]);
}

// Convert a pixel measurement into a UnitValue in rulerUnits
function pixelsToAppUnits(v) {
    if (app.preferences.rulerUnits == Units.PIXELS)
        return UnitValue(v, "px");
    else {
        // Divide by doc's DPI, convert to inch, then convert to ruler units.
        var appUnits = DOMunitToCSS[app.preferences.rulerUnits];
        return UnitValue((UnitValue(v / app.activeDocument.resolution, "in")).as(appUnits), appUnits);
    }
}

// Format a DOM UnitValue as a CSS string, using the rulerUnits units.
UnitValue.prototype.asCSS = function () {
    var cssUnits = DOMunitToCSS[app.preferences.rulerUnits];
    return round1k(this.as(cssUnits)) + cssUnits;
}

// Return the absolute value of a UnitValue as a UnitValue
UnitValue.prototype.abs = function () {
    return UnitValue(Math.abs(this.value), this.type);
}

// It turns out no matter what your PS units pref is set to, the DOM/PSEvent
// system happily hands you values in whatever whacky units it feels like.
// This normalizes the unit output to the ruler setting, for consistency in CSS.
// Note: This isn't a method because "desc" can either be an ActionDescriptor
// or an ActionList (in which case the "ID" is the index).
function getPSUnitValue(desc, ID) {
    var srcUnitsID = desc.getUnitDoubleType(ID);

    if (srcUnitsID == unitNone) // Um, unitless unitvalues are just...numbers.
        return round1k(desc.getUnitDoubleValue(ID));

    // Angles and percentages are typically things like gradient parameters,
    // and should be left as-is.
    if ((srcUnitsID == unitAngle) || (srcUnitsID == unitPercent))
        return round1k(desc.getUnitDoubleValue(ID)) + unitIDToCSS[srcUnitsID];

    // Skip conversion if coming and going in pixels
    if (((srcUnitsID == unitPixels) || (srcUnitsID == enumRulerPixels)) &&
        (app.preferences.rulerUnits == Units.PIXELS))
        return round1k(desc.getUnitDoubleValue(ID)) + "px";

    // Other units to pixels must first convert to points, 
    // then expanded by the actual doc resolution (measured in DPI)
    if (app.preferences.rulerUnits == Units.PIXELS)
        return round1k(desc.getUnitDoubleValue(ID) * unitIDToPt[srcUnitsID] *
            app.activeDocument.resolution / 72) + "px";

    var DOMunitStr = DOMunitToCSS[app.preferences.rulerUnits];

    // Pixels must be explictly converted to other units
    if ((srcUnitsID == unitPixels) || (srcUnitsID == enumRulerPixels))
        return pixelsToAppUnits(desc.getUnitDoubleValue(ID)).as(DOMunitStr) + DOMunitStr;

    // Otherwise, let Photoshop do generic conversion.
    return round1k(UnitValue(desc.getUnitDoubleValue(ID),
        unitIDToCSS[srcUnitsID]
    ).as(DOMunitStr)) + DOMunitStr;
}

// Attempt decoding of reference types.  This generates an object with two keys, 
// "refclass" and "value".  So a channel reference looks like:
//    { refclass:'channel', value: 1 }
// Note the dump method compresses this to the text "{ channel: 1 }", but internally
// the form above is used.  This is because ExtendScript doesn't have a good method
// for enumerating keys.
function getReference(ref) {
    var v;
    switch (ref.getForm()) {
        case ReferenceFormType.CLASSTYPE:
            v = typeIDToStringID(ref.getDesiredClass());
            break;
        case ReferenceFormType.ENUMERATED:
            v = ref.getEnumeratedValue();
            break;
        case ReferenceFormType.IDENTIFIER:
            v = ref.getIdentifier();
            break;
        case ReferenceFormType.INDEX:
            v = ref.getIndex();
            break;
        case ReferenceFormType.NAME:
            v = ref.getName();
            break;
        case ReferenceFormType.OFFSET:
            v = ref.getOffset();
            break;
        case ReferenceFormType.PROPERTY:
            v = ref.getProperty();
            break;
        default:
            v = null;
    }

    return {
        refclass: typeIDToStringID(ref.getDesiredClass()),
        value: v
    };
}

// For non-recursive types, return the value.  Note unit types are
// returned as strings with the unit suffix, if you want just the number 
// you'll need to strip off the type and convert it to Number()
// Note: This isn't a method because "desc" can either be an ActionDescriptor
// or an ActionList (in which case the "ID" is the index).
function getFlatType(desc, ID) {
    switch (desc.getType(ID)) {
        case DescValueType.BOOLEANTYPE:
            return desc.getBoolean(ID);
        case DescValueType.STRINGTYPE:
            return desc.getString(ID);
        case DescValueType.INTEGERTYPE:
            return desc.getInteger(ID);
        case DescValueType.DOUBLETYPE:
            return desc.getDouble(ID);
        case DescValueType.UNITDOUBLE:
            return getPSUnitValue(desc, ID);
        case DescValueType.ENUMERATEDTYPE:
            return typeIDToStringID(desc.getEnumerationValue(ID));
        case DescValueType.REFERENCETYPE:
            return getReference(desc.getReference(ID));
        case DescValueType.RAWTYPE:
            return desc.getData(ID);
        case DescValueType.ALIASTYPE:
            return desc.getPath(ID);
        case DescValueType.CLASSTYPE:
            return typeIDToStringID(desc.getClass(ID));
        default:
            return desc.getType(ID).toString();
    }
}

//////////////////////////////////// ActionDescriptor //////////////////////////////////////

ActionDescriptor.prototype.getFlatType = function (ID) {
    return getFlatType(this, ID);
}

ActionList.prototype.getFlatType = function (index) {
    // Share the ActionDesciptor code via duck typing
    return getFlatType(this, index);
}

// Traverse the object described the string in the current layer.
// Objects take the form of the nested descriptor IDs (the code above figures out the types on the fly).
// So 
//     AGMStrokeStyleInfo.strokeStyleContent.'Clr '.'Rd  '
// translates to doing a eventGet of stringIDToTypeID("AGMStrokeStyleInfo") on the current layer,
// then doing:
//   desc.getObject(s2ID("AGMStrokeStyleInfo"))
//		.getObject(s2ID("strokeStyleContent)).getObject(c2ID('Clr ')).getDouble('Rd  ');
// 
ActionDescriptor.prototype.getVal = function (keyList, firstListItemOnly) {
    if (typeof (keyList) == 'string') // Make keyList an array if not already
        keyList = keyList.split('.');

    if (typeof (firstListItemOnly) == "undefined")
        firstListItemOnly = true;

    // If there are no more keys to traverse, just return this object.
    if (keyList.length == 0)
        return this;

    keyStr = keyList.shift();
    keyID = makeID(keyStr);

    if (this.hasKey(keyID))
        switch (this.getType(keyID)) {
            case DescValueType.OBJECTTYPE:
                return this.getObjectValue(keyID).getVal(keyList, firstListItemOnly);
            case DescValueType.LISTTYPE:
                var xx = this.getList(keyID); // THIS IS CREEPY - original code below fails in random places on the same document.
                return /*this.getList( keyID )*/ xx.getVal(keyList, firstListItemOnly);
            default:
                return this.getFlatType(keyID);
        }
    else
        return null;
}

// Traverse the actionList using the keyList (see below)
ActionList.prototype.getVal = function (keyList, firstListItemOnly) {
    if (typeof (keyList) == 'string') // Make keyList an array if not already
        keyList = keyList.split('.');

    if (typeof (firstListItemOnly) == "undefined")
        firstListItemOnly = true;

    // Instead of ID, pass list item #.  Duck typing.
    if (firstListItemOnly)
        switch (this.getType(0)) {
            case DescValueType.OBJECTTYPE:
                return this.getObjectValue(0).getVal(keyList, firstListItemOnly);
            case DescValueType.LISTTYPE:
                return this.getList(0).getVal(keyList, firstListItemOnly);
            default:
                return this.getFlatType(0);
        }
    else {
        var i, result = [];
        for (i = 0; i < this.count; ++i)
            switch (this.getType(i)) {
                case DescValueType.OBJECTTYPE:
                    result.push(this.getObjectValue(i).getVal(keyList, firstListItemOnly));
                    break;
                case DescValueType.LISTTYPE:
                    result.push(this.getList(i).getVal(keyList, firstListItemOnly));
                    break;
                default:
                    result.push(this.getFlatType(i));
            }
        return result;
    }
}

ActionDescriptor.prototype.extractBounds = function () {
    function getbnd(desc, key) {
        return makeUnitVal(desc.getVal(key));
    }
    return [getbnd(this, "left"), getbnd(this, "top"), getbnd(this, "right"), getbnd(this, "bottom")];
}

ActionDescriptor.dumpValue = function (flatValue) {
    if ((typeof flatValue == "object") && (typeof flatValue.refclass == "string"))
        return "{ " + flatValue.refclass + ": " + flatValue.value + " }";
    else
        return flatValue;
}

// Debugging - recursively walk a descriptor and dump out all of the keys
// Note we only dump stringIDs.  If you look in UActions.cpp:CInitialStringToIDEntry,
// there is a table converting most (all?) charIDs into stringIDs.
ActionDescriptor.prototype.dumpDesc = function (keyName) {
    var i;
    if (typeof (keyName) == "undefined")
        keyName = "";

    for (i = 0; i < this.count; ++i) {
        try {
            var key = this.getKey(i);
            var ref;
            var thisKey = keyName + "." + app.typeIDToStringID(key);
            switch (this.getType(key)) {
                case DescValueType.OBJECTTYPE:
                    this.getObjectValue(key).dumpDesc(thisKey);
                    break;

                case DescValueType.LISTTYPE:
                    this.getList(key).dumpDesc(thisKey);
                    break;

                case DescValueType.REFERENCETYPE:
                    ref = this.getFlatType(key);
                    $.writeln(thisKey + ":ref:" + ref.refclass + ":" + ref.value);
                    COPYCSS.textProperties[thisKey] = ref.value;
                    break;

                default:
                    $.writeln(thisKey +
                        ": " + ActionDescriptor.dumpValue(this.getFlatType(key)));
                    COPYCSS.textProperties[thisKey] = ActionDescriptor.dumpValue(this.getFlatType(key));
            }
        } catch (err) {
            $.writeln("Error " + keyName + "[" + i + "]: " + err.message);
        }
    }
}

ActionList.prototype.dumpDesc = function (keyName) {
    var i;
    if (typeof (keyName) == "undefined")
        keyName = "";

    if (this.count == 0)
        $.writeln(keyName + " <empty list>");
    else
        for (i = 0; i < this.count; ++i) {
            try {
                if (this.getType(i) == DescValueType.OBJECTTYPE)
                    this.getObjectValue(i).dumpDesc(keyName + "[" + i + "]");
                else
                    if (this.getType(i) == DescValueType.LISTTYPE)
                        this.getList(i).dumpDesc(keyName + "[" + i + "]");
                    else
                        $.writeln(keyName + "[" + i + "]:" +
                            ActionDescriptor.dumpValue(this.getFlatType(i)));
            } catch (err) {
                $.writeln("Error " + keyName + "[" + i + "]: " + err.message);
            }
        }
}

//////////////////////////////////// ProgressBar //////////////////////////////////////

// "ProgressBar" provides an abstracted interface to the progress bar DOM. It keeps
// track of the total steps and number of steps completed so task steps can simply call
// nextProgress().

function ProgressBar() {
    this.totalProgressSteps = 0;
    this.currentProgress = 0;
}

// You must set COPYCSS.totalProgressSteps to the total number of
// steps to complete before calling this or nextProgress().
// Returns true if aborted.
ProgressBar.prototype.updateProgress = function (done) {
    if (this.totalProgressSteps == 0)
        return false;

    return !app.updateProgress(done, this.totalProgressSteps);
}

// Returns true if aborted.
ProgressBar.prototype.nextProgress = function () {
    this.currentProgress++;
    return this.updateProgress(this.currentProgress);
}

//////////////////////////////////// PSLayer //////////////////////////////////////

// The overhead for using Photoshop DOM layers is high, and can be
// really high if you need to switch the active layer.  This class provides
// a cache and accessor functions for layers bypassing the DOM.

function PSLayerInfo(layerIndex, isBG) {
    this.index = layerIndex;
    this.boundsCache = null;
    this.descCache = {};

    if (isBG) {
        this.layerID = "BG";
        this.layerKind = kBackgroundSheet;
    } else {
        // See TLayerElement::Make() to learn how layers are located by PS events.
        var ref = new ActionReference();
        ref.putProperty(classProperty, keyLayerID);
        ref.putIndex(classLayer, layerIndex);
        this.layerID = executeActionGet(ref).getVal("layerID");
        this.layerKind = this.getLayerAttr("layerKind");
        this.visible = this.getLayerAttr("visible");
    }
}

PSLayerInfo.layerIDToIndex = function (layerID) {
    var ref = new ActionReference();
    ref.putProperty(classProperty, keyItemIndex);
    ref.putIdentifier(classLayer, layerID);
    return executeActionGet(ref).getVal("itemIndex");
}

PSLayerInfo.prototype.makeLayerActive = function () {
    var desc = new ActionDescriptor();
    var ref = new ActionReference();
    ref.putIdentifier(classLayer, this.layerID);
    desc.putReference(typeNULL, ref);
    executeAction(eventSelect, desc, DialogModes.NO);
}

PSLayerInfo.prototype.getLayerAttr = function (keyString, layerDesc) {
    var layerDesc;
    var keyList = keyString.split('.');

    if ((typeof (layerDesc) == "undefined") || (layerDesc == null)) {
        // Cache the IDs, because some (e.g., Text) take a while to get.
        if (typeof this.descCache[keyList[0]] == "undefined") {
            var ref = new ActionReference();
            ref.putProperty(classProperty, makeID(keyList[0]));
            ref.putIndex(classLayer, this.index);
            layerDesc = executeActionGet(ref);
            this.descCache[keyList[0]] = layerDesc;
        } else
            layerDesc = this.descCache[keyList[0]];
    }

    return layerDesc.getVal(keyList);
}

PSLayerInfo.prototype.getBounds = function (ignoreEffects) {
    var boundsDesc;
    if (typeof ignoreEffects == "undefined")
        ignoreEffects = false;
    if (ignoreEffects)
        boundsDesc = this.getLayerAttr("boundsNoEffects");
    else {
        if (this.boundsCache)
            return this.boundsCache;
        boundsDesc = this.getLayerAttr("bounds");
    }

    if (this.getLayerAttr("artboardEnabled"))
        boundsDesc = this.getLayerAttr("artboard.artboardRect");

    var bounds = boundsDesc.extractBounds();

    if (!ignoreEffects)
        this.boundsCache = bounds;

    return bounds;
}

// Get a list of descriptors.  Returns NULL if one of them is unavailable.
PSLayerInfo.prototype.getLayerAttrList = function (keyString) {
    var i, keyList = keyString.split('.');
    var descList = [];
    // First item from the layer
    var desc = this.getLayerAttr(keyList[0]);
    if (!desc)
        return null;
    descList.push(desc);
    if (keyList.length == 1)
        return descList;

    for (i = 1; i < keyList.length; ++i) {
        desc = descList[i - 1].getVal(keyList[i]);
        if (desc == null) return null;
        descList.push(desc);
    }
    return descList;
}

PSLayerInfo.prototype.descToColorList = function (colorDesc, colorPath) {
    function roundColor(x) {
        x = Math.round(x);
        return (x > 255) ? 255 : x;
    }

    var i, rgb = ["'Rd  '", "'Grn '", "'Bl  '"]; // Note double quotes around single quotes
    var rgbTxt = [];
    // See if the color is really there
    colorDesc = this.getLayerAttr(colorPath, colorDesc);
    if (!colorDesc)
        return null;

    for (i in rgb)
        rgbTxt.push(roundColor(colorDesc.getVal(rgb[i])));
    return rgbTxt;
}

// If the desc has a 'Clr ' object, create CSS "rgb( rrr, ggg, bbb )" output from it.
PSLayerInfo.prototype.descToCSSColor = function (colorDesc, colorPath) {
    var rgbTxt = this.descToColorList(colorDesc, colorPath);
    if (!rgbTxt)
        return null;
    return "rgb(" + rgbTxt.join(", ") + ")";
}

PSLayerInfo.prototype.descToRGBAColor = function (colorPath, opacity, colorDesc) {
    var rgbTxt = this.descToColorList(colorDesc, colorPath);
    rgbTxt = rgbTxt ? rgbTxt : ["0", "0", "0"];

    if (!((opacity > 0.0) && (opacity < 1.0)))
        opacity = opacity / 255.0;

    if (opacity == 1.0)
        return "rgb(" + rgbTxt.join(", ") + ")";
    else
        return "rgba(" + rgbTxt.join(", ") + ", " + round1k(opacity) + ")";
}

function DropShadowInfo(xoff, yoff, dsDesc) {
    this.xoff = xoff;
    this.yoff = yoff;
    this.dsDesc = dsDesc;
}

PSLayerInfo.getEffectOffset = function (fxDesc) {
    var xoff, yoff, angle;

    // Assumes degrees, PS users aren't into radians.
    if (fxDesc.getVal("useGlobalAngle"))
        angle = stripUnits(COPYCSS.getAppAttr("globalAngle.globalLightingAngle")) * (Math.PI / 180.0);
    else
        angle = stripUnits(fxDesc.getVal("localLightingAngle")) * (Math.PI / 180.0);
    // Photoshop describes the drop shadow in polar coordinates, while CSS uses cartesian coords.
    var distance = fxDesc.getVal("distance");
    var distUnits = distance.replace(/[\d.]+/g, "");
    distance = stripUnits(distance);
    return [round1k(-Math.cos(angle) * distance) + distUnits,
    round1k(Math.sin(angle) * distance) + distUnits
    ];
}

// New lfx: dropShadowMulti, frameFXMulti, gradientFillMulti, innerShadowMulti, solidFillMulti, 
PSLayerInfo.prototype.getDropShadowInfo = function (shadowType, boundsInfo, psEffect) {
    psEffect = (typeof psEffect == "undefined") ? "dropShadow" : psEffect;
    var lfxDesc = this.getLayerAttr("layerEffects");
    var dsDesc = lfxDesc ? lfxDesc.getVal(psEffect) : null;
    var lfxOn = this.getLayerAttr("layerFXVisible");

    // Gather the effect and effectMulti descriptors into a single list. 
    // It will be one or the other
    var dsDescList = null;
    if (lfxDesc)
        dsDescList = dsDesc ? [dsDesc] : lfxDesc.getVal(psEffect + "Multi", false);

    // If any of the other (non-drop-shadow) layer effects are on, then
    // flag this so we use the proper bounds calculation.
    if ((typeof shadowType != "undefined") && (typeof boundsInfo != "undefined") &&
        (shadowType == "box-shadow") && lfxDesc && lfxOn && !dsDescList) {
        var i, fxList = ["dropShadow", "innerShadow", "outerGlow", "innerGlow",
            "bevelEmboss", "chromeFX", "solidFill", "gradientFill"
        ];
        for (i in fxList)
            if (lfxDesc.getVal(fxList[i] + ".enabled")) {
                boundsInfo.hasLayerEffect = true;
                break;
            }
        // Search multis as well
        if (!boundsInfo.hasLayerEffect) {
            var fxMultiList = ["dropShadowMulti", "frameFXMulti", "gradientFillMulti",
                "innerShadowMulti", "solidFillMulti"
            ];
            for (i in fxMultiList) {
                var j, fxs = lfxDesc.getVal(fxMultiList[i]);
                for (j = 0; j < fxs.length; ++j)
                    if (fxs[j].getVal("enabled")) {
                        boundsInfo.hasLayerEffect = true;
                        break;
                    }
                if (boundsInfo.hasLayerEffect) break;
            }
        }
    }

    // Bail out if effect turned off (no eyeball)
    if (!dsDescList || !lfxOn)
        return null;

    var i, dropShadows = [];
    for (i = 0; i < dsDescList.length; ++i)
        if (dsDescList[i].getVal("enabled")) {
            var offset = PSLayerInfo.getEffectOffset(dsDescList[i]);
            dropShadows.push(new DropShadowInfo(offset[0], offset[1], dsDescList[i]));
        }
    return (dropShadows.length > 0) ? dropShadows : null;
}

//
// Return text with substituted descriptors.  Note items delimited
// in $'s are substituted with values looked up from the layer data
// e.g.: 
//     border-width: $AGMStrokeStyleInfo.strokeStyleLineWidth$;"
// puts the stroke width into the output.  If the descriptor isn't
// found, no output is generated.
//
PSLayerInfo.prototype.replaceDescKey = function (cssText, baseDesc) {
    // Locate any $parameters$ to be substituted.
    var i, subs = cssText.match(/[$]([^$]+)[$]/g);
    var replacementFailed = false;

    function testAndReplace(item) {
        if (item != null)
            cssText = cssText.replace(/[$]([^$]+)[$]/, item);
        else
            replacementFailed = true;
    }

    if (subs) {
        // Stupid JS regex leaves whole match in capture group!
        for (i = 0; i < subs.length; ++i)
            subs[i] = subs[i].split("$")[1];

        if (typeof (baseDesc) == "undefined")
            baseDesc = null;
        if (!subs)
            alert('Missing substitution text in CSS/SVG spec');

        for (i = 0; i < subs.length; ++i) {
            // Handle color as a special case
            if (subs[i].match(/'Clr '/))
                testAndReplace(this.descToCSSColor(baseDesc, subs[i]));
            else if (subs[i].match(/(^|[.])color$/))
                testAndReplace(this.descToCSSColor(baseDesc, subs[i]));
            else
                testAndReplace(this.getLayerAttr(subs[i], baseDesc));
        }
    }
    return [replacementFailed, cssText];
}

// If useLayerFX is false, then don't check it.  By default it's checked.
PSLayerInfo.prototype.gradientDesc = function (useLayerFX) {
    if (typeof useLayerFX == "undefined")
        useLayerFX = true;
    var descList = this.getLayerAttr("adjustment");
    if (descList && descList.getVal("gradient")) {
        return descList;
    } else // If there's no adjustment layer, see if we have one from layerFX...
    {
        if (useLayerFX)
            descList = this.getLayerAttr("layerEffects.gradientFill");
    }
    return descList;
}

function GradientInfo(gradDesc) {
    this.angle = gradDesc.getVal("angle");
    this.opacity = gradDesc.getVal("opacity");
    this.opacity = this.opacity ? stripUnits(this.opacity) / 100.0 : 1;
    if (this.angle == null)
        this.angle = "0deg";
    this.type = gradDesc.getVal("type");
    // Get rid of the new "gradientType:" prefix
    this.type = this.type.replace(/^gradientType:/, "");
    if ((this.type != "linear") && (this.type != "radial"))
        this.type = "linear"; // punt
    this.reverse = gradDesc.getVal("reverse") ? true : false;
}

// Extendscript operator overloading
GradientInfo.prototype["=="] = function (src) {
    return (this.angle === src.angle) &&
        (this.type === src.type) &&
        (this.reverse === src.reverse);
}

PSLayerInfo.prototype.gradientInfo = function (useLayerFX) {
    var gradDesc = this.gradientDesc(useLayerFX);
    // Make sure null is returned if we aren't using layerFX and there's no adj layer
    if (!useLayerFX && gradDesc && !gradDesc.getVal("gradient"))
        return null;
    return (gradDesc && (!useLayerFX || gradDesc.getVal("enabled"))) ? new GradientInfo(gradDesc) : null;
}

// Gradient stop object, made from PS gradient.colors/gradient.transparency descriptor
function GradientStop(desc, maxVal) {
    this.r = 0;
    this.g = 0;
    this.b = 0;
    this.m = 100;
    this.location = 0;
    this.midPoint = 50;
    if (typeof desc != "undefined") {
        var colorDesc = desc.getVal("color");
        if (colorDesc) {
            this.r = Math.round(colorDesc.getVal("red"));
            this.g = Math.round(colorDesc.getVal("green"));
            this.b = Math.round(colorDesc.getVal("blue"));
        }
        var opacity = desc.getVal("opacity");
        this.m = opacity ? stripUnits(opacity) : 100;
        this.location = (desc.getVal("location") / maxVal) * 100;
        this.midPoint = desc.getVal("midpoint");
    }
}

GradientStop.prototype.copy = function (matte, location) {
    var result = new GradientStop();
    result.r = this.r;
    result.g = this.g;
    result.b = this.b;
    result.m = (typeof matte == "undefined") ? this.m : matte;
    result.location = (typeof location == "undefined") ? this.location : location;
    result.midPoint = this.midPoint;
    return result;
}

GradientStop.prototype["=="] = function (src) {
    return (this.r === src.r) && (this.g === src.g) &&
        (this.b === src.b) && (this.m === src.m) &&
        (this.location === src.location) &&
        (this.midPoint === src.midPoint);
}

// Lerp ("linear interpolate")
GradientStop.lerp = function (t, a, b) {
    return Math.round(t * (b - a) + a);
} // Same as (1-t)*a + t*b

GradientStop.prototype.interpolate = function (dest, t1) {
    var result = new GradientStop();
    result.r = GradientStop.lerp(t1, this.r, dest.r);
    result.g = GradientStop.lerp(t1, this.g, dest.g);
    result.b = GradientStop.lerp(t1, this.b, dest.b);
    result.m = GradientStop.lerp(t1, this.m, dest.m);
    return result;
}

GradientStop.prototype.colorString = function (noTransparency) {
    if (typeof noTransparency == "undefined")
        noTransparency = false;
    var compList = (noTransparency || (this.m == 100)) ?
        [this.r, this.g, this.b] :
        [this.r, this.g, this.b, this.m / 100];
    var tag = (compList.length == 3) ? "rgb(" : "rgba(";
    return tag + compList.join(",") + ")";
}

GradientStop.prototype.toString = function () {
    return this.colorString() + " " + Math.round(this.location) + "%";
}

GradientStop.reverseStoplist = function (stopList) {
    stopList.reverse();
    // Fix locations to ascending order
    for (var s in stopList)
        stopList[s].location = 100 - stopList[s].location;
    return stopList;
}

GradientStop.dumpStops = function (stopList) {
    for (var i in stopList)
        $.writeln(stopList[i]);
}

// Gradient format: linear-gradient( <angle>, rgb( rr, gg, bb ) xx%, rgb( rr, gg, bb ), yy%, ... );
PSLayerInfo.prototype.gradientColorStops = function () {
    // Create local representation of PS stops
    function makeStopList(descList, maxVal) {
        var s, stopList = [];
        for (s in descList)
            stopList.push(new GradientStop(descList[s], maxVal));

        // Replace Photoshop "midpoints" with complete new stops
        for (s = 1; s < stopList.length; ++s) {
            if (stopList[s].midPoint != 50) {
                var newStop = stopList[s - 1].interpolate(stopList[s], 0.5);
                newStop.location = GradientStop.lerp(stopList[s].midPoint / 100.0,
                    stopList[s - 1].location,
                    stopList[s].location);
                stopList.splice(s, 0, newStop);
                s += 1; // Skip new stop
            }
        }
        return stopList;
    }

    var gdesc = this.gradientDesc();
    var psGrad = gdesc ? gdesc.getVal("gradient") : null;
    if (psGrad) {
        //		var maxVal = psGrad.getVal( "interpolation" );	// I swear it used to find this.
        var maxVal = 4096;

        var c, colorStops = makeStopList(psGrad.getVal("colors", false), maxVal);
        var m, matteStops = makeStopList(psGrad.getVal("transparency", false), maxVal);

        // Check to see if any matte stops are active
        var matteActive = false;
        for (m in matteStops)
            if (!matteActive)
                matteActive = (matteStops[m].m != 100);

        if (matteActive) {
            // First, copy matte values from matching matte stops to the color stops
            c = 0;
            for (m in matteStops) {
                while ((c < colorStops.length) && (colorStops[c].location < matteStops[m].location))
                    c++;
                if ((c < colorStops.length) && (colorStops[c].location == matteStops[m].location))
                    colorStops[c].m = matteStops[m].m;
            }

            // Make sure the end locations match up
            if (colorStops[colorStops.length - 1].location < matteStops[matteStops.length - 1].location)
                colorStops.push(colorStops[colorStops.length - 1].copy(colorStops[colorStops.length - 1].m, matteStops[matteStops.length - 1].location));

            // Now weave the lists together
            m = 0;
            c = 0;
            while (c < colorStops.length) {
                // Must adjust color stop's matte to interpolate matteStops
                if (colorStops[c].location < matteStops[m].location) {
                    var t = (colorStops[c].location - matteStops[m - 1].location) /
                        (matteStops[m].location - matteStops[m - 1].location);
                    colorStops[c].m = GradientStop.lerp(t, matteStops[m - 1].m, matteStops[m].m);
                    c++;
                }
                // Must add matte stop to color stop list
                if (matteStops[m].location < colorStops[c].location) {
                    var t, newStop;
                    // If matte stops exist in front of the 1st color stop
                    if (c < 1) {
                        newStop = colorStops[0].copy(matteStops[m].m, matteStops[m].location);
                    } else {
                        t = (matteStops[m].location - colorStops[c - 1].location) /
                            (colorStops[c].location - colorStops[c - 1].location);
                        newStop = colorStops[c - 1].interpolate(colorStops[c], t);
                        newStop.m = matteStops[m].m;
                        newStop.location = matteStops[m].location;
                    }
                    colorStops.splice(c, 0, newStop);
                    m++;
                    c++; // Step past newly added color stop
                }
                // Same, was fixed above
                if (matteStops[m].location == colorStops[c].location) {
                    m++;
                    c++;
                }
            }
            // If any matte stops remain, add those too.
            while (m < matteStops.length) {
                var newStop = colorStops[c - 1].copy(matteStops[m].m, matteStops[m].location);
                colorStops.push(newStop);
                m++;
            }
        }

        return colorStops;
    } else
        return null;
}

//////////////////////////////////// CSSToClipboard //////////////////////////////////////

// Base object to scope the rest of the functions in.
function CSSToClipboard() {
    // Constructor moved to reset(), so it can be called via a script.
}

cssToClip = new CSSToClipboard();
COPYCSS.textProperties = {};
//new Array();

COPYCSS.reset = function () {
    this.pluginName = "CSSToClipboard";
    this.cssText = "";
    this.indentSpaces = "";
    this.browserTags = ["-moz-", "-webkit-", "-ms-"];
    this.currentLayer = null;
    this.currentPSLayerInfo = null;

    this.groupLevel = 0;
    this.currentLeft = 0;
    this.currentTop = 0;

    this.groupProgress = new ProgressBar();

    this.aborted = false;

    // Work-around for screwy layer indexing.
    this.documentIndexOffset = 0;
    try {
        // This throws an error if there's no background
        if (app.activeDocument.backgroundLayer)
            this.documentIndexOffset = 1;
    } catch (err) { }
}

COPYCSS.reset();

// Call Photoshop to copy text to the system clipboard
COPYCSS.copyTextToClipboard = function (txt) {
    var testStrDesc = new ActionDescriptor();

    testStrDesc.putString(keyTextData, txt);
    executeAction(ktextToClipboardStr, testStrDesc, DialogModes.NO);
}

COPYCSS.copyCSSToClipboard = function () {
    this.logToHeadlights("Copy to CSS invoked");
    this.copyTextToClipboard(this.cssText);
}

COPYCSS.isCSSLayerKind = function (layerKind) {
    if (typeof layerKind == "undefined")
        layerKind = this.currentPSLayerInfo.layerKind;

    switch (layerKind) {
        case kVectorSheet:
            return true;
        case kTextSheet:
            return true;
        case kPixelSheet:
            return true;
        case kLayerGroupSheet:
            return true;
    }
    return false
}

// Listen carefully:  When the Photoshop DOM *reports an index to you*, it uses one based
// indexing.  When *you request* layer info with ref.putIndex( classLayer, index ),
// it uses *zero* based indexing.  The DOM should probably stick to the zero-based
// index, so the adjustment is made here.
// Oh god, it gets worse...the indexing is zero based if there's no background layer.
COPYCSS.setCurrentLayer = function (layer) {
    this.currentLayer = layer;
    this.currentPSLayerInfo = new PSLayerInfo(layer.itemIndex - this.documentIndexOffset, layer.isBackgroundLayer);
}

COPYCSS.getCurrentLayer = function () {
    if (!this.currentLayer)
        this.setCurrentLayer(app.activeDocument.activeLayer);
    return this.currentLayer;
}

// These shims connect the original cssToClip with the new PSLayerInfo object.
COPYCSS.getLayerAttr = function (keyString, layerDesc) {
    return this.currentPSLayerInfo.getLayerAttr(keyString, layerDesc);
}

COPYCSS.getLayerBounds = function (ignoreEffects) {
    return this.currentPSLayerInfo.getBounds(ignoreEffects);
}

COPYCSS.descToCSSColor = function (colorDesc, colorPath) {
    return this.currentPSLayerInfo.descToCSSColor(colorDesc, colorPath);
}

// Like getLayerAttr, but returns an app attribute.  No caching.
COPYCSS.getPSAttr = function (keyStr, objectClass) {
    var keyList = keyStr.split('.');
    var ref = new ActionReference();
    ref.putProperty(classProperty, makeID(keyList[0]));
    ref.putEnumerated(objectClass, typeOrdinal, enumTarget);

    var resultDesc = executeActionGet(ref);

    return resultDesc.getVal(keyList);
}

COPYCSS.getAppAttr = function (keyStr) {
    return this.getPSAttr(keyStr, classApplication);
}

COPYCSS.getDocAttr = function (keyStr) {
    return this.getPSAttr(keyStr, classDocument);
}

COPYCSS.pushIndent = function () {
    this.indentSpaces += "  ";
}

COPYCSS.popIndent = function () {
    if (this.indentSpaces.length < 2)
        alert("Error - indent underflow");
    this.indentSpaces = this.indentSpaces.slice(0, -2);
}

COPYCSS.addText = function (text, browserTagList) {
    var i;
    if (typeof browserTagList == "undefined")
        browserTagList = null;

    if (browserTagList)
        for (i in browserTagList)
            this.cssText += (this.indentSpaces + browserTagList[i] + text + "\n");
    else
        this.cssText += (this.indentSpaces + text + "\n");
    //	$.writeln(text);	// debug
}

COPYCSS.addStyleLine = function (cssText, baseDesc, browserTagList) {
    var result = this.currentPSLayerInfo.replaceDescKey(cssText, baseDesc);
    var replacementFailed = result[0];
    cssText = result[1];

    if (!replacementFailed)
        this.addText(cssText, browserTagList);

    return !replacementFailed;
}

// Text items need to try both the base and the default descriptors
COPYCSS.addStyleLine2 = function (cssText, baseDesc, backupDesc) {
    if (!this.addStyleLine(cssText, baseDesc) && backupDesc)
        this.addStyleLine(cssText, backupDesc);
}

// Text is handled as a special case, to take care of rounding issues.
// In particular, we're avoiding 30.011 and 29.942, which round1k would miss
// Seriously fractional text sizes (as specified by "roundMargin") are left as-is
COPYCSS.addTextSize = function (baseDesc, backupDesc) {
    var roundMargin = 0.2; // Values outside of this are left un-rounded
    var sizeText = this.getLayerAttr("size", baseDesc);
    if (!sizeText)
        sizeText = this.getLayerAttr("size", backupDesc);
    if (!sizeText)
        return;
    var unitRxp = /[\d.-]+\s*(\w+)/g;
    var units = unitRxp.exec(sizeText);
    if (!units) return;
    units = units[1];
    var textNum = stripUnits(sizeText);
    var roundOff = textNum - (textNum | 0);
    if ((roundOff < roundMargin) || (roundOff > (1.0 - roundMargin)))
        this.addText("font-size: " + Math.round(textNum) + units + ";");
    else
        this.addStyleLine2("font-size: $size$;", baseDesc, backupDesc);
}

// Checks the geometry, and returns "ellipse", "roundrect" 
// or "null" (if the points don't match round rect/ellipse pattern).
// NOTE: All of this should go away when the DAG metadata is available
// to just tell you what the radius is.
// NOTE2: The path for a shape is ONLY visible when that shape is the active
// layer.  So you must set the shape in question to be the active layer before
// calling this function.  This really slows down the script, unfortunately.
COPYCSS.extractShapeGeometry = function () {
    // We accept a shape as conforming if the coords are within "magnitude"
    // of the overall size.
    function near(a, b, magnitude) {
        a = Math.abs(a);
        b = Math.abs(b);
        return Math.abs(a - b) < (Math.max(a, b) / magnitude);
    }

    function sameCoord(pathPt, xy) {
        return (pathPt.rightDirection[xy] == pathPt.anchor[xy]) &&
            (pathPt.leftDirection[xy] == pathPt.anchor[xy]);
    }

    function dumpPts(pts) // For debug viewing in Matlab
    {
        function pt2str(pt) {
            return "[" + Math.floor(pt[0]) + ", " + Math.floor(pt[1]) + "]";
        }
        var i;
        for (i = 0; i < pts.length; ++i)
            $.writeln("[" + [pt2str(pts[i].rightDirection), pt2str(pts[i].anchor), pt2str(pts[i].leftDirection)].join("; ") + "];");
    }

    // Control point location for Bezier arcs.
    // See problem 1, http://www.graphics.stanford.edu/courses/cs248-98-fall/Final/q1.html
    const kEllipseDist = 4 * (Math.sqrt(2) - 1) / 3;

    if (app.activeDocument.pathItems.length == 0)
        return null; // No path

    // Grab the path name from the layer name (it's auto-generated)
    var i, pathName = localize("$$$/ShapeLayerPathName=^0 Shape Path");
    var path = app.activeDocument.pathItems[pathName.replace(/[^]0/, app.activeDocument.activeLayer.name)];

    // If we have a plausible path, walk the geometry and see if it matches a shape we know about.
    if ((path.kind == PathKind.VECTORMASK) && (path.subPathItems.length == 1)) {
        var subPath = path.subPathItems[0];
        if (subPath.closed && (subPath.pathPoints.length == 4)) // Ellipse?
        {
            function next(index) {
                return (index + 1) % 4;
            }

            function prev(index) {
                return (index > 0) ? (index - 1) : 3;
            }
            var pts = subPath.pathPoints;

            // dumpPts( pts );
            for (i = 0; i < 4; ++i) {
                var xy = i % 2; // 0 = x, 1 = y, alternates as we traverse the oval sides
                if (!sameCoord(pts[i], 1 - xy)) return null;
                if (!near(pts[i].leftDirection[xy] - pts[i].anchor[xy],
                    (pts[next(i)].anchor[xy] - pts[i].anchor[xy]) * kEllipseDist, 100)) return null;
                if (!near(pts[i].anchor[xy] - pts[i].rightDirection[xy],
                    (pts[prev(i)].anchor[xy] - pts[i].anchor[xy]) * kEllipseDist, 100)) return null;
            }
            // Return the X,Y radius
            return [pts[1].anchor[0] - pts[0].anchor[0], pts[1].anchor[1] - pts[0].anchor[1], "ellipse"];
        } else if (subPath.closed && (subPath.pathPoints.length == 8)) // RoundRect?
        {
            var pts = subPath.pathPoints;
            //dumpPts( pts );
            function sameCoord2(pt, xy, io) {
                return (sameCoord(pt, xy) &&
                    (((io == 0) && (pt.rightDirection[1 - xy] == pt.anchor[1 - xy])) ||
                        ((io == 1) && (pt.leftDirection[1 - xy] == pt.anchor[1 - xy]))));
            }

            function next(index) {
                return (index + 1) % 8;
            }

            function prev(index) {
                return (index > 0) ? (index - 1) : 7;
            }

            function arm(pt, xy, io) {
                return (io == 0) ? pt.rightDirection[xy] : pt.leftDirection[xy];
            }

            for (i = 0; i < 8; ++i) {
                var io = i % 2; // Incoming / Outgoing vector on the anchor point
                var hv = (i >> 1) % 2; // Horizontal / Vertical side of the round rect
                if (!sameCoord2(pts[i], 1 - hv, 1 - io)) return null;
                if (io == 0) {
                    if (!near(arm(pts[i], hv, io) - pts[i].anchor[hv],
                        (pts[prev(i)].anchor[hv] - pts[i].anchor[hv]) * kEllipseDist, 10))
                        return null;
                } else {
                    if (!near(arm(pts[i], hv, io) - pts[i].anchor[hv],
                        (pts[next(i)].anchor[hv] - pts[i].anchor[hv]) * kEllipseDist, 10))
                        return null;
                }
            }
            return [pts[2].anchor[0] - pts[1].anchor[0], pts[2].anchor[1] - pts[1].anchor[1], "round rect"];
        }
    }
}

// Gradient format: linear-gradient( <angle>, rgb( rr, gg, bb ) xx%, rgb( rr, gg, bb ), yy%, ... );
COPYCSS.gradientToCSS = function () {
    var colorStops = this.currentPSLayerInfo.gradientColorStops();
    var gradInfo = this.currentPSLayerInfo.gradientInfo();

    if (colorStops && gradInfo) {
        if (gradInfo.reverse)
            colorStops = GradientStop.reverseStoplist(colorStops);

        if (gradInfo.type == "linear")
            return gradInfo.type + "-gradient( " + gradInfo.angle + ", " + colorStops.join(", ") + ");";
        // Radial - right now gradient is always centered (50% 50%)
        if (gradInfo.type == "radial")
            return gradInfo.type + "-gradient( 50% 50%, circle closest-side, " + colorStops.join(", ") + ");";
    } else
        return null;
}

// Translate Photoshop drop shadow.  May need work with layerEffects.scale,
// and need to figure out what's up with the global angle.
COPYCSS.addDropShadow = function (shadowType, boundsInfo) {
    var dsInfo = this.currentPSLayerInfo.getDropShadowInfo(shadowType, boundsInfo, "dropShadow");
    var isInfo = this.currentPSLayerInfo.getDropShadowInfo(shadowType, boundsInfo, "innerShadow");
    if (!(dsInfo || isInfo))
        return;

    function map(lst, fn) {
        var i, result = [];
        for (i = 0; i < lst.length; ++i)
            result.push(fn(lst[i]));
        return result;
    }

    function getShadowCSS(info, skipSpread) {
        // Translate PS parameters to CSS style
        var opacity = info.dsDesc.getVal("opacity");
        // LFX reports "opacity" as a percentage, so convert it to decimal
        opacity = opacity ? stripUnits(opacity) / 100.0 : 1;
        var colorSpec = COPYCSS.currentPSLayerInfo.descToRGBAColor("color", opacity, info.dsDesc);
        var size = stripUnits(info.dsDesc.getVal("blur"));
        var chokeMatte = stripUnits(info.dsDesc.getVal("chokeMatte"));
        var spread = size * chokeMatte / 100;
        var blurRad = size - spread;
        // Hack - spread is not used for text shadows.
        var spreadStr = skipSpread ? "" : spread + "px "

        return info.xoff + " " + info.yoff + " " +
            blurRad + "px " + spreadStr + colorSpec;
    }

    function insetShadowCSS(info) {
        return "inset " + getShadowCSS(info);
    }

    function textShadowCSS(info) {
        return getShadowCSS(info, true);
    }

    // You say CSS was designed by committee?  Really?
    if (shadowType == "box-shadow") {
        var i, shadows = [];
        if (dsInfo)
            shadows = map(dsInfo, getShadowCSS);
        if (isInfo) // push.apply == extend
            shadows.push.apply(shadows, map(isInfo, insetShadowCSS));

        this.addText(shadowType + ": " + shadows.join(",") + ";");

        boundsInfo.hasLayerEffect = true;
    }

    // CSS doesn't support inner shadow, just drop shadow
    if (dsInfo && (shadowType == "text-shadow")) {
        var shadows = map(dsInfo, textShadowCSS);
        this.addText(shadowType + ": " + shadows.join(",") + ";");
    }
}

COPYCSS.addOpacity = function (opacity) {
    opacity = (typeof opacity == "number") ? opacity : this.getLayerAttr("opacity");
    if ((typeof opacity == "number") && (opacity < 255))
        this.addText("opacity: " + round1k(opacity / 255) + ";");
}

COPYCSS.addRGBAColor = function (param, opacity, colorDesc) {
    this.addText(param + ': ' + this.currentPSLayerInfo.descToRGBAColor("color", opacity, colorDesc) + ';');
}

function BoundsParameters() {
    this.borderWidth = 0;
    this.textOffset = null;
    this.hasLayerEffect = false;
    this.textLine = false;
    this.rawTextBounds = null;
    this.textHasDecenders = false;
    this.textFontSize = 0;
    this.textLineHeight = 1.2;
}

COPYCSS.addObjectBounds = function (boundsInfo) {
    var curLayer = this.getCurrentLayer();

    var bounds = this.getLayerBounds(boundsInfo.hasLayerEffect);

    if (boundsInfo.rawTextBounds) {
        // If the text has been transformed, rawTextBounds is set.  We need
        // to set the CSS bounds to reflect the *un*transformed text, placed about
        // the center of the transformed text's bounding box.
        var cenx = bounds[0] + (bounds[2] - bounds[0]) / 2;
        var ceny = bounds[1] + (bounds[3] - bounds[1]) / 2;
        var txtWidth = boundsInfo.rawTextBounds[2] - boundsInfo.rawTextBounds[0];
        var txtHeight = boundsInfo.rawTextBounds[3] - boundsInfo.rawTextBounds[1];
        bounds[0] = cenx - (txtWidth / 2);
        bounds[1] = ceny - (txtHeight / 2);
        bounds[2] = bounds[0] + txtWidth;
        bounds[3] = bounds[1] + txtHeight;
    }

    if (boundsInfo.textLine &&
        !boundsInfo.hasLayerEffect &&
        (boundsInfo.textFontSize !== 0)) {
        var actualTextPixelHeight = (bounds[3] - bounds[1]).as('px');
        var textBoxHeight = boundsInfo.textFontSize * boundsInfo.textLineHeight;
        var correction = (actualTextPixelHeight - textBoxHeight) / 2;
        // If the text doesn't have decenders, then the correction by the PS baseline will
        // be off (the text is instead centered vertically in the CSS text box).  This applies
        // a different correciton for this case.
        if (boundsInfo.textOffset) {
            if (boundsInfo.textHasDecenders) {
                var lineHeightCorrection = (boundsInfo.textFontSize - (boundsInfo.textFontSize * boundsInfo.textLineHeight)) / 2;
                boundsInfo.textOffset[1] += lineHeightCorrection;
            } else
                boundsInfo.textOffset[1] = UnitValue(correction, 'px');
        }
    }

    if ((this.groupLevel == 0) && boundsInfo.textOffset) {
        this.addText("position: absolute;");
        this.addText("left: " + (bounds[0] + boundsInfo.textOffset[0]).asCSS() + ";");
        this.addText("top: " + (bounds[1] + boundsInfo.textOffset[1]).asCSS() + ";");
    } else {
        // Go through the DOM to ensure we're working in Pixels
        var left = bounds[0];
        var top = bounds[1];

        if (boundsInfo.textOffset == null)
            boundsInfo.textOffset = [0, 0];

        // Intuitively you'd think this would be "relative", but you'd be wrong.
        // "Absolute" coordinates are relative to the container.
        this.addText("position: absolute;");
        this.addText("left: " + (left -
            this.currentLeft +
            boundsInfo.textOffset[0]).asCSS() + ";");
        this.addText("top: " + (top -
            this.currentTop +
            boundsInfo.textOffset[1]).asCSS() + ";");
    }

    // Go through the DOM to ensure we're working in Pixels
    var width = bounds[2] - bounds[0];
    var height = bounds[3] - bounds[1];

    // In CSS, the border width is added to the -outside- of the bounds.  In order to match
    // the default behavior in PS, we adjust it here.
    if (boundsInfo.borderWidth > 0) {
        width -= 2 * boundsInfo.borderWidth;
        height -= 2 * boundsInfo.borderWidth;
    }
    // Don't generate a width for "line" (paint) style text.
    if (!boundsInfo.textLine) {
        this.addText("width: " + ((width < 0) ? 0 : width.asCSS()) + ";");
        this.addText("height: " + ((height < 0) ? 0 : height.asCSS()) + ";");
    }
}

// Only called for shape (vector) layers.
COPYCSS.getShapeLayerCSS = function (boundsInfo) {
    // If we have AGM stroke style info, generate that.
    var agmDesc = this.getLayerAttr("AGMStrokeStyleInfo");
    boundsInfo.borderWidth = 0;
    var opacity = this.getLayerAttr("opacity");

    if (agmDesc && agmDesc.getVal("strokeEnabled")) {
        // Assumes pixels!
        boundsInfo.borderWidth = makeUnitVal(agmDesc.getVal("strokeStyleLineWidth"));
        this.addStyleLine("border-width: $strokeStyleLineWidth$;", agmDesc);
        this.addStyleLine("border-color: $strokeStyleContent.color$;", agmDesc);
        var cap = agmDesc.getVal("strokeStyleLineCapType");
        var dashes = agmDesc.getVal("strokeStyleLineDashSet", false);

        if (dashes && dashes.length > 0) {
            if ((cap == "strokeStyleRoundCap") && (dashes[0] == 0))
                this.addStyleLine("border-style: dotted;");
            if ((cap == "strokeStyleButtCap") && (dashes[0] > 0))
                this.addStyleLine("border-style: dashed;");
        } else
            this.addStyleLine("border-style: solid;");
    }

    // Check for layerFX style borders
    var fxDesc = this.getLayerAttr("layerEffects.frameFX");
    if (fxDesc && fxDesc.getVal("enabled") &&
        (fxDesc.getVal("paintType") == "solidColor")) {
        opacity = (stripUnits(fxDesc.getVal("opacity")) / 100) * opacity;

        boundsInfo.borderWidth = makeUnitVal(fxDesc.getVal("size")); // Assumes pixels!
        this.addStyleLine("border-style: solid;");
        this.addStyleLine("border-width: $size$;", fxDesc);
        this.addStyleLine("border-color: $color$;", fxDesc);
    }

    // The Path for a shape *only* becomes visible when that shape is the active layer,
    // so we need to make the current layer active before we extract geometry information.
    // Yes, I know this is painfully slow, modifying the DOM or PS to behave otherwise is hard.
    var saveLayer = app.activeDocument.activeLayer;
    app.activeDocument.activeLayer = this.getCurrentLayer();
    var shapeGeom = this.extractShapeGeometry();
    app.activeDocument.activeLayer = saveLayer;

    // We assume path coordinates are in pixels, they're not stored as UnitValues in the DOM.
    if (shapeGeom) {
        // In CSS, the borderRadius needs to be added to the borderWidth, otherwise ovals
        // turn into rounded rects.
        if (shapeGeom[2] == "ellipse")
            this.addText("border-radius: 50%;");
        else {
            var radius = Math.round((shapeGeom[0] + shapeGeom[1]) / 2);
            // Note: path geometry is -always- in points ... unless the ruler type is Pixels.
            radius = (app.preferences.rulerUnits == Units.PIXELS) ?
                radius = pixelsToAppUnits(radius) :
                radius = UnitValue(radius, "pt");

            COPYCSS.addText("border-radius: " + radius.asCSS() + ";");
        }
    }

    var i, gradientCSS = this.gradientToCSS();
    if (!agmDesc // If AGM object, only fill if explictly turned on
        ||
        (agmDesc && agmDesc.getVal("fillEnabled"))) {
        if (gradientCSS) {
            for (i in this.browserTags)
                this.addText("background-image: " + this.browserTags[i] + gradientCSS);
        } else {
            var fillOpacity = this.getLayerAttr("fillOpacity") / 255.0;
            if (fillOpacity < 1.0)
                this.addRGBAColor("background-color", fillOpacity, this.getLayerAttr("adjustment"));
            else
                this.addStyleLine("background-color: $adjustment.color$;");
        }
    }
    this.addOpacity(opacity);

    this.addDropShadow("box-shadow", boundsInfo);
}

// Only called for text layers.
COPYCSS.getTextLayerCSS = function (boundsInfo) {
    function isStyleOn(textDesc, defTextDesc, styleKey, onText) {
        var styleText = textDesc.getVal(styleKey);
        if (!styleText && defTextDesc)
            styleText = defTextDesc.getVal(styleKey);
        return (styleText && (styleText.search(onText) >= 0));
    }

    // If the text string is empty, then trying to access the attributes fails, so exit now.
    var textString = this.getLayerAttr("textKey.textKey");
    if (textString.length === 0)
        return;

    var cssUnits = DOMunitToCSS[app.preferences.rulerUnits];
    boundsInfo.textOffset = [UnitValue(0, cssUnits), UnitValue(0, cssUnits)];
    var leadingOffset = 0;

    var opacity = (this.getLayerAttr("opacity") / 255.0) * (this.getLayerAttr("fillOpacity") / 255.0);

    var textDesc = this.getLayerAttr("textKey.textStyleRange.textStyle");
    var defaultDesc = this.getLayerAttr("textKey.paragraphStyleRange.paragraphStyle.defaultStyle");
    if (!defaultDesc)
        defaultDesc = this.getLayerAttr("textKey.textStyleRange.textStyle.baseParentStyle");
    if (textDesc) {
        //		this.addStyleLine2( "font-size: $size$;", textDesc, defaultDesc );
        this.addTextSize(textDesc, defaultDesc);
        this.addStyleLine2('font-family: "$fontName$";', textDesc, defaultDesc);
        if (opacity == 1.0)
            this.addStyleLine2("color: $color$;", textDesc, defaultDesc); // Color can just default to black
        else {
            if (textDesc.getVal("color"))
                this.addRGBAColor("color", opacity, textDesc);
            else
                this.addRGBAColor("color", opacity, defaultDesc);
        }

        // This table is: [PS Style event key ; PS event value keyword to search for ; corresponding CSS]
        var styleTable = [
            ["fontStyleName", "Bold", "font-weight: bold;"],
            ["fontStyleName", "Italic", "font-style: italic;"],
            ["strikethrough", "StrikethroughOn", "text-decoration: line-through;"],
            ["underline", "underlineOn", "text-decoration: underline;"],
            // Need RE, otherwise conflicts w/"smallCaps"
            ["fontCaps", /^allCaps/, "text-transform: uppercase;"],
            ["fontCaps", "smallCaps", "font-variant: small-caps;"],
            // These should probably also modify the font size?
            ["baseline", "superScript", "vertical-align: super;"],
            ["baseline", "subScript", "vertical-align: sub;"]
        ];

        var i;
        for (i in styleTable)
            if (isStyleOn(textDesc, defaultDesc, styleTable[i][0], styleTable[i][1]))
                this.addText(styleTable[i][2]);

        // Synthesize the line-height from the "leading" (line spacing) / font-size
        var fontSize = textDesc.getVal("size");
        if (!fontSize && defaultDesc) fontSize = defaultDesc.getVal("size");
        var fontLeading = textDesc.getVal("leading");
        if (fontSize)
            fontSize = stripUnits(fontSize);
        if (fontSize && fontLeading) {
            leadingOffset = fontLeading;
            boundsInfo.textLineHeight = round1k(stripUnits(fontLeading) / fontSize);
        }
        this.addText("line-height: " + boundsInfo.textLineHeight + ";");

        if (fontSize)
            boundsInfo.textFontSize = fontSize;

        var pgraphStyle = this.getLayerAttr("textKey.paragraphStyleRange.paragraphStyle");
        if (pgraphStyle) {
            this.addStyleLine("text-align: $align$;", pgraphStyle);
            var lineIndent = pgraphStyle.getVal("firstLineIndent");
            if (lineIndent && (stripUnits(lineIndent) != 0))
                this.addStyleLine("text-indent: $firstLineIndent$;", pgraphStyle);
            // PS startIndent for whole 'graph, CSS is?
        }

        // Update boundsInfo
        this.addDropShadow("text-shadow", boundsInfo);
        // text-indent text-align letter-spacing line-height

        var baseDesc = this.getLayerAttr("textKey");

        function txtBnd(id) {
            return makeUnitVal(baseDesc.getVal(id));
        }
        boundsInfo.textOffset = [txtBnd("bounds.left") - txtBnd("boundingBox.left"),
        txtBnd("bounds.top") - txtBnd("boundingBox.top") + makeUnitVal(leadingOffset)
        ];
        if (this.getLayerAttr("textKey.textShape.char") == "paint")
            boundsInfo.textLine = true;

        // This seems to be the one reliable indicator that the text has decenders
        // below the baseline, indicating the positioning in CSS must be handled
        // differently.
        if (txtBnd("boundingBox.bottom").as('px') / fontSize > 0.03)
            boundsInfo.textHasDecenders = true;

        // Matrix: [xx xy 0; yx yy 0; tx ty 1], if not identiy, then add it.
        var textXform = this.getLayerAttr("textKey.transform");
        var vScale = textDesc.getVal("verticalScale");
        var hScale = textDesc.getVal("horizontalScale");
        vScale = (typeof vScale == "number") ? round1k(vScale / 100.0) : 1;
        hScale = (typeof hScale == "number") ? round1k(hScale / 100.0) : 1;
        if (textXform) {
            function xfm(key) {
                return textXform.getVal(key);
            }

            var xformData = this.currentPSLayerInfo.replaceDescKey("[$xx$, $xy$, $yx$, $yy$, $tx$, $ty$]", textXform);
            var m = eval(xformData[1]);
            m[0] *= hScale;
            m[3] *= vScale;
            if (!((m[0] == 1) && (m[1] == 0) &&
                (m[2] == 0) && (m[3] == 1) &&
                (m[4] == 0) && (m[5] == 0))) {
                boundsInfo.rawTextBounds = baseDesc.getVal("boundingBox").extractBounds();
                this.addText("transform: matrix( " + m.join(",") + ");", this.browserTags);
            }
        } else {
            // Case for text not otherwise transformed.
            if ((vScale != 1.0) || (hScale != 1.0)) {
                boundsInfo.rawTextBounds = baseDesc.getVal("boundingBox").extractBounds();
                this.addText("transform: scale(" + hScale + ", " + vScale + ");", this.browserTags);
            }
        }
    }
}

COPYCSS.getPixelLayerCSS = function () {
    var name = this.getLayerAttr("name");
    // If suffix isn't present, add one.  Assume file is in same folder as parent.
    if (name.search(/[.]((\w){3,4})$/) < 0) {
        this.addStyleLine('background-image: url("$name$.png");');
    } else {
        // If the layer has a suffix, assume Generator-style naming conventions
        var docSuffix = app.activeDocument.name.search(/([.]psd)$/i);
        var docFolder = (docSuffix < 0) ? app.activeDocument.name :
            app.activeDocument.name.slice(0, docSuffix);
        docFolder += "-assets/"; // The "-assets" is not localized.

        // Weed out any Generator parameters, if present.
        var m = name.match(/(?:[\dx%? ])*([^.+,\n\r]+)([.]\w+)+$/);
        if (m) {
            name = m[1] + m[2];
        }

        this.addText('background-image: url("' + docFolder + name + '");');
    }
    var fillOpacity = this.getLayerAttr("fillOpacity") / 255.0;
    this.addOpacity(this.getLayerAttr("opacity") * fillOpacity);
}

// This walks the group and outputs all visible items in that group.  If the current
// layer is not a group, then it walks to the end of the document (i.e., for dumping
// the whole document).
COPYCSS.getGroupLayers = function (currentLayer, memberTest, processAllLayers) {

    processAllLayers = (typeof processAllLayers === "undefined") ? false : processAllLayers;
    // If processing all of the layers, don't stop at the end of the first group
    var layerLevel = processAllLayers ? 2 : 1;
    var visibleLevel = layerLevel;
    var curIndex = currentLayer.index;
    var saveGroup = [];

    if (currentLayer.layerKind === kLayerGroupSheet) {
        if (!currentLayer.visible) {
            return;
        }
        curIndex--; // Step to next layer in group so layerLevel is correct
    }

    var groupLayers = [];
    while ((curIndex > 0) && (layerLevel > 0)) {
        var nextLayer = new PSLayerInfo(curIndex, false);
        if (memberTest(nextLayer.layerKind)) {
            if (nextLayer.layerKind === kLayerGroupSheet) {
                if (nextLayer.visible && (visibleLevel === layerLevel)) {
                    visibleLevel++;
                    // The layers and section bounds must be swapped
                    // in order to process the group's layerFX 
                    saveGroup.push(nextLayer);
                    groupLayers.push(kHiddenSectionBounder);
                }
                layerLevel++;
            } else {
                if (nextLayer.visible && (visibleLevel === layerLevel)) {
                    groupLayers.push(nextLayer);
                }
            }
        } else
            if (nextLayer.layerKind === kHiddenSectionBounder) {
                layerLevel--;
                if (layerLevel < visibleLevel) {
                    visibleLevel = layerLevel;
                    if (saveGroup.length > 0) {
                        groupLayers.push(saveGroup.pop());
                    }
                }
            }
        curIndex--;
    }
    return groupLayers;
};

// Recursively count the number of layers in the group, for progress bar
COPYCSS.countGroupLayers = function (layerGroup, memberTest) {
    if (!memberTest)
        memberTest = COPYCSS.isCSSLayerKind;
    var currentLayer = new PSLayerInfo(layerGroup.itemIndex - COPYCSS.documentIndexOffset);
    var groupLayers = this.getGroupLayers(currentLayer, memberTest);
    var i, visLayers = 0;
    for (i = 0; i < groupLayers.length; ++i)
        if (typeof groupLayers[i] === "object")
            visLayers++;
    return visLayers;
}

// The CSS for nested DIVs (essentially; what's going on with groups) 
// are NOT specified hierarchically.  So we need to finish this group's
// output, then create the CSS for everything in it.
COPYCSS.pushGroupLevel = function () {
    if (this.groupLevel == 0) {
        var numSteps = this.countGroupLayers(this.getCurrentLayer()) + 1;
        this.groupProgress.totalProgressSteps = numSteps;
    }
    this.groupLevel++;
}

COPYCSS.popGroupLevel = function () {
    var i, saveGroupLayer = this.getCurrentLayer();
    var saveLeft = this.currentLeft,
        saveTop = this.currentTop;
    var bounds = this.getLayerBounds();

    this.currentLeft = bounds[0];
    this.currentTop = bounds[1];
    var notAborted = true;

    for (i = 0;
        ((i < saveGroupLayer.layers.length) && notAborted); ++i) {
        this.setCurrentLayer(saveGroupLayer.layers[i]);
        if (this.isCSSLayerKind())
            notAborted = this.gatherLayerCSS();
    }
    this.setCurrentLayer(saveGroupLayer);
    this.groupLevel--;
    this.currentLeft = saveLeft;
    this.currentTop = saveTop;
    return notAborted;
}

COPYCSS.layerNameToCSS = function (layerName) {
    const kMaxLayerNameLength = 50;

    // Remove any user-supplied class/ID delimiter
    if ((layerName[0] == ".") || (layerName[0] == "#"))
        layerName = layerName.slice(1);

    // Remove any other creepy punctuation.
    var badStuff = /[“”";!.?,'`@’#'$%^&*)(+=|}{><\x2F\s-]/g
    var layerName = layerName.replace(badStuff, "_");

    // Text layer names may be arbitrarily long; keep it real
    if (layerName.length > kMaxLayerNameLength)
        layerName = layerName.slice(0, kMaxLayerNameLength - 3);

    // Layers can't start with digits, force an _ in front in that case.
    if (layerName.match(/^[\d].*/))
        layerName = "_" + layerName;

    return layerName;
}

// Gather the CSS info for the current layer, and add it to this.cssText
// Returns FALSE if the process was aborted.
COPYCSS.gatherLayerCSS = function () {
    // Script can't be called from PS context menu unless there is an active layer
    var curLayer = this.getCurrentLayer();

    // Skip invisible or non-css-able layers.
    var layerKind = this.currentPSLayerInfo.layerKind;
    if (layerKind === kBackgroundSheet) // Background == pixels. Never in groups.
        layerKind = kPixelSheet;
    if ((!this.isCSSLayerKind(layerKind)) || (!curLayer.visible))
        return true;

    var isCSSid = (curLayer.name[0] == '#'); // Flag if generating ID not class
    var layerName = this.layerNameToCSS(curLayer.name);

    this.addText((isCSSid ? "#" : ".") + layerName + " {");
    this.pushIndent();
    var boundsInfo = new BoundsParameters();

    switch (layerKind) {
        case kLayerGroupSheet:
            this.pushGroupLevel();
            break;
        case kVectorSheet:
            this.getShapeLayerCSS(boundsInfo);
            break;
        case kTextSheet:
            this.getTextLayerCSS(boundsInfo);
            break;
        case kPixelSheet:
            this.getPixelLayerCSS();
            break;
    }

    var aborted = false;
    if (this.groupLevel > 0)
        aborted = this.groupProgress.nextProgress();
    if (aborted)
        return false;

    // Use the Opacity tag for groups, so it applies to all descendants.
    if (layerKind == kLayerGroupSheet)
        this.addOpacity();
    this.addObjectBounds(boundsInfo);
    this.addStyleLine("z-index: $itemIndex$;");

    this.popIndent();
    this.addText("}");

    var notAborted = true;

    // If we're processing a group, now is the time to process the member layers.
    if ((curLayer.typename == "LayerSet") &&
        (this.groupLevel > 0))
        notAborted = this.popGroupLevel();

    return notAborted;
}

// Main entry point
COPYCSS.copyLayerCSSToClipboard = function () {
    var resultObj = new Object();

    app.doProgress(localize("$$$/Photoshop/Progress/CopyCSSProgress=Copying CSS..."), "this.copyLayerCSSToClipboardWithProgress(resultObj)");

    return resultObj.msg;
}

COPYCSS.copyLayerCSSToClipboardWithProgress = function (outResult) {
    this.reset();
    var saveUnits = app.preferences.rulerUnits;

    app.preferences.rulerUnits = Units.PIXELS; // Web dudes want pixels.

    try {
        var elapsedTime, then = new Date();
        if (!this.gatherLayerCSS())
            return; // aborted
        elapsedTime = new Date() - then;
    } catch (err) {
        // Copy CSS fails if a new doc pops open before it's finished, possible if Cmd-N is selected
        // before the progress bar is up.  This message isn't optimal, but it was too late to get a
        // proper error message translated, so this was close enough.
        // MUST USE THIS FOR RELEASE PRIOR TO CS7/PS14
        //		alert( localize( "$$$/MaskPanel/MaskSelection/NoLayerSelected=No layer selected" ) );
        alert(localize("$$$/Scripts/CopyCSSToClipboard/Error=Internal error creating CSS: ") + err.message +
            localize("$$$/Scripts/CopyCSSToClipboard/ErrorLine= at script line ") + err.line);
    }

    COPYCSS.copyCSSToClipboard();
    if (saveUnits)
        app.preferences.rulerUnits = saveUnits;

    // We can watch this in ESTK without screwing up the app
    outResult.msg = ("time: " + (elapsedTime / 1000.0) + " sec");
}

// ----- End of CopyCSSToClipboard script proper.  What follows is test & debugging code -----

// Dump out a layer attribute as text.  This is how you learn what attributes are available.
// Note this only works for ActionDescriptor or ActionList layer attributes; for simple
// types just call COPYCSS.getLayerAttr().
COPYCSS.dumpLayerAttr = function (keyName) {
    // COPYCSS.textProperties = {};
    this.setCurrentLayer(app.activeDocument.activeLayer);
    var ref = new ActionReference();
    ref.putIdentifier(classLayer, app.activeDocument.activeLayer.id);
    layerDesc = executeActionGet(ref);

    var desc = layerDesc.getVal(keyName, false);
    if (!desc)
        return;
    if ((desc.typename == "ActionDescriptor") || (desc.typename == "ActionList"))
        desc.dumpDesc(keyName);
    else
        if ((typeof desc != "string") && (desc.length >= 1)) {
            s = []
            for (var i in desc) {
                if ((typeof desc[i] == "object") &&
                    (desc[i].typename in {
                        "ActionDescriptor": 1,
                        "ActionList": 1
                    }))
                    desc[i].dumpDesc(keyName + "[" + i + "]");
                else
                    s.push(desc[i].dumpDesc(keyName))
            }
            if (s.length > 0)
                $.writeln(keyName + ": [" + s.join(", ") + "]");
        } else
            $.writeln(keyName + ": " + ActionDescriptor.dumpValue(desc));
}

// Taken from inspection of ULayerElement.cpp
COPYCSS.allLayerAttrs = ['AGMStrokeStyleInfo', 'adjustment', 'background', 'bounds',
    'boundsNoEffects', 'channelRestrictions', 'color', 'count', 'fillOpacity', 'filterMaskDensity',
    'filterMaskFeather', 'generatorSettings', 'globalAngle', 'group', 'hasFilterMask',
    'hasUserMask', 'hasVectorMask', 'itemIndex', 'layer3D', 'layerEffects', 'layerFXVisible',
    'layerSection', 'layerID', 'layerKind', 'layerLocking', 'layerSVGdata', 'layerSection',
    'linkedLayerIDs', 'metadata', 'mode', 'name', 'opacity', 'preserveTransparency',
    'smartObject', 'targetChannels', 'textKey', 'useAlignedRendering', 'useAlignedRendering',
    'userMaskDensity', 'userMaskEnabled', 'userMaskFeather', 'userMaskLinked',
    'vectorMaskDensity', 'vectorMaskFeather', 'videoLayer', 'visible', 'visibleChannels',
    'XMPMetadataAsUTF8'
];

// Dump all the available attributes on the layer.  
COPYCSS.dumpAllLayerAttrs = function () {
    this.setCurrentLayer(app.activeDocument.activeLayer);

    var ref = new ActionReference();
    ref.putIndex(classLayer, app.activeDocument.activeLayer.itemIndex);
    var desc = executeActionGet(ref);

    var i;
    for (i = 0; i < this.allLayerAttrs.length; ++i) {
        var attr = this.allLayerAttrs[i];
        var attrDesc = null;
        try {
            attrDesc = this.getLayerAttr(attr);
            if (attrDesc)
                this.dumpLayerAttr(attr);
            else
                $.writeln(attr + ": null");
        } catch (err) {
            $.writeln(attr + ': ' + err.message);
        }
    }
}

// Walk the document's layers and describe them.
COPYCSS.dumpLayers = function (layerSet) {
    var i, layerID;
    if (typeof layerSet == "undefined")
        layerSet = app.activeDocument;

    for (i = 0; i < layerSet.layers.length; ++i) {
        if (layerSet.layers[i].typename == "LayerSet")
            this.dumpLayers(layerSet.layers[i]);
        this.setCurrentLayer(layerSet.layers[i]);
        layerID = (layerSet.layers[i].isBackground) ? "BG" : COPYCSS.getLayerAttr("layerID");
        $.writeln("Layer[" + COPYCSS.getLayerAttr("itemIndex") + "] ID=" + layerID + " name: " + COPYCSS.getLayerAttr("name"));
    }
}

COPYCSS.logToHeadlights = function (eventRecord) {
    var headlightsActionID = stringIDToTypeID("headlightsLog");
    var desc = new ActionDescriptor();
    desc.putString(stringIDToTypeID("subcategory"), "Export");
    desc.putString(stringIDToTypeID("eventRecord"), eventRecord);
    executeAction(headlightsActionID, desc, DialogModes.NO);
}



function testProgress() {
    app.doProgress(localize("$$$/Photoshop/Progress/CopyCSSProgress=Copying CSS..."), "testProgressTask()");
}

function testProgressTask() {
    var i, total = 10;
    var progBar = new ProgressBar();
    progBar.totalProgressSteps = total;
    for (i = 0; i <= total; ++i) {
        //		if (progBar.updateProgress( i ))
        if (progBar.nextProgress()) {
            $.writeln('cancelled');
            break;
        }
        $.sleep(800);
    }
}

// Debug.  Uncomment one of these lines, and watch the output
// in the ESTK "JavaScript Console" panel.

// Walk the layers
//runCopyCSSFromScript = true; COPYCSS.dumpLayers();

// Print out some interesting objects
runCopyCSSFromScript = true; COPYCSS.dumpLayerAttr( "AGMStrokeStyleInfo" );
runCopyCSSFromScript = true; COPYCSS.dumpLayerAttr( "adjustment" );  // Gradient, etc.
runCopyCSSFromScript = true; COPYCSS.dumpLayerAttr( "layerEffects" );  // Layer FX, drop shadow, etc.
//~ runCopyCSSFromScript = true;
COPYCSS.dumpLayerAttr("textKey");
runCopyCSSFromScript = true;
COPYCSS.dumpLayerAttr("bounds");

// Backdoor to allow using this script as a library; 
// if ((typeof (runCopyCSSFromScript) == 'undefined') ||
//     (runCopyCSSFromScript == false))
//COPYCSS.copyLayerCSSToClipboard();     

Let us know if this helps. Or if you can attach the psd file, I will check once.