@openclaw/whatsapp 2026.5.24-beta.2 → 2026.5.26-beta.1

package/node_modules/gifwrap/test/test_properties.js

@@ -1,277 +0,0 @@
-'use strict';
-
-const assert = require('chai').assert;
-const Tools = require('./lib/tools');
-const { Gif, GifFrame, GifCodec, GifError, GifUtil } = require('../src/index');
-
-const defaultCodec = new GifCodec();
-
-describe("Gif width/height", () => {
-
-    it("sets width/height = size of the frames", () => {
-
-        const w = 24, h = 10;
-        const frames = [
-            new GifFrame(w, h),
-            new GifFrame(w, h, 0xffffffff)
-        ];
-        return defaultCodec.encodeGif(frames)
-        .then(gif => {
-            assert.strictEqual(gif.width, w);
-            assert.strictEqual(gif.height, h);
-        });
-    });
-
-    it("sets width/height = size of largest frame", () => {
-
-        const w = 24, h = 10;
-        const frames = [
-            new GifFrame(w - 1, h - 1),
-            new GifFrame(w, h, 0xffffffff)
-        ];
-        return defaultCodec.encodeGif(frames)
-        .then(gif => {
-            assert.strictEqual(gif.width, w);
-            assert.strictEqual(gif.height, h);
-        });
-    });
-
-    it("sets width/height = largest frame boundary", () => {
-
-        const w = 24, h = 10;
-        const frames = [
-            new GifFrame(w - 1, h - 1, {
-                xOffset: 1,
-                yOffset: 1
-            }),
-            new GifFrame(w, h, 0xffffffff)
-        ];
-        return defaultCodec.encodeGif(frames)
-        .then(gif => {
-            assert.strictEqual(gif.width, w);
-            assert.strictEqual(gif.height, h);
-        });
-    });
-});
-
-describe("Gif loop count", () => {
-
-    it("decodes an infinite loop", () => {
-
-        return GifUtil.read(Tools.getGifPath('countConstantDelay0'))
-        .then(gif => {
-
-            assert.strictEqual(gif.loops, 0);
-        });
-    });
-
-    it("decodes a single-pass loop", () => {
-
-        return GifUtil.read(Tools.getGifPath('countConstantDelay1'))
-        .then(gif => {
-
-            assert.strictEqual(gif.loops, 1);
-        });
-    });
-
-    it("decodes a three-pass loop", () => {
-
-        return GifUtil.read(Tools.getGifPath('countConstantDelay3'))
-        .then(gif => {
-
-            assert.strictEqual(gif.loops, 3);
-        });
-    });
-
-    it("encodes an infinite loop", () => {
-
-        return _verifyEncodesLoopCount('countConstantDelay3', 0);
-    });
-
-    it("encodes a single-pass loop", () => {
-
-        return _verifyEncodesLoopCount('countConstantDelay0', 1);
-    });
-
-    it("encodes a three-pass loop", () => {
-
-        return _verifyEncodesLoopCount('countConstantDelay1', 3);
-    });
-});
-
-describe("Gif transparency", () => {
-
-    it("indicates no transparency", () => {
-
-        return GifUtil.read(Tools.getGifPath('twoFrameMultiOpaque'))
-        .then(readGif => {
-
-            assert.strictEqual(readGif.usesTransparency, false);
-            return defaultCodec.encodeGif(readGif.frames);
-        })
-        .then(encodedGif => {
-
-            assert.strictEqual(encodedGif.usesTransparency, false);
-        })
-    });
-
-    it("indicates transparency", () => {
-
-        return GifUtil.read(Tools.getGifPath('threeFrameMonoTrans'))
-        .then(readGif => {
-
-            assert.strictEqual(readGif.usesTransparency, true);
-            return defaultCodec.encodeGif(readGif.frames);
-        })
-        .then(encodedGif => {
-
-            assert.strictEqual(encodedGif.usesTransparency, true);
-        })
-    });
-});
-
-describe("GifFrame x/y-offsets", () => {
-
-    it("accommodates/encodes offsets", () => {
-
-        return GifUtil.read(Tools.getGifPath('count5x7'))
-        .then(readGif => {
-
-            const frames = readGif.frames;
-            assert(frames.length >= 4, "precondition for test");
-            assert.strictEqual(readGif.width, 5);
-            assert.strictEqual(readGif.height, 7);
-            frames.forEach(frame => {
-
-                _verifyFrameOffsets(frame, 0, 0);
-            });
-            frames[1].xOffset = 1;
-            frames[1].yOffset = 2;
-            frames[2].xOffset = 2;
-            frames[2].yOffset = 1;
-            return defaultCodec.encodeGif(frames);
-        })
-        .then(encodedGif => {
-
-            assert.strictEqual(encodedGif.width, 7);
-            assert.strictEqual(encodedGif.height, 9);
-            return defaultCodec.decodeGif(encodedGif.buffer);
-        })
-        .then(decodedGif => {
-
-            assert.strictEqual(decodedGif.width, 7);
-            assert.strictEqual(decodedGif.height, 9);
-            const frames = decodedGif.frames;
-            _verifyFrameOffsets(frames[0], 0, 0);
-            _verifyFrameOffsets(frames[1], 1, 2);
-            _verifyFrameOffsets(frames[2], 2, 1);
-            _verifyFrameOffsets(frames[3], 0, 0);
-        });
-    });
-});
-
-describe("GifFrame delay", () => {
-
-    it("confirms a constant frame-delay GIF", () => {
-
-        return GifUtil.read(Tools.getGifPath('countConstantDelay0'))
-        .then(readGif => {
-
-            readGif.frames.forEach(frame => {
-
-                assert.strictEqual(frame.delayCentisecs, 33);
-            });
-        });
-    });
-
-    it("confirms a variable frame-delay GIF", () => {
-
-        return GifUtil.read(Tools.getGifPath('countIncreasingDelay'))
-        .then(readGif => {
-
-            const frames = readGif.frames;
-            for (let i = 0; i < frames.length; ++i) {
-                assert.strictEqual(frames[i].delayCentisecs, (i + 1)*25);
-            }
-        });
-    });
-
-    it("encodes varying frame delays", () => {
-
-        return GifUtil.read(Tools.getGifPath('countConstantDelay0'))
-        .then(readGif => {
-        
-            const frames = readGif.frames;
-            for (let i = 0; i < frames.length; ++i) {
-                frames[i].delayCentisecs = (i + 1)*25;
-            }
-            return defaultCodec.encodeGif(frames, { loops: readGif.loops });
-        })
-        .then(encodedGif => {
-
-            return defaultCodec.decodeGif(encodedGif.buffer);
-        })
-        .then(decodedGif => {
-
-            const frames = decodedGif.frames;
-            for (let i = 0; i < frames.length; ++i) {
-                assert.strictEqual(frames[i].delayCentisecs, (i + 1)*25);
-            }
-        });
-    });
-});
-
-describe("GifFrame disposal method", () => {
-
-    it("encodes/decodes disposal", () => {
-
-        return GifUtil.read(Tools.getGifPath('countConstantDelay0'))
-        .then(readGif => {
-        
-            const frames = readGif.frames;
-            assert(frames.length >= 4, "precondition for test");
-            frames.forEach(frame => {
-
-                assert.strictEqual(frame.disposalMethod,
-                        GifFrame.DisposeToBackgroundColor);
-            });
-            for (let i = 0; i < 4; ++i) {
-                frames[i].disposalMethod = i;
-            }
-            return defaultCodec.encodeGif(frames, { loops: readGif.loops });
-        })
-        .then(encodedGif => {
-
-            return defaultCodec.decodeGif(encodedGif.buffer);
-        })
-        .then(decodedGif => {
-
-            const frames = decodedGif.frames;
-            for (let i = 0; i < 4; ++i) {
-                assert.strictEqual(frames[i].disposalMethod, i);
-            }
-        });
-    });
-});
-
-function _verifyEncodesLoopCount(sourceFilename, loopCount) {
-    return GifUtil.read(Tools.getGifPath(sourceFilename))
-    .then(readGif => {
-
-        return defaultCodec.encodeGif(readGif.frames, { loops: loopCount });
-    })
-    .then(encodedGif => {
-
-        assert.strictEqual(encodedGif.loops, loopCount);
-        return defaultCodec.decodeGif(encodedGif.buffer);
-    })
-    .then(decodedGif => {
-
-        assert.strictEqual(decodedGif.loops, loopCount);
-    });
-}
-
-function _verifyFrameOffsets(frame, xOffset, yOffset) {
-    assert.strictEqual(frame.xOffset, xOffset);
-    assert.strictEqual(frame.yOffset, yOffset);
-}

package/node_modules/gifwrap/test/test_quantize.js

@@ -1,292 +0,0 @@
-'use strict';
-
-const assert = require('chai').assert;
-const Jimp = require('jimp');
-const Tools = require('./lib/tools');
-const { BitmapImage, GifUtil } = require('../src/index');
-
-describe("graphics color index reduction", () => {
-
-    it("Dekker-quantizes down to 32 colors", () => {
-
-        return _graphicsTest('quantizeDekker', 32);
-    });
-
-    it("Dekker-quantizes down to 256 colors", () => {
-
-        return _graphicsTest('quantizeDekker', 256);
-    });
-
-    it("Sorokin-quantizes down to 32 colors", () => {
-
-        return _graphicsTest('quantizeSorokin', 32);
-    });
-
-    it("Sorokin-quantizes down to 256 colors", () => {
-
-        return _graphicsTest('quantizeSorokin', 256);
-    });
-
-    it("Wu-quantizes down to 32 colors", () => {
-
-        return _graphicsTest('quantizeWu', 32);
-    });
-
-    it("Wu-quantizes down to 256 colors", () => {
-
-        return _graphicsTest('quantizeWu', 256);
-    });
-});
-
-describe("photo color index reduction", () => {
-
-    it("Dekker-quantizes down to 32 colors", () => {
-
-        return _photoTest('quantizeDekker', 32);
-    });
-
-    it("Dekker-quantizes down to 256 colors", () => {
-
-        return _photoTest('quantizeDekker', 256);
-    });
-
-    it("Sorokin-quantizes down to 32 colors", () => {
-
-        return _photoTest('quantizeSorokin', 32);
-    });
-
-    it("Sorokin-quantizes down to 256 colors", () => {
-
-        return _photoTest('quantizeSorokin', 256);
-    });
-
-    it("Wu-quantizes down to 32 colors", () => {
-
-        return _photoTest('quantizeWu', 32);
-    });
-
-    it("Wu-quantizes down to 256 colors", () => {
-
-        return _photoTest('quantizeWu', 256);
-    });
-});
-
-describe("dithering", () => {
-
-    it("FloydSteinberg-dither of Dekker-quantized 256 colors", () => {
-
-        return _ditherTest('quantizeDekker', 256, null, 'FloydSteinberg');
-    });
-
-    it("FloydSteinberg-dither of Sorokin-quantized 256 colors", () => {
-
-        return _ditherTest('quantizeSorokin', 256, 'min-pop', 'FloydSteinberg');
-    });
-
-    it("FloydSteinberg-dither of Wu-quantized 256 colors", () => {
-
-        return _ditherTest('quantizeWu', 256, 5, 'FloydSteinberg');
-    });
-});
-
-describe("reduce colors across a series of images", () => {
-
-    const specialOpaque = 0xffffffff;
-    const specialTransparent = 0;
-
-    it("Dekker-quantizes an opaque image series down to 256 colors", (done) => {
-
-        _seriesTest('quantizeDekker', specialOpaque);
-        done();
-    });
-
-    it("Dekker-quantizes an image series with transparency down to 256 colors", (done) => {
-
-        _seriesTest('quantizeDekker', specialTransparent);
-        done();
-    });
-
-    it("Sorokin-quantizes an opaque image series down to 256 colors", (done) => {
-
-        _seriesTest('quantizeSorokin', specialOpaque);
-        done();
-    });
-
-    it("Sorokin-quantizes an image series with transparency down to 256 colors", (done) => {
-
-        _seriesTest('quantizeSorokin', specialTransparent);
-        done();
-    });
-
-    it("Wu-quantizes an opaque image series down to 256 colors", (done) => {
-
-        _seriesTest('quantizeWu', specialOpaque);
-        done();
-    });
-
-    it("Wu-quantizes an image series with transparency down to 256 colors", (done) => {
-
-        _seriesTest('quantizeWu', specialTransparent);
-        done();
-    });
-});
-
-function _ditherTest(method, maxColors, modifier, ditherAlg) {
-    return _reductionTest("sculptmap.png", false, method, maxColors, modifier, {
-        ditherAlgorithm: ditherAlg
-    });
-}
-
-function _graphicsTest(method, maxColors) {
-    return _reductionTest("sculptmap.png", false, method, maxColors)
-    .then(() => {
-
-        return _reductionTest("rosewithtrans.png", true, method, maxColors);
-    })
-}
-
-function _hasTransparency(colorSet) {
-    for (let rgba of colorSet.values()) {
-        if ((rgba & 0xff) === 0x00) {
-            return true;
-        }
-    }
-    return false;
-}
-
-function _photoTest(method, maxColors) {
-    return _reductionTest("hairstreak.jpg", false, method, maxColors);
-}
-
-function _reductionTest(sourceFile, usesTransparency, method, maxColors, modifier, dither) {
-    const baseFile = sourceFile.substr(0, sourceFile.length - 4);
-    const suffix = method.substr(8);
-    let expectedFile = `quantized/${baseFile}${maxColors}_${suffix}`;
-    if (dither) {
-        expectedFile += '_' + dither.ditherAlgorithm;
-    }
-    expectedFile += '.png';
-    const label = `${method}(${maxColors}) - ${baseFile}`;
-    const writeFile = null; //expectedFile;
-    let work;
-
-    return new Promise((resolve, reject) => {
-        new Jimp(Tools.getFixturePath(sourceFile), (err, manyJimp) => {
-
-            if (err) return reject(err);
-            new Jimp(Tools.getFixturePath(expectedFile), (err, limitedJimp) => {
-
-                if (err) return reject(err);
-                work = new BitmapImage(manyJimp.bitmap);
-
-                const inputColorSet = work.getRGBASet();
-                assert.strictEqual(_hasTransparency(inputColorSet), usesTransparency, label);
-                assert.isAtLeast(inputColorSet.size, maxColors + 1, label);
-
-                if (method === 'quantizeDekker') {
-                    GifUtil[method](work, maxColors, dither);
-                }
-                else {
-                    GifUtil[method](work, maxColors, modifier, dither);
-                }
-
-                const workBuf = work.bitmap.data;
-                const limitedBuf = limitedJimp.bitmap.data;
-                assert.strictEqual(workBuf.length, manyJimp.bitmap.data.length, label);
-                assert.strictEqual(workBuf.compare(limitedBuf), 0, label);
-
-                const outputColorSet = work.getRGBASet();
-                assert.strictEqual(_hasTransparency(outputColorSet), usesTransparency, label);
-                assert.isAtMost(outputColorSet.size, maxColors, label);
-                resolve();
-            });
-        });
-    })
-    .then(() => {
-        if (writeFile) {
-            return _writeJimp(writeFile, work.bitmap);
-        }
-    });
-}
-
-function _seriesTest(method, specialColor) {
-    const images = [];
-    const width = 32, height = 32;
-    const maxColors = 256;
-
-    let image = new BitmapImage(width, height);
-    let buf = image.bitmap.data;
-    let bi = 0;
-    for (let y = 0; y < height; ++y) {
-        for (let x = 0; x < width; ++x) {
-            buf[bi] = x * 8;
-            buf[bi + 1] = y * 8;
-            buf[bi + 3] = 255;
-            bi += 4;
-        }
-    }
-    images.push(image); // 32 * 32 = 1024 colors
-
-    image = new BitmapImage(width, height);
-    buf = image.bitmap.data;
-    bi = 0;
-    for (let y = 0; y < height; ++y) {
-        for (let x = 0; x < width; ++x) {
-            buf[bi] = x * 8 + 4;
-            buf[bi + 1] = y * 8 + 4;
-            buf[bi + 3] = 255;
-            bi += 4;
-        }
-    }
-    images.push(image); // 32 * 32 = 1024 more colors
-
-    image = new BitmapImage(width, height);
-    buf = image.bitmap.data;
-    bi = 0;
-    for (let y = 0; y < height; ++y) {
-        for (let x = 0; x < width; ++x) {
-            if (x < width / 2) {
-                buf.writeUInt32BE(255, bi);
-            }
-            else {
-                buf.writeUInt32BE(specialColor, bi);
-            }
-            bi += 4;
-        }
-    }
-    images.push(image); // 1 more color (white), which should be there
-
-    GifUtil[method](images, maxColors);
-
-    const colorSet = new Set();
-    images.forEach(image => {
-
-        buf = image.bitmap.data;
-        for (let bi = 0; bi < buf.length; bi += 4) {
-            colorSet.add(buf.readUInt32BE(bi, true));
-        }
-    });
-    assert.isAtMost(colorSet.size, maxColors);
-    assert(colorSet.has(specialColor), "has special color");
-}
-
-function _writeJimp(filename, bitmap) {
-
-    const jimp = new Jimp(1, 1);
-    jimp.bitmap = bitmap;
-
-    return new Promise((resolve, reject) => {
-
-        jimp.write(filename, (err) => {
-            if (err) return reject(err);
-            resolve();
-        });
-    }).then(() => {
-
-        console.log(`WROTE ${filename}`);
-    })
-    .catch((err) => {
-
-        console.log(`WRITE FAILED ${err.stack}`);
-    });
-}

package/node_modules/image-q/LICENSE

@@ -1,49 +0,0 @@
-# image-quantization (https://github.com/igor-bezkrovny/image-quantization)
-
-The MIT License (MIT)
-
-Copyright (c) 2015 Igor Bezkrovny
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-# http://members.ozemail.com.au/~dekker/NEUQUANT.HTML
-
-NeuQuant Neural-Net Quantization Algorithm
-------------------------------------------
-
-Copyright (c) 1994 Anthony Dekker
-
-NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See
-"Kohonen neural networks for optimal colour quantization" in "Network:
-Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of
-the algorithm.
-
-Any party obtaining a copy of these files from the author, directly or
-indirectly, is granted, free of charge, a full and unrestricted irrevocable,
-world-wide, paid up, royalty-free, nonexclusive right and license to deal in
-this software and documentation files (the "Software"), including without
-limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons who
-receive copies from any such party to do so, with the only requirement being
-that this copyright notice remain intact.
-
-# https://github.com/leeoniya/RgbQuant.js
-
-Copyright (c) 2015, Leon Sorokin
-All rights reserved. (MIT Licensed)