const numComps = this.numComps;

[7000] Fix | Delete

const scaled = new Float32Array(numComps);

[7001] Fix | Delete

const tinted = new Float32Array(baseNumComps);

[7002] Fix | Delete

let i, j;

[7003] Fix | Delete

for (i = 0; i < count; i++) {

[7004] Fix | Delete

for (j = 0; j < numComps; j++) {

[7005] Fix | Delete

scaled[j] = src[srcOffset++] * scale;

[7006] Fix | Delete

}

[7007] Fix | Delete

tintFn(scaled, 0, tinted, 0);

[7008] Fix | Delete

if (usesZeroToOneRange) {

[7009] Fix | Delete

for (j = 0; j < baseNumComps; j++) {

[7010] Fix | Delete

baseBuf[pos++] = tinted[j] * 255;

[7011] Fix | Delete

}

[7012] Fix | Delete

} else {

[7013] Fix | Delete

base.getRgbItem(tinted, 0, baseBuf, pos);

[7014] Fix | Delete

pos += baseNumComps;

[7015] Fix | Delete

}

[7016] Fix | Delete

}

[7017] Fix | Delete

if (!isPassthrough) {

[7018] Fix | Delete

base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01);

[7019] Fix | Delete

}

[7020] Fix | Delete

}

[7021] Fix | Delete

getOutputLength(inputLength, alpha01) {

[7022] Fix | Delete

return this.base.getOutputLength(inputLength * this.base.numComps / this.numComps, alpha01);

[7023] Fix | Delete

}

[7024] Fix | Delete

}

[7025] Fix | Delete

class PatternCS extends ColorSpace {

[7026] Fix | Delete

constructor(baseCS) {

[7027] Fix | Delete

super("Pattern", null);

[7028] Fix | Delete

this.base = baseCS;

[7029] Fix | Delete

}

[7030] Fix | Delete

isDefaultDecode(decodeMap, bpc) {

[7031] Fix | Delete

unreachable("Should not call PatternCS.isDefaultDecode");

[7032] Fix | Delete

}

[7033] Fix | Delete

}

[7034] Fix | Delete

class IndexedCS extends ColorSpace {

[7035] Fix | Delete

constructor(base, highVal, lookup) {

[7036] Fix | Delete

super("Indexed", 1);

[7037] Fix | Delete

this.base = base;

[7038] Fix | Delete

this.highVal = highVal;

[7039] Fix | Delete

const length = base.numComps * highVal;

[7040] Fix | Delete

this.lookup = new Uint8Array(length);

[7041] Fix | Delete

if (lookup instanceof BaseStream) {

[7042] Fix | Delete

const bytes = lookup.getBytes(length);

[7043] Fix | Delete

this.lookup.set(bytes);

[7044] Fix | Delete

} else if (typeof lookup === "string") {

[7045] Fix | Delete

for (let i = 0; i < length; ++i) {

[7046] Fix | Delete

this.lookup[i] = lookup.charCodeAt(i) & 0xff;

[7047] Fix | Delete

}

[7048] Fix | Delete

} else {

[7049] Fix | Delete

throw new FormatError(`IndexedCS - unrecognized lookup table: ${lookup}`);

[7050] Fix | Delete

}

[7051] Fix | Delete

}

[7052] Fix | Delete

getRgbItem(src, srcOffset, dest, destOffset) {

[7053] Fix | Delete

const numComps = this.base.numComps;

[7054] Fix | Delete

const start = src[srcOffset] * numComps;

[7055] Fix | Delete

this.base.getRgbBuffer(this.lookup, start, 1, dest, destOffset, 8, 0);

[7056] Fix | Delete

}

[7057] Fix | Delete

getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {

[7058] Fix | Delete

const base = this.base;

[7059] Fix | Delete

const numComps = base.numComps;

[7060] Fix | Delete

const outputDelta = base.getOutputLength(numComps, alpha01);

[7061] Fix | Delete

const lookup = this.lookup;

[7062] Fix | Delete

for (let i = 0; i < count; ++i) {

[7063] Fix | Delete

const lookupPos = src[srcOffset++] * numComps;

[7064] Fix | Delete

base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);

[7065] Fix | Delete

destOffset += outputDelta;

[7066] Fix | Delete

}

[7067] Fix | Delete

}

[7068] Fix | Delete

