dynamic-qris
Version:
Convert static QRIS to dynamic QRIS
1,503 lines (1,498 loc) • 1.38 MB
JavaScript
// @bun
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getProtoOf = Object.getPrototypeOf;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod[key],
enumerable: true
});
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
// node_modules/omggif/omggif.js
var require_omggif = __commonJS((exports) => {
var GifWriter = function(buf, width, height, gopts) {
var p = 0;
var gopts = gopts === undefined ? {} : gopts;
var loop_count = gopts.loop === undefined ? null : gopts.loop;
var global_palette = gopts.palette === undefined ? null : gopts.palette;
if (width <= 0 || height <= 0 || width > 65535 || height > 65535)
throw new Error("Width/Height invalid.");
function check_palette_and_num_colors(palette2) {
var num_colors = palette2.length;
if (num_colors < 2 || num_colors > 256 || num_colors & num_colors - 1) {
throw new Error("Invalid code/color length, must be power of 2 and 2 .. 256.");
}
return num_colors;
}
buf[p++] = 71;
buf[p++] = 73;
buf[p++] = 70;
buf[p++] = 56;
buf[p++] = 57;
buf[p++] = 97;
var gp_num_colors_pow2 = 0;
var background = 0;
if (global_palette !== null) {
var gp_num_colors = check_palette_and_num_colors(global_palette);
while (gp_num_colors >>= 1)
++gp_num_colors_pow2;
gp_num_colors = 1 << gp_num_colors_pow2;
--gp_num_colors_pow2;
if (gopts.background !== undefined) {
background = gopts.background;
if (background >= gp_num_colors)
throw new Error("Background index out of range.");
if (background === 0)
throw new Error("Background index explicitly passed as 0.");
}
}
buf[p++] = width & 255;
buf[p++] = width >> 8 & 255;
buf[p++] = height & 255;
buf[p++] = height >> 8 & 255;
buf[p++] = (global_palette !== null ? 128 : 0) | gp_num_colors_pow2;
buf[p++] = background;
buf[p++] = 0;
if (global_palette !== null) {
for (var i = 0, il = global_palette.length;i < il; ++i) {
var rgb = global_palette[i];
buf[p++] = rgb >> 16 & 255;
buf[p++] = rgb >> 8 & 255;
buf[p++] = rgb & 255;
}
}
if (loop_count !== null) {
if (loop_count < 0 || loop_count > 65535)
throw new Error("Loop count invalid.");
buf[p++] = 33;
buf[p++] = 255;
buf[p++] = 11;
buf[p++] = 78;
buf[p++] = 69;
buf[p++] = 84;
buf[p++] = 83;
buf[p++] = 67;
buf[p++] = 65;
buf[p++] = 80;
buf[p++] = 69;
buf[p++] = 50;
buf[p++] = 46;
buf[p++] = 48;
buf[p++] = 3;
buf[p++] = 1;
buf[p++] = loop_count & 255;
buf[p++] = loop_count >> 8 & 255;
buf[p++] = 0;
}
var ended = false;
this.addFrame = function(x, y, w, h, indexed_pixels, opts) {
if (ended === true) {
--p;
ended = false;
}
opts = opts === undefined ? {} : opts;
if (x < 0 || y < 0 || x > 65535 || y > 65535)
throw new Error("x/y invalid.");
if (w <= 0 || h <= 0 || w > 65535 || h > 65535)
throw new Error("Width/Height invalid.");
if (indexed_pixels.length < w * h)
throw new Error("Not enough pixels for the frame size.");
var using_local_palette = true;
var palette2 = opts.palette;
if (palette2 === undefined || palette2 === null) {
using_local_palette = false;
palette2 = global_palette;
}
if (palette2 === undefined || palette2 === null)
throw new Error("Must supply either a local or global palette.");
var num_colors = check_palette_and_num_colors(palette2);
var min_code_size = 0;
while (num_colors >>= 1)
++min_code_size;
num_colors = 1 << min_code_size;
var delay = opts.delay === undefined ? 0 : opts.delay;
var disposal = opts.disposal === undefined ? 0 : opts.disposal;
if (disposal < 0 || disposal > 3)
throw new Error("Disposal out of range.");
var use_transparency = false;
var transparent_index = 0;
if (opts.transparent !== undefined && opts.transparent !== null) {
use_transparency = true;
transparent_index = opts.transparent;
if (transparent_index < 0 || transparent_index >= num_colors)
throw new Error("Transparent color index.");
}
if (disposal !== 0 || use_transparency || delay !== 0) {
buf[p++] = 33;
buf[p++] = 249;
buf[p++] = 4;
buf[p++] = disposal << 2 | (use_transparency === true ? 1 : 0);
buf[p++] = delay & 255;
buf[p++] = delay >> 8 & 255;
buf[p++] = transparent_index;
buf[p++] = 0;
}
buf[p++] = 44;
buf[p++] = x & 255;
buf[p++] = x >> 8 & 255;
buf[p++] = y & 255;
buf[p++] = y >> 8 & 255;
buf[p++] = w & 255;
buf[p++] = w >> 8 & 255;
buf[p++] = h & 255;
buf[p++] = h >> 8 & 255;
buf[p++] = using_local_palette === true ? 128 | min_code_size - 1 : 0;
if (using_local_palette === true) {
for (var i2 = 0, il2 = palette2.length;i2 < il2; ++i2) {
var rgb2 = palette2[i2];
buf[p++] = rgb2 >> 16 & 255;
buf[p++] = rgb2 >> 8 & 255;
buf[p++] = rgb2 & 255;
}
}
p = GifWriterOutputLZWCodeStream(buf, p, min_code_size < 2 ? 2 : min_code_size, indexed_pixels);
return p;
};
this.end = function() {
if (ended === false) {
buf[p++] = 59;
ended = true;
}
return p;
};
this.getOutputBuffer = function() {
return buf;
};
this.setOutputBuffer = function(v) {
buf = v;
};
this.getOutputBufferPosition = function() {
return p;
};
this.setOutputBufferPosition = function(v) {
p = v;
};
};
var GifWriterOutputLZWCodeStream = function(buf, p, min_code_size, index_stream) {
buf[p++] = min_code_size;
var cur_subblock = p++;
var clear_code = 1 << min_code_size;
var code_mask = clear_code - 1;
var eoi_code = clear_code + 1;
var next_code = eoi_code + 1;
var cur_code_size = min_code_size + 1;
var cur_shift = 0;
var cur = 0;
function emit_bytes_to_buffer(bit_block_size) {
while (cur_shift >= bit_block_size) {
buf[p++] = cur & 255;
cur >>= 8;
cur_shift -= 8;
if (p === cur_subblock + 256) {
buf[cur_subblock] = 255;
cur_subblock = p++;
}
}
}
function emit_code(c) {
cur |= c << cur_shift;
cur_shift += cur_code_size;
emit_bytes_to_buffer(8);
}
var ib_code = index_stream[0] & code_mask;
var code_table = {};
emit_code(clear_code);
for (var i = 1, il = index_stream.length;i < il; ++i) {
var k = index_stream[i] & code_mask;
var cur_key = ib_code << 8 | k;
var cur_code = code_table[cur_key];
if (cur_code === undefined) {
cur |= ib_code << cur_shift;
cur_shift += cur_code_size;
while (cur_shift >= 8) {
buf[p++] = cur & 255;
cur >>= 8;
cur_shift -= 8;
if (p === cur_subblock + 256) {
buf[cur_subblock] = 255;
cur_subblock = p++;
}
}
if (next_code === 4096) {
emit_code(clear_code);
next_code = eoi_code + 1;
cur_code_size = min_code_size + 1;
code_table = {};
} else {
if (next_code >= 1 << cur_code_size)
++cur_code_size;
code_table[cur_key] = next_code++;
}
ib_code = k;
} else {
ib_code = cur_code;
}
}
emit_code(ib_code);
emit_code(eoi_code);
emit_bytes_to_buffer(1);
if (cur_subblock + 1 === p) {
buf[cur_subblock] = 0;
} else {
buf[cur_subblock] = p - cur_subblock - 1;
buf[p++] = 0;
}
return p;
};
var GifReader = function(buf) {
var p = 0;
if (buf[p++] !== 71 || buf[p++] !== 73 || buf[p++] !== 70 || buf[p++] !== 56 || (buf[p++] + 1 & 253) !== 56 || buf[p++] !== 97) {
throw new Error("Invalid GIF 87a/89a header.");
}
var width = buf[p++] | buf[p++] << 8;
var height = buf[p++] | buf[p++] << 8;
var pf0 = buf[p++];
var global_palette_flag = pf0 >> 7;
var num_global_colors_pow2 = pf0 & 7;
var num_global_colors = 1 << num_global_colors_pow2 + 1;
var background = buf[p++];
buf[p++];
var global_palette_offset = null;
var global_palette_size = null;
if (global_palette_flag) {
global_palette_offset = p;
global_palette_size = num_global_colors;
p += num_global_colors * 3;
}
var no_eof = true;
var frames = [];
var delay = 0;
var transparent_index = null;
var disposal = 0;
var loop_count = null;
this.width = width;
this.height = height;
while (no_eof && p < buf.length) {
switch (buf[p++]) {
case 33:
switch (buf[p++]) {
case 255:
if (buf[p] !== 11 || buf[p + 1] == 78 && buf[p + 2] == 69 && buf[p + 3] == 84 && buf[p + 4] == 83 && buf[p + 5] == 67 && buf[p + 6] == 65 && buf[p + 7] == 80 && buf[p + 8] == 69 && buf[p + 9] == 50 && buf[p + 10] == 46 && buf[p + 11] == 48 && buf[p + 12] == 3 && buf[p + 13] == 1 && buf[p + 16] == 0) {
p += 14;
loop_count = buf[p++] | buf[p++] << 8;
p++;
} else {
p += 12;
while (true) {
var block_size = buf[p++];
if (!(block_size >= 0))
throw Error("Invalid block size");
if (block_size === 0)
break;
p += block_size;
}
}
break;
case 249:
if (buf[p++] !== 4 || buf[p + 4] !== 0)
throw new Error("Invalid graphics extension block.");
var pf1 = buf[p++];
delay = buf[p++] | buf[p++] << 8;
transparent_index = buf[p++];
if ((pf1 & 1) === 0)
transparent_index = null;
disposal = pf1 >> 2 & 7;
p++;
break;
case 254:
while (true) {
var block_size = buf[p++];
if (!(block_size >= 0))
throw Error("Invalid block size");
if (block_size === 0)
break;
p += block_size;
}
break;
default:
throw new Error("Unknown graphic control label: 0x" + buf[p - 1].toString(16));
}
break;
case 44:
var x = buf[p++] | buf[p++] << 8;
var y = buf[p++] | buf[p++] << 8;
var w = buf[p++] | buf[p++] << 8;
var h = buf[p++] | buf[p++] << 8;
var pf2 = buf[p++];
var local_palette_flag = pf2 >> 7;
var interlace_flag = pf2 >> 6 & 1;
var num_local_colors_pow2 = pf2 & 7;
var num_local_colors = 1 << num_local_colors_pow2 + 1;
var palette_offset = global_palette_offset;
var palette_size = global_palette_size;
var has_local_palette = false;
if (local_palette_flag) {
var has_local_palette = true;
palette_offset = p;
palette_size = num_local_colors;
p += num_local_colors * 3;
}
var data_offset = p;
p++;
while (true) {
var block_size = buf[p++];
if (!(block_size >= 0))
throw Error("Invalid block size");
if (block_size === 0)
break;
p += block_size;
}
frames.push({
x,
y,
width: w,
height: h,
has_local_palette,
palette_offset,
palette_size,
data_offset,
data_length: p - data_offset,
transparent_index,
interlaced: !!interlace_flag,
delay,
disposal
});
break;
case 59:
no_eof = false;
break;
default:
throw new Error("Unknown gif block: 0x" + buf[p - 1].toString(16));
break;
}
}
this.numFrames = function() {
return frames.length;
};
this.loopCount = function() {
return loop_count;
};
this.frameInfo = function(frame_num) {
if (frame_num < 0 || frame_num >= frames.length)
throw new Error("Frame index out of range.");
return frames[frame_num];
};
this.decodeAndBlitFrameBGRA = function(frame_num, pixels) {
var frame = this.frameInfo(frame_num);
var num_pixels = frame.width * frame.height;
var index_stream = new Uint8Array(num_pixels);
GifReaderLZWOutputIndexStream(buf, frame.data_offset, index_stream, num_pixels);
var palette_offset2 = frame.palette_offset;
var trans = frame.transparent_index;
if (trans === null)
trans = 256;
var framewidth = frame.width;
var framestride = width - framewidth;
var xleft = framewidth;
var opbeg = (frame.y * width + frame.x) * 4;
var opend = ((frame.y + frame.height) * width + frame.x) * 4;
var op = opbeg;
var scanstride = framestride * 4;
if (frame.interlaced === true) {
scanstride += width * 4 * 7;
}
var interlaceskip = 8;
for (var i = 0, il = index_stream.length;i < il; ++i) {
var index = index_stream[i];
if (xleft === 0) {
op += scanstride;
xleft = framewidth;
if (op >= opend) {
scanstride = framestride * 4 + width * 4 * (interlaceskip - 1);
op = opbeg + (framewidth + framestride) * (interlaceskip << 1);
interlaceskip >>= 1;
}
}
if (index === trans) {
op += 4;
} else {
var r = buf[palette_offset2 + index * 3];
var g = buf[palette_offset2 + index * 3 + 1];
var b = buf[palette_offset2 + index * 3 + 2];
pixels[op++] = b;
pixels[op++] = g;
pixels[op++] = r;
pixels[op++] = 255;
}
--xleft;
}
};
this.decodeAndBlitFrameRGBA = function(frame_num, pixels) {
var frame = this.frameInfo(frame_num);
var num_pixels = frame.width * frame.height;
var index_stream = new Uint8Array(num_pixels);
GifReaderLZWOutputIndexStream(buf, frame.data_offset, index_stream, num_pixels);
var palette_offset2 = frame.palette_offset;
var trans = frame.transparent_index;
if (trans === null)
trans = 256;
var framewidth = frame.width;
var framestride = width - framewidth;
var xleft = framewidth;
var opbeg = (frame.y * width + frame.x) * 4;
var opend = ((frame.y + frame.height) * width + frame.x) * 4;
var op = opbeg;
var scanstride = framestride * 4;
if (frame.interlaced === true) {
scanstride += width * 4 * 7;
}
var interlaceskip = 8;
for (var i = 0, il = index_stream.length;i < il; ++i) {
var index = index_stream[i];
if (xleft === 0) {
op += scanstride;
xleft = framewidth;
if (op >= opend) {
scanstride = framestride * 4 + width * 4 * (interlaceskip - 1);
op = opbeg + (framewidth + framestride) * (interlaceskip << 1);
interlaceskip >>= 1;
}
}
if (index === trans) {
op += 4;
} else {
var r = buf[palette_offset2 + index * 3];
var g = buf[palette_offset2 + index * 3 + 1];
var b = buf[palette_offset2 + index * 3 + 2];
pixels[op++] = r;
pixels[op++] = g;
pixels[op++] = b;
pixels[op++] = 255;
}
--xleft;
}
};
};
var GifReaderLZWOutputIndexStream = function(code_stream, p, output, output_length) {
var min_code_size = code_stream[p++];
var clear_code = 1 << min_code_size;
var eoi_code = clear_code + 1;
var next_code = eoi_code + 1;
var cur_code_size = min_code_size + 1;
var code_mask = (1 << cur_code_size) - 1;
var cur_shift = 0;
var cur = 0;
var op = 0;
var subblock_size = code_stream[p++];
var code_table = new Int32Array(4096);
var prev_code = null;
while (true) {
while (cur_shift < 16) {
if (subblock_size === 0)
break;
cur |= code_stream[p++] << cur_shift;
cur_shift += 8;
if (subblock_size === 1) {
subblock_size = code_stream[p++];
} else {
--subblock_size;
}
}
if (cur_shift < cur_code_size)
break;
var code = cur & code_mask;
cur >>= cur_code_size;
cur_shift -= cur_code_size;
if (code === clear_code) {
next_code = eoi_code + 1;
cur_code_size = min_code_size + 1;
code_mask = (1 << cur_code_size) - 1;
prev_code = null;
continue;
} else if (code === eoi_code) {
break;
}
var chase_code = code < next_code ? code : prev_code;
var chase_length = 0;
var chase = chase_code;
while (chase > clear_code) {
chase = code_table[chase] >> 8;
++chase_length;
}
var k = chase;
var op_end = op + chase_length + (chase_code !== code ? 1 : 0);
if (op_end > output_length) {
console.log("Warning, gif stream longer than expected.");
return;
}
output[op++] = k;
op += chase_length;
var b = op;
if (chase_code !== code)
output[op++] = k;
chase = chase_code;
while (chase_length--) {
chase = code_table[chase];
output[--b] = chase & 255;
chase >>= 8;
}
if (prev_code !== null && next_code < 4096) {
code_table[next_code++] = prev_code << 8 | k;
if (next_code >= code_mask + 1 && cur_code_size < 12) {
++cur_code_size;
code_mask = code_mask << 1 | 1;
}
}
prev_code = code;
}
if (op !== output_length) {
console.log("Warning, gif stream shorter than expected.");
}
return output;
};
try {
exports.GifWriter = GifWriter;
exports.GifReader = GifReader;
} catch (e) {
}
});
// node_modules/gifwrap/src/bitmapimage.js
var require_bitmapimage = __commonJS((exports, module) => {
class BitmapImage {
constructor(...args) {
if (args.length === 0) {
throw new Error("constructor requires parameters");
}
const firstArg = args[0];
if (firstArg !== null && typeof firstArg === "object") {
if (firstArg instanceof BitmapImage) {
const sourceBitmap = firstArg.bitmap;
this.bitmap = {
width: sourceBitmap.width,
height: sourceBitmap.height,
data: new Buffer(sourceBitmap.width * sourceBitmap.height * 4)
};
sourceBitmap.data.copy(this.bitmap.data);
} else if (firstArg.width && firstArg.height && firstArg.data) {
this.bitmap = firstArg;
} else {
throw new Error("unrecognized constructor parameters");
}
} else if (typeof firstArg === "number" && typeof args[1] === "number") {
const width = firstArg;
const height = args[1];
const thirdArg = args[2];
this.bitmap = { width, height };
if (Buffer.isBuffer(thirdArg)) {
this.bitmap.data = thirdArg;
} else {
this.bitmap.data = new Buffer(width * height * 4);
if (typeof thirdArg === "number") {
this.fillRGBA(thirdArg);
}
}
} else {
throw new Error("unrecognized constructor parameters");
}
}
blit(toImage, toX, toY, fromX, fromY, fromWidth, fromHeight) {
if (fromX + fromWidth > this.bitmap.width) {
throw new Error("copy exceeds width of source bitmap");
}
if (toX + fromWidth > toImage.bitmap.width) {
throw new Error("copy exceeds width of target bitmap");
}
if (fromY + fromHeight > this.bitmap.height) {
throw new Error("copy exceeds height of source bitmap");
}
if (toY + fromHeight > toImage.bitmap.height) {
throw new Erro("copy exceeds height of target bitmap");
}
const sourceBuf = this.bitmap.data;
const targetBuf = toImage.bitmap.data;
const sourceByteWidth = this.bitmap.width * 4;
const targetByteWidth = toImage.bitmap.width * 4;
const copyByteWidth = fromWidth * 4;
let si = fromY * sourceByteWidth + fromX * 4;
let ti = toY * targetByteWidth + toX * 4;
while (--fromHeight >= 0) {
sourceBuf.copy(targetBuf, ti, si, si + copyByteWidth);
si += sourceByteWidth;
ti += targetByteWidth;
}
return this;
}
fillRGBA(rgba) {
const buf = this.bitmap.data;
const bufByteWidth = this.bitmap.height * 4;
let bi = 0;
while (bi < bufByteWidth) {
buf.writeUInt32BE(rgba, bi);
bi += 4;
}
while (bi < buf.length) {
buf.copy(buf, bi, 0, bufByteWidth);
bi += bufByteWidth;
}
return this;
}
getRGBA(x, y) {
const bi = (y * this.bitmap.width + x) * 4;
return this.bitmap.data.readUInt32BE(bi);
}
getRGBASet() {
const rgbaSet = new Set;
const buf = this.bitmap.data;
for (let bi = 0;bi < buf.length; bi += 4) {
rgbaSet.add(buf.readUInt32BE(bi, true));
}
return rgbaSet;
}
greyscale() {
const buf = this.bitmap.data;
this.scan(0, 0, this.bitmap.width, this.bitmap.height, (x, y, idx) => {
const grey = Math.round(0.299 * buf[idx] + 0.587 * buf[idx + 1] + 0.114 * buf[idx + 2]);
buf[idx] = grey;
buf[idx + 1] = grey;
buf[idx + 2] = grey;
});
return this;
}
reframe(xOffset, yOffset, width, height, fillRGBA) {
const cropX = xOffset < 0 ? 0 : xOffset;
const cropY = yOffset < 0 ? 0 : yOffset;
const cropWidth = width + cropX > this.bitmap.width ? this.bitmap.width - cropX : width;
const cropHeight = height + cropY > this.bitmap.height ? this.bitmap.height - cropY : height;
const newX = xOffset < 0 ? -xOffset : 0;
const newY = yOffset < 0 ? -yOffset : 0;
let image2;
if (fillRGBA === undefined) {
if (cropX !== xOffset || cropY != yOffset || cropWidth !== width || cropHeight !== height) {
throw new GifError(`fillRGBA required for this reframing`);
}
image2 = new BitmapImage(width, height);
} else {
image2 = new BitmapImage(width, height, fillRGBA);
}
this.blit(image2, newX, newY, cropX, cropY, cropWidth, cropHeight);
this.bitmap = image2.bitmap;
return this;
}
scale(factor) {
if (factor === 1) {
return;
}
if (!Number.isInteger(factor) || factor < 1) {
throw new Error("the scale must be an integer >= 1");
}
const sourceWidth = this.bitmap.width;
const sourceHeight = this.bitmap.height;
const destByteWidth = sourceWidth * factor * 4;
const sourceBuf = this.bitmap.data;
const destBuf = new Buffer(sourceHeight * destByteWidth * factor);
let sourceIndex = 0;
let priorDestRowIndex;
let destIndex = 0;
for (let y = 0;y < sourceHeight; ++y) {
priorDestRowIndex = destIndex;
for (let x = 0;x < sourceWidth; ++x) {
const color = sourceBuf.readUInt32BE(sourceIndex, true);
for (let cx = 0;cx < factor; ++cx) {
destBuf.writeUInt32BE(color, destIndex);
destIndex += 4;
}
sourceIndex += 4;
}
for (let cy = 1;cy < factor; ++cy) {
destBuf.copy(destBuf, destIndex, priorDestRowIndex, destIndex);
destIndex += destByteWidth;
priorDestRowIndex += destByteWidth;
}
}
this.bitmap = {
width: sourceWidth * factor,
height: sourceHeight * factor,
data: destBuf
};
return this;
}
scanAllCoords(scanHandler) {
const width = this.bitmap.width;
const bufferLength = this.bitmap.data.length;
let x = 0;
let y = 0;
for (let bi = 0;bi < bufferLength; bi += 4) {
scanHandler(x, y, bi);
if (++x === width) {
x = 0;
++y;
}
}
}
scanAllIndexes(scanHandler) {
const bufferLength = this.bitmap.data.length;
for (let bi = 0;bi < bufferLength; bi += 4) {
scanHandler(bi);
}
}
}
module.exports = BitmapImage;
});
// node_modules/gifwrap/src/gif.js
var require_gif = __commonJS((exports) => {
class Gif {
constructor(buffer, frames, spec) {
this.width = spec.width;
this.height = spec.height;
this.loops = spec.loops;
this.usesTransparency = spec.usesTransparency;
this.colorScope = spec.colorScope;
this.frames = frames;
this.buffer = buffer;
}
}
Gif.GlobalColorsPreferred = 0;
Gif.GlobalColorsOnly = 1;
Gif.LocalColorsOnly = 2;
class GifError2 extends Error {
constructor(messageOrError) {
super(messageOrError);
if (messageOrError instanceof Error) {
this.stack = "Gif" + messageOrError.stack;
}
}
}
exports.Gif = Gif;
exports.GifError = GifError2;
});
// node_modules/image-q/dist/cjs/image-q.cjs
var require_image_q = __commonJS((exports, module) => {
var correctGamma = function(n) {
return n > 0.04045 ? ((n + 0.055) / 1.055) ** 2.4 : n / 12.92;
};
var rgb2xyz = function(r, g, b) {
r = correctGamma(r / 255);
g = correctGamma(g / 255);
b = correctGamma(b / 255);
return {
x: r * 0.4124 + g * 0.3576 + b * 0.1805,
y: r * 0.2126 + g * 0.7152 + b * 0.0722,
z: r * 0.0193 + g * 0.1192 + b * 0.9505
};
};
var degrees2radians = function(n) {
return n * (Math.PI / 180);
};
var max3 = function(a, b, c) {
let m = a;
if (m < b)
m = b;
if (m < c)
m = c;
return m;
};
var min3 = function(a, b, c) {
let m = a;
if (m > b)
m = b;
if (m > c)
m = c;
return m;
};
var intInRange = function(value, low, high) {
if (value > high)
value = high;
if (value < low)
value = low;
return value | 0;
};
var inRange0to255Rounded = function(n) {
n = Math.round(n);
if (n > 255)
n = 255;
else if (n < 0)
n = 0;
return n;
};
var inRange0to255 = function(n) {
if (n > 255)
n = 255;
else if (n < 0)
n = 0;
return n;
};
var stableSort = function(arrayToSort, callback) {
const type = typeof arrayToSort[0];
let sorted;
if (type === "number" || type === "string") {
const ord = Object.create(null);
for (let i = 0, l = arrayToSort.length;i < l; i++) {
const val = arrayToSort[i];
if (ord[val] || ord[val] === 0)
continue;
ord[val] = i;
}
sorted = arrayToSort.sort((a, b) => callback(a, b) || ord[a] - ord[b]);
} else {
const ord2 = arrayToSort.slice(0);
sorted = arrayToSort.sort((a, b) => callback(a, b) || ord2.indexOf(a) - ord2.indexOf(b));
}
return sorted;
};
var rgb2hsl = function(r, g, b) {
const min = min3(r, g, b);
const max = max3(r, g, b);
const delta = max - min;
const l = (min + max) / 510;
let s = 0;
if (l > 0 && l < 1)
s = delta / (l < 0.5 ? max + min : 510 - max - min);
let h = 0;
if (delta > 0) {
if (max === r) {
h = (g - b) / delta;
} else if (max === g) {
h = 2 + (b - r) / delta;
} else {
h = 4 + (r - g) / delta;
}
h *= 60;
if (h < 0)
h += 360;
}
return { h, s, l };
};
var pivot = function(n) {
return n > 0.008856 ? n ** (1 / 3) : 7.787 * n + 16 / 116;
};
var xyz2lab = function(x2, y2, z) {
x2 = pivot(x2 / refX);
y2 = pivot(y2 / refY);
z = pivot(z / refZ);
if (116 * y2 - 16 < 0)
throw new Error("xxx");
return {
L: Math.max(0, 116 * y2 - 16),
a: 500 * (x2 - y2),
b: 200 * (y2 - z)
};
};
var rgb2lab = function(r, g, b) {
const xyz = rgb2xyz(r, g, b);
return xyz2lab(xyz.x, xyz.y, xyz.z);
};
var pivot2 = function(n) {
return n > 0.206893034 ? n ** 3 : (n - 16 / 116) / 7.787;
};
var lab2xyz = function(L, a, b) {
const y2 = (L + 16) / 116;
const x2 = a / 500 + y2;
const z = y2 - b / 200;
return {
x: refX2 * pivot2(x2),
y: refY2 * pivot2(y2),
z: refZ2 * pivot2(z)
};
};
var correctGamma2 = function(n) {
return n > 0.0031308 ? 1.055 * n ** (1 / 2.4) - 0.055 : 12.92 * n;
};
var xyz2rgb = function(x2, y2, z) {
const r = correctGamma2(x2 * 3.2406 + y2 * -1.5372 + z * -0.4986);
const g = correctGamma2(x2 * -0.9689 + y2 * 1.8758 + z * 0.0415);
const b = correctGamma2(x2 * 0.0557 + y2 * -0.204 + z * 1.057);
return {
r: inRange0to255Rounded(r * 255),
g: inRange0to255Rounded(g * 255),
b: inRange0to255Rounded(b * 255)
};
};
var lab2rgb = function(L, a, b) {
const xyz = lab2xyz(L, a, b);
return xyz2rgb(xyz.x, xyz.y, xyz.z);
};
var hueGroup = function(hue, segmentsNumber) {
const maxHue = 360;
const seg = maxHue / segmentsNumber;
const half = seg / 2;
for (let i = 1, mid = seg - half;i < segmentsNumber; i++, mid += seg) {
if (hue >= mid && hue < mid + seg)
return i;
}
return 0;
};
var createArray1D = function(dimension1) {
const a = [];
for (let k = 0;k < dimension1; k++) {
a[k] = 0;
}
return a;
};
var createArray4D = function(dimension1, dimension2, dimension3, dimension4) {
const a = new Array(dimension1);
for (let i = 0;i < dimension1; i++) {
a[i] = new Array(dimension2);
for (let j = 0;j < dimension2; j++) {
a[i][j] = new Array(dimension3);
for (let k = 0;k < dimension3; k++) {
a[i][j][k] = new Array(dimension4);
for (let l = 0;l < dimension4; l++) {
a[i][j][k][l] = 0;
}
}
}
}
return a;
};
var createArray3D = function(dimension1, dimension2, dimension3) {
const a = new Array(dimension1);
for (let i = 0;i < dimension1; i++) {
a[i] = new Array(dimension2);
for (let j = 0;j < dimension2; j++) {
a[i][j] = new Array(dimension3);
for (let k = 0;k < dimension3; k++) {
a[i][j][k] = 0;
}
}
}
return a;
};
var fillArray3D = function(a, dimension1, dimension2, dimension3, value) {
for (let i = 0;i < dimension1; i++) {
a[i] = [];
for (let j = 0;j < dimension2; j++) {
a[i][j] = [];
for (let k = 0;k < dimension3; k++) {
a[i][j][k] = value;
}
}
}
};
var fillArray1D = function(a, dimension1, value) {
for (let i = 0;i < dimension1; i++) {
a[i] = value;
}
};
function* hilbertCurve(width, height, callback) {
const maxBound = Math.max(width, height);
const level = Math.floor(Math.log(maxBound) / Math.log(2) + 1);
const tracker = new ProgressTracker(width * height, 99);
const data = {
width,
height,
level,
callback,
tracker,
index: 0,
x: 0,
y: 0
};
yield* walkHilbert(data, 1);
visit(data, 0);
}
function* walkHilbert(data, direction) {
if (data.level < 1)
return;
if (data.tracker.shouldNotify(data.index)) {
yield { progress: data.tracker.progress };
}
data.level--;
switch (direction) {
case 2:
yield* walkHilbert(data, 1);
visit(data, 3);
yield* walkHilbert(data, 2);
visit(data, 4);
yield* walkHilbert(data, 2);
visit(data, 2);
yield* walkHilbert(data, 4);
break;
case 3:
yield* walkHilbert(data, 4);
visit(data, 2);
yield* walkHilbert(data, 3);
visit(data, 1);
yield* walkHilbert(data, 3);
visit(data, 3);
yield* walkHilbert(data, 1);
break;
case 1:
yield* walkHilbert(data, 2);
visit(data, 4);
yield* walkHilbert(data, 1);
visit(data, 3);
yield* walkHilbert(data, 1);
visit(data, 1);
yield* walkHilbert(data, 3);
break;
case 4:
yield* walkHilbert(data, 3);
visit(data, 1);
yield* walkHilbert(data, 4);
visit(data, 2);
yield* walkHilbert(data, 4);
visit(data, 4);
yield* walkHilbert(data, 2);
break;
default:
break;
}
data.level++;
}
var visit = function(data, direction) {
if (data.x >= 0 && data.x < data.width && data.y >= 0 && data.y < data.height) {
data.callback(data.x, data.y);
data.index++;
}
switch (direction) {
case 2:
data.x--;
break;
case 3:
data.x++;
break;
case 1:
data.y--;
break;
case 4:
data.y++;
break;
}
};
var ssim = function(image1, image2) {
if (image1.getHeight() !== image2.getHeight() || image1.getWidth() !== image2.getWidth()) {
throw new Error("Images have different sizes!");
}
const bitsPerComponent = 8;
const L = (1 << bitsPerComponent) - 1;
const c1 = (K1 * L) ** 2;
const c2 = (K2 * L) ** 2;
let numWindows = 0;
let mssim = 0;
iterate(image1, image2, (lumaValues1, lumaValues2, averageLumaValue1, averageLumaValue2) => {
let sigxy = 0;
let sigsqx = 0;
let sigsqy = 0;
for (let i = 0;i < lumaValues1.length; i++) {
sigsqx += (lumaValues1[i] - averageLumaValue1) ** 2;
sigsqy += (lumaValues2[i] - averageLumaValue2) ** 2;
sigxy += (lumaValues1[i] - averageLumaValue1) * (lumaValues2[i] - averageLumaValue2);
}
const numPixelsInWin = lumaValues1.length - 1;
sigsqx /= numPixelsInWin;
sigsqy /= numPixelsInWin;
sigxy /= numPixelsInWin;
const numerator = (2 * averageLumaValue1 * averageLumaValue2 + c1) * (2 * sigxy + c2);
const denominator = (averageLumaValue1 ** 2 + averageLumaValue2 ** 2 + c1) * (sigsqx + sigsqy + c2);
const ssim2 = numerator / denominator;
mssim += ssim2;
numWindows++;
});
return mssim / numWindows;
};
var iterate = function(image1, image2, callback) {
const windowSize = 8;
const width = image1.getWidth();
const height = image1.getHeight();
for (let y2 = 0;y2 < height; y2 += windowSize) {
for (let x2 = 0;x2 < width; x2 += windowSize) {
const windowWidth = Math.min(windowSize, width - x2);
const windowHeight = Math.min(windowSize, height - y2);
const lumaValues1 = calculateLumaValuesForWindow(image1, x2, y2, windowWidth, windowHeight);
const lumaValues2 = calculateLumaValuesForWindow(image2, x2, y2, windowWidth, windowHeight);
const averageLuma1 = calculateAverageLuma(lumaValues1);
const averageLuma2 = calculateAverageLuma(lumaValues2);
callback(lumaValues1, lumaValues2, averageLuma1, averageLuma2);
}
}
};
var calculateLumaValuesForWindow = function(image2, x2, y2, width, height) {
const pointArray = image2.getPointArray();
const lumaValues = [];
let counter = 0;
for (let j = y2;j < y2 + height; j++) {
const offset = j * image2.getWidth();
for (let i = x2;i < x2 + width; i++) {
const point = pointArray[offset + i];
lumaValues[counter] = point.r * 0.2126 + point.g * 0.7152 + point.b * 0.0722;
counter++;
}
}
return lumaValues;
};
var calculateAverageLuma = function(lumaValues) {
let sumLuma = 0;
for (const luma of lumaValues) {
sumLuma += luma;
}
return sumLuma / lumaValues.length;
};
var buildPaletteSync = function(images, {
colorDistanceFormula,
paletteQuantization,
colors
} = {}) {
const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
const paletteQuantizer = paletteQuantizationToPaletteQuantizer(distanceCalculator, paletteQuantization, colors);
images.forEach((image2) => paletteQuantizer.sample(image2));
return paletteQuantizer.quantizeSync();
};
async function buildPalette(images, {
colorDistanceFormula,
paletteQuantization,
colors,
onProgress
} = {}) {
return new Promise((resolve2, reject2) => {
const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
const paletteQuantizer = paletteQuantizationToPaletteQuantizer(distanceCalculator, paletteQuantization, colors);
images.forEach((image2) => paletteQuantizer.sample(image2));
let palette2;
const iterator = paletteQuantizer.quantize();
const next = () => {
try {
const result = iterator.next();
if (result.done) {
resolve2(palette2);
} else {
if (result.value.palette)
palette2 = result.value.palette;
if (onProgress)
onProgress(result.value.progress);
setImmediateImpl(next);
}
} catch (error) {
reject2(error);
}
};
setImmediateImpl(next);
});
}
var applyPaletteSync = function(image2, palette2, { colorDistanceFormula, imageQuantization } = {}) {
const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
const imageQuantizer = imageQuantizationToImageQuantizer(distanceCalculator, imageQuantization);
return imageQuantizer.quantizeSync(image2, palette2);
};
async function applyPalette(image2, palette2, {
colorDistanceFormula,
imageQuantization,
onProgress
} = {}) {
return new Promise((resolve2, reject2) => {
const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
const imageQuantizer = imageQuantizationToImageQuantizer(distanceCalculator, imageQuantization);
let outPointContainer;
const iterator = imageQuantizer.quantize(image2, palette2);
const next = () => {
try {
const result = iterator.next();
if (result.done) {
resolve2(outPointContainer);
} else {
if (result.value.pointContainer) {
outPointContainer = result.value.pointContainer;
}
if (onProgress)
onProgress(result.value.progress);
setImmediateImpl(next);
}
} catch (error) {
reject2(error);
}
};
setImmediateImpl(next);
});
}
var colorDistanceFormulaToColorDistance = function(colorDistanceFormula = "euclidean-bt709") {
switch (colorDistanceFormula) {
case "cie94-graphic-arts":
return new CIE94GraphicArts;
case "cie94-textiles":
return new CIE94Textiles;
case "ciede2000":
return new CIEDE2000;
case "color-metric":
return new CMetric;
case "euclidean":
return new Euclidean;
case "euclidean-bt709":
return new EuclideanBT709;
case "euclidean-bt709-noalpha":
return new EuclideanBT709NoAlpha;
case "manhattan":
return new Manhattan;
case "manhattan-bt709":
return new ManhattanBT709;
case "manhattan-nommyde":
return new ManhattanNommyde;
case "pngquant":
return new PNGQuant;
default:
throw new Error(`Unknown colorDistanceFormula ${colorDistanceFormula}`);
}
};
var imageQuantizationToImageQuantizer = function(distanceCalculator, imageQuantization = "floyd-steinberg") {
switch (imageQuantization) {
case "nearest":
return new NearestColor(distanceCalculator);
case "riemersma":
return new ErrorDiffusionRiemersma(distanceCalculator);
case "floyd-steinberg":
return new ErrorDiffusionArray(distanceCalculator, 0);
case "false-floyd-steinberg":
return new ErrorDiffusionArray(distanceCalculator, 1);
case "stucki":
return new ErrorDiffusionArray(distanceCalculator, 2);
case "atkinson":
return new ErrorDiffusionArray(distanceCalculator, 3);
case "jarvis":
return new ErrorDiffusionArray(distanceCalculator, 4);
case "burkes":
return new ErrorDiffusionArray(distanceCalculator, 5);
case "sierra":
return new ErrorDiffusionArray(distanceCalculator, 6);
case "two-sierra":
return new ErrorDiffusionArray(distanceCalculator, 7);
case "sierra-lite":
return new ErrorDiffusionArray(distanceCalculator, 8);
default:
throw new Error(`Unknown imageQuantization ${imageQuantization}`);
}
};
var paletteQuantizationToPaletteQuantizer = function(distanceCalculator, paletteQuantization = "wuquant", colors = 256) {
switch (paletteQuantization) {
case "neuquant":
return new NeuQuant(distanceCalculator, colors);
case "rgbquant":
return new RGBQuant(distanceCalculator, colors);
case "wuquant":
return new WuQuant(distanceCalculator, colors);
case "neuquant-float":
return new NeuQuantFloat(distanceCalculator, colors);
default:
throw new Error(`Unknown paletteQuantization ${paletteQuantization}`);
}
};
var __defProp2 = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2 = Object.getOwnPropertyNames;
var __hasOwnProp2 = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __markAsModule = (target) => __defProp2(target, "__esModule", { value: true });
var __export2 = (target, all) => {
for (var name in all)
__defProp2(target, name, { get: all[name], enumerable: true });
};
var __reExport = (target, module2, copyDefault, desc) => {
if (module2 && typeof module2 === "object" || typeof module2 === "function") {
for (let key of __getOwnPropNames2(module2))
if (!__hasOwnProp2.call(target, key) && (copyDefault || key !== "default"))
__defProp2(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
}
return target;
};
var __toCommonJS = ((cache) => {
return (module2, temp) => {
return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
};
})(typeof WeakMap !== "undefined" ? new WeakMap : 0);
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
var src_exports = {};
__export2(src_exports, {
applyPalette: () => applyPalette,
applyPaletteSync: () => applyPaletteSync,
buildPalette: () => buildPalette,
buildPaletteSync: () => buildPaletteSync,
constants: () => constants_exports,
conversion: () => conversion_exports,
distance: () => distance_exports,
image: () => image_exports,
palette: () => palette_exports,
quality: () => quality_exports,
utils: () => utils_exports
});
var constants_exports = {};
__export2(constants_exports, {
bt709: () => bt709_exports
});
var bt709_exports = {};
__export2(bt709_exports, {
Y: () => Y,
x: () => x,
y: () => y
});
var Y = ((Y2) => {
Y2[Y2["RED"] = 0.2126] = "RED";
Y2[Y2["GREEN"] = 0.7152] = "GREEN";
Y2[Y2["BLUE"] = 0.0722] = "BLUE";
Y2[Y2["WHITE"] = 1] = "WHITE";
return Y2;
})(Y || {});
var x = ((x2) => {
x2[x2["RED"] = 0.64] = "RED";
x2[x2["GREEN"] = 0.3] = "GREEN";
x2[x2["BLUE"] = 0.15] = "BLUE";
x2[x2["WHITE"] = 0.3127] = "WHITE";
return x2;
})(x || {});
var y = ((y2) => {
y2[y2["RED"] = 0.33] = "RED";
y2[y2["GREEN"] = 0.6] = "GREEN";
y2[y2["BLUE"] = 0.06] = "BLUE";
y2[y2["WHITE"] = 0.329] = "WHITE";
return y2;
})(y || {});
var conversion_exports = {};
__export2(conversion_exports, {
lab2rgb: () => lab2rgb,
lab2xyz: () => lab2xyz,
rgb2hsl: () => rgb2hsl,
rgb2lab: () => rgb2lab,
rgb2xyz: () => rgb2xyz,
xyz2lab: () => xyz2lab,
xyz2rgb: () => xyz2rgb
});
var arithmetic_exports = {};
__export2(arithmetic_exports, {
degrees2radians: () => degrees2radians,
inRange0to255: () => inRange0to255,
inRange0to255Rounded: () => inRange0to255Rounded,
intInRange: () => intInRange,
max3: () => max3,
min3: () => min3,
stableSort: () => stableSort
});
var refX = 0.95047;
var refY = 1;
var refZ = 1.08883;
var refX2 = 0.95047;
var refY2 = 1;
var refZ2 = 1.08883;
var distance_exports = {};
__export2(distance_exports, {
AbstractDistanceCalculator: () => AbstractDistanceCalculator,
AbstractEuclidean: () => AbstractEuclidean,
AbstractManhattan: () => AbstractManhattan,
CIE94GraphicArts: () => CIE94GraphicArts,
CIE94Textiles: () => CIE94Textiles,
CIEDE2000: () => CIEDE2000,
CMetric: () => CMetric,
Euclidean: () => Euclidean,
EuclideanBT709: () => EuclideanBT709,
EuclideanBT709NoAlpha: () => EuclideanBT709NoAlpha,
Manhattan: () => Manhattan,
ManhattanBT709: () => ManhattanBT709,
ManhattanNommyde: () => ManhattanNommyde,
PNGQuant: () => PNGQuant
});
var AbstractDistanceCalculator = class {
constructor() {
__publicField(this, "_maxDistance");
__publicField(this, "_whitePoint");
this._setDefaults();
this.setWhitePoint(255, 255, 255, 255);
}
setWhitePoint(r, g, b, a) {
this._whitePoint = {
r: r > 0 ? 255 / r : 0,
g: g > 0 ? 255 / g : 0,
b: b > 0 ? 255 / b : 0,
a: a > 0 ? 255 / a : 0
};
this._maxDistance = this.calculateRaw(r, g, b, a, 0, 0, 0, 0);
}
calculateNormalized(colorA, colorB) {
return this.calculateRaw(colorA.r, colorA.g, colorA.b, colorA.a, colorB.r, colorB.g, colorB.b, colorB.a) / this._maxDistance;
}
};
var AbstractCIE94 = class extends AbstractDistanceCalculator {
calculateRaw(r1, g1, b1, a1, r2, g2, b2, a2) {
const lab1 = rgb2lab(inRange0to255(r1 * this._whitePoint.r), inRange0to255(g1 * this._whitePoint.g), inRange0to255(b1 * this._whitePoint.b));
const lab2 = rgb2lab(inRange0to255(r2 * this._whitePoint.r), inRange0to255(g2 * this._whitePoint.g), inRange0to255(b2 * this._whitePoint.b));
const dL = lab1.L - lab2.L;
const dA = lab1.a - lab2.a;
const dB = lab1.b - lab2.b;
const c1 = Math.sqrt(lab1.a * lab1.a + lab1.b * lab1.b);
const c2 = Math.sqrt(lab2.a * lab2.a + lab2.b * lab2.b);
const dC = c1 - c2;
let deltaH = dA * dA + dB * dB - dC * dC;
deltaH = deltaH < 0 ? 0 : Math.sqrt(deltaH);
const dAlpha = (a2 - a1) * this._whitePoint.a * this._kA;
return Math.sqrt((dL / this._Kl) ** 2 + (dC / (1 + this._K1 * c1)) ** 2 + (deltaH / (1 + this._K2 * c1)) ** 2 + dAlpha ** 2);
}
};
var CIE94Textiles = class extends AbstractCIE94 {
_setDefaults() {
this._Kl = 2;
this._K1 = 0.048;
this._K2 = 0.014;
this._kA = 0.25 * 50 / 255;
}
};
var CIE94GraphicArts = class extends AbstractCIE94 {
_setDefaults() {
this._Kl = 1;
this._K1 = 0.045;
this._K2 = 0.015;
this._kA = 0.25 * 100 / 255;
}
};
var _CIEDE2000 = class extends AbstractDistanceCalculator {
_setDefaults() {
}
static _calculatehp(b, ap) {
const hp = Math.atan2(b, ap);
if (hp >= 0)
return hp;
return hp + _CIEDE2000._deg360InRad;
}
static _calculateRT(ahp, aCp) {
const aCp_to_7 = aCp ** 7;
const R_C = 2 * Math.sqrt(aCp_to_7 / (aCp_to_7 + _CIEDE2000._pow25to7));
const delta_theta = _CIEDE2000._deg30InRad * Math.exp(-(((ahp - _CIEDE2000._deg275InRad) / _CIEDE2000._deg25InRad) ** 2));
return -Math.sin(2 * delta_theta) * R_C;
}
static _calculateT(ahp) {
return 1 - 0.17 * Math.cos(ahp - _CIEDE2000._deg30InRad) + 0.24 * Math.cos(ahp * 2) + 0.32 * Math.cos(ahp * 3 + _CIEDE2000._deg6InRad) - 0.2 * Math.cos(ahp * 4 - _CIEDE2000._deg63InRad);
}
static _calculate_ahp(C1pC2p, h_bar, h1p, h2p) {
const hpSum = h1p + h2p;
if (C1pC2p === 0)
return hpSum;
if (h_bar <= _CIEDE2000._deg180InRad)
return hpSum / 2;
if (hpSum < _CIEDE2000._deg360InRad) {
return (hpSum + _CIEDE2000._deg360InRad) / 2;
}
return (hpSum - _CIEDE2000._deg360InRad) / 2;
}
static _calculate_dHp(C1pC2p, h_bar, h2p, h1p) {
let dhp;
if (C1pC2p === 0) {
dhp = 0;
} else if (h_bar <= _CIEDE2000._deg180InRad) {
dhp = h2p - h1p;
} else if (h2p <= h1p) {
dhp = h2p - h1p + _CIEDE2000._deg360InRad;
} else {
dhp = h2p - h