@idraw/util 0.3.0-alpha.4 → 0.3.0-alpha.7

package/dist/esm/index.d.ts

@@ -0,0 +1,71 @@
+import { delay, compose, throttle } from './lib/time';
+import { downloadImageFromCanvas } from './lib/file';
+import { toColorHexStr, toColorHexNum, isColorStr } from './lib/color';
+import { createUUID } from './lib/uuid';
+import { deepClone } from './lib/data';
+import istype from './lib/istype';
+import { loadImage, loadSVG, loadHTML } from './lib/loader';
+import Context from './lib/context';
+import is from './lib/is';
+import check from './lib/check';
+export { is, check, delay, compose, throttle, loadImage, loadSVG, loadHTML, downloadImageFromCanvas, toColorHexStr, toColorHexNum, isColorStr, createUUID, istype, deepClone, Context };
+declare const _default: {
+    is: {
+        x: (value: any) => boolean;
+        y: (value: any) => boolean;
+        w: (value: any) => boolean;
+        h: (value: any) => boolean;
+        angle: (value: any) => boolean;
+        number: (value: any) => boolean;
+        borderWidth: (value: any) => boolean;
+        borderRadius: (value: any) => boolean;
+        color: (value: any) => boolean;
+        imageSrc: (value: any) => boolean;
+        imageURL: (value: any) => boolean;
+        imageBase64: (value: any) => boolean;
+        svg: (value: any) => boolean;
+        html: (value: any) => boolean;
+        text: (value: any) => boolean;
+        fontSize: (value: any) => boolean;
+        lineHeight: (value: any) => boolean;
+        textAlign: (value: any) => boolean;
+        fontFamily: (value: any) => boolean;
+        fontWeight: (value: any) => boolean;
+        strokeWidth: (value: any) => boolean;
+    };
+    check: {
+        attrs: (attrs: any) => boolean;
+        textDesc: (desc: any) => boolean;
+        rectDesc: (desc: any) => boolean;
+        circleDesc: (desc: any) => boolean;
+        imageDesc: (desc: any) => boolean;
+        svgDesc: (desc: any) => boolean;
+        htmlDesc: (desc: any) => boolean;
+    };
+    delay: typeof delay;
+    compose: typeof compose;
+    throttle: typeof throttle;
+    loadImage: typeof loadImage;
+    loadSVG: typeof loadSVG;
+    loadHTML: typeof loadHTML;
+    downloadImageFromCanvas: typeof downloadImageFromCanvas;
+    toColorHexStr: typeof toColorHexStr;
+    toColorHexNum: typeof toColorHexNum;
+    isColorStr: typeof isColorStr;
+    createUUID: typeof createUUID;
+    istype: {
+        type(data: any, lowerCase?: boolean | undefined): string;
+        array(data: any): boolean;
+        json(data: any): boolean;
+        function(data: any): boolean;
+        asyncFunction(data: any): boolean;
+        string(data: any): boolean;
+        number(data: any): boolean;
+        undefined(data: any): boolean;
+        null(data: any): boolean;
+        promise(data: any): boolean;
+    };
+    deepClone: typeof deepClone;
+    Context: typeof Context;
+};
+export default _default;

package/{esm → dist/esm}/index.js

@@ -8,4 +8,22 @@ import { loadImage, loadSVG, loadHTML } from './lib/loader';
 import Context from './lib/context';
 import is from './lib/is';
 import check from './lib/check';
-export { is, check, delay, compose, throttle, loadImage, loadSVG, loadHTML, downloadImageFromCanvas, toColorHexStr, toColorHexNum, isColorStr, createUUID, istype, deepClone, Context, };
+export { is, check, delay, compose, throttle, loadImage, loadSVG, loadHTML, downloadImageFromCanvas, toColorHexStr, toColorHexNum, isColorStr, createUUID, istype, deepClone, Context };
+export default {
+    is,
+    check,
+    delay,
+    compose,
+    throttle,
+    loadImage,
+    loadSVG,
+    loadHTML,
+    downloadImageFromCanvas,
+    toColorHexStr,
+    toColorHexNum,
+    isColorStr,
+    createUUID,
+    istype,
+    deepClone,
+    Context
+};