getOutputLength(inputLength, alpha01) {

[7069] Fix | Delete

return this.base.getOutputLength(inputLength * this.base.numComps, alpha01);

[7070] Fix | Delete

}

[7071] Fix | Delete

isDefaultDecode(decodeMap, bpc) {

[7072] Fix | Delete

if (!Array.isArray(decodeMap)) {

[7073] Fix | Delete

return true;

[7074] Fix | Delete

}

[7075] Fix | Delete

if (decodeMap.length !== 2) {

[7076] Fix | Delete

warn("Decode map length is not correct");

[7077] Fix | Delete

return true;

[7078] Fix | Delete

}

[7079] Fix | Delete

if (!Number.isInteger(bpc) || bpc < 1) {

[7080] Fix | Delete

warn("Bits per component is not correct");

[7081] Fix | Delete

return true;

[7082] Fix | Delete

}

[7083] Fix | Delete

return decodeMap[0] === 0 && decodeMap[1] === (1 << bpc) - 1;

[7084] Fix | Delete

}

[7085] Fix | Delete

}

[7086] Fix | Delete

class DeviceGrayCS extends ColorSpace {

[7087] Fix | Delete

constructor() {

[7088] Fix | Delete

super("DeviceGray", 1);

[7089] Fix | Delete

}

[7090] Fix | Delete

getRgbItem(src, srcOffset, dest, destOffset) {

[7091] Fix | Delete

const c = src[srcOffset] * 255;

[7092] Fix | Delete

dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c;

[7093] Fix | Delete

}

[7094] Fix | Delete

getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {

[7095] Fix | Delete

const scale = 255 / ((1 << bits) - 1);

[7096] Fix | Delete

let j = srcOffset,

[7097] Fix | Delete

q = destOffset;

[7098] Fix | Delete

for (let i = 0; i < count; ++i) {

[7099] Fix | Delete

const c = scale * src[j++];

[7100] Fix | Delete

dest[q++] = c;

[7101] Fix | Delete

dest[q++] = c;

[7102] Fix | Delete

dest[q++] = c;

[7103] Fix | Delete

q += alpha01;

[7104] Fix | Delete

}

[7105] Fix | Delete

}

[7106] Fix | Delete

getOutputLength(inputLength, alpha01) {

[7107] Fix | Delete

return inputLength * (3 + alpha01);

[7108] Fix | Delete

}

[7109] Fix | Delete

}

[7110] Fix | Delete

class DeviceRgbCS extends ColorSpace {

[7111] Fix | Delete

constructor() {

[7112] Fix | Delete

super("DeviceRGB", 3);

[7113] Fix | Delete

}

[7114] Fix | Delete

getRgbItem(src, srcOffset, dest, destOffset) {

[7115] Fix | Delete

dest[destOffset] = src[srcOffset] * 255;

[7116] Fix | Delete

dest[destOffset + 1] = src[srcOffset + 1] * 255;

[7117] Fix | Delete

dest[destOffset + 2] = src[srcOffset + 2] * 255;

[7118] Fix | Delete

}

[7119] Fix | Delete

getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {

[7120] Fix | Delete

if (bits === 8 && alpha01 === 0) {

[7121] Fix | Delete

dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);

[7122] Fix | Delete

return;

[7123] Fix | Delete

}

[7124] Fix | Delete

const scale = 255 / ((1 << bits) - 1);

[7125] Fix | Delete

let j = srcOffset,

[7126] Fix | Delete

q = destOffset;

[7127] Fix | Delete

for (let i = 0; i < count; ++i) {

[7128] Fix | Delete

dest[q++] = scale * src[j++];

[7129] Fix | Delete

dest[q++] = scale * src[j++];

[7130] Fix | Delete

dest[q++] = scale * src[j++];

[7131] Fix | Delete

q += alpha01;

[7132] Fix | Delete

}

[7133] Fix | Delete

}

[7134] Fix | Delete

getOutputLength(inputLength, alpha01) {

[7135] Fix | Delete

return inputLength * (3 + alpha01) / 3 | 0;

[7136] Fix | Delete

}

[7137] Fix | Delete

isPassthrough(bits) {

[7138] Fix | Delete

return bits === 8;

[7139] Fix | Delete

}

[7140] Fix | Delete

}

[7141] Fix | Delete

