@ohos-ports/html2canvas-pro 0.0.0-stage → 2.3.2-beta.0

package/dist/lib/css/types/color-spaces/a98.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * A98-RGB related functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertA98rgb = exports.a98FromXYZ = exports.a98Linear2a98 = exports.a982a98Linear = exports.a98Linear2xyz = exports.xyz2a98Linear = void 0;
+const color_utilities_1 = require("../color-utilities");
+const srgb_1 = require("./srgb");
+/**
+ * Convert XYZ to a98 linear
+ *
+ * @param xyz
+ */
+const xyz2a98Linear = (xyz) => {
+    return (0, color_utilities_1.multiplyMatrices)([
+        2.0415879038107465, -0.5650069742788596, -0.34473135077832956, -0.9692436362808795, 1.8759675015077202,
+        0.04155505740717557, 0.013444280632031142, -0.11836239223101838, 1.0151749943912054
+    ], xyz);
+};
+exports.xyz2a98Linear = xyz2a98Linear;
+/**
+ * Convert XYZ to a98 linear
+ *
+ * @param a98
+ */
+const a98Linear2xyz = (a98) => {
+    return (0, color_utilities_1.multiplyMatrices)([
+        0.5766690429101305, 0.1855582379065463, 0.1882286462349947, 0.29734497525053605, 0.6273635662554661,
+        0.0752914584939978, 0.02703136138641234, 0.07068885253582723, 0.9913375368376388
+    ], a98);
+};
+exports.a98Linear2xyz = a98Linear2xyz;
+/**
+ * Convert A98 RGB to rgb linear
+ *
+ * @param rgb
+ */
+const a982a98Linear = (rgb) => {
+    const mapped = rgb.map((c) => {
+        const sign = c < 0 ? -1 : 1, abs = Math.abs(c);
+        return sign * abs ** (563 / 256);
+    });
+    return [mapped[0], mapped[1], mapped[2]];
+};
+exports.a982a98Linear = a982a98Linear;
+/**
+ * Convert A98 RGB Linear to A98
+ *
+ * @param rgb
+ */
+const a98Linear2a98 = (rgb) => {
+    const mapped = rgb.map((c) => {
+        const sign = c < 0 ? -1 : 1, abs = Math.abs(c);
+        return sign * abs ** (256 / 563);
+    });
+    return [mapped[0], mapped[1], mapped[2]];
+};
+exports.a98Linear2a98 = a98Linear2a98;
+/**
+ * Convert XYZ to A98
+ *
+ * @param args
+ */
+const a98FromXYZ = (args) => {
+    const [r, g, b] = (0, exports.a98Linear2a98)((0, exports.xyz2a98Linear)([args[0], args[1], args[2]]));
+    return [r, g, b, args[3]];
+};
+exports.a98FromXYZ = a98FromXYZ;
+/**
+ * Convert A98 to XYZ and Pack
+ *
+ * @param args
+ */
+const convertA98rgb = (args) => {
+    const srgb_linear = (0, srgb_1.xyz2rgbLinear)((0, exports.a98Linear2xyz)((0, exports.a982a98Linear)([args[0], args[1], args[2]])));
+    return (0, color_utilities_1.packSrgbLinear)([srgb_linear[0], srgb_linear[1], srgb_linear[2], args[3]]);
+};
+exports.convertA98rgb = convertA98rgb;