package/dist/esm/lib/check.d.ts

@@ -0,0 +1,17 @@
+declare function attrs(attrs: any): boolean;
+declare function rectDesc(desc: any): boolean;
+declare function circleDesc(desc: any): boolean;
+declare function imageDesc(desc: any): boolean;
+declare function svgDesc(desc: any): boolean;
+declare function htmlDesc(desc: any): boolean;
+declare function textDesc(desc: any): boolean;
+declare const check: {
+    attrs: typeof attrs;
+    textDesc: typeof textDesc;
+    rectDesc: typeof rectDesc;
+    circleDesc: typeof circleDesc;
+    imageDesc: typeof imageDesc;
+    svgDesc: typeof svgDesc;
+    htmlDesc: typeof htmlDesc;
+};
+export default check;

package/dist/esm/lib/check.js

@@ -0,0 +1,115 @@
+import is from './is';
+function attrs(attrs) {
+    const { x, y, w, h, angle } = attrs;
+    if (!(is.x(x) && is.y(y) && is.w(w) && is.h(h) && is.angle(angle))) {
+        return false;
+    }
+    if (!(angle >= -360 && angle <= 360)) {
+        return false;
+    }
+    return true;
+}
+function box(desc = {}) {
+    const { borderColor, borderRadius, borderWidth } = desc;
+    if (desc.hasOwnProperty('borderColor') && !is.color(borderColor)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('borderRadius') && !is.number(borderRadius)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('borderWidth') && !is.number(borderWidth)) {
+        return false;
+    }
+    return true;
+}
+function rectDesc(desc) {
+    const { bgColor } = desc;
+    if (desc.hasOwnProperty('bgColor') && !is.color(bgColor)) {
+        return false;
+    }
+    if (!box(desc)) {
+        return false;
+    }
+    return true;
+}
+function circleDesc(desc) {
+    const { bgColor, borderColor, borderWidth } = desc;
+    if (desc.hasOwnProperty('bgColor') && !is.color(bgColor)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('borderColor') && !is.color(borderColor)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('borderWidth') && !is.number(borderWidth)) {
+        return false;
+    }
+    return true;
+}
+function imageDesc(desc) {
+    const { src } = desc;
+    if (!is.imageSrc(src)) {
+        return false;
+    }
+    return true;
+}
+function svgDesc(desc) {
+    const { svg } = desc;
+    if (!is.svg(svg)) {
+        return false;
+    }
+    return true;
+}
+function htmlDesc(desc) {
+    const { html } = desc;
+    if (!is.html(html)) {
+        return false;
+    }
+    return true;
+}
+function textDesc(desc) {
+    const { text, color, fontSize, lineHeight, fontFamily, textAlign, fontWeight, bgColor, strokeWidth, strokeColor } = desc;
+    if (!is.text(text)) {
+        return false;
+    }
+    if (!is.color(color)) {
+        return false;
+    }
+    if (!is.fontSize(fontSize)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('bgColor') && !is.color(bgColor)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('fontWeight') && !is.fontWeight(fontWeight)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('lineHeight') && !is.lineHeight(lineHeight)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('fontFamily') && !is.fontFamily(fontFamily)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('textAlign') && !is.textAlign(textAlign)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('strokeWidth') && !is.strokeWidth(strokeWidth)) {
+        return false;
+    }
+    if (desc.hasOwnProperty('strokeColor') && !is.color(strokeColor)) {
+        return false;
+    }
+    if (!box(desc)) {
+        return false;
+    }
+    return true;
+}
+const check = {
+    attrs,
+    textDesc,
+    rectDesc,
+    circleDesc,
+    imageDesc,
+    svgDesc,
+    htmlDesc,
+};
+export default check;

package/dist/esm/lib/color.d.ts

@@ -0,0 +1,3 @@
+export declare function toColorHexNum(color: string): number;
+export declare function toColorHexStr(color: number): string;
+export declare function isColorStr(color?: string): boolean;

package/dist/esm/lib/color.js