class DeviceCmykCS extends ColorSpace {

[7142] Fix | Delete

constructor() {

[7143] Fix | Delete

super("DeviceCMYK", 4);

[7144] Fix | Delete

}

[7145] Fix | Delete

#toRgb(src, srcOffset, srcScale, dest, destOffset) {

[7146] Fix | Delete

const c = src[srcOffset] * srcScale;

[7147] Fix | Delete

const m = src[srcOffset + 1] * srcScale;

[7148] Fix | Delete

const y = src[srcOffset + 2] * srcScale;

[7149] Fix | Delete

const k = src[srcOffset + 3] * srcScale;

[7150] Fix | Delete

dest[destOffset] = 255 + c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k + -285.2331026137004) + m * (1.7149763477362134 * m - 5.6096736904047315 * y + -17.873870861415444 * k - 5.497006427196366) + y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) + k * (-21.86122147463605 * k - 189.48180835922747);

[7151] Fix | Delete

dest[destOffset + 1] = 255 + c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k + -79.2970844816548) + m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) + y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) + k * (-20.737325471181034 * k - 187.80453709719578);

[7152] Fix | Delete

dest[destOffset + 2] = 255 + c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k + -14.183576799673286) + m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) + y * (0.03296041114873217 * y + 115.60384449646641 * k + -193.58209356861505) + k * (-22.33816807309886 * k - 180.12613974708367);

[7153] Fix | Delete

}

[7154] Fix | Delete

getRgbItem(src, srcOffset, dest, destOffset) {

[7155] Fix | Delete

this.#toRgb(src, srcOffset, 1, dest, destOffset);

[7156] Fix | Delete

}

[7157] Fix | Delete

getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {

[7158] Fix | Delete

const scale = 1 / ((1 << bits) - 1);

[7159] Fix | Delete

for (let i = 0; i < count; i++) {

[7160] Fix | Delete

this.#toRgb(src, srcOffset, scale, dest, destOffset);

[7161] Fix | Delete

srcOffset += 4;

[7162] Fix | Delete

destOffset += 3 + alpha01;

[7163] Fix | Delete

}

[7164] Fix | Delete

}

[7165] Fix | Delete

getOutputLength(inputLength, alpha01) {

[7166] Fix | Delete

return inputLength / 4 * (3 + alpha01) | 0;

[7167] Fix | Delete

}

[7168] Fix | Delete

}

[7169] Fix | Delete

class CalGrayCS extends ColorSpace {

[7170] Fix | Delete

constructor(whitePoint, blackPoint, gamma) {

[7171] Fix | Delete

super("CalGray", 1);

[7172] Fix | Delete

if (!whitePoint) {

[7173] Fix | Delete

throw new FormatError("WhitePoint missing - required for color space CalGray");

[7174] Fix | Delete

}

[7175] Fix | Delete

[this.XW, this.YW, this.ZW] = whitePoint;

[7176] Fix | Delete

[this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];

[7177] Fix | Delete

this.G = gamma || 1;

[7178] Fix | Delete

if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {

[7179] Fix | Delete

throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);

[7180] Fix | Delete

}

[7181] Fix | Delete

if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {

[7182] Fix | Delete

info(`Invalid BlackPoint for ${this.name}, falling back to default.`);

[7183] Fix | Delete

this.XB = this.YB = this.ZB = 0;

[7184] Fix | Delete

}

[7185] Fix | Delete

if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {

[7186] Fix | Delete

warn(`${this.name}, BlackPoint: XB: ${this.XB}, YB: ${this.YB}, ` + `ZB: ${this.ZB}, only default values are supported.`);

[7187] Fix | Delete

}

[7188] Fix | Delete

if (this.G < 1) {

[7189] Fix | Delete

info(`Invalid Gamma: ${this.G} for ${this.name}, falling back to default.`);

[7190] Fix | Delete

this.G = 1;

[7191] Fix | Delete

}

[7192] Fix | Delete

}

[7193] Fix | Delete

#toRgb(src, srcOffset, dest, destOffset, scale) {

[7194] Fix | Delete

const A = src[srcOffset] * scale;

[7195] Fix | Delete

const AG = A ** this.G;

[7196] Fix | Delete

const L = this.YW * AG;

[7197] Fix | Delete

const val = Math.max(295.8 * L ** 0.3333333333333333 - 40.8, 0);

