@dicebear/core 5.0.0-alpha.0 → 5.0.0-alpha.13

package/{dist → lib}/core.d.ts

@@ -1,3 +1,3 @@
-import type { Style, StyleOptions } from './types';
-export declare function createAvatar<O extends {}>(style: Style<O>, options?: StyleOptions<O>): string;
-export declare function createPreview<O extends {}>(style: Style<O>, options: StyleOptions<O>, property: keyof StyleOptions<O>): string | undefined;
+import type { Style, StyleOptions } from './types.js';
+export declare function createAvatar<O extends {}>(style: Style<O>, options?: StyleOptions<O>): string;
+export declare function createPreview<O extends {}>(style: Style<O>, options: StyleOptions<O>, property: keyof StyleOptions<O>): string | undefined;

package/lib/core.js

@@ -0,0 +1,70 @@
+import * as svgUtils from './utils/svg.js';
+import { merge as mergeOptions } from './utils/options.js';
+import { create as createPrng } from './utils/prng.js';
+import { convertToDataUri } from './utils/svg.js';
+export function createAvatar(style, options = {}) {
+    var _a, _b;
+    options = mergeOptions(style, options);
+    const prng = createPrng(options.seed);
+    const result = style.create({ prng: prng, options });
+    const backgroundColor = prng.pick((_a = options.backgroundColor) !== null && _a !== void 0 ? _a : []);
+    if (options.size) {
+        result.attributes.width = options.size.toString();
+        result.attributes.height = options.size.toString();
+    }
+    if (options.scale !== undefined && options.scale !== 100) {
+        result.body = svgUtils.addScale(result, options.scale);
+    }
+    if (options.flip) {
+        result.body = svgUtils.addFlip(result);
+    }
+    if (options.rotate) {
+        result.body = svgUtils.addRotate(result, options.rotate);
+    }
+    if (options.translateX || options.translateY) {
+        result.body = svgUtils.addTranslate(result, options.translateX, options.translateY);
+    }
+    if (backgroundColor && backgroundColor !== 'transparent') {
+        result.body = svgUtils.addBackgroundColor(result, backgroundColor);
+    }
+    if (options.radius || options.clip) {
+        result.body = svgUtils.addViewboxMask(result, (_b = options.radius) !== null && _b !== void 0 ? _b : 0);
+    }
+    let avatar = `<svg ${svgUtils.createAttrString(result.attributes)}>` +
+        `${svgUtils.getMetadata(style)}` +
+        `${result.body}` +
+        `</svg>`;
+    return options.dataUri ? convertToDataUri(avatar) : avatar;
+}
+export function createPreview(style, options, property) {
+    var _a, _b;
+    options = mergeOptions(style, options);
+    const prng = createPrng(options.seed);
+    let result = (_a = style.preview) === null || _a === void 0 ? void 0 : _a.call(style, { prng, options, property });
+    const backgroundColor = prng.pick((_b = options.backgroundColor) !== null && _b !== void 0 ? _b : []);
+    const hasBackgroundColor = backgroundColor && backgroundColor !== 'transparent';
+    const isBackgroundVisible = property === 'backgroundColor';
+    if (undefined === result) {
+        if (hasBackgroundColor && isBackgroundVisible) {
+            result = {
+                attributes: {
+                    viewBox: `0 0 1 1`,
+                    fill: 'none',
+                    'shape-rendering': 'auto',
+                },
+                body: ``,
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (hasBackgroundColor && isBackgroundVisible) {
+        result.body = svgUtils.addBackgroundColor(result, backgroundColor);
+    }
+    let avatar = `<svg ${svgUtils.createAttrString(result.attributes)}>` +
+        `${svgUtils.getMetadata(style)}` +
+        `${result.body}` +
+        `</svg>`;
+    return options.dataUri ? convertToDataUri(avatar) : avatar;
+}

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * DiceBear (@dicebear/core)
+ *
+ * Code licensed under MIT (https://github.com/dicebear/dicebear/blob/main/LICENSE)
+ * Copyright (c) 2021 Florian Körner
+ */
+export * from './core.js';
+export * from './schema.js';
+export * from './types.js';

package/lib/index.js

@@ -0,0 +1,9 @@
+/*!
+ * DiceBear (@dicebear/core)
+ *
+ * Code licensed under MIT (https://github.com/dicebear/dicebear/blob/main/LICENSE)
+ * Copyright (c) 2021 Florian Körner
+ */
+export * from './core.js';
+export * from './schema.js';
+export * from './types.js';

package/lib/schema.d.ts

@@ -0,0 +1,2 @@
+import { JSONSchema7 } from 'json-schema';
+export declare const schema: JSONSchema7;

package/lib/schema.js

@@ -0,0 +1,76 @@
+export const schema = {
+    type: 'object',
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    title: 'Options',
+    properties: {
+        seed: {
+            type: 'string',
+            examples: ['Jane Doe', 'John Doe'],
+        },
+        dataUri: {
+            type: 'boolean',
+            default: false,
+            examples: [true, false],
+        },
+        flip: {
+            type: 'boolean',
+            default: false,
+            examples: [true, false],
+        },
+        rotate: {
+            type: 'integer',
+            minimum: 0,
+            maximum: 360,
+            default: 0,
+            examples: [0, 45, 90, 135, 180, 225, 270, 315],
+        },
+        scale: {
+            type: 'integer',
+            minimum: 0,
+            maximum: 200,
+            default: 100,
+            examples: [50, 100, 150],
+        },
+        radius: {
+            type: 'integer',
+            minimum: 0,
+            maximum: 50,
+            default: 0,
+            examples: [0, 10, 20, 30, 40, 50],
+        },
+        size: {
+            type: 'integer',
+            minimum: 1,
+            examples: [128, 256, 512, 1024],
+        },
+        backgroundColor: {
+            type: 'array',
+            uniqueItems: true,
+            items: {
+                type: 'string',
+                pattern: '^([0-9a-zA-Z]+|#[a-fA-F0-9]{3}|#[a-fA-F0-9]{4}|#[a-fA-F0-9]{6}|#[a-fA-F0-9]{8})$',
+            },
+            examples: ['#FFD5DC', '#FFDFBF', '#C0EADE', '#B6E3F4', '#D1D4F9'],
+        },
+        translateX: {
+            type: 'integer',
+            minimum: -100,
+            maximum: 100,
+            default: 0,
+            examples: [-50, -25, 0, 25, 50],
+        },
+        translateY: {
+            type: 'integer',
+            minimum: -100,
+            maximum: 100,
+            default: 0,
+            examples: [-50, -25, 0, 25, 50],
+        },
+        clip: {
+            type: 'boolean',
+            default: true,
+            examples: [true, false],
+        },
+    },
+    additionalProperties: false,
+};

package/{dist → lib}/types.d.ts

@@ -1,54 +1,66 @@
-import type { JSONSchema7 } from 'json-schema';
-import type { Options } from './options';
-export interface Prng {
-    seed: string;
-    bool(likelihood?: number): boolean;
-    integer(min: number, max: number): number;
-    pick<T>(arr: T[]): T;
-}
-export declare type StyleSchema = JSONSchema7;
-export declare type StyleOptions<O extends {}> = Partial<O & Options>;
-export interface StyleCreateProps<O> {
-    prng: Prng;
-    options: StyleOptions<O>;
-}
-export declare type StyleCreate<O extends {}> = (props: StyleCreateProps<O>) => StyleCreateResult;
-export interface StyleCreateResultAttributes {
-    viewBox: string;
-    [key: string]: string;
-}
-export interface StyleCreateResult {
-    attributes: StyleCreateResultAttributes;
-    body: string;
-}
-export interface StylePreviewProps<O> {
-    prng: Prng;
-    options: StyleOptions<O>;
-    property: keyof StyleOptions<O>;
-}
-export declare type StylePreview<O extends {}> = (props: StylePreviewProps<O>) => StylePreviewResult;
-export interface StylePreviewResultAttributes {
-    viewBox: string;
-    [key: string]: string;
-}
-export declare type StylePreviewResult = undefined | {
-    attributes: StyleCreateResultAttributes;
-    head?: string;
-    body: string;
-};
-export interface StyleMeta {
-    title?: string;
-    creator?: string | string[];
-    source?: string;
-    license?: {
-        name: string;
-        url: string;
-    };
-    contributor?: string | string[];
-}
-export interface Style<O extends {}> {
-    meta: StyleMeta;
-    schema: StyleSchema;
-    create: StyleCreate<O>;
-    preview?: StylePreview<O>;
-}
+import { JSONSchema7 } from 'json-schema';
+export interface Options {
+    seed?: string;
+    dataUri?: boolean;
+    flip?: boolean;
+    rotate?: number;
+    scale?: number;
+    radius?: number;
+    size?: number;
+    backgroundColor?: string[];
+    translateX?: number;
+    translateY?: number;
+    clip?: boolean;
+}
+export interface Prng {
+    seed: string;
+    bool(likelihood?: number): boolean;
+    integer(min: number, max: number): number;
+    pick<T>(arr: T[]): T;
+}
+export declare type StyleSchema = JSONSchema7;
+export declare type StyleOptions<O extends {}> = Partial<O & Options>;
+export interface StyleCreateProps<O> {
+    prng: Prng;
+    options: StyleOptions<O>;
+}
+export declare type StyleCreate<O extends {}> = (props: StyleCreateProps<O>) => StyleCreateResult;
+export interface StyleCreateResultAttributes {
+    viewBox: string;
+    [key: string]: string;
+}
+export interface StyleCreateResult {
+    attributes: StyleCreateResultAttributes;
+    body: string;
+}
+export interface StylePreviewProps<O> {
+    prng: Prng;
+    options: StyleOptions<O>;
+    property: keyof StyleOptions<O>;
+}
+export declare type StylePreview<O extends {}> = (props: StylePreviewProps<O>) => StylePreviewResult;
+export interface StylePreviewResultAttributes {
+    viewBox: string;
+    [key: string]: string;
+}
+export declare type StylePreviewResult = undefined | {
+    attributes: StyleCreateResultAttributes;
+    head?: string;
+    body: string;
+};
+export interface StyleMeta {
+    title?: string;
+    creator?: string | string[];
+    source?: string;
+    license?: {
+        name: string;
+        url: string;
+    };
+    contributor?: string | string[];
+}
+export interface Style<O extends {}> {
+    meta: StyleMeta;
+    schema: StyleSchema;
+    create: StyleCreate<O>;
+    preview?: StylePreview<O>;
+}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/{dist → lib}/utils/escape.d.ts

@@ -1 +1 @@
-export declare function xml(attr: string): string;
+export declare function xml(attr: string): string;

package/lib/utils/escape.js

@@ -0,0 +1,8 @@
+export function xml(attr) {
+    return attr
+        .replace(/&/g, '&')
+        .replace(/'/g, ''')
+        .replace(/"/g, '"')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}

package/lib/utils/options.d.ts

@@ -0,0 +1,3 @@
+import type { Style, StyleOptions, StyleSchema } from '../types.js';
+export declare function defaults(schema: StyleSchema): Record<string, unknown>;
+export declare function merge<O extends {}>(style: Style<O>, options: StyleOptions<O>): StyleOptions<O>;

package/lib/utils/options.js

@@ -0,0 +1,32 @@
+import { schema } from '../schema.js';
+export function defaults(schema) {
+    var _a;
+    let result = {};
+    let props = (_a = schema.properties) !== null && _a !== void 0 ? _a : {};
+    Object.keys(props).forEach((key) => {
+        let val = props[key];
+        if (typeof val === 'object' && undefined !== val.default) {
+            if (Array.isArray(val.default)) {
+                result[key] = [...val.default];
+            }
+            else if (typeof val.default === 'object') {
+                result[key] = { ...val.default };
+            }
+            else {
+                result[key] = val.default;
+            }
+        }
+    });
+    return result;
+}
+export function merge(style, options) {
+    let result = {
+        ...{
+            seed: Math.random().toString(),
+        },
+        ...defaults(schema),
+        ...defaults(style.schema),
+        ...options,
+    };
+    return result;
+}

package/{dist → lib}/utils/prng.d.ts

@@ -1,2 +1,2 @@
-import type { Prng } from '../types';
-export declare function create(seed?: string): Prng;
+import type { Prng } from '../types.js';
+export declare function create(seed?: string): Prng;

package/lib/utils/prng.js

@@ -0,0 +1,39 @@
+const MIN = -2147483648;
+const MAX = 2147483647;
+function xorshift(value) {
+    value ^= value << 13;
+    value ^= value >> 17;
+    value ^= value << 5;
+    return value;
+}
+function hashSeed(seed) {
+    let hash = 0;
+    for (let i = 0; i < seed.length; i++) {
+        hash = ((hash << 5) - hash + seed.charCodeAt(i)) | 0;
+        hash = xorshift(hash);
+    }
+    return hash;
+}
+function randomSeed() {
+    return MIN + Math.floor((MAX - MIN) * Math.random()).toString();
+}
+export function create(seed) {
+    seed = seed !== null && seed !== void 0 ? seed : randomSeed();
+    let value = hashSeed(seed) || 1;
+    const next = () => (value = xorshift(value));
+    const integer = (min, max) => {
+        return Math.floor(((next() - MIN) / (MAX - MIN)) * (max + 1 - min) + min);
+    };
+    return {
+        seed,
+        bool(likelihood = 50) {
+            return integer(0, 100) <= likelihood;
+        },
+        integer(min, max) {
+            return integer(min, max);
+        },
+        pick(arr) {
+            return arr[integer(0, arr.length - 1)];
+        },
+    };
+}

package/{dist → lib}/utils/svg.d.ts

@@ -1,39 +1,37 @@
-import type { Options } from '../options';
-import type { Style, StyleCreateResult, StyleCreateResultAttributes } from '../types';
-declare type CreateGroupProps = {
-    children: string;
-    x: number;
-    y: number;
-};
-export declare function createGroup({ children, x, y }: CreateGroupProps): string;
-export declare function getXmlnsAttributes(): {
-    'xmlns:dc': string;
-    'xmlns:cc': string;
-    'xmlns:rdf': string;
-    'xmlns:svg': string;
-    xmlns: string;
-};
-export declare function getMetadata<O extends Options>(style: Style<O>): string;
-export declare function getMetadataWorkTitle<O extends Options>(style: Style<O>): string;
-export declare function getMetadataWorkCreator<O extends Options>(style: Style<O>): string;
-export declare function getMetadataWorkSource<O extends Options>(style: Style<O>): string;
-export declare function getMetadataWorkLicense<O extends Options>(style: Style<O>): string;
-export declare function getMetadataWorkContributor<O extends Options>(style: Style<O>): string;
-export declare function getMetadataWorkAgents(agents: string[]): string[];
-export declare function getMetadataLicense<O extends Options>(style: Style<O>): string;
-export declare function getViewBox(result: StyleCreateResult): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-export declare function addBackgroundColor(result: StyleCreateResult, backgroundColor: string): string;
-export declare function addScale(result: StyleCreateResult, scale: number): string;
-export declare function addTranslate(result: StyleCreateResult, x?: number, y?: number): string;
-export declare function addRotate(result: StyleCreateResult, rotate: number): string;
-export declare function addFlip(result: StyleCreateResult): string;
-export declare function addViewboxMask(result: StyleCreateResult, radius: number): string;
-export declare function createAttrString(attributes: StyleCreateResultAttributes): string;
-export declare function removeWhitespace(svg: string): string;
-export declare function convertToDataUri(svg: string): string;
-export {};
+import type { Options, Style, StyleCreateResult, StyleCreateResultAttributes } from '../types.js';
+declare type CreateGroupProps = {
+    children: string;
+    x: number;
+    y: number;
+};
+export declare function createGroup({ children, x, y }: CreateGroupProps): string;
+export declare function getXmlnsAttributes(): {
+    'xmlns:dc': string;
+    'xmlns:cc': string;
+    'xmlns:rdf': string;
+    'xmlns:svg': string;
+    xmlns: string;
+};
+export declare function getMetadata<O extends Options>(style: Style<O>): string;
+export declare function getMetadataWorkTitle<O extends Options>(style: Style<O>): string;
+export declare function getMetadataWorkCreator<O extends Options>(style: Style<O>): string;
+export declare function getMetadataWorkSource<O extends Options>(style: Style<O>): string;
+export declare function getMetadataWorkLicense<O extends Options>(style: Style<O>): string;
+export declare function getMetadataWorkContributor<O extends Options>(style: Style<O>): string;
+export declare function getMetadataWorkAgents(agents: string[]): string[];
+export declare function getMetadataLicense<O extends Options>(style: Style<O>): string;
+export declare function getViewBox(result: StyleCreateResult): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function addBackgroundColor(result: StyleCreateResult, backgroundColor: string): string;
+export declare function addScale(result: StyleCreateResult, scale: number): string;
+export declare function addTranslate(result: StyleCreateResult, x?: number, y?: number): string;
+export declare function addRotate(result: StyleCreateResult, rotate: number): string;
+export declare function addFlip(result: StyleCreateResult): string;
+export declare function addViewboxMask(result: StyleCreateResult, radius: number): string;
+export declare function createAttrString(attributes: StyleCreateResultAttributes): string;
+export declare function convertToDataUri(svg: string): string;
+export {};

package/lib/utils/svg.js

@@ -0,0 +1,178 @@
+import * as escape from './escape.js';
+const ccLicenses = {
+    by: {
+        permits: ['Reproduction', 'Distribution', 'DerivativeWorks'],
+        requires: ['Notice', 'Attribution'],
+        prohibits: [],
+    },
+    'by-sa': {
+        permits: ['Reproduction', 'Distribution', 'DerivativeWorks'],
+        requires: ['Notice', 'Attribution', 'ShareAlike'],
+        prohibits: [],
+    },
+    'by-nd': {
+        permits: ['Reproduction', 'Distribution'],
+        requires: ['Notice', 'Attribution'],
+        prohibits: [],
+    },
+    'by-nc': {
+        permits: ['Reproduction', 'Distribution', 'DerivativeWorks'],
+        requires: ['Notice', 'Attribution'],
+        prohibits: ['CommercialUse'],
+    },
+    'by-nc-sa': {
+        permits: ['Reproduction', 'Distribution', 'DerivativeWorks'],
+        requires: ['Notice', 'Attribution', 'ShareAlike'],
+        prohibits: ['CommercialUse'],
+    },
+    'by-nc-nd': {
+        permits: ['Reproduction', 'Distribution'],
+        requires: ['Notice', 'Attribution'],
+        prohibits: ['CommercialUse'],
+    },
+    zero: {
+        permits: ['Reproduction', 'Distribution', 'DerivativeWorks'],
+        requires: [],
+        prohibits: [],
+    },
+};
+export function createGroup({ children, x, y }) {
+    return `<g transform="translate(${x}, ${y})">${children}</g>`;
+}
+export function getXmlnsAttributes() {
+    return {
+        'xmlns:dc': 'http://purl.org/dc/elements/1.1/',
+        'xmlns:cc': 'http://creativecommons.org/ns#',
+        'xmlns:rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+        'xmlns:svg': 'http://www.w3.org/2000/svg',
+        xmlns: 'http://www.w3.org/2000/svg',
+    };
+}
+export function getMetadata(style) {
+    return (`<metadata>` +
+        `<rdf:RDF>` +
+        `<cc:Work>` +
+        `<dc:format>image/svg+xml</dc:format>` +
+        `<dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage" />` +
+        `${getMetadataWorkTitle(style)}` +
+        `${getMetadataWorkCreator(style)}` +
+        `${getMetadataWorkSource(style)}` +
+        `${getMetadataWorkLicense(style)}` +
+        `${getMetadataWorkContributor(style)}` +
+        `</cc:Work>` +
+        `${getMetadataLicense(style)}` +
+        `</rdf:RDF>` +
+        `</metadata>`);
+}
+export function getMetadataWorkTitle(style) {
+    if (style.meta.title) {
+        return `<dc:title>${style.meta.title}</dc:title>`;
+    }
+    return '';
+}
+export function getMetadataWorkCreator(style) {
+    if (style.meta.creator) {
+        let creators = Array.isArray(style.meta.creator) ? style.meta.creator : [style.meta.creator];
+        return `<dc:creator>${getMetadataWorkAgents(creators)}</dc:creator>`;
+    }
+    return '';
+}
+export function getMetadataWorkSource(style) {
+    if (style.meta.source) {
+        return `<dc:source>${style.meta.source}</dc:source>`;
+    }
+    return '';
+}
+export function getMetadataWorkLicense(style) {
+    if (style.meta.license) {
+        return `<cc:license rdf:resource="${style.meta.license.url}" />`;
+    }
+    return '';
+}
+export function getMetadataWorkContributor(style) {
+    if (style.meta.contributor) {
+        let contributors = Array.isArray(style.meta.contributor) ? style.meta.contributor : [style.meta.contributor];
+        return `<dc:contributor>${getMetadataWorkAgents(contributors)}</dc:contributor>`;
+    }
+    return '';
+}
+export function getMetadataWorkAgents(agents) {
+    return agents.map((agent) => `<cc:Agent><dc:title>${agent}</dc:title></cc:Agent>`);
+}
+export function getMetadataLicense(style) {
+    var _a, _b;
+    let match = (_a = style.meta.license) === null || _a === void 0 ? void 0 : _a.url.match(/^https?:\/\/creativecommons.org\/(?:licenses|publicdomain)\/([a-z\-]+)\/\d.\d\//);
+    if (match) {
+        let license = ccLicenses[match[1]];
+        if (license) {
+            let result = ``;
+            license.permits.forEach((permits) => {
+                result += `<cc:permits rdf:resource="https://creativecommons.org/ns#${permits}" />`;
+            });
+            license.requires.forEach((requires) => {
+                result += `<cc:requires rdf:resource="https://creativecommons.org/ns#${requires}" />`;
+            });
+            license.prohibits.forEach((prohibits) => {
+                result += `<cc:prohibits rdf:resource="https://creativecommons.org/ns#${prohibits}" />`;
+            });
+            return `<cc:License rdf:about="${(_b = style.meta.license) === null || _b === void 0 ? void 0 : _b.url}">${result}</cc:License>`;
+        }
+    }
+    return '';
+}
+export function getViewBox(result) {
+    let viewBox = result.attributes['viewBox'].split(' ');
+    let x = parseInt(viewBox[0]);
+    let y = parseInt(viewBox[1]);
+    let width = parseInt(viewBox[2]);
+    let height = parseInt(viewBox[3]);
+    return {
+        x,
+        y,
+        width,
+        height,
+    };
+}
+export function addBackgroundColor(result, backgroundColor) {
+    let { width, height, x, y } = getViewBox(result);
+    return `<rect fill="${backgroundColor}" width="${width}" height="${height}" x="${x}" y="${y}" />${result.body}`;
+}
+export function addScale(result, scale) {
+    let { width, height, x, y } = getViewBox(result);
+    let percent = scale ? (scale - 100) / 100 : 0;
+    let translateX = (width / 2 + x) * percent * -1;
+    let translateY = (height / 2 + y) * percent * -1;
+    return `<g transform="translate(${translateX} ${translateY}) scale(${scale / 100})">${result.body}</g>`;
+}
+export function addTranslate(result, x, y) {
+    let viewBox = getViewBox(result);
+    let translateX = (viewBox.width + viewBox.x * 2) * ((x !== null && x !== void 0 ? x : 0) / 100);
+    let translateY = (viewBox.height + viewBox.y * 2) * ((y !== null && y !== void 0 ? y : 0) / 100);
+    return `<g transform="translate(${translateX} ${translateY})">${result.body}</g>`;
+}
+export function addRotate(result, rotate) {
+    let { width, height, x, y } = getViewBox(result);
+    return `<g transform="rotate(${rotate}, ${width / 2 + x}, ${height / 2 + y})">${result.body}</g>`;
+}
+export function addFlip(result) {
+    let { width, x } = getViewBox(result);
+    return `<g transform="scale(-1 1) translate(${width * -1 - x * 2} 0)">${result.body}</g>`;
+}
+export function addViewboxMask(result, radius) {
+    let { width, height, x, y } = getViewBox(result);
+    let rx = radius ? (width * radius) / 100 : 0;
+    let ry = radius ? (height * radius) / 100 : 0;
+    return (`<mask id="viewboxMask">` +
+        `<rect width="${width}" height="${height}" rx="${rx}" ry="${ry}" x="${x}" y="${y}" fill="#fff" />` +
+        `</mask>` +
+        `<g mask="url(#viewboxMask)">${result.body}</g>`);
+}
+export function createAttrString(attributes) {
+    attributes = { ...getXmlnsAttributes(), ...attributes };
+    return Object.keys(attributes)
+        .map((attr) => `${escape.xml(attr)}="${escape.xml(attributes[attr])}"`)
+        .join(' ');
+}
+export function convertToDataUri(svg) {
+    return `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`;
+}