@@ -0,0 +1,9 @@
+export function toColorHexNum(color) {
+    return parseInt(color.replace(/^\#/, '0x'));
+}
+export function toColorHexStr(color) {
+    return '#' + color.toString(16);
+}
+export function isColorStr(color) {
+    return typeof color === 'string' && /^\#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(color);
+}

package/dist/esm/lib/context.d.ts

@@ -0,0 +1,80 @@
+import { TypeContext, TypeBoardSizeOptions } from '@idraw/types';
+type Options = {
+    width: number;
+    height: number;
+    contextWidth: number;
+    contextHeight: number;
+    devicePixelRatio: number;
+};
+type Transform = {
+    scale?: number;
+    scrollX?: number;
+    scrollY?: number;
+};
+declare class Context implements TypeContext {
+    private _opts;
+    private _ctx;
+    private _transform;
+    constructor(ctx: CanvasRenderingContext2D, opts: Options);
+    getContext(): CanvasRenderingContext2D;
+    resetSize(opts: TypeBoardSizeOptions): void;
+    calcDeviceNum(num: number): number;
+    calcScreenNum(num: number): number;
+    getSize(): {
+        width: number;
+        height: number;
+        contextWidth: number;
+        contextHeight: number;
+        devicePixelRatio: number;
+    };
+    setTransform(config: Transform): void;
+    getTransform(): {
+        scale: number;
+        scrollX: number;
+        scrollY: number;
+    };
+    setFillStyle(color: string | CanvasPattern | CanvasGradient): void;
+    fill(fillRule?: CanvasFillRule | undefined): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean | undefined): void;
+    rect(x: number, y: number, w: number, h: number): void;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    clearRect(x: number, y: number, w: number, h: number): void;
+    beginPath(): void;
+    closePath(): void;
+    lineTo(x: number, y: number): void;
+    moveTo(x: number, y: number): void;
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    setLineWidth(w: number): number;
+    setLineDash(nums: number[]): void;
+    isPointInPath(x: number, y: number): boolean;
+    isPointInPathWithoutScroll(x: number, y: number): boolean;
+    setStrokeStyle(color: string): void;
+    stroke(): void;
+    translate(x: number, y: number): void;
+    rotate(angle: number): void;
+    drawImage(...args: any[]): void;
+    createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
+    measureText(text: string): TextMetrics;
+    setTextAlign(align: CanvasTextAlign): void;
+    fillText(text: string, x: number, y: number, maxWidth?: number | undefined): void;
+    strokeText(text: string, x: number, y: number, maxWidth?: number | undefined): void;
+    setFont(opts: {
+        fontSize: number;
+        fontFamily?: string;
+        fontWeight?: 'bold';
+    }): void;
+    setTextBaseline(baseline: CanvasTextBaseline): void;
+    setGlobalAlpha(alpha: number): void;
+    save(): void;
+    restore(): void;
+    scale(ratioX: number, ratioY: number): void;
+    setShadowColor(color: string): void;
+    setShadowOffsetX(offsetX: number): void;
+    setShadowOffsetY(offsetY: number): void;
+    setShadowBlur(blur: number): void;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean | undefined): void;
+    private _doSize;
+    private _doX;
+    private _doY;
+}
+export default Context;

package/dist/esm/lib/context.js