package/dist/lib/css/types/color-spaces/p3.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Display-P3 related functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertP3 = exports.p3FromXYZ = exports.p3ToXYZ = exports.p3Linear2p3 = exports.p32p3Linear = exports.xyzToP3Linear = exports.p3LinearToXyz = void 0;
+const srgb_1 = require("./srgb");
+const color_utilities_1 = require("../color-utilities");
+/**
+ * Convert P3 Linear to xyz
+ *
+ * @param p3l
+ */
+const p3LinearToXyz = (p3l) => {
+    return (0, color_utilities_1.multiplyMatrices)([
+        0.4865709486482162, 0.26566769316909306, 0.1982172852343625, 0.2289745640697488, 0.6917385218365064,
+        0.079286914093745, 0.0, 0.04511338185890264, 1.043944368900976
+    ], p3l);
+};
+exports.p3LinearToXyz = p3LinearToXyz;
+/**
+ * Convert XYZ to P3 Linear
+ *
+ * @param xyz
+ */
+const xyzToP3Linear = (xyz) => {
+    return (0, color_utilities_1.multiplyMatrices)([
+        2.493496911941425, -0.9313836179191239, -0.40271078445071684, -0.8294889695615747, 1.7626640603183463,
+        0.023624685841943577, 0.03584583024378447, -0.07617238926804182, 0.9568845240076872
+    ], xyz);
+};
+exports.xyzToP3Linear = xyzToP3Linear;
+/**
+ * Convert P3 to P3 linear
+ *
+ * @param p3
+ */
+const p32p3Linear = (p3) => {
+    return p3.map((c) => {
+        const sign = c < 0 ? -1 : 1, abs = c * sign;
+        if (abs <= 0.04045) {
+            return c / 12.92;
+        }
+        return sign * ((c + 0.055) / 1.055) ** 2.4 || 0;
+    });
+};
+exports.p32p3Linear = p32p3Linear;
+/**
+ * Convert P3 Linear to P3
+ *
+ * @param p3l
+ */
+const p3Linear2p3 = (p3l) => {
+    return (0, srgb_1.srgbLinear2rgb)(p3l);
+};
+exports.p3Linear2p3 = p3Linear2p3;
+/**
+ * Convert P3 to XYZ
+ *
+ * @param args
+ */
+const p3ToXYZ = (args) => {
+    const p3_linear = (0, exports.p32p3Linear)([args[0], args[1], args[2]]);
+    return (0, exports.p3LinearToXyz)([p3_linear[0], p3_linear[1], p3_linear[2]]);
+};
+exports.p3ToXYZ = p3ToXYZ;
+/**
+ * Convert XYZ to P3
+ *
+ * @param args
+ */
+const p3FromXYZ = (args) => {
+    const [r, g, b] = (0, exports.p3Linear2p3)((0, exports.xyzToP3Linear)([args[0], args[1], args[2]]));
+    return [r, g, b, args[3]];
+};
+exports.p3FromXYZ = p3FromXYZ;
+/**
+ * Convert P3 to SRGB and Pack
+ *
+ * @param args
+ */
+const convertP3 = (args) => {
+    const xyz = (0, exports.p3ToXYZ)([args[0], args[1], args[2]]);
+    return (0, color_utilities_1.packXYZ)([xyz[0], xyz[1], xyz[2], args[3]]);
+};
+exports.convertP3 = convertP3;

package/dist/lib/css/types/color-spaces/pro-photo.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Pro Photo related functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertProPhoto = exports.proPhotoFromXYZ = exports.proPhotoToXYZ = exports.proPhotoLinearToProPhoto = exports.proPhotoToProPhotoLinear = exports.xyzToProPhotoLinear = exports.proPhotoLinearToXyz = void 0;
+const color_utilities_1 = require("../color-utilities");
+/**
+ * Convert linear-light display-p3 to XYZ D65
+ *
+ * @param p3
+ */
+const proPhotoLinearToXyz = (p3) => {
+    return (0, color_utilities_1.multiplyMatrices)([
+        0.7977666449006423, 0.13518129740053308, 0.0313477341283922, 0.2880748288194013, 0.711835234241873,
+        0.00008993693872564, 0.0, 0.0, 0.8251046025104602
+    ], p3);
+};
+exports.proPhotoLinearToXyz = proPhotoLinearToXyz;
+/**
+ * Convert XYZ D65 to linear-light display-p3
+ *
+ * @param xyz
+ */
+const xyzToProPhotoLinear = (xyz) => {
+    return (0, color_utilities_1.multiplyMatrices)([
+        1.3457868816471583, -0.25557208737979464, -0.05110186497554526, -0.5446307051249019, 1.5082477428451468,
+        0.02052744743642139, 0.0, 0.0, 1.2119675456389452
+    ], xyz);
+};
+exports.xyzToProPhotoLinear = xyzToProPhotoLinear;
+/**
+ * Convert Pro-Photo to Pro-Photo Linear
+ *
+ * @param p3
+ */
+const proPhotoToProPhotoLinear = (p3) => {
+    return p3.map((c) => {
+        return c < 16 / 512 ? c / 16 : c ** 1.8;
+    });
+};
+exports.proPhotoToProPhotoLinear = proPhotoToProPhotoLinear;
+/**
+ * Convert Pro-Photo Linear to Pro-Photo
+ *
+ * @param p3
+ */
+const proPhotoLinearToProPhoto = (p3) => {
+    return p3.map((c) => {
+        return c > 1 / 512 ? c ** (1 / 1.8) : c * 16;
+    });
+};
+exports.proPhotoLinearToProPhoto = proPhotoLinearToProPhoto;
+/**
+ * Convert Pro-Photo to XYZ
+ *
+ * @param args
+ */
+const proPhotoToXYZ = (args) => {
+    const prophoto_linear = (0, exports.proPhotoToProPhotoLinear)([args[0], args[1], args[2]]);
+    return (0, color_utilities_1.d50toD65)((0, exports.proPhotoLinearToXyz)([prophoto_linear[0], prophoto_linear[1], prophoto_linear[2]]));
+};
+exports.proPhotoToXYZ = proPhotoToXYZ;
+/**
+ * Convert XYZ to Pro-Photo
+ *
+ * @param args
+ */
+const proPhotoFromXYZ = (args) => {
+    const [r, g, b] = (0, exports.proPhotoLinearToProPhoto)((0, exports.xyzToProPhotoLinear)((0, color_utilities_1.d65toD50)([args[0], args[1], args[2]])));
+    return [r, g, b, args[3]];
+};
+exports.proPhotoFromXYZ = proPhotoFromXYZ;
+/**
+ * Convert Pro-Photo to XYZ and Pack
+ *
+ * @param args
+ */
+const convertProPhoto = (args) => {
+    const xyz = (0, exports.proPhotoToXYZ)([args[0], args[1], args[2]]);
+    return (0, color_utilities_1.packXYZ)([xyz[0], xyz[1], xyz[2], args[3]]);
+};
+exports.convertProPhoto = convertProPhoto;