[7198] Fix | Delete

dest[destOffset] = val;

[7199] Fix | Delete

dest[destOffset + 1] = val;

[7200] Fix | Delete

dest[destOffset + 2] = val;

[7201] Fix | Delete

}

[7202] Fix | Delete

getRgbItem(src, srcOffset, dest, destOffset) {

[7203] Fix | Delete

this.#toRgb(src, srcOffset, dest, destOffset, 1);

[7204] Fix | Delete

}

[7205] Fix | Delete

getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {

[7206] Fix | Delete

const scale = 1 / ((1 << bits) - 1);

[7207] Fix | Delete

for (let i = 0; i < count; ++i) {

[7208] Fix | Delete

this.#toRgb(src, srcOffset, dest, destOffset, scale);

[7209] Fix | Delete

srcOffset += 1;

[7210] Fix | Delete

destOffset += 3 + alpha01;

[7211] Fix | Delete

}

[7212] Fix | Delete

}

[7213] Fix | Delete

getOutputLength(inputLength, alpha01) {

[7214] Fix | Delete

return inputLength * (3 + alpha01);

[7215] Fix | Delete

}

[7216] Fix | Delete

}

[7217] Fix | Delete

class CalRGBCS extends ColorSpace {

[7218] Fix | Delete

static #BRADFORD_SCALE_MATRIX = new Float32Array([0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296]);

[7219] Fix | Delete

static #BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([0.9869929, -0.1470543, 0.1599627, 0.4323053, 0.5183603, 0.0492912, -0.0085287, 0.0400428, 0.9684867]);

[7220] Fix | Delete

static #SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([3.2404542, -1.5371385, -0.4985314, -0.9692660, 1.8760108, 0.0415560, 0.0556434, -0.2040259, 1.0572252]);

[7221] Fix | Delete

static #FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]);

[7222] Fix | Delete

static #tempNormalizeMatrix = new Float32Array(3);

[7223] Fix | Delete

static #tempConvertMatrix1 = new Float32Array(3);

[7224] Fix | Delete

static #tempConvertMatrix2 = new Float32Array(3);

[7225] Fix | Delete

static #DECODE_L_CONSTANT = ((8 + 16) / 116) ** 3 / 8.0;

[7226] Fix | Delete

constructor(whitePoint, blackPoint, gamma, matrix) {

[7227] Fix | Delete

super("CalRGB", 3);

[7228] Fix | Delete

if (!whitePoint) {

[7229] Fix | Delete

throw new FormatError("WhitePoint missing - required for color space CalRGB");

[7230] Fix | Delete

}

[7231] Fix | Delete

const [XW, YW, ZW] = this.whitePoint = whitePoint;

[7232] Fix | Delete

const [XB, YB, ZB] = this.blackPoint = blackPoint || new Float32Array(3);

[7233] Fix | Delete

[this.GR, this.GG, this.GB] = gamma || new Float32Array([1, 1, 1]);

[7234] Fix | Delete

[this.MXA, this.MYA, this.MZA, this.MXB, this.MYB, this.MZB, this.MXC, this.MYC, this.MZC] = matrix || new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);

[7235] Fix | Delete

if (XW < 0 || ZW < 0 || YW !== 1) {

[7236] Fix | Delete

throw new FormatError(`Invalid WhitePoint components for ${this.name}, no fallback available`);

[7237] Fix | Delete

}

[7238] Fix | Delete

if (XB < 0 || YB < 0 || ZB < 0) {

[7239] Fix | Delete

info(`Invalid BlackPoint for ${this.name} [${XB}, ${YB}, ${ZB}], ` + "falling back to default.");

[7240] Fix | Delete

this.blackPoint = new Float32Array(3);

[7241] Fix | Delete

}

[7242] Fix | Delete

if (this.GR < 0 || this.GG < 0 || this.GB < 0) {

[7243] Fix | Delete

info(`Invalid Gamma [${this.GR}, ${this.GG}, ${this.GB}] for ` + `${this.name}, falling back to default.`);

[7244] Fix | Delete

this.GR = this.GG = this.GB = 1;

[7245] Fix | Delete

}

[7246] Fix | Delete

}

[7247] Fix | Delete

#matrixProduct(a, b, result) {

[7248] Fix | Delete

result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];