@@ -0,0 +1,194 @@
+class Context {
+    constructor(ctx, opts) {
+        this._opts = opts;
+        this._ctx = ctx;
+        this._transform = {
+            scale: 1,
+            scrollX: 0,
+            scrollY: 0,
+        };
+    }
+    getContext() {
+        return this._ctx;
+    }
+    resetSize(opts) {
+        this._opts = Object.assign(Object.assign({}, this._opts), opts);
+    }
+    calcDeviceNum(num) {
+        return num * this._opts.devicePixelRatio;
+    }
+    calcScreenNum(num) {
+        return num / this._opts.devicePixelRatio;
+    }
+    getSize() {
+        return {
+            width: this._opts.width,
+            height: this._opts.height,
+            contextWidth: this._opts.contextWidth,
+            contextHeight: this._opts.contextHeight,
+            devicePixelRatio: this._opts.devicePixelRatio,
+        };
+    }
+    setTransform(config) {
+        this._transform = Object.assign(Object.assign({}, this._transform), config);
+    }
+    getTransform() {
+        return {
+            scale: this._transform.scale,
+            scrollX: this._transform.scrollX,
+            scrollY: this._transform.scrollY,
+        };
+    }
+    setFillStyle(color) {
+        this._ctx.fillStyle = color;
+    }
+    fill(fillRule) {
+        return this._ctx.fill(fillRule || 'nonzero');
+    }
+    arc(x, y, radius, startAngle, endAngle, anticlockwise) {
+        return this._ctx.arc(this._doSize(x), this._doSize(y), this._doSize(radius), startAngle, endAngle, anticlockwise);
+    }
+    rect(x, y, w, h) {
+        return this._ctx.rect(this._doSize(x), this._doSize(y), this._doSize(w), this._doSize(h));
+    }
+    fillRect(x, y, w, h) {
+        return this._ctx.fillRect(this._doSize(x), this._doSize(y), this._doSize(w), this._doSize(h));
+    }
+    clearRect(x, y, w, h) {
+        return this._ctx.clearRect(this._doSize(x), this._doSize(y), this._doSize(w), this._doSize(h));
+    }
+    beginPath() {
+        return this._ctx.beginPath();
+    }
+    closePath() {
+        return this._ctx.closePath();
+    }
+    lineTo(x, y) {
+        return this._ctx.lineTo(this._doSize(x), this._doSize(y));
+    }
+    moveTo(x, y) {
+        return this._ctx.moveTo(this._doSize(x), this._doSize(y));
+    }
+    arcTo(x1, y1, x2, y2, radius) {
+        return this._ctx.arcTo(this._doSize(x1), this._doSize(y1), this._doSize(x2), this._doSize(y2), this._doSize(radius));
+    }
+    setLineWidth(w) {
+        return this._ctx.lineWidth = this._doSize(w);
+    }
+    setLineDash(nums) {
+        return this._ctx.setLineDash(nums.map(n => this._doSize(n)));
+    }
+    isPointInPath(x, y) {
+        return this._ctx.isPointInPath(this._doX(x), this._doY(y));
+    }
+    isPointInPathWithoutScroll(x, y) {
+        return this._ctx.isPointInPath(this._doSize(x), this._doSize(y));
+    }
+    setStrokeStyle(color) {
+        this._ctx.strokeStyle = color;
+    }
+    stroke() {
+        return this._ctx.stroke();
+    }
+    translate(x, y) {
+        return this._ctx.translate(this._doSize(x), this._doSize(y));
+    }
+    rotate(angle) {
+        return this._ctx.rotate(angle);
+    }
+    drawImage(...args) {
+        const image = args[0];
+        const sx = args[1];
+        const sy = args[2];
+        const sw = args[3];
+        const sh = args[4];
+        const dx = args[args.length - 4];
+        const dy = args[args.length - 3];
+        const dw = args[args.length - 2];
+        const dh = args[args.length - 1];
+        if (args.length === 9) {
+            return this._ctx.drawImage(image, this._doSize(sx), this._doSize(sy), this._doSize(sw), this._doSize(sh), this._doSize(dx), this._doSize(dy), this._doSize(dw), this._doSize(dh));
+        }
+        else {
+            return this._ctx.drawImage(image, this._doSize(dx), this._doSize(dy), this._doSize(dw), this._doSize(dh));
+        }
+    }
+    createPattern(image, repetition) {
+        return this._ctx.createPattern(image, repetition);
+    }
+    measureText(text) {
+        return this._ctx.measureText(text);
+    }
+    setTextAlign(align) {
+        this._ctx.textAlign = align;
+    }
+    fillText(text, x, y, maxWidth) {
+        if (maxWidth !== undefined) {
+            return this._ctx.fillText(text, this._doSize(x), this._doSize(y), this._doSize(maxWidth));
+        }
+        else {
+            return this._ctx.fillText(text, this._doSize(x), this._doSize(y));
+        }
+    }
+    strokeText(text, x, y, maxWidth) {
+        if (maxWidth !== undefined) {
+            return this._ctx.strokeText(text, this._doSize(x), this._doSize(y), this._doSize(maxWidth));
+        }
+        else {
+            return this._ctx.strokeText(text, this._doSize(x), this._doSize(y));
+        }
+    }
+    setFont(opts) {
+        const strList = [];
+        if (opts.fontWeight === 'bold') {
+            strList.push(`${opts.fontWeight}`);
+        }
+        strList.push(`${this._doSize(opts.fontSize || 12)}px`);
+        strList.push(`${opts.fontFamily || 'sans-serif'}`);
+        this._ctx.font = `${strList.join(' ')}`;
+    }
+    setTextBaseline(baseline) {
+        this._ctx.textBaseline = baseline;
+    }
+    setGlobalAlpha(alpha) {
+        this._ctx.globalAlpha = alpha;
+    }
+    save() {
+        this._ctx.save();
+    }
+    restore() {
+        this._ctx.restore();
+    }
+    scale(ratioX, ratioY) {
+        this._ctx.scale(ratioX, ratioY);
+    }
+    setShadowColor(color) {
+        this._ctx.shadowColor = color;
+    }
+    setShadowOffsetX(offsetX) {
+        this._ctx.shadowOffsetX = this._doSize(offsetX);
+    }
+    setShadowOffsetY(offsetY) {
+        this._ctx.shadowOffsetY = this._doSize(offsetY);
+    }
+    setShadowBlur(blur) {
+        this._ctx.shadowBlur = this._doSize(blur);
+    }
+    ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, counterclockwise) {
+        this._ctx.ellipse(this._doSize(x), this._doSize(y), this._doSize(radiusX), this._doSize(radiusY), rotation, startAngle, endAngle, counterclockwise);
+    }
+    _doSize(num) {
+        return this._opts.devicePixelRatio * num;
+    }
+    _doX(x) {
+        const { scale, scrollX } = this._transform;
+        const _x = (x - scrollX) / scale;
+        return this._doSize(_x);
+    }
+    _doY(y) {
+        const { scale, scrollY } = this._transform;
+        const _y = (y - scrollY) / scale;
+        return this._doSize(_y);
+    }
+}
+export default Context;

package/dist/esm/lib/data.d.ts

@@ -0,0 +1 @@
+export declare function deepClone(target: any): any;

package/dist/esm/lib/data.js

@@ -0,0 +1,27 @@
+export function deepClone(target) {
+    function _clone(t) {
+        const type = is(t);
+        if (['Null', 'Number', 'String', 'Boolean', 'Undefined'].indexOf(type) >= 0) {
+            return t;
+        }
+        else if (type === 'Array') {
+            const arr = [];
+            t.forEach((item) => {
+                arr.push(_clone(item));
+            });
+            return arr;
+        }
+        else if (type === 'Object') {
+            const obj = {};
+            const keys = Object.keys(t);
+            keys.forEach((key) => {
+                obj[key] = _clone(t[key]);
+            });
+            return obj;
+        }
+    }
+    return _clone(target);
+}
+function is(data) {
+    return Object.prototype.toString.call(data).replace(/[\]|\[]{1,1}/ig, '').split(' ')[1];
+}

package/dist/esm/lib/file.d.ts

@@ -0,0 +1,6 @@
+type ImageType = 'image/jpeg' | 'image/png';
+export declare function downloadImageFromCanvas(canvas: HTMLCanvasElement, opts: {
+    filename: string;
+    type: ImageType;
+}): void;
+export {};

package/dist/esm/lib/file.js

@@ -0,0 +1,10 @@
+export function downloadImageFromCanvas(canvas, opts) {
+    const { filename, type = 'image/jpeg' } = opts;
+    const stream = canvas.toDataURL(type);
+    const downloadLink = document.createElement('a');
+    downloadLink.href = stream;
+    downloadLink.download = filename;
+    const downloadClickEvent = document.createEvent('MouseEvents');
+    downloadClickEvent.initEvent('click', true, false);
+    downloadLink.dispatchEvent(downloadClickEvent);
+}

package/dist/esm/lib/is.d.ts

@@ -0,0 +1,45 @@
+declare function number(value: any): boolean;
+declare function x(value: any): boolean;
+declare function y(value: any): boolean;
+declare function w(value: any): boolean;
+declare function h(value: any): boolean;
+declare function angle(value: any): boolean;
+declare function borderWidth(value: any): boolean;
+declare function borderRadius(value: any): boolean;
+declare function color(value: any): boolean;
+declare function imageURL(value: any): boolean;
+declare function imageBase64(value: any): boolean;
+declare function imageSrc(value: any): boolean;
+declare function svg(value: any): boolean;
+declare function html(value: any): boolean;
+declare function text(value: any): boolean;
+declare function fontSize(value: any): boolean;
+declare function lineHeight(value: any): boolean;
+declare function strokeWidth(value: any): boolean;
+declare function textAlign(value: any): boolean;
+declare function fontFamily(value: any): boolean;
+declare function fontWeight(value: any): boolean;
+declare const is: {
+    x: typeof x;
+    y: typeof y;
+    w: typeof w;
+    h: typeof h;
+    angle: typeof angle;
+    number: typeof number;
+    borderWidth: typeof borderWidth;
+    borderRadius: typeof borderRadius;
+    color: typeof color;
+    imageSrc: typeof imageSrc;
+    imageURL: typeof imageURL;
+    imageBase64: typeof imageBase64;
+    svg: typeof svg;
+    html: typeof html;
+    text: typeof text;
+    fontSize: typeof fontSize;
+    lineHeight: typeof lineHeight;
+    textAlign: typeof textAlign;
+    fontFamily: typeof fontFamily;
+    fontWeight: typeof fontWeight;
+    strokeWidth: typeof strokeWidth;
+};
+export default is;

package/dist/esm/lib/is.js

@@ -0,0 +1,81 @@
+import { isColorStr } from './color';
+function number(value) {
+    return (typeof value === 'number' && (value > 0 || value <= 0));
+}
+function x(value) {
+    return number(value);
+}
+function y(value) {
+    return number(value);
+}
+function w(value) {
+    return (typeof value === 'number' && value >= 0);
+}
+function h(value) {
+    return (typeof value === 'number' && value >= 0);
+}
+function angle(value) {
+    return (typeof value === 'number' && value >= -360 && value <= 360);
+}
+function borderWidth(value) {
+    return w(value);
+}
+function borderRadius(value) {
+    return number(value) && value >= 0;
+}
+function color(value) {
+    return isColorStr(value);
+}
+function imageURL(value) {
+    return (typeof value === 'string' && /^(http:\/\/|https:\/\/|\.\/|\/)/.test(`${value}`));
+}
+function imageBase64(value) {
+    return (typeof value === 'string' && /^(data:image\/)/.test(`${value}`));
+}
+function imageSrc(value) {
+    return (imageBase64(value) || imageURL(value));
+}
+function svg(value) {
+    return (typeof value === 'string' && /^(<svg[\s]{1,}|<svg>)/i.test(`${value}`.trim()) && /<\/[\s]{0,}svg>$/i.test(`${value}`.trim()));
+}
+function html(value) {
+    let result = false;
+    if (typeof value === 'string') {
+        let div = document.createElement('div');
+        div.innerHTML = value;
+        if (div.children.length > 0) {
+            result = true;
+        }
+        div = null;
+    }
+    return result;
+}
+function text(value) {
+    return typeof value === 'string';
+}
+function fontSize(value) {
+    return number(value) && value > 0;
+}
+function lineHeight(value) {
+    return number(value) && value > 0;
+}
+function strokeWidth(value) {
+    return number(value) && value > 0;
+}
+function textAlign(value) {
+    return ['center', 'left', 'right'].includes(value);
+}
+function fontFamily(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function fontWeight(value) {
+    return ['bold'].includes(value);
+}
+const is = {
+    x, y, w, h, angle, number,
+    borderWidth, borderRadius, color,
+    imageSrc, imageURL, imageBase64, svg, html,
+    text, fontSize, lineHeight, textAlign, fontFamily, fontWeight,
+    strokeWidth,
+};
+export default is;