/*
 * SDK Pullenti Unitext, version 4.33, fabruary 2026. Copyright (c) 2013-2026, Pullenti. All rights reserved. 
 * Non-Commercial Freeware and Commercial Software. 
 * This class is generated using the converter UniSharping (www.unisharping.ru) from Pullenti C# project. 
 * The latest version of the code is available on the site www.pullenti.ru
 */

const Utils = require("./../../../unisharp/Utils");
const Hashtable = require("./../../../unisharp/Hashtable");
const RefOutArgWrapper = require("./../../../unisharp/RefOutArgWrapper");
const Stream = require("./../../../unisharp/Stream");
const MemoryStream = require("./../../../unisharp/MemoryStream");

const ReadUtils = require("./ReadUtils");
const ToggleOperand = require("./ToggleOperand");
const SinglePropertyModifiers = require("./SinglePropertyModifiers");
const ColorRef = require("./ColorRef");
const BasicTypesReader = require("./BasicTypesReader");

class SinglePropertyValue {
    
    static parseValue(sprm, value) {
        switch (sprm) { 
        case SinglePropertyModifiers.sprmCFRMarkDel: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFRMarkIns: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFFldVanish: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCPicLocation: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmCIbstRMark: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmCDttmRMark: {
            return SinglePropertyValue.parseDTTM(value);
        }
        case SinglePropertyModifiers.sprmCFData: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmCIdslRMark: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmCSymbol: {
            return SinglePropertyValue.parseCSymbolOperand(value);
        }
        case SinglePropertyModifiers.sprmCFOle2: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmCHighlight: {
            return SinglePropertyValue.parseIco(value);
        }
        case SinglePropertyModifiers.sprmCFWebHidden: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCRsidProp: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmCRsidText: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmCRsidRMDel: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmCFSpecVanish: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFMathPr: {
            return SinglePropertyValue.parseMathPrOperand(value);
        }
        case SinglePropertyModifiers.sprmCIstd: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmCIstdPermute: {
            return SinglePropertyValue.parseSPPOperand(value);
        }
        case SinglePropertyModifiers.sprmCPlain: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmCKcd: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmCFBold: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFItalic: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFStrike: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFOutline: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFShadow: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFSmallCaps: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFCaps: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFVanish: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCKul: {
            return SinglePropertyValue.parseKul(value);
        }
        case SinglePropertyModifiers.sprmCDxaSpace: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmCIco: {
            return SinglePropertyValue.parseIco(value);
        }
        case SinglePropertyModifiers.sprmCHps: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmCHpsPos: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmCMajority: {
            return SinglePropertyValue.parseCMajorityOperand(value);
        }
        case SinglePropertyModifiers.sprmCIss: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmCHpsKern: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmCHresi: {
            return SinglePropertyValue.parseHresiOperand(value);
        }
        case SinglePropertyModifiers.sprmCRgFtc0: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmCRgFtc1: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmCRgFtc2: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmCCharScale: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmCFDStrike: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFImprint: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFSpec: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFObj: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmCPropRMark90: {
            return SinglePropertyValue.parsePropRMarkOperand(value);
        }
        case SinglePropertyModifiers.sprmCFEmboss: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCSfxText: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmCFBiDi: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFBoldBi: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFItalicBi: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFtcBi: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmCLidBi: {
            return SinglePropertyValue.parseLID(value);
        }
        case SinglePropertyModifiers.sprmCIcoBi: {
            return SinglePropertyValue.parseIco(value);
        }
        case SinglePropertyModifiers.sprmCHpsBi: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmCDispFldRMark: {
            return SinglePropertyValue.parseDispFldRmOperand(value);
        }
        case SinglePropertyModifiers.sprmCIbstRMarkDel: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmCDttmRMarkDel: {
            return SinglePropertyValue.parseDTTM(value);
        }
        case SinglePropertyModifiers.sprmCBrc80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmCShd80: {
            return SinglePropertyValue.parseShd80(value);
        }
        case SinglePropertyModifiers.sprmCIdslRMarkDel: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmCFUsePgsuSettings: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCRgLid0_80: {
            return SinglePropertyValue.parseLID(value);
        }
        case SinglePropertyModifiers.sprmCRgLid1_80: {
            return SinglePropertyValue.parseLID(value);
        }
        case SinglePropertyModifiers.sprmCIdctHint: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmCCv: {
            return SinglePropertyValue.parseCOLORREF(value);
        }
        case SinglePropertyModifiers.sprmCShd: {
            return SinglePropertyValue.parseSHDOperand(value);
        }
        case SinglePropertyModifiers.sprmCBrc: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmCRgLid0: {
            return SinglePropertyValue.parseLID(value);
        }
        case SinglePropertyModifiers.sprmCRgLid1: {
            return SinglePropertyValue.parseLID(value);
        }
        case SinglePropertyModifiers.sprmCFNoProof: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCFitText: {
            return SinglePropertyValue.parseCFitTextOperand(value);
        }
        case SinglePropertyModifiers.sprmCCvUl: {
            return SinglePropertyValue.parseCOLORREF(value);
        }
        case SinglePropertyModifiers.sprmCFELayout: {
            return SinglePropertyValue.parseFarEastLayoutOperand(value);
        }
        case SinglePropertyModifiers.sprmCLbcCRJ: {
            return SinglePropertyValue.parseLBCOperand(value);
        }
        case SinglePropertyModifiers.sprmCFComplexScripts: {
            return SinglePropertyValue.parseToggleOperand(value);
        }
        case SinglePropertyModifiers.sprmCWall: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmCCnf: {
            return SinglePropertyValue.parseCNFOperand(value);
        }
        case SinglePropertyModifiers.sprmCNeedFontFixup: {
            return SinglePropertyValue.parseFFM(value);
        }
        case SinglePropertyModifiers.sprmCPbiIBullet: {
            return SinglePropertyValue.parseCP(value);
        }
        case SinglePropertyModifiers.sprmCPbiGrf: {
            return SinglePropertyValue.parsePbiGrfOperand(value);
        }
        case SinglePropertyModifiers.sprmCPropRMark: {
            return SinglePropertyValue.parsePropRMarkOperand(value);
        }
        case SinglePropertyModifiers.sprmCFSdtVanish: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPIstd: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmPIstdPermute: {
            return SinglePropertyValue.parseSPPOperand(value);
        }
        case SinglePropertyModifiers.sprmPIncLvl: {
            return SinglePropertyValue.parseSByte(value);
        }
        case SinglePropertyModifiers.sprmPJc80: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmPFKeep: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFKeepFollow: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFPageBreakBefore: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPIlvl: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmPIlfo: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmPFNoLineNumb: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPChgTabsPapx: {
            return SinglePropertyValue.parsePChgTabsPapxOperand(value);
        }
        case SinglePropertyModifiers.sprmPDxaRight80: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmPDxaLeft80: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmPNest80: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmPDxaLeft180: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmPDyaLine: {
            return SinglePropertyValue.parseLSPD(value);
        }
        case SinglePropertyModifiers.sprmPDyaBefore: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmPDyaAfter: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmPChgTabs: {
            return SinglePropertyValue.parsePChgTabsOperand(value);
        }
        case SinglePropertyModifiers.sprmPFInTable: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFTtp: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPDxaAbs: {
            return SinglePropertyValue.parseXAS_plusOne(value);
        }
        case SinglePropertyModifiers.sprmPDyaAbs: {
            return SinglePropertyValue.parseYAS_plusOne(value);
        }
        case SinglePropertyModifiers.sprmPDxaWidth: {
            return SinglePropertyValue.parseXAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmPPc: {
            return SinglePropertyValue.parsePositionCodeOperand(value);
        }
        case SinglePropertyModifiers.sprmPWr: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmPBrcTop80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPBrcLeft80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPBrcBottom80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPBrcRight80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPBrcBetween80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPBrcBar80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPFNoAutoHyph: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPWHeightAbs: {
            return SinglePropertyValue.parseWHeightAbs(value);
        }
        case SinglePropertyModifiers.sprmPDcs: {
            return SinglePropertyValue.parseDCS(value);
        }
        case SinglePropertyModifiers.sprmPShd80: {
            return SinglePropertyValue.parseShd80(value);
        }
        case SinglePropertyModifiers.sprmPDyaFromText: {
            return SinglePropertyValue.parseYAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmPDxaFromText: {
            return SinglePropertyValue.parseXAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmPFLocked: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFWidowControl: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFKinsoku: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFWordWrap: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFOverflowPunct: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFTopLinePunct: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFAutoSpaceDE: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFAutoSpaceDN: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPWAlignFont: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmPFrameTextFlow: {
            return SinglePropertyValue.parseFrameTextFlowOperand(value);
        }
        case SinglePropertyModifiers.sprmPOutLvl: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmPFBiDi: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFNumRMIns: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPNumRM: {
            return SinglePropertyValue.parseNumRMOperand(value);
        }
        case SinglePropertyModifiers.sprmPHugePapx: {
            return SinglePropertyValue.parseUInt32(value);
        }
        case SinglePropertyModifiers.sprmPFUsePgsuSettings: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFAdjustRight: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPItap: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmPDtap: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmPFInnerTableCell: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFInnerTtp: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPShd: {
            return SinglePropertyValue.parseSHDOperand(value);
        }
        case SinglePropertyModifiers.sprmPBrcTop: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmPBrcLeft: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmPBrcBottom: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmPBrcRight: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmPBrcBetween: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmPBrcBar: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmPDxcRight: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmPDxcLeft: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmPDxcLeft1: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmPDylBefore: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmPDylAfter: {
            return SinglePropertyValue.parseInt16(value);
        }
        case SinglePropertyModifiers.sprmPFOpenTch: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFDyaBeforeAuto: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPFDyaAfterAuto: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPDxaRight: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmPDxaLeft: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmPNest: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmPDxaLeft1: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmPJc: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmPFNoAllowOverlap: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPWall: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPIpgp: {
            return SinglePropertyValue.parseUInt32(value);
        }
        case SinglePropertyModifiers.sprmPCnf: {
            return SinglePropertyValue.parseCNFOperand(value);
        }
        case SinglePropertyModifiers.sprmPRsid: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmPIstdListPermute: {
            return SinglePropertyValue.parseSPPOperand(value);
        }
        case SinglePropertyModifiers.sprmPTableProps: {
            return SinglePropertyValue.parseUInt32(value);
        }
        case SinglePropertyModifiers.sprmPTIstdInfo: {
            return SinglePropertyValue.parsePTIstdInfoOperand(value);
        }
        case SinglePropertyModifiers.sprmPFContextualSpacing: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPPropRMark: {
            return SinglePropertyValue.parsePropRMarkOperand(value);
        }
        case SinglePropertyModifiers.sprmPFMirrorIndents: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmPTtwo: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmTJc90: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmTDxaLeft: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmTDxaGapHalf: {
            return SinglePropertyValue.parseXAS(value);
        }
        case SinglePropertyModifiers.sprmTFCantSplit90: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTTableHeader: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTTableBorders80: {
            return SinglePropertyValue.parseTableBordersOperand80(value);
        }
        case SinglePropertyModifiers.sprmTDyaRowHeight: {
            return SinglePropertyValue.parseYAS(value);
        }
        case SinglePropertyModifiers.sprmTDefTable: {
            return SinglePropertyValue.parseTDefTableOperand(value);
        }
        case SinglePropertyModifiers.sprmTDefTableShd80: {
            return SinglePropertyValue.parseDefTableShd80Operand(value);
        }
        case SinglePropertyModifiers.sprmTTlp: {
            return SinglePropertyValue.parseTLP(value);
        }
        case SinglePropertyModifiers.sprmTFBiDi: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTDefTableShd3rd: {
            return SinglePropertyValue.parseDefTableShdOperand(value);
        }
        case SinglePropertyModifiers.sprmTPc: {
            return SinglePropertyValue.parsePositionCodeOperand(value);
        }
        case SinglePropertyModifiers.sprmTDxaAbs: {
            return SinglePropertyValue.parseXAS_plusOne(value);
        }
        case SinglePropertyModifiers.sprmTDyaAbs: {
            return SinglePropertyValue.parseYAS_plusOne(value);
        }
        case SinglePropertyModifiers.sprmTDxaFromText: {
            return SinglePropertyValue.parseXAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmTDyaFromText: {
            return SinglePropertyValue.parseYAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmTDefTableShd: {
            return SinglePropertyValue.parseDefTableShdOperand(value);
        }
        case SinglePropertyModifiers.sprmTTableBorders: {
            return SinglePropertyValue.parseTableBordersOperand(value);
        }
        case SinglePropertyModifiers.sprmTTableWidth: {
            return SinglePropertyValue.parseFtsWWidth_Table(value);
        }
        case SinglePropertyModifiers.sprmTFAutofit: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTDefTableShd2nd: {
            return SinglePropertyValue.parseDefTableShdOperand(value);
        }
        case SinglePropertyModifiers.sprmTWidthBefore: {
            return SinglePropertyValue.parseFtsWWidth_TablePart(value);
        }
        case SinglePropertyModifiers.sprmTWidthAfter: {
            return SinglePropertyValue.parseFtsWWidth_TablePart(value);
        }
        case SinglePropertyModifiers.sprmTFKeepFollow: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTBrcTopCv: {
            return SinglePropertyValue.parseBrcCvOperand(value);
        }
        case SinglePropertyModifiers.sprmTBrcLeftCv: {
            return SinglePropertyValue.parseBrcCvOperand(value);
        }
        case SinglePropertyModifiers.sprmTBrcBottomCv: {
            return SinglePropertyValue.parseBrcCvOperand(value);
        }
        case SinglePropertyModifiers.sprmTBrcRightCv: {
            return SinglePropertyValue.parseBrcCvOperand(value);
        }
        case SinglePropertyModifiers.sprmTDxaFromTextRight: {
            return SinglePropertyValue.parseXAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmTDyaFromTextBottom: {
            return SinglePropertyValue.parseYAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmTSetBrc80: {
            return SinglePropertyValue.parseTableBrc80Operand(value);
        }
        case SinglePropertyModifiers.sprmTInsert: {
            return SinglePropertyValue.parseTInsertOperand(value);
        }
        case SinglePropertyModifiers.sprmTDelete: {
            return SinglePropertyValue.parseItcFirstLim(value);
        }
        case SinglePropertyModifiers.sprmTDxaCol: {
            return SinglePropertyValue.parseTDxaColOperand(value);
        }
        case SinglePropertyModifiers.sprmTMerge: {
            return SinglePropertyValue.parseItcFirstLim(value);
        }
        case SinglePropertyModifiers.sprmTSplit: {
            return SinglePropertyValue.parseItcFirstLim(value);
        }
        case SinglePropertyModifiers.sprmTTextFlow: {
            return SinglePropertyValue.parseCellRangeTextFlow(value);
        }
        case SinglePropertyModifiers.sprmTVertMerge: {
            return SinglePropertyValue.parseVertMergeOperand(value);
        }
        case SinglePropertyModifiers.sprmTVertAlign: {
            return SinglePropertyValue.parseCellRangeVertAlign(value);
        }
        case SinglePropertyModifiers.sprmTSetShd: {
            return SinglePropertyValue.parseTableShadeOperand(value);
        }
        case SinglePropertyModifiers.sprmTSetShdOdd: {
            return SinglePropertyValue.parseTableShadeOperand(value);
        }
        case SinglePropertyModifiers.sprmTSetBrc: {
            return SinglePropertyValue.parseTableBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellPadding: {
            return SinglePropertyValue.parseCSSAOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellSpacingDefault: {
            return SinglePropertyValue.parseCSSAOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellPaddingDefault: {
            return SinglePropertyValue.parseCSSAOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellWidth: {
            return SinglePropertyValue.parseTableCellWidthOperand(value);
        }
        case SinglePropertyModifiers.sprmTFitText: {
            return SinglePropertyValue.parseCellRangeFitText(value);
        }
        case SinglePropertyModifiers.sprmTFCellNoWrap: {
            return SinglePropertyValue.parseCellRangeNoWrap(value);
        }
        case SinglePropertyModifiers.sprmTIstd: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmTCellPaddingStyle: {
            return SinglePropertyValue.parseCSSAOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellFHideMark: {
            return SinglePropertyValue.parseCellHideMarkOperand(value);
        }
        case SinglePropertyModifiers.sprmTSetShdTable: {
            return SinglePropertyValue.parseSHDOperand(value);
        }
        case SinglePropertyModifiers.sprmTWidthIndent: {
            return SinglePropertyValue.parseFtsWWidth_Indent(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcType: {
            return SinglePropertyValue.parseTCellBrcTypeOperand(value);
        }
        case SinglePropertyModifiers.sprmTFBiDi90: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTFNoAllowOverlap: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTFCantSplit: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTPropRMark: {
            return SinglePropertyValue.parsePropRMarkOperand(value);
        }
        case SinglePropertyModifiers.sprmTWall: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTIpgp: {
            return SinglePropertyValue.parseUInt32(value);
        }
        case SinglePropertyModifiers.sprmTCnf: {
            return SinglePropertyValue.parseCNFOperand(value);
        }
        case SinglePropertyModifiers.sprmTDefTableShdRaw: {
            return SinglePropertyValue.parseDefTableShdOperand(value);
        }
        case SinglePropertyModifiers.sprmTDefTableShdRaw2nd: {
            return SinglePropertyValue.parseDefTableShdOperand(value);
        }
        case SinglePropertyModifiers.sprmTDefTableShdRaw3rd: {
            return SinglePropertyValue.parseDefTableShdOperand(value);
        }
        case SinglePropertyModifiers.sprmTRsid: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmTCellVertAlignStyle: {
            return SinglePropertyValue.parseVerticalAlign(value);
        }
        case SinglePropertyModifiers.sprmTCellNoWrapStyle: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcTopStyle: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcBottomStyle: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcLeftStyle: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcRightStyle: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcInsideHStyle: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcInsideVStyle: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcTL2BRStyle: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellBrcTR2BLStyle: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmTCellShdStyle: {
            return SinglePropertyValue.parseSHDOperand(value);
        }
        case SinglePropertyModifiers.sprmTCHorzBands: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmTCVertBands: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmTJc: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmScnsPgn: {
            return SinglePropertyValue.parseCNS(value);
        }
        case SinglePropertyModifiers.sprmSiHeadingPgn: {
            return SinglePropertyValue.parseByte(value);
        }
        case SinglePropertyModifiers.sprmSDxaColWidth: {
            return SinglePropertyValue.parseSDxaColWidthOperand(value);
        }
        case SinglePropertyModifiers.sprmSDxaColSpacing: {
            return SinglePropertyValue.parseSDxaColSpacingOperand(value);
        }
        case SinglePropertyModifiers.sprmSFEvenlySpaced: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSFProtected: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSDmBinFirst: {
            return SinglePropertyValue.parseSDmBinOperand(value);
        }
        case SinglePropertyModifiers.sprmSDmBinOther: {
            return SinglePropertyValue.parseSDmBinOperand(value);
        }
        case SinglePropertyModifiers.sprmSBkc: {
            return SinglePropertyValue.parseSBkcOperand(value);
        }
        case SinglePropertyModifiers.sprmSFTitlePage: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSCcolumns: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSDxaColumns: {
            return SinglePropertyValue.parseXAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmSNfcPgn: {
            return SinglePropertyValue.parseMSONFC(value);
        }
        case SinglePropertyModifiers.sprmSFPgnRestart: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSFEndnote: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSLnc: {
            return SinglePropertyValue.parseSLncOperand(value);
        }
        case SinglePropertyModifiers.sprmSNLnnMod: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSDxaLnn: {
            return SinglePropertyValue.parseXAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmSDyaHdrTop: {
            return SinglePropertyValue.parseYAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmSDyaHdrBottom: {
            return SinglePropertyValue.parseYAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmSLBetween: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSVjc: {
            return SinglePropertyValue.parseVic(value);
        }
        case SinglePropertyModifiers.sprmSLnnMin: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSPgnStart97: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSBOrientation: {
            return SinglePropertyValue.parseSBOrientationOperan(value);
        }
        case SinglePropertyModifiers.sprmSXaPage: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSYaPage: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSDxaLeft: {
            return SinglePropertyValue.parseXAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmSDxaRight: {
            return SinglePropertyValue.parseXAS_nonNeg(value);
        }
        case SinglePropertyModifiers.sprmSDyaTop: {
            return SinglePropertyValue.parseYAS(value);
        }
        case SinglePropertyModifiers.sprmSDyaBottom: {
            return SinglePropertyValue.parseYAS(value);
        }
        case SinglePropertyModifiers.sprmSDzaGutter: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSDmPaperReq: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSFBiDi: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSFRTLGutter: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSBrcTop80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmSBrcLeft80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmSBrcBottom80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmSBrcRight80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmSPgbProp: {
            return SinglePropertyValue.parseSPgbPropOperand(value);
        }
        case SinglePropertyModifiers.sprmSDxtCharSpace: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmSDyaLinePitch: {
            return SinglePropertyValue.parseYAS(value);
        }
        case SinglePropertyModifiers.sprmSClm: {
            return SinglePropertyValue.parseSClmOperand(value);
        }
        case SinglePropertyModifiers.sprmSTextFlow: {
            return SinglePropertyValue.parseMSOTXFL(value);
        }
        case SinglePropertyModifiers.sprmSBrcTop: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmSBrcLeft: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmSBrcBottom: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmSBrcRight: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmSWall: {
            return SinglePropertyValue.parseBool(value);
        }
        case SinglePropertyModifiers.sprmSRsid: {
            return SinglePropertyValue.parseInt32(value);
        }
        case SinglePropertyModifiers.sprmSFpc: {
            return SinglePropertyValue.parseSFpcOperand(value);
        }
        case SinglePropertyModifiers.sprmSRncFtn: {
            return SinglePropertyValue.parseRnc(value);
        }
        case SinglePropertyModifiers.sprmSRncEdn: {
            return SinglePropertyValue.parseRnc(value);
        }
        case SinglePropertyModifiers.sprmSNFtn: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSNfcFtnRef: {
            return SinglePropertyValue.parseMSONFC(value);
        }
        case SinglePropertyModifiers.sprmSNEdn: {
            return SinglePropertyValue.parseUInt16(value);
        }
        case SinglePropertyModifiers.sprmSNfcEdnRef: {
            return SinglePropertyValue.parseMSONFC(value);
        }
        case SinglePropertyModifiers.sprmSPropRMark: {
            return SinglePropertyValue.parsePropRMarkOperand(value);
        }
        case SinglePropertyModifiers.sprmSPgnStart: {
            return SinglePropertyValue.parseUInt32(value);
        }
        case SinglePropertyModifiers.sprmPicBrcTop80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPicBrcLeft80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPicBrcBottom80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPicBrcRight80: {
            return SinglePropertyValue.parseBrc80(value);
        }
        case SinglePropertyModifiers.sprmPicBrcTop: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmPicBrcLeft: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        case SinglePropertyModifiers.sprmPicBrcBottom: {
            return SinglePropertyValue.parseBrcOperand(value);
        }
        default: {
            throw new Error("Unknow sprm value");
        }
        }
    }
    
    static parseBool(value) {
        return value[0] !== (0);
    }
    
    static parseBrc80(value) {
        let result = new Hashtable();
        result.put("LineWidth", (value[0]) * SinglePropertyValue.dptConstant);
        result.put("BorderType", value[1]);
        result.put("Color", value[2]);
        result.put("Space", (((value[3]) & 0x1F)) * SinglePropertyValue.dptConstant);
        result.put("Shadow", (((value[3]) & 0x20)) !== 0);
        result.put("Frame", (((value[3]) & 0x40)) !== 0);
        return result;
    }
    
    static parseBrcCvOperand(value) {
        return [ColorRef.fromBytes(value, 0), ColorRef.fromBytes(value, 4), ColorRef.fromBytes(value, 8), ColorRef.fromBytes(value, 12)];
    }
    
    static parseBrcOperand(value) {
        let result = new Hashtable();
        result.put("Color", ColorRef.fromBytes(value, 0));
        result.put("LineWidth", (value[4]) * SinglePropertyValue.dptConstant);
        result.put("BorderType", value[5]);
        result.put("Space", (((value[6]) & 0x1F)) * SinglePropertyValue.dptConstant);
        result.put("Shadow", (((value[6]) & 0x20)) !== 0);
        result.put("Frame", (((value[6]) & 0x40)) !== 0);
        return result;
    }
    
    static parseByte(value) {
        return value[0];
    }
    
    static parseCellHideMarkOperand(value) {
        let result = new Hashtable();
        result.put("Range", new Int32Array([value[0], value[1]]));
        result.put("NoHeight", value[2] !== (0));
        return result;
    }
    
    static parseCellRangeFitText(value) {
        let result = new Hashtable();
        result.put("Range", new Int32Array([value[0], value[1]]));
        result.put("FitText", value[2] !== (0));
        return result;
    }
    
    static parseCellRangeNoWrap(value) {
        let result = new Hashtable();
        result.put("Range", new Int32Array([value[0], value[1]]));
        result.put("NoWrap", value[2] !== (0));
        return result;
    }
    
    static parseCellRangeTextFlow(value) {
        let result = new Hashtable();
        result.put("Range", new Int32Array([value[0], value[1]]));
        result.put("TextFlow", Utils.bytesToObject(value, 2, 'ushort', 2));
        return result;
    }
    
    static parseCellRangeVertAlign(value) {
        let result = new Hashtable();
        result.put("Range", new Int32Array([value[0], value[1]]));
        result.put("VertAlign", value[2]);
        return result;
    }
    
    static parseCFitTextOperand(value) {
        let result = new Hashtable();
        result.put("FitText", (Utils.bytesToObject(value, 0, 'int', 4)) * SinglePropertyValue.dxaConstant);
        result.put("FitTextID", Utils.bytesToObject(value, 2, 'int', 4));
        return result;
    }
    
    static parseCMajorityOperand(value) {
        let ms = new MemoryStream(value); 
        try {
            let read = 0;
            let wrapread532 = new RefOutArgWrapper(read);
            let prls = BasicTypesReader.readPrls(ms, value.length, wrapread532);
            read = wrapread532.value;
            let result = new Hashtable();
            for (const prl of prls) {
                let name = SinglePropertyModifiers.map.get(prl.sprm.sprm);
                result.put(name.substring(4), SinglePropertyValue.parseValue(prl.sprm.sprm, prl.operand));
            }
            return result;
        }
        finally {
            ms.close();
        }
    }
    
    static parseCNFOperand(value) {
        let ms = new MemoryStream(value); 
        try {
            let read = 0;
            let result = new Hashtable();
            let wrapread534 = new RefOutArgWrapper(read);
            result.put("$FormattingCondition", Utils.bytesToObject(ReadUtils.readExactRef(ms, ReadUtils.wordSize, wrapread534), 0, 'ushort', 2));
            read = wrapread534.value;
            let wrapread533 = new RefOutArgWrapper(read);
            let prls = BasicTypesReader.readPrls(ms, value.length - read, wrapread533);
            read = wrapread533.value;
            for (const prl of prls) {
                let name = SinglePropertyModifiers.map.get(prl.sprm.sprm);
                result.put(name.substring(4), SinglePropertyValue.parseValue(prl.sprm.sprm, prl.operand));
            }
            return result;
        }
        finally {
            ms.close();
        }
    }
    
    static parseCNS(value) {
        return value[0];
    }
    
    static parseCOLORREF(value) {
        return ColorRef.fromBytes(value, 0);
    }
    
    static parseCP(value) {
        return Utils.bytesToObject(value, 0, 'uint', 4);
    }
    
    static parseCSSAOperand(value) {
        throw new Error();
    }
    
    static parseCSymbolOperand(value) {
        let result = new Hashtable();
        result.put("FontIndex", Utils.bytesToObject(value, 0, 'ushort', 2));
        result.put("Symbol", String.fromCharCode(Utils.bytesToObject(value, 2, 'ushort', 2)));
        return result;
    }
    
    static parseDCS(value) {
        let result = new Hashtable();
        result.put("DropCap", ((value[0]) & 0x1F));
        result.put("DropLines", ((value[0]) >>> 5));
        return result;
    }
    
    static parseDefTableShd80Operand(value) {
        throw new Error();
    }
    
    static parseDefTableShdOperand(value) {
        throw new Error();
    }
    
    static parseDispFldRmOperand(value) {
        throw new Error();
    }
    
    static parseDTTM(value) {
        return BasicTypesReader.parseDTTM(Utils.bytesToObject(value, 0, 'uint', 4));
    }
    
    static parseFarEastLayoutOperand(value) {
        throw new Error();
    }
    
    static parseFFM(value) {
        return value[0];
    }
    
    static parseFrameTextFlowOperand(value) {
        let result = new Hashtable();
        result.put("Vertical", (((value[0]) & 0x01)) !== 0);
        result.put("Backwards", (((value[0]) & 0x02)) !== 0);
        result.put("RotateFont", (((value[0]) & 0x04)) !== 0);
        return result;
    }
    
    static parseFtsWWidth_Indent(value) {
        throw new Error();
    }
    
    static parseFtsWWidth_Table(value) {
        throw new Error();
    }
    
    static parseFtsWWidth_TablePart(value) {
        throw new Error();
    }
    
    static parseHresiOperand(value) {
        let result = new Hashtable();
        result.put("WordBreakingMethod", value[0]);
        result.put("Character", String.fromCharCode(value[1]));
        return result;
    }
    
    static parseIco(value) {
        return value[0];
    }
    
    static parseInt16(value) {
        return Utils.bytesToObject(value, 0, 'short', 2);
    }
    
    static parseInt32(value) {
        return Utils.bytesToObject(value, 0, 'int', 4);
    }
    
    static parseItcFirstLim(value) {
        return new Int32Array([value[0], value[1]]);
    }
    
    static parseKul(value) {
        return value[0];
    }
    
    static parseLBCOperand(value) {
        return value[0];
    }
    
    static parseLID(value) {
        return Utils.bytesToObject(value, 0, 'ushort', 2);
    }
    
    static parseLSPD(value) {
        throw new Error();
    }
    
    static parseMathPrOperand(value) {
        throw new Error();
    }
    
    static parseMSONFC(value) {
        throw new Error();
    }
    
    static parseMSOTXFL(value) {
        throw new Error();
    }
    
    static parseNumRMOperand(value) {
        throw new Error();
    }
    
    static parsePbiGrfOperand(value) {
        throw new Error();
    }
    
    static parsePChgTabsOperand(value) {
        throw new Error();
    }
    
    static parsePChgTabsPapxOperand(value) {
        throw new Error();
    }
    
    static parsePositionCodeOperand(value) {
        throw new Error();
    }
    
    static parsePropRMarkOperand(value) {
        throw new Error();
    }
    
    static parsePTIstdInfoOperand(value) {
        throw new Error();
    }
    
    static parseRnc(value) {
        throw new Error();
    }
    
    static parseSBkcOperand(value) {
        throw new Error();
    }
    
    static parseSBOrientationOperan(value) {
        throw new Error();
    }
    
    static parseSByte(value) {
        return value[0];
    }
    
    static parseSClmOperand(value) {
        throw new Error();
    }
    
    static parseSDmBinOperand(value) {
        throw new Error();
    }
    
    static parseSDxaColSpacingOperand(value) {
        throw new Error();
    }
    
    static parseSDxaColWidthOperand(value) {
        throw new Error();
    }
    
    static parseSFpcOperand(value) {
        throw new Error();
    }
    
    static parseShd80(value) {
        throw new Error();
    }
    
    static parseSHDOperand(value) {
        throw new Error();
    }
    
    static parseSLncOperand(value) {
        throw new Error();
    }
    
    static parseSPgbPropOperand(value) {
        throw new Error();
    }
    
    static parseSPPOperand(value) {
        throw new Error();
    }
    
    static parseTableBordersOperand(value) {
        throw new Error();
    }
    
    static parseTableBordersOperand80(value) {
        throw new Error();
    }
    
    static parseTableBrc80Operand(value) {
        throw new Error();
    }
    
    static parseTableBrcOperand(value) {
        throw new Error();
    }
    
    static parseTableCellWidthOperand(value) {
        throw new Error();
    }
    
    static parseTableShadeOperand(value) {
        throw new Error();
    }
    
    static parseTCellBrcTypeOperand(value) {
        throw new Error();
    }
    
    static parseTDefTableOperand(value) {
        throw new Error();
    }
    
    static parseTDxaColOperand(value) {
        throw new Error();
    }
    
    static parseTInsertOperand(value) {
        throw new Error();
    }
    
    static parseTLP(value) {
        throw new Error();
    }
    
    static parseToggleOperand(value) {
        return ToggleOperand.of(value[0]);
    }
    
    static parseUInt16(value) {
        return Utils.bytesToObject(value, 0, 'ushort', 2);
    }
    
    static parseUInt32(value) {
        return Utils.bytesToObject(value, 0, 'uint', 4);
    }
    
    static parseVerticalAlign(value) {
        throw new Error();
    }
    
    static parseVertMergeOperand(value) {
        throw new Error();
    }
    
    static parseVic(value) {
        throw new Error();
    }
    
    static parseWHeightAbs(value) {
        throw new Error();
    }
    
    static parseXAS(value) {
        throw new Error();
    }
    
    static parseXAS_nonNeg(value) {
        throw new Error();
    }
    
    static parseXAS_plusOne(value) {
        throw new Error();
    }
    
    static parseYAS(value) {
        throw new Error();
    }
    
    static parseYAS_nonNeg(value) {
        throw new Error();
    }
    
    static parseYAS_plusOne(value) {
        throw new Error();
    }
    
    static static_constructor() {
        SinglePropertyValue.dptConstant = 0.125;
        SinglePropertyValue.dxaConstant = 0.125;
    }
}


SinglePropertyValue.static_constructor();

module.exports = SinglePropertyValue