[7249] Fix | Delete

result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];

[7250] Fix | Delete

result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];

[7251] Fix | Delete

}

[7252] Fix | Delete

#toFlat(sourceWhitePoint, LMS, result) {

[7253] Fix | Delete

result[0] = LMS[0] * 1 / sourceWhitePoint[0];

[7254] Fix | Delete

result[1] = LMS[1] * 1 / sourceWhitePoint[1];

[7255] Fix | Delete

result[2] = LMS[2] * 1 / sourceWhitePoint[2];

[7256] Fix | Delete

}

[7257] Fix | Delete

#toD65(sourceWhitePoint, LMS, result) {

[7258] Fix | Delete

const D65X = 0.95047;

[7259] Fix | Delete

const D65Y = 1;

[7260] Fix | Delete

const D65Z = 1.08883;

[7261] Fix | Delete

result[0] = LMS[0] * D65X / sourceWhitePoint[0];

[7262] Fix | Delete

result[1] = LMS[1] * D65Y / sourceWhitePoint[1];

[7263] Fix | Delete

result[2] = LMS[2] * D65Z / sourceWhitePoint[2];

[7264] Fix | Delete

}

[7265] Fix | Delete

#sRGBTransferFunction(color) {

[7266] Fix | Delete

if (color <= 0.0031308) {

[7267] Fix | Delete

return this.#adjustToRange(0, 1, 12.92 * color);

[7268] Fix | Delete

}

[7269] Fix | Delete

if (color >= 0.99554525) {

[7270] Fix | Delete

return 1;

[7271] Fix | Delete

}

[7272] Fix | Delete

return this.#adjustToRange(0, 1, (1 + 0.055) * color ** (1 / 2.4) - 0.055);

[7273] Fix | Delete

}

[7274] Fix | Delete

#adjustToRange(min, max, value) {

[7275] Fix | Delete

return Math.max(min, Math.min(max, value));

[7276] Fix | Delete

}

[7277] Fix | Delete

#decodeL(L) {

[7278] Fix | Delete

if (L < 0) {

[7279] Fix | Delete

return -this.#decodeL(-L);

[7280] Fix | Delete

}

[7281] Fix | Delete

if (L > 8.0) {

[7282] Fix | Delete

return ((L + 16) / 116) ** 3;

[7283] Fix | Delete

}

[7284] Fix | Delete

return L * CalRGBCS.#DECODE_L_CONSTANT;

[7285] Fix | Delete

}

[7286] Fix | Delete

#compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {

[7287] Fix | Delete

if (sourceBlackPoint[0] === 0 && sourceBlackPoint[1] === 0 && sourceBlackPoint[2] === 0) {

[7288] Fix | Delete

result[0] = XYZ_Flat[0];

[7289] Fix | Delete

result[1] = XYZ_Flat[1];

[7290] Fix | Delete

result[2] = XYZ_Flat[2];

[7291] Fix | Delete

return;

[7292] Fix | Delete

}

[7293] Fix | Delete

const zeroDecodeL = this.#decodeL(0);

[7294] Fix | Delete

const X_DST = zeroDecodeL;

[7295] Fix | Delete

const X_SRC = this.#decodeL(sourceBlackPoint[0]);

[7296] Fix | Delete

const Y_DST = zeroDecodeL;

[7297] Fix | Delete

const Y_SRC = this.#decodeL(sourceBlackPoint[1]);

[7298] Fix | Delete

const Z_DST = zeroDecodeL;

[7299] Fix | Delete

const Z_SRC = this.#decodeL(sourceBlackPoint[2]);

[7300] Fix | Delete

const X_Scale = (1 - X_DST) / (1 - X_SRC);

[7301] Fix | Delete

const X_Offset = 1 - X_Scale;

[7302] Fix | Delete

const Y_Scale = (1 - Y_DST) / (1 - Y_SRC);

[7303] Fix | Delete

const Y_Offset = 1 - Y_Scale;

[7304] Fix | Delete

const Z_Scale = (1 - Z_DST) / (1 - Z_SRC);

[7305] Fix | Delete

const Z_Offset = 1 - Z_Scale;

[7306] Fix | Delete

result[0] = XYZ_Flat[0] * X_Scale + X_Offset;

[7307] Fix | Delete

result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;

[7308] Fix | Delete

result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;

[7309] Fix | Delete

}

[7310] Fix | Delete

#normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {

[7311] Fix | Delete

if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {

[7312] Fix | Delete

result[0] = XYZ_In[0];

[7313] Fix | Delete

result[1] = XYZ_In[1];

[7314] Fix | Delete

result[2] = XYZ_In[2];

[7315] Fix | Delete

return;

[7316] Fix | Delete

}

[7317] Fix | Delete

const LMS = result;

[7318] Fix | Delete

this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);

[7319] Fix | Delete

const LMS_Flat = CalRGBCS.#tempNormalizeMatrix;

[7320] Fix | Delete

this.#toFlat(sourceWhitePoint, LMS, LMS_Flat);

[7321] Fix | Delete

this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);

[7322] Fix | Delete

}

[7323] Fix | Delete

#normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {

[7324] Fix | Delete

const LMS = result;

[7325] Fix | Delete

this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_MATRIX, XYZ_In, LMS);

[7326] Fix | Delete

const LMS_D65 = CalRGBCS.#tempNormalizeMatrix;

[7327] Fix | Delete

this.#toD65(sourceWhitePoint, LMS, LMS_D65);

[7328] Fix | Delete

this.#matrixProduct(CalRGBCS.#BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);

[7329] Fix | Delete

}

[7330] Fix | Delete

#toRgb(src, srcOffset, dest, destOffset, scale) {

[7331] Fix | Delete

const A = this.#adjustToRange(0, 1, src[srcOffset] * scale);

[7332] Fix | Delete

const B = this.#adjustToRange(0, 1, src[srcOffset + 1] * scale);

[7333] Fix | Delete

const C = this.#adjustToRange(0, 1, src[srcOffset + 2] * scale);

[7334] Fix | Delete

const AGR = A === 1 ? 1 : A ** this.GR;

[7335] Fix | Delete

const BGG = B === 1 ? 1 : B ** this.GG;

[7336] Fix | Delete

const CGB = C === 1 ? 1 : C ** this.GB;

[7337] Fix | Delete

const X = this.MXA * AGR + this.MXB * BGG + this.MXC * CGB;

[7338] Fix | Delete

const Y = this.MYA * AGR + this.MYB * BGG + this.MYC * CGB;

[7339] Fix | Delete

const Z = this.MZA * AGR + this.MZB * BGG + this.MZC * CGB;

[7340] Fix | Delete

const XYZ = CalRGBCS.#tempConvertMatrix1;

[7341] Fix | Delete

XYZ[0] = X;

[7342] Fix | Delete

XYZ[1] = Y;

[7343] Fix | Delete

XYZ[2] = Z;

[7344] Fix | Delete

const XYZ_Flat = CalRGBCS.#tempConvertMatrix2;

[7345] Fix | Delete

this.#normalizeWhitePointToFlat(this.whitePoint, XYZ, XYZ_Flat);

[7346] Fix | Delete

const XYZ_Black = CalRGBCS.#tempConvertMatrix1;

[7347] Fix | Delete

this.#compensateBlackPoint(this.blackPoint, XYZ_Flat, XYZ_Black);

[7348] Fix | Delete

const XYZ_D65 = CalRGBCS.#tempConvertMatrix2;

[7349] Fix | Delete

this.#normalizeWhitePointToD65(CalRGBCS.#FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65);

[7350] Fix | Delete

const SRGB = CalRGBCS.#tempConvertMatrix1;

[7351] Fix | Delete

this.#matrixProduct(CalRGBCS.#SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);

[7352] Fix | Delete

dest[destOffset] = this.#sRGBTransferFunction(SRGB[0]) * 255;

[7353] Fix | Delete

dest[destOffset + 1] = this.#sRGBTransferFunction(SRGB[1]) * 255;

[7354] Fix | Delete

dest[destOffset + 2] = this.#sRGBTransferFunction(SRGB[2]) * 255;

[7355] Fix | Delete

}

[7356] Fix | Delete

getRgbItem(src, srcOffset, dest, destOffset) {

[7357] Fix | Delete

this.#toRgb(src, srcOffset, dest, destOffset, 1);

[7358] Fix | Delete

}

[7359] Fix | Delete

getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {

[7360] Fix | Delete

const scale = 1 / ((1 << bits) - 1);

[7361] Fix | Delete

for (let i = 0; i < count; ++i) {

[7362] Fix | Delete

this.#toRgb(src, srcOffset, dest, destOffset, scale);

[7363] Fix | Delete

srcOffset += 3;

[7364] Fix | Delete

destOffset += 3 + alpha01;

[7365] Fix | Delete

}

[7366] Fix | Delete

}

[7367] Fix | Delete

getOutputLength(inputLength, alpha01) {

[7368] Fix | Delete

return inputLength * (3 + alpha01) / 3 | 0;

[7369] Fix | Delete

}

[7370] Fix | Delete

}

[7371] Fix | Delete

class LabCS extends ColorSpace {

[7372] Fix | Delete

constructor(whitePoint, blackPoint, range) {

[7373] Fix | Delete

super("Lab", 3);

[7374] Fix | Delete

if (!whitePoint) {

[7375] Fix | Delete

throw new FormatError("WhitePoint missing - required for color space Lab");

[7376] Fix | Delete

}

[7377] Fix | Delete

[this.XW, this.YW, this.ZW] = whitePoint;

[7378] Fix | Delete

[this.amin, this.amax, this.bmin, this.bmax] = range || [-100, 100, -100, 100];

[7379] Fix | Delete

[this.XB, this.YB, this.ZB] = blackPoint || [0, 0, 0];

[7380] Fix | Delete

if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {

[7381] Fix | Delete

throw new FormatError("Invalid WhitePoint components, no fallback available");

[7382] Fix | Delete

}

[7383] Fix | Delete

if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {

[7384] Fix | Delete

info("Invalid BlackPoint, falling back to default");

[7385] Fix | Delete

this.XB = this.YB = this.ZB = 0;

[7386] Fix | Delete

}

[7387] Fix | Delete

if (this.amin > this.amax || this.bmin > this.bmax) {

[7388] Fix | Delete

info("Invalid Range, falling back to defaults");

[7389] Fix | Delete

this.amin = -100;

[7390] Fix | Delete

this.amax = 100;

[7391] Fix | Delete

this.bmin = -100;

[7392] Fix | Delete

this.bmax = 100;

[7393] Fix | Delete

}

[7394] Fix | Delete

}

[7395] Fix | Delete

#fn_g(x) {

[7396] Fix | Delete

return x >= 6 / 29 ? x ** 3 : 108 / 841 * (x - 4 / 29);

[7397] Fix | Delete

}

[7398] Fix | Delete

#decode(value, high1, low2, high2) {

[7399] Fix | Delete

return low2 + value * (high2 - low2) / high1;

[7400] Fix | Delete

}

[7401] Fix | Delete

#toRgb(src, srcOffset, maxVal, dest, destOffset) {

[7402] Fix | Delete

let Ls = src[srcOffset];

[7403] Fix | Delete

let as = src[srcOffset + 1];

[7404] Fix | Delete

let bs = src[srcOffset + 2];

[7405] Fix | Delete

if (maxVal !== false) {

[7406] Fix | Delete

Ls = this.#decode(Ls, maxVal, 0, 100);

[7407] Fix | Delete

as = this.#decode(as, maxVal, this.amin, this.amax);

[7408] Fix | Delete

bs = this.#decode(bs, maxVal, this.bmin, this.bmax);

[7409] Fix | Delete

}

[7410] Fix | Delete

if (as > this.amax) {

[7411] Fix | Delete

as = this.amax;

[7412] Fix | Delete

} else if (as < this.amin) {

[7413] Fix | Delete

as = this.amin;

[7414] Fix | Delete

}

[7415] Fix | Delete

if (bs > this.bmax) {

[7416] Fix | Delete

bs = this.bmax;

[7417] Fix | Delete

} else if (bs < this.bmin) {

[7418] Fix | Delete

bs = this.bmin;

[7419] Fix | Delete

}

[7420] Fix | Delete

const M = (Ls + 16) / 116;

[7421] Fix | Delete

const L = M + as / 500;

[7422] Fix | Delete

const N = M - bs / 200;

[7423] Fix | Delete

const X = this.XW * this.#fn_g(L);

[7424] Fix | Delete

const Y = this.YW * this.#fn_g(M);

[7425] Fix | Delete

const Z = this.ZW * this.#fn_g(N);

[7426] Fix | Delete

let r, g, b;

[7427] Fix | Delete

if (this.ZW < 1) {

[7428] Fix | Delete

r = X * 3.1339 + Y * -1.617 + Z * -0.4906;

[7429] Fix | Delete

g = X * -0.9785 + Y * 1.916 + Z * 0.0333;

[7430] Fix | Delete

b = X * 0.072 + Y * -0.229 + Z * 1.4057;

[7431] Fix | Delete

} else {

[7432] Fix | Delete

r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;

[7433] Fix | Delete

g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;

[7434] Fix | Delete

b = X * 0.0557 + Y * -0.204 + Z * 1.057;

[7435] Fix | Delete

}

[7436] Fix | Delete

dest[destOffset] = Math.sqrt(r) * 255;

[7437] Fix | Delete

dest[destOffset + 1] = Math.sqrt(g) * 255;

[7438] Fix | Delete

dest[destOffset + 2] = Math.sqrt(b) * 255;

[7439] Fix | Delete

}

[7440] Fix | Delete

getRgbItem(src, srcOffset, dest, destOffset) {

[7441] Fix | Delete

this.#toRgb(src, srcOffset, false, dest, destOffset);

[7442] Fix | Delete

}

[7443] Fix | Delete

getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {

[7444] Fix | Delete

const maxVal = (1 << bits) - 1;

[7445] Fix | Delete

for (let i = 0; i < count; i++) {

[7446] Fix | Delete

this.#toRgb(src, srcOffset, maxVal, dest, destOffset);

[7447] Fix | Delete

srcOffset += 3;

[7448] Fix | Delete

destOffset += 3 + alpha01;

[7449] Fix | Delete

}

[7450] Fix | Delete

}

[7451] Fix | Delete

getOutputLength(inputLength, alpha01) {

[7452] Fix | Delete

return inputLength * (3 + alpha01) / 3 | 0;

[7453] Fix | Delete

}

[7454] Fix | Delete

isDefaultDecode(decodeMap, bpc) {

[7455] Fix | Delete

return true;

[7456] Fix | Delete

}

[7457] Fix | Delete

get usesZeroToOneRange() {

[7458] Fix | Delete

return shadow(this, "usesZeroToOneRange", false);

[7459] Fix | Delete

}

[7460] Fix | Delete

}

[7461] Fix | Delete

[7462] Fix | Delete

;// CONCATENATED MODULE: ./src/core/binary_cmap.js

[7463] Fix | Delete

[7464] Fix | Delete

[7465] Fix | Delete

[7466] Fix | Delete

[7467] Fix | Delete

[7468] Fix | Delete

[7469] Fix | Delete

[7470] Fix | Delete

function hexToInt(a, size) {

[7471] Fix | Delete

let n = 0;

[7472] Fix | Delete

for (let i = 0; i <= size; i++) {

[7473] Fix | Delete

n = n << 8 | a[i];

[7474] Fix | Delete

}

[7475] Fix | Delete

return n >>> 0;

[7476] Fix | Delete

}

[7477] Fix | Delete

function hexToStr(a, size) {

[7478] Fix | Delete

if (size === 1) {

[7479] Fix | Delete

return String.fromCharCode(a[0], a[1]);

[7480] Fix | Delete

}

[7481] Fix | Delete

if (size === 3) {

[7482] Fix | Delete

return String.fromCharCode(a[0], a[1], a[2], a[3]);

[7483] Fix | Delete

}

[7484] Fix | Delete

return String.fromCharCode(...a.subarray(0, size + 1));

[7485] Fix | Delete

}

[7486] Fix | Delete

function addHex(a, b, size) {

[7487] Fix | Delete

let c = 0;

[7488] Fix | Delete

for (let i = size; i >= 0; i--) {

[7489] Fix | Delete

c += a[i] + b[i];

[7490] Fix | Delete

a[i] = c & 255;

[7491] Fix | Delete

c >>= 8;

[7492] Fix | Delete

}

[7493] Fix | Delete

}

[7494] Fix | Delete

function incHex(a, size) {

[7495] Fix | Delete

let c = 1;

[7496] Fix | Delete

for (let i = size; i >= 0 && c > 0; i--) {

[7497] Fix | Delete

c += a[i];

[7498] Fix | Delete

a[i] = c & 255;

[7499] Fix | Delete