package/dist/lib/css/types/color-spaces/rec2020.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * REC2020 related functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRec2020 = exports.rec2020FromXYZ = exports.rec2020ToXYZ = exports.xyzToRec2020Linear = exports.rec2020LinearToXyz = exports.rec2020Linear2rec2020 = exports.rec20202rec2020Linear = void 0;
+const color_utilities_1 = require("../color-utilities");
+const _a = 1.09929682680944;
+const _b = 0.018053968510807;
+/**
+ * Convert rec2020 to rec2020 linear
+ *
+ * @param rgb
+ */
+const rec20202rec2020Linear = (rgb) => {
+    return rgb.map(function (c) {
+        return c < _b * 4.5 ? c / 4.5 : Math.pow((c + _a - 1) / _a, 1 / 0.45);
+    });
+};
+exports.rec20202rec2020Linear = rec20202rec2020Linear;
+/**
+ * Convert rec2020 linear to rec2020
+ *
+ * @param rgb
+ */
+const rec2020Linear2rec2020 = (rgb) => {
+    return rgb.map(function (c) {
+        return c >= _b ? _a * Math.pow(c, 0.45) - (_a - 1) : 4.5 * c;
+    });
+};
+exports.rec2020Linear2rec2020 = rec2020Linear2rec2020;
+/**
+ * Convert rec2020 linear to XYZ D65
+ *
+ * @param rec
+ */
+const rec2020LinearToXyz = (rec) => {
+    return (0, color_utilities_1.multiplyMatrices)([
+        0.6369580483012914, 0.14461690358620832, 0.1688809751641721, 0.2627002120112671, 0.6779980715188708,
+        0.05930171646986196, 0.0, 0.028072693049087428, 1.060985057710791
+    ], rec);
+};
+exports.rec2020LinearToXyz = rec2020LinearToXyz;
+/**
+ * Convert XYZ D65 to rec2020 linear
+ *
+ * @param xyz
+ */
+const xyzToRec2020Linear = (xyz) => {
+    return (0, color_utilities_1.multiplyMatrices)([
+        1.716651187971268, -0.355670783776392, -0.25336628137366, -0.666684351832489, 1.616481236634939,
+        0.0157685458139111, 0.017639857445311, -0.042770613257809, 0.942103121235474
+    ], xyz);
+};
+exports.xyzToRec2020Linear = xyzToRec2020Linear;
+/**
+ * Convert Rec2020 to XYZ
+ *
+ * @param args
+ */
+const rec2020ToXYZ = (args) => {
+    const rec2020_linear = (0, exports.rec20202rec2020Linear)([args[0], args[1], args[2]]);
+    return (0, exports.rec2020LinearToXyz)([rec2020_linear[0], rec2020_linear[1], rec2020_linear[2]]);
+};
+exports.rec2020ToXYZ = rec2020ToXYZ;
+/**
+ * Convert XYZ to Rec2020
+ *
+ * @param args
+ */
+const rec2020FromXYZ = (args) => {
+    const [r, g, b] = (0, exports.rec2020Linear2rec2020)((0, exports.xyzToRec2020Linear)([args[0], args[1], args[2]]));
+    return [r, g, b, args[3]];
+};
+exports.rec2020FromXYZ = rec2020FromXYZ;
+/**
+ * Convert Rec2020 to SRGB and Pack
+ *
+ * @param args
+ */
+const convertRec2020 = (args) => {
+    const xyz = (0, exports.rec2020ToXYZ)([args[0], args[1], args[2]]);
+    return (0, color_utilities_1.packXYZ)([xyz[0], xyz[1], xyz[2], args[3]]);
+};
+exports.convertRec2020 = convertRec2020;

package/dist/lib/css/types/color-spaces/srgb.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * SRGB related functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.srgbLinearFromXYZ = exports.srgbFromXYZ = exports.rgb2rgbLinear = exports.srgbLinear2rgb = exports.rgbLinear2xyz = exports.xyz2rgbLinear = void 0;
+const color_math_1 = require("../color-math");
+/**
+ * Convert XYZ to linear-light sRGB
+ *
+ * @param xyz
+ */
+const xyz2rgbLinear = (xyz) => {
+    return (0, color_math_1.multiplyMatrices)([
+        3.2409699419045226, -1.537383177570094, -0.4986107602930034, -0.9692436362808796, 1.8759675015077202,
+        0.04155505740717559, 0.05563007969699366, -0.20397695888897652, 1.0569715142428786
+    ], xyz);
+};
+exports.xyz2rgbLinear = xyz2rgbLinear;
+/**
+ * Convert XYZ to linear-light sRGB
+ *
+ * @param xyz
+ */
+const rgbLinear2xyz = (xyz) => {
+    return (0, color_math_1.multiplyMatrices)([
+        0.41239079926595934, 0.357584339383878, 0.1804807884018343, 0.21263900587151027, 0.715168678767756,
+        0.07219231536073371, 0.01933081871559182, 0.11919477979462598, 0.9505321522496607
+    ], xyz);
+};
+exports.rgbLinear2xyz = rgbLinear2xyz;
+/**
+ * Convert sRGB to RGB
+ *
+ * @param rgb
+ */
+const srgbLinear2rgb = (rgb) => {
+    return rgb.map((c) => {
+        const sign = c < 0 ? -1 : 1, abs = Math.abs(c);
+        return abs > 0.0031308 ? sign * (1.055 * abs ** (1 / 2.4) - 0.055) : 12.92 * c;
+    });
+};
+exports.srgbLinear2rgb = srgbLinear2rgb;
+/**
+ * Convert RGB to sRGB
+ *
+ * @param rgb
+ */
+const rgb2rgbLinear = (rgb) => {
+    return rgb.map((c) => {
+        const sign = c < 0 ? -1 : 1, abs = Math.abs(c);
+        return abs <= 0.04045 ? c / 12.92 : sign * ((abs + 0.055) / 1.055) ** 2.4;
+    });
+};
+exports.rgb2rgbLinear = rgb2rgbLinear;
+/**
+ * XYZ to SRGB
+ *
+ * @param args
+ */
+const srgbFromXYZ = (args) => {
+    const [r, g, b] = (0, exports.srgbLinear2rgb)((0, exports.xyz2rgbLinear)([args[0], args[1], args[2]]));
+    return [r, g, b, args[3]];
+};
+exports.srgbFromXYZ = srgbFromXYZ;
+/**
+ * XYZ to SRGB-Linear
+ * @param args
+ */
+const srgbLinearFromXYZ = (args) => {
+    const [r, g, b] = (0, exports.xyz2rgbLinear)([args[0], args[1], args[2]]);
+    return [
+        (0, color_math_1.clamp)(Math.round(r * 255), 0, 255),
+        (0, color_math_1.clamp)(Math.round(g * 255), 0, 255),
+        (0, color_math_1.clamp)(Math.round(b * 255), 0, 255),
+        args[3]
+    ];
+};
+exports.srgbLinearFromXYZ = srgbLinearFromXYZ;