{"version":3,"file":"animated-creative.84476d6344b030f51d66.js","mappings":"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","sources":["webpack://LIB/webpack/runtime/load script","webpack://LIB/../ad/utils/browser.ts","webpack://LIB/./serialization/image-settings-serializer.ts","webpack://LIB/../ad/utils/image-optimizer.ts","webpack://LIB/../ad/utils/url.ts","webpack://LIB/./actions/actions.utils.ts","webpack://LIB/./animation.utils.ts","webpack://LIB/./animator.ts","webpack://LIB/./color.ts","webpack://LIB/./color.utils.ts","webpack://LIB/./elements/feed/feeds.utils.ts","webpack://LIB/./elements/rich-text/text-nodes.ts","webpack://LIB/./elements/widget/events.ts","webpack://LIB/./font-service.utils.ts","webpack://LIB/./nodes/base-data-node.ts","webpack://LIB/./nodes/creative-data-node.ts","webpack://LIB/./nodes/helpers.ts","webpack://LIB/./nodes/data-node.utils.ts","webpack://LIB/./rendering/formula.utils.ts","webpack://LIB/./rendering/states.utils.ts","webpack://LIB/./serialization/property-value-serializer.ts","webpack://LIB/./serialization/text-serializer.ts","webpack://LIB/./timing-functions.ts","webpack://LIB/../domain/action.ts","webpack://LIB/../domain/animation.ts","webpack://LIB/../domain/color.ts","webpack://LIB/../domain/creative.ts","webpack://LIB/../domain/image.ts","webpack://LIB/../domain/property.ts","webpack://LIB/../domain/style.ts","webpack://LIB/../domain/social.ts","webpack://LIB/../domain/transition.ts","webpack://LIB/../domain/user.ts","webpack://LIB/../domain/widget.ts","webpack://LIB/../domain/workspace.ts","webpack://LIB/../domain/nodes.ts","webpack://LIB/../domain/text.ts","webpack://LIB/../utils/clone.ts","webpack://LIB/../utils/di.decorators.ts","webpack://LIB/../utils/di.ts","webpack://LIB/../utils/errors/errors.ts","webpack://LIB/../utils/event-emitter.ts","webpack://LIB/../utils/geom.ts","webpack://LIB/../utils/matrix.ts","webpack://LIB/../utils/promises.ts","webpack://LIB/../utils/safe-eval.ts","webpack://LIB/../utils/sanitizer.ts","webpack://LIB/../utils/simple-cache.ts","webpack://LIB/../utils/utils.ts","webpack://LIB/../../node_modules/tslib/tslib.es6.js","webpack://LIB/webpack/bootstrap","webpack://LIB/webpack/runtime/define property getters","webpack://LIB/webpack/runtime/ensure chunk","webpack://LIB/webpack/runtime/get javascript chunk filename","webpack://LIB/webpack/runtime/hasOwnProperty shorthand","webpack://LIB/webpack/runtime/make namespace object","webpack://LIB/webpack/runtime/publicPath","webpack://LIB/webpack/runtime/jsonp chunk loading","webpack://LIB/../utils/dom-utils.ts","webpack://LIB/../utils/performance.ts","webpack://LIB/../ad/domain/ad-events.ts","webpack://LIB/./elements/rich-text/rich-text.bidi-chars.ts","webpack://LIB/./elements/rich-text/rich-text.ts","webpack://LIB/./css-styles.ts","webpack://LIB/./animator-lite.ts","webpack://LIB/../utils/errors/error-message.enum.ts","webpack://LIB/../utils/svg-utils.ts","webpack://LIB/./svg-background.ts","webpack://LIB/../ad/utils/dom.ts","webpack://LIB/./visitor.ts","webpack://LIB/./renderer.ts","webpack://LIB/./creative.ts","webpack://LIB/./creative.container.ts","webpack://LIB/./animated-creative.ts"],"sourcesContent":["var inProgress = {};\nvar dataWebpackPrefix = \"LIB:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\t;\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","// @ts-nocheck\n// https://stackoverflow.com/a/9851769/5161346\n\nconst userAgent = (window.navigator?.userAgent || '').toLowerCase();\n\n// Opera 8.0+\nexport const isOpera = (!!window.opr && !!opr.addons) || !!window.opera || userAgent.indexOf(' opr/') >= 0;\n\n// Firefox 1.0+\nexport const isFirefox = typeof InstallTrigger !== 'undefined';\n\n// Any apple browser including safari, wkWebview, uiWebView.\nexport const isAppleBrowser = window.navigator?.vendor?.indexOf('Apple') > -1;\n\n// Safari\nexport const isSafari = isAppleBrowser && navigator.userAgent.indexOf('crios') === -1 && userAgent.indexOf('fxios') === -1;\n\n// Internet Explorer 6-11\nexport const isIE = /* @cc_on!@ */false || !!document.documentMode;\n\n// Edge 15-18\nexport const isEdge = !isIE && !!window.StyleMedia;\n\n// Chrome 1 - 79\nexport const isChrome = /Chrome/.test(navigator.userAgent) && /Google Inc/.test(navigator.vendor);\n\n// Edge (based on chromium) detection\n// eslint-disable-next-line eqeqeq\nexport const isEdgeChromium = isChrome && (userAgent.indexOf('edg') != -1);\n\n// Blink engine detection\nexport const isBlink = (isChrome || isOpera || isEdgeChromium) && !!window.CSS;\n\nexport const isIpad = (userAgent.match(/(iPad)/) /* iOS pre 13 */\n    || (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1) /* iPad OS 13 */);\n\n\n/**\n * Extract iOS version from User agent.\n * Note that this won't find iPads with version 13 and above\n * because Apple are idiots\n */\n// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\nexport const preciseIOSVersion = (function () {\n    try {\n        const agent = window.navigator.userAgent;\n        const start = agent.indexOf('OS ');\n\n        if ((agent.indexOf('iPhone') > -1 || agent.indexOf('iPad') > -1) && start > -1) {\n            const simple = Number(agent.substr(start + 3, 4).replace('_', '.'));\n            const full = agent\n                .substr(start + 3)\n                .split(' ')[0]\n                .replace(/_/g, '.')\n                .split('.')\n                .map(v => Number(v));\n\n            return {\n                simple,\n                full: {\n                    major: full[0],\n                    minor: full[1],\n                    patch: full[2] || 0\n                }\n            };\n        }\n    }\n    catch (e) { console.warn('Could not get iOS version.'); }\n\n    return { simple: 0, full: { major: 0, minor: 0, patch: 0 } };\n}());\n\n/** Note probably not accurate but need it for version */\nexport function getBrowserVersion(): number {\n\n    const ua = navigator.userAgent;\n    let tem;\n    let M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\\/))\\/?\\s*(\\d+)/i) || [];\n\n    if (/trident/i.test(M[1])) {\n        tem = /\\brv[ :]+(\\d+)/g.exec(ua) || [];\n        return parseFloat(tem[1]) || -1;\n    }\n    if (M[1] === 'Chrome') {\n        tem = ua.match(/\\b(OPR|Edge)\\/(\\d+)/);\n        if (tem != null) {\n            return parseFloat(tem[2]) || -1;\n        }\n    }\n    M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];\n    if ((tem = ua.match(/version\\/(\\d+)/i)) != null) {\n        M.splice(1, 1, tem[1]);\n    }\n    return parseFloat(M[1]) || -1;\n}\n","import { DEFAULT_IMAGE_SETTINGS, IImageSettings, ImageFitOption, ImageSizeMode, ISerializedImageElement, ISerializedImageSettings, IPosition, ISize } from '@studio/domain';\nimport { aspectRatioScale } from '@studio/utils/geom';\nimport { clamp } from '@studio/utils/utils';\n\nexport function deserializeImageSettings(element: ISerializedImageElement, originalSize?: Partial<ISize>): IImageSettings {\n    return element.imageSettings ? { ...element.imageSettings } : migrateFitToImageSettings(element, originalSize);\n}\n\nexport function serializeImageSettings(settings: IImageSettings): ISerializedImageSettings {\n    return { ...settings };\n}\n\nfunction migrateFitToImageSettings(element: ISerializedImageElement, originalSize: Partial<ISize> = {}): IImageSettings {\n\n\n    // Feeds do not have an image asset\n    if (!originalSize.width || !originalSize.height) {\n        originalSize.width = element.width;\n        originalSize.height = element.height;\n    }\n\n    let highDpi = false;\n    if (typeof element.highDpi === 'string') {\n        highDpi = element.highDpi === 'true'\n            ? true\n            : false;\n    }\n\n    let quality = element.quality;\n    if (typeof element.quality === 'string') {\n        quality = Number(element.quality);\n    }\n\n    const settings: IImageSettings = {\n        quality: quality,\n        highDpi: highDpi,\n        sizeMode: fitOptionToSizeMode(element.fitOption),\n        ...getFitPositionAsFractionAlign(element, originalSize as ISize)\n    };\n\n    return settings;\n}\n\n\n/**\n * Translates fitPositionX/Y to an align\n */\n export function getFitPositionAsFractionAlign(element:  ISerializedImageElement, originalSize: ISize): IPosition {\n\n    let x = 0.5;\n    let y = 0.5;\n\n    const fitOption = element.fitOption;\n    const fitPositionX = Number(element.fitPositionX);\n    const fitPositionY = Number(element.fitPositionY);\n\n    // fitPosition only applies to cover. Contain is not supported yet\n    if (fitOption === 'cover' && originalSize?.width && originalSize?.height) {\n        const renderedImageSize = aspectRatioScale(originalSize, element, 'cover');\n        if (fitPositionX) {\n            const overflow = renderedImageSize.width - element.width;\n            if (overflow > 0) {\n                // fitPositionX = -1 meeans that we move the image 0.5px left\n                x = clamp(0.5 - (fitPositionX * 0.5) / overflow, 0, 1);\n            }\n        }\n        if (fitPositionY) {\n            const overflow = renderedImageSize.height - element.height;\n            if (overflow > 0) {\n                // fitPositionY = -1 meeans that we move the image 0.5px up\n                y = clamp(0.5 - (fitPositionY * 0.5) / overflow, 0, 1);\n            }\n        }\n    }\n\n    return {\n        x,\n        y,\n    };\n}\n\nexport function fitOptionToSizeMode(fitOption?: ImageFitOption | ImageSizeMode | string): ImageSizeMode {\n    switch (fitOption) {\n        case 'cover':\n        case 'crop':\n            return ImageSizeMode.Crop;\n        case 'distort':\n        case 'stretch':\n            return ImageSizeMode.Stretch;\n        case 'contain':\n        case 'fit':\n            return ImageSizeMode.Fit;\n        default:\n            return DEFAULT_IMAGE_SETTINGS.sizeMode;\n    }\n}\n","import { IBounds, IPosition, ISize, ImageFitOption, DEFAULT_IMAGE_QUALITY, ImageSizeMode, IImageViewElement, IImageElementDataNode } from '../../domain';\nimport { alignWithinBounds, aspectRatioScale, boundsToPointRect, HorizontalAlign, roundBounds, VerticalAlign } from '@studio/utils/geom';\nimport { sanitizeUrl } from '@studio/utils/sanitizer';\nimport { clamp, omitUndefined, roundToNearestMultiple } from '@studio/utils/utils';\nimport { fitOptionToSizeMode } from '../../creative/serialization/image-settings-serializer';\nimport { preciseIOSVersion } from './browser';\nimport { getFileExtension, objectToQueryString, isRelativeUrl, getUrlParameters, replaceOrigin, isSameDomain, isBase64 } from './url';\n\ninterface IImageOptimizerUrlBuilderOptions {\n    webP: boolean;\n    dpr: number;\n    origin: string;\n    defaultOrigin: string;\n}\n\nexport class ImageOptimizerUrlBuilder {\n\n    private static _options: IImageOptimizerUrlBuilderOptions;\n\n    static get origin(): string | undefined {\n        return ImageOptimizerUrlBuilder._options?.origin;\n    }\n\n    /**\n     * @summary\n     * Initialize ImageOptimizer class to build image urls\n     */\n    static async init_m(origin: string = '', defaultOrigin: string = '', dpr: number = 1): Promise<boolean> {\n\n        // WebP loading is broken in iOS >= 14.3 < 14.5.0\n        let webP = false;\n        const minorIOSVersion = preciseIOSVersion.simple;\n        if (minorIOSVersion > 0 && minorIOSVersion >= 14.3 && minorIOSVersion < 14.5) {\n            webP = false;\n        }\n        else {\n            webP = await testWebP();\n        }\n\n        ImageOptimizerUrlBuilder._options = {\n            webP,\n            dpr,\n            origin,\n            defaultOrigin\n        };\n\n        return webP;\n    }\n\n    static getCroppingOptions(element: IImageElementDataNode): ICroppingOptions | undefined {\n        const imageSettings = element.imageSettings;\n        if (imageSettings.sizeMode === ImageSizeMode.Crop) {\n            return getCroppingOptions(element, element.imageAsset as ISize, imageSettings.x, imageSettings.y);\n        }\n    }\n\n    static getUrlByElement_m(element: IImageElementDataNode, settings: IImageOptimizerGetUrlByElementOptions = {}): string {\n        const { imageAsset, imageSettings } = element;\n        const size = getMaxScaledSize(element, settings.sizeLimit);\n        const url = settings.feedUrl || imageAsset?.url || '';\n        const defaultQuality = settings.force ? 100 : undefined;\n        const quality = typeof imageSettings.quality === 'number'\n            ? imageSettings.quality\n            : defaultQuality;\n        let sizeMode = imageSettings.sizeMode;\n        const cropping = settings.cropping;\n\n        // Feeded images should always keep ratio\n        if (!imageAsset) {\n            sizeMode = sizeMode === ImageSizeMode.Crop ? ImageSizeMode.Crop : ImageSizeMode.Fit;\n        }\n\n        const { origin, defaultOrigin, webP } = ImageOptimizerUrlBuilder._options;\n        const format = getFormat(url, webP);\n\n        // Optimization turned off, just validate url\n        if (format === 'svg' || format === 'gif' || typeof quality === 'undefined') {\n            const urlWithOrigin = (origin && defaultOrigin && isSameDomain(url, defaultOrigin) && window['ENVIRONMENT'] !== 'local')\n                ? replaceOrigin(url, origin)\n                : url;\n\n            return sanitizeUrl(urlWithOrigin);\n        }\n\n        // Return retina image if optimize is off in DV\n        const dpr = ImageOptimizerUrlBuilder.getDevicePixelRatio(typeof imageSettings.quality === 'number' ? imageSettings.highDpi : true);\n\n        return ImageOptimizerUrlBuilder.getUrl(url, { ...size, sizeMode, quality, cropping, dpr });\n    }\n\n    /**\n     * Get url to the image optimizer.\n     * WARNING: adding _m suffix to the method name will crash widgets using this\n     * @param url\n     * @param options\n     * @returns\n     */\n    static getUrl(url: string, options: IImageOptimizerUrlOptions): string {\n        const baseOptions = ImageOptimizerUrlBuilder._options;\n        if (!baseOptions) {\n            throw new Error('ImageOptimizerUrlBuilder not initiated');\n        }\n\n        return getImageOptimizerUrl(url, {\n            webpSupport: baseOptions.webP,\n            imageOptimizerOrigin: baseOptions.origin,\n            dpr: baseOptions.dpr,\n            ...omitUndefined(options),\n        });\n    }\n\n    /**\n     * Check if an url or element is a cropped image. It might be needed\n     * to detect if an image can be expected to have the same ratio as original image or not.\n     * Note that images might already be cropped without affecting url when creative is used\n     * as an \"html-export\"\n     * @param urlOrElement\n     * @returns\n     */\n    static isCropped_m(urlOrElement: IImageViewElement | string = ''): boolean {\n\n        const url = typeof urlOrElement === 'string' ? urlOrElement : (urlOrElement.imageUrl || '');\n\n        // In html-export image optimizer will not be available\n        if (!this._options.origin && typeof urlOrElement !== 'string') {\n\n            // Svg and gifs are never cropped (gifs due to problems with IO)\n            const format = getImageExtension(url);\n            const isNotSvgOrGif = format !== 'svg' && format !== 'gif';\n            const isSizeModeCrop = urlOrElement.__data.imageSettings.sizeMode === ImageSizeMode.Crop;\n\n            // HTML-exported ads will have relative url's and should already be cropped\n            return isRelativeUrl(url) && isSizeModeCrop && isNotSvgOrGif && !isBase64(url);\n        }\n\n        return !!url && ImageOptimizerUrlBuilder._isOptimized(url) && !!getUrlParameters(url)['x1'];\n    }\n\n    /**\n     * Get original url from optimized or non optimized string\n     */\n    static getOriginalUrl(url: string = ''): string {\n        if (ImageOptimizerUrlBuilder._isOptimized(url)) {\n            return getOriginalUrl(url) || '';\n        }\n        return url;\n    }\n\n    /**\n     * Check if url goes through image optimizer to request an optimized url;\n     * @param url\n     * @returns\n     */\n    private static _isOptimized(url: string): boolean {\n        const origin = ImageOptimizerUrlBuilder.origin;\n        return !!origin && isOptimizedUrl(url, origin);\n    }\n\n    static getDevicePixelRatio(highDpi?: boolean): number {\n\n        // Note that this is affected by browser zoom so it can be like 1.6012\n        const dpr = window.devicePixelRatio;\n\n        if (highDpi && dpr) {\n\n            // Decrease load on IO by only having a few different variants of the same image (1x, 1.5x and 2x)\n            return clamp(roundToNearestMultiple(dpr, 0.5), 1, 2);\n        }\n        return this._options.dpr;\n    }\n}\n\nexport function getImageOptimizerUrl(url: string, options: IImageOptimizerUrlOptions): string {\n\n    if (!url) {\n        throw new Error('No image url provided');\n    }\n\n    // Crash if it's not a friendly url\n    sanitizeUrl(url);\n\n    // Apply default values\n    options = { ...imageOptimizerDefaults, ...omitUndefined(options)};\n\n    const imageOptimizerOrigin = options.imageOptimizerOrigin || '';\n\n    // No URL to optimizer specified or relative (incl. base64) => Use original image\n    if (!sanitizeUrl(imageOptimizerOrigin) || isRelativeUrl(url)) {\n        return url;\n    }\n\n    const format = getFormat(url, options.webpSupport);\n\n    // Don't optimize SVG (or when wepb is not supported ignore gifs as well)\n    if (format === 'svg' || format === 'gif') {\n        return url;\n    }\n\n    // Support if an already optimized url is passed in by taking the ?u=encodedurl part as url\n    if (url.indexOf(imageOptimizerOrigin) > -1) {\n        const param = getUrlParameters(url)['u'];\n\n        if (typeof param === 'string') {\n            url = decodeURIComponent(param);\n        }\n    }\n\n\n    if (!options.width || !options.height) {\n        throw new Error('No size provided');\n    }\n\n    const position = options.position\n    ? { positionX: options.position.x, positionY: options.position.y }\n    : undefined;\n\n    // Never show more than @2x resolution due to file size\n    const dpr = clamp(options.dpr || 1, 1, 2);\n    const w = Math.round(options.width * dpr);\n    const h = Math.round(options.height * dpr);\n\n    // IO Doesn't crop images with quality 100 so make quality range from 0-99 temporarily\n    const q = typeof options.quality === 'number' ? clamp(options.quality, 0, 99) : undefined;\n\n    // WARNING: DO NOT CHANGE THE ORDER, DOING SO WILL INVALIDATE CACHING\n    const imageOptimizerParameters: IImageOptimizerParameters = {\n        u: encodeURIComponent(url),\n        w,\n        h,\n        q,\n        f: format,\n        rt: getOptimizerRatioParameter(options.sizeMode || options.fitOption),\n        ...position,\n        ...options.cropping\n    };\n\n    const query = objectToQueryString(imageOptimizerParameters);\n\n    return `${imageOptimizerOrigin}/api/image/${options.method}${query}`;\n}\n\nexport function getCroppingOptions(size: ISize, originalSize?: ISize, alignH: HorizontalAlign = 0.5, alignV: VerticalAlign = 0.5): ICroppingOptions | undefined {\n\n    if (!originalSize || !originalSize.width || !originalSize.height) {\n        return;\n    }\n\n    // Image size on canvas including the hidden/overflow areas\n    const renderedImageSize = { ...aspectRatioScale(originalSize, size, 'cover'), x: 0, y: 0 };\n\n    // Area within renderedImageSize to crop\n    const croppingArea = alignWithinBounds(size, renderedImageSize, alignH, alignV);\n\n    const scale = originalSize.width / renderedImageSize.width;\n\n    // In IO crop happens BEFORE resizing so use positions relative to original size\n    const crop: IBounds = roundBounds({\n        x: croppingArea.x * scale,\n        y: croppingArea.y * scale,\n        width: croppingArea.width * scale,\n        height: croppingArea.height * scale\n    });\n\n    const points = boundsToPointRect(crop);\n\n    // Never overflow original image (will cause a 400-error from IO)\n    points.x2 = Math.min(points.x2, originalSize.width);\n    points.y2 = Math.min(points.y2, originalSize.height);\n\n    return points;\n}\n\nlet webPPromise: Promise<boolean>;\nexport function testWebP(): Promise<boolean> {\n    if (!webPPromise) {\n        webPPromise = new Promise(res => {\n            const webP = new Image();\n            webP.onload = webP.onerror = (): void => res(webP.height === 2);\n            webP.src = 'data:image/webp;base64,UklGRjoAAABXRUJQVlA4IC4AAACyAgCdASoCAAIALmk0mk0iIiIiIgBoSygABc6WWgAA/veff/0PP8bA//LwYAAA';\n        });\n    }\n    return webPPromise;\n}\n\nexport function getFormat(url: string, webPSupport: boolean = false): ImageFormats {\n    const originalFormat = getImageExtension(url);\n\n    /**\n     * Certain gifs does not render properly on iOS if it's\n     * rendered as an animated webp\n     */\n    const iOSVersion = preciseIOSVersion.simple;\n    if (originalFormat === 'gif' && iOSVersion > 0 && iOSVersion >= 14 && iOSVersion < 16) {\n        webPSupport = false;\n    }\n\n    // SVG can't be converted to webp\n    if (originalFormat === 'svg') {\n        return originalFormat;\n    }\n    // WebP not supported\n    else if (!webPSupport) {\n        return !originalFormat || originalFormat === 'webp' ? 'png' : originalFormat;\n    }\n\n    return 'webp';\n}\n\nfunction getOptimizerRatioParameter(fitOption?: ImageFitOption | ImageSizeMode): undefined | 'cover' | 'contain' {\n\n    const sizeMode = fitOptionToSizeMode(fitOption);\n\n    // Distort requires the image optimizer to contain the image\n    if (sizeMode === ImageSizeMode.Stretch) {\n        return 'contain';\n    }\n    if (sizeMode === ImageSizeMode.Fit) {\n        return 'contain';\n    }\n    if (sizeMode === ImageSizeMode.Crop) {\n        return 'cover';\n    }\n}\n\nfunction getMaxScaledSize(element: IImageElementDataNode, sizeLimit?: ISize): ISize {\n\n    const imageAsset = element.imageAsset;\n\n    let scale = element.states.reduce((accumulator, state) => {\n        const scaleX = state.scaleX || 0;\n        const scaleY = state.scaleY || 0;\n        return Math.max(scaleX, scaleY, accumulator);\n    }, 1);\n\n    if (sizeLimit) {\n        // Cap size increase so that image never is larger than limit (with fit 'cover')\n        if (element.width <= sizeLimit.width || element.height <= sizeLimit.height) {\n            const coverSize = aspectRatioScale(element, sizeLimit, 'cover');\n            scale = Math.min(coverSize.width / element.width, scale);\n        }\n        // Element is overflowing size limit, don't increase size\n        else {\n            scale = 1;\n        }\n    }\n\n    // Don't allow image getting larger than original\n    if (imageAsset?.width && imageAsset?.height) {\n        const assetWidth = imageAsset.width;\n        const assetHeight = imageAsset.height;\n\n        if (assetWidth < element.width * scale) {\n            return {\n                width: assetWidth,\n                height: assetHeight\n            };\n        }\n    }\n\n    return {\n        width: element.width * scale,\n        height: element.height * scale\n    };\n}\n\nexport function getImageExtension(url?: string): ImageFormats | undefined {\n    const format = getFileExtension(url);\n\n    switch (format) {\n        case 'jpg':\n            return 'jpeg';\n        case 'webp':\n        case 'jpeg':\n        case 'gif':\n        case 'png':\n        case 'svg':\n            return format;\n    }\n}\n\n/**\n * Get url parameter from a Image Optimiser URL\n * @param url\n * @returns\n */\nexport function getOriginalUrl(url?: string): string | undefined {\n    return getUrlParameters(url)['u'];\n}\n\nexport function isOptimizedUrl(url: string, imageOptimizerOrigin: string): boolean {\n    return url.indexOf(imageOptimizerOrigin) > -1 && !!getOriginalUrl(url);\n}\n\ntype ImageFormats = 'webp' | 'jpeg' | 'gif' | 'png' | 'svg';\n\n/**\n * Parameters supported by the optimizer service\n */\ninterface IImageOptimizerParameters {\n\n    // Url to original image. Need to be encoded.\n    u: string;\n\n    // Formats supported to optimize\n    f: 'webp' | 'jpeg' | 'png';\n\n    // Quality\n    q?: number;\n\n    // Size\n    w: number;\n    h: number;\n\n    // Image Position parameters\n    positionX?: number;\n    positionY?: number;\n\n    // Cropping parameters\n    x1?: number;\n    x2?: number;\n    y1?: number;\n    y2?: number;\n\n    /**\n     * How size should be calculated (like css background-size).\n     * Undefined meens true distort image returned to the size given by w & h\n     */\n    rt?: 'contain' | 'cover';\n}\n\n// Note, this is used in widget-editor.component as well but raw text. It should match this interface\nexport interface IImageOptimizerUrlOptions {\n    webpSupport?: boolean;\n    imageOptimizerOrigin?: string;\n    width: number;\n    height: number;\n    originalSize?: ISize;\n    /**\n     * Deprecated but might have references from widgets\n     */\n    fitOption?: ImageFitOption;\n    sizeMode?: ImageSizeMode;\n    cropping?: ICroppingOptions;\n    position?: IPosition;\n    quality?: number;\n    format?: 'webp' | 'jpeg' | 'gif' | 'png' | 'svg';\n    method?: 'optimize' | 'optimizepositionedimage';\n    highDpi?: boolean;\n    dpr?: number;\n}\n\nexport interface IImageOptimizerGetUrlByElementOptions {\n\n    /**\n     * A url from a feed that will override the one in imageAsset.url\n     */\n    feedUrl?: string;\n\n    /**\n     * Defaults to true if not set\n     */\n    crop?: boolean;\n\n    /**\n     * A size the image is not allowed to pass when\n     * applying scaleX & scaleY to the size calculation\n     */\n    sizeLimit?: ISize\n\n    /**\n     * Force optimization to override optimization on/off option.\n     * Defaults to false\n     */\n    force?: boolean;\n\n    /**\n     * Defines the cropping size for fitOption cover\n     */\n    cropping?: ICroppingOptions;\n}\n\nexport const imageOptimizerDefaults: Partial<IImageOptimizerUrlOptions> = {\n    webpSupport: false,\n    imageOptimizerOrigin: '',\n    method: 'optimize',\n    quality: DEFAULT_IMAGE_QUALITY,\n    dpr: 1\n};\n\nexport interface ICroppingOptions {\n    x1: number;\n    y1: number;\n    x2: number;\n    y2: number;\n}\n","import { IUrlParameterMap } from '../domain/url-parameters';\nimport { SimpleCache } from '@studio/utils/simple-cache';\n\nexport const safeUrlRegex = /(javascript|about|data)(:|%3A)/ig;\nconst domainRegex = /^(?:https?:\\/\\/)?(?:[^@\\/\\n]+@)?(?:www\\.)?([^:\\/?\\n]+)/igm;\nconst urlRegex = /[(http(s)?):\\/\\/(www\\.)?a-zA-Z0-9@:%._\\+~#=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%_\\+.~#?&//=]*)/i;\n\nexport function getUrlParameters(url: string | undefined = ''): IUrlParameterMap {\n\n    const urlParams = {};\n\n    const cache = SimpleCache.get<IUrlParameterMap>(url);\n\n    if (cache) {\n        return cache;\n    }\n\n    if (url && url.indexOf('?') > -1) {\n\n        // For modern browsers\n        try {\n            (new URL(url)).searchParams.forEach((value, key) => {\n                urlParams[key] = value;\n            });\n        }\n        catch {\n            url = url.substring(url.indexOf('?') + 1);\n\n            let match: RegExpExecArray | null;\n            // Regex for replacing addition symbol with a space\n            const search = /([^&=]+)=?([^&]*)/g;\n            const decode = (s: string): string => {\n                try {\n                    s = decodeURIComponent(s.replace(/\\+/g, ' '));\n                // eslint-disable-next-line no-empty\n                } catch { }\n                return s;\n            };\n\n            const query = url || window.location.search.substring(1);\n\n            while (match = search.exec(query)) {\n                urlParams[decode(match[1])] = decode(match[2]);\n            }\n        }\n    }\n\n    SimpleCache.set(url, urlParams);\n\n    return urlParams;\n}\n\nexport function isEncodedUrl(url: string): boolean {\n    // What to do with app links like blocket://\n    return url\n        .toLowerCase()\n        .replace(/(https?%3A)?(?=%2F%2F)/i, '')\n        .indexOf('%2f%2f') === 0;\n}\n\nexport function isRelativeUrl(url: string): boolean {\n    return !!url && url.replace(/^https?:/, '').indexOf('//') !== 0;\n}\n\nexport function isUrl(url: string | undefined): boolean {\n    return typeof url === 'string' && !!url.match(urlRegex);\n}\n\nexport function isBase64(str?: string): boolean {\n    return !!str && str.startsWith('data:image');\n}\n\nexport function isBase64Video(str?: string): boolean {\n    return !!str && str.startsWith('data:video');\n}\n\nexport function addProtocol(url?: string, protocol: 'http' | 'https' | undefined = 'https'): string | undefined {\n    if (!url || url === '#') {\n        return url;\n    }\n\n    // Links without protocol messes up iOS safari\n    if (url.indexOf('//') === 0) {\n        url = protocol + ':' + url;\n    }\n\n    // Make sure url starts with http:// or https://\n    else if (url.indexOf('http') !== 0) {\n        url = protocol + '://' + url;\n    }\n\n    return url;\n}\n\n/**\n * Merge two parts of a url.\n * Applies a slash between if missing and removes if it has two adjacent.\n * @param domain\n * @param path\n */\nexport function concatUrl(domain: string = '', path: string = ''): string {\n    if (domain.length && path.length) {\n        if (domain.charAt(domain.length - 1) !== '/') {\n            domain += '/';\n        }\n        if (path.charAt(0) === '/') {\n            path = path.substr(1);\n        }\n    }\n\n    return domain + path;\n}\n\n/**\n * Turn object into query parameters\n * @param obj\n */\nexport function serializeObject(obj: any): string {\n    const str: string[] = [];\n\n    if (typeof obj === 'object') {\n        for (const key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                str.push(encodeURIComponent(key) + '=' + encodeURIComponent(obj[key]));\n            }\n        }\n    }\n\n    return str.join('&');\n}\n\nexport function getDomain(url?: string, stripProtocol: boolean = true): string | undefined {\n    if (typeof url === 'string') {\n        const match = url.match(domainRegex);\n        if (match) {\n            return stripProtocol ? removeProtocol(match[0]) : match[0];\n        }\n    }\n}\n\nexport function removeProtocol(url: string): string {\n    return url.replace(/^((https?:)?\\/\\/)/gim, '');\n}\n\nexport function hasParameter(parameters: IUrlParameterMap, key: string, ): boolean {\n    return parameters[key] !== undefined;\n}\n\nexport function parameterToBool(parameter?: string): boolean | undefined {\n\n    if (!parameter) {\n        return undefined;\n    }\n\n    switch (parameter.toLowerCase()) {\n        case '1':\n        case 'on':\n        case 'true':\n        case 'yes':\n            return true;\n        case '0':\n        case 'off':\n        case 'false':\n        case 'no':\n            return false;\n        default:\n            return undefined;\n    }\n}\n\nexport function parameterToUrl(parameter?: string): string {\n    if (!parameter) {\n        return '';\n    }\n    return isEncodedUrl(parameter) ? decodeURIComponent(parameter) : parameter;\n}\n\nexport function replaceOrigin(url: string, newOrigin: string): string {\n    if (!newOrigin) {\n        return url;\n    }\n    return url.replace(new URL(url).origin, new URL(newOrigin).origin);\n}\n\nexport function isBannerflow(url: string): boolean {\n    if (!url) {\n        return false;\n    }\n    const hostname = typeof URL === 'function' ? new URL(url).hostname : getDomain(url, true);\n    return !!hostname && !!hostname.match(/((bannerflow\\.)|(studio\\.local))/g);\n}\n\nexport function isSameDomain(a: string, b: string): boolean {\n    return getDomain(a) === getDomain(b);\n}\n\nexport function removeQueryParams(url: string): string {\n    return url.replace(/\\?.*/g, '');\n}\n\n\nexport function getUrlsInString(str: string): string[] {\n    return str && str.match(/(https?:\\/\\/[^\\s]+)/g) || [];\n}\n\n/**\n * Return the first url that's not undefined. '' means that we should prevent click\n */\nexport function getFirstUrl(...urls: Array<string | undefined> | []): string | undefined {\n    // NOSONAR\n    for (let i = 0; i < urls.length; i++) {\n        if (urls[i] !== undefined && urls[i] !== null) {\n            return urls[i];\n        }\n    }\n    return undefined;\n}\n\n\nexport function objectToQueryString(params: any, removeEmpty: boolean = true): string {\n    if (typeof params === 'object') {\n        const queries: string[] = [];\n        for (const key in params) {\n            const value = params[key];\n            if ((value !== undefined && value.toString()) || !removeEmpty) {\n                queries.push(key + '=' + value);\n            }\n        }\n\n        return queries.length ? '?' + queries.join('&') : '';\n    }\n    return '';\n}\n\nexport function getFileExtension(url?: string): string | undefined {\n    if (url) {\n        const matches = url.match(/\\.[0-9a-z]{1,4}$/i);\n        if (matches) {\n            return matches[0].substr(1).toLowerCase();\n        }\n    }\n}\n\nexport function removeFileExtension(value: string): string {\n    return value.replace(/\\.(jpg|png|gif|svg|mp4)$/, '');\n}\n\nexport function isVideoFile(url: string): boolean {\n    const ext = getFileExtension(url);\n    if (ext) {\n        return /(mp4|mov|webm|h264)/.test(ext);\n    }\n    return false;\n}\n\nexport function isSVGFile(url: string): boolean {\n    const ext = getFileExtension(url);\n    if (ext) {\n        return ext === 'svg';\n    }\n    return false;\n}\n\nexport function isInLocalEnvironment(): boolean {\n    if (!window) {\n        return false;\n    }\n    if (window.location.protocol === 'file:') {\n        return true;\n    }\n\n    return false;\n}\n\nexport function getOrigin(str: string): string {\n    try {\n        const url = new URL(str);\n        return url.origin;\n    }\n    catch {\n        try {\n            if (!isUrl(str)) {\n                throw new Error('Provided value is not a valid url.');\n            }\n            const a = document.createElement('a');\n            a.href = str;\n            return a.origin;\n        }\n        catch (e) {\n            throw new Error(e as string);\n        }\n    }\n}\n\nexport function getFileName(url: string): string {\n    const segments = new URL(url).pathname.split('/');\n    return segments.pop() || url;\n}\n\nexport function addMissingProtocol(url: string): string {\n    return /https?:\\/\\//.test(url) ? url : 'https://' + url;\n}\n","import { OneOfElementDataNodes } from '@studio/domain';\nimport { uuidv4 } from '../../utils/utils';\nimport { ActionOperationMethod, ActionTrigger, IAction, ReservedActionId, MouseOrTouchEvent } from '../../domain/action';\nimport { DEFAULT_TIMING_FUNCTION } from '../timing-functions';\n\n\ninterface ICreateActionOptions {\n    target?: string;\n    stateId?: string;\n    method?: ActionOperationMethod;\n    triggers?: ActionTrigger[];\n    templateId?: ReservedActionId;\n    preventClickThrough?: boolean;\n}\n\nexport function createAction(options: ICreateActionOptions = {}): IAction {\n\n    if (!options.target) {\n        if (options.templateId) {\n            throw new Error('Actions with templateId requires a target.');\n        }\n\n        if (options.stateId) {\n            throw new Error('Actions with state IDs requires a target.');\n        }\n    }\n\n\n    if (options.triggers?.find(trigger => trigger === ActionTrigger.TouchEnd)) {\n        options.triggers.push(ActionTrigger.TouchCancel);\n    }\n\n    const action: IAction = {\n        id: uuidv4(),\n        triggers: options.triggers?.length\n            ? options.triggers\n            : [ActionTrigger.MouseDown],\n        operations: [{\n            method: options.method || ActionOperationMethod.SetState,\n            value: options.method === ActionOperationMethod.OpenUrl\n                ? ''\n                : options.stateId || undefined,\n            target: options.target || undefined,\n            animation: DEFAULT_ACTION_ANIMATION\n        }],\n        conditions: [],\n        disabled: false,\n        templateId: options.templateId,\n        preventClickThrough: options.preventClickThrough\n    };\n\n    return action;\n}\n\ninterface IActionEventListeners {\n    ActionHandler: IActionHandler;\n}\n\nexport interface IActionHandler {\n    callback: (event: MouseOrTouchEvent, trigger: ActionTrigger, forceClearStates?: boolean) => void;\n}\n\nexport function registerActionEventHandlers(ActionHandler: IActionHandler): IActionEventListeners {\n    const triggers: IActionEventListeners = {} as IActionEventListeners;\n    for (const trigger in ActionTrigger) {\n        triggers[ActionTrigger[trigger]] = (event: MouseOrTouchEvent, forceClearStates?: boolean): void => ActionHandler.callback(event, ActionTrigger[trigger], forceClearStates);\n    }\n    return triggers;\n}\n\nexport function isReservedAction(action: IAction): boolean {\n    return !!action.templateId;\n}\n\nexport function hasActionPreventClickthrough(dataElement?: OneOfElementDataNodes): boolean {\n    const actions = dataElement?.actions;\n    if (!actions) {\n        return false;\n    }\n\n    return actions.some(action =>\n        !action.disabled && action.preventClickThrough\n    );\n}\n\nexport function hasActionTargetUrl(dataElement?: OneOfElementDataNodes): boolean {\n    const actions = dataElement?.actions;\n    if (!actions) {\n        return false;\n    }\n\n    return actions.some(action =>\n        !action.disabled &&\n        action.operations.some(op => op.method === ActionOperationMethod.OpenUrl && op.value)\n    );\n}\n\nexport function isCancelTrigger(trigger: ActionTrigger): boolean {\n    return trigger === ActionTrigger.MouseLeave\n        || trigger === ActionTrigger.TouchEnd\n        || trigger === ActionTrigger.TouchCancel;\n}\n\nexport function isStateActionMethod(method: ActionOperationMethod): boolean {\n    const stateMethods = [\n        ActionOperationMethod.SetState,\n        ActionOperationMethod.RemoveState,\n        ActionOperationMethod.ClearStates\n    ];\n\n    return stateMethods.indexOf(method) > -1;\n}\n\n\nexport const DEFAULT_ACTION_ANIMATION = {\n    timingFunction: DEFAULT_TIMING_FUNCTION,\n    duration: 0.2\n};\n","import { handleError } from '@studio/utils/errors';\nimport { capitalize, getUniqueName } from '@studio/utils/string';\nimport { clamp, deepEqual, omit, toFixedDecimal, uuidv4 } from '@studio/utils/utils';\nimport { ISerializedAnimation, ISerializedDataElement, IAnimationTemplate, IAnimation, IAnimationKeyframe, AnimationType, OneOfElementDataNodes, IAnimationSettings, TimingFunctionKey, IState, ITime, ITimeAndDuration, OneOfStatePropertyKeys, keyframeProperties, animatableProperties, OneOfDataNodes } from '@studio/domain';\nimport { createEmptyState, getStateById, isEmptyState, isEqualStates } from '@creative/rendering/states.utils';\nimport { DEFAULT_TIMING_FUNCTION } from './timing-functions';\nimport { isHidden } from './nodes/helpers';\n\n/**\n * Time in second between large.\n */\nexport const IN_OUT_ANIMATION_GAP = 0.02;\nexport const MIN_ELEMENT_DURATION = 0.1;\nexport const MIN_ANIMATION_DURATION = 0.1;\nexport const MIN_KEYFRAME_DISTANCE = 0.08;\nexport const KEYFRAME_SNAP_DISTANCE = 0.02;\n\nexport type TimelineResizeDirection = 'left' | 'right' | 'both';\n\nexport type KeyframeTemplate = ITime & Partial<IState & IAnimationKeyframe>;\ntype KeyframeAndState = { keyframe: IAnimationKeyframe, state: IState };\ntype KeyframesAndStates = { keyframes: IAnimationKeyframe[], states: IState[] };\n\ninterface IAnimationInputSettings {\n    name?: string;\n    type?: AnimationType;\n    timingFunction?: TimingFunctionKey;\n}\n\nexport function addAnimationToElement(element: OneOfElementDataNodes, settings: IAnimationInputSettings = {}, keyframesTemplates: KeyframeTemplate[] = []): IAnimation {\n    const animation = createAnimation(element, settings);\n    const { keyframes, states } = createKeyframesAndStatesFromTemplates(...keyframesTemplates);\n\n    animation.keyframes.push(...keyframes);\n    element.animations.push(animation);\n    element.states.push(...states);\n\n    element.animations.sort(sortAnimations);\n\n    return animation;\n}\n\nexport function createAnimation(element: OneOfElementDataNodes, settings: IAnimationInputSettings = {}): IAnimation {\n    let name = getUniqueName(settings.name || 'Animation', element.animations.map(animation => animation.name));\n\n    if (isTransitionType(settings.type)) {\n        name += ' ' + settings.type;\n    }\n\n    const animation: IAnimation = {\n        id: uuidv4(),\n        keyframes: [],\n        name,\n        timingFunction: settings.timingFunction || DEFAULT_TIMING_FUNCTION,\n        type: settings.type || 'keyframe',\n    };\n    return animation;\n}\n\nexport function createKeyframesAndStatesFromTemplates(...templates: KeyframeTemplate[]): KeyframesAndStates {\n\n    const keyframeTemplates = templates.filter(t =>\n        Object.keys(filterKeyframePropertiesFromKeyframeTemplate(t)).length\n    );\n    const defaultTemplates = templates.filter(t => keyframeTemplates.indexOf(t) === -1);\n\n    // Create all keyframes that have a state\n    const { keyframes, states } = createKeyframesWithStates(...keyframeTemplates);\n\n    // Apply all default state keyframes\n    defaultTemplates.forEach(t => keyframes.push(createKeyframe(t)));\n\n    keyframes.sort(sortByTime);\n\n    return { keyframes, states };\n}\n\nexport function createKeyframesWithStates(...keyframeTemplates: KeyframeTemplate[]): KeyframesAndStates {\n    const states: IState[] = [];\n    const keyframes: IAnimationKeyframe[] = [];\n\n    for (let i = 0; i < keyframeTemplates.length; i++) {\n\n        const k = keyframeTemplates[i];\n\n        const stateProps = filterKeyframePropertiesFromKeyframeTemplate(k);\n\n        const newState = createEmptyState();\n        const state = {\n            ...newState,\n            ...stateProps,\n            id: newState.id\n        };\n        states.push(state);\n\n        k.stateId = newState.id;\n\n        keyframes.push(createKeyframe(k));\n    }\n    keyframes.sort(sortByTime);\n\n    return { keyframes, states };\n}\n\n/**\n * Get duration of an animation\n * @param animation\n */\nexport function getAnimationDuration(animation: IAnimation | IAnimationTemplate): number {\n    return getDuration(...animation.keyframes);\n}\n\n/**\n * Get time when animation starts.\n * Note that time is relative to element.time\n * @param animation\n */\nexport function getAnimationTime(animation: IAnimation): number {\n    return getTime(...animation.keyframes);\n}\n\n\n// export function getDurationOfAnimations(animations: IAnimation[]): number {\n//     let from = Number.MAX_VALUE;\n//     let to = 0;\n\n//     if (animations && animations.length) {\n//         animations.forEach(animation => {\n//             const start = getAnimationTime(animation);\n//             const end = start + getAnimationDuration(animation);\n//             from = Math.min(from, start);\n//             to = Math.min(to, end);\n//         });\n//         return to - from;\n//     }\n//     return 0;\n// }\n\n/**\n * Change duration of a single animation.\n */\nexport function setAnimationDuration(animation: IAnimation, duration: number): void {\n    const { keyframes, type } = animation;\n    if (!keyframes || !keyframes.length) {\n        throw new Error(`Can't set duration on an animation without keyframes`);\n    }\n\n    duration = Math.max(getMinAnimationDuration(animation), duration);\n\n    validateDuration(duration);\n\n    const currentDuration = getAnimationDuration(animation);\n\n    // Single keyframes have 0 duration which can't scale...\n    if (currentDuration) {\n        const scale = duration / currentDuration;\n\n        // The keyframe that should stay in place (0 for everything fluid)\n        const reference = isTransitionType(type) ? (type === 'out' ? keyframes[keyframes.length - 1] : keyframes[0]).time : 0;\n\n        keyframes.forEach((keyframe) => {\n            const dt = keyframe.time - reference;\n            keyframe.time = reference + dt * scale;\n            keyframe.duration = (keyframe.duration || 0) * scale;\n        });\n    }\n}\n\nexport function fixTransitionKeyframesAlign(element: OneOfElementDataNodes, animation: IAnimation): void {\n    const keyframes = animation.keyframes;\n    if (keyframes.length > 1) {\n        if (animation.type === 'in') {\n            keyframes[0].time = 0;\n        }\n        else if (animation.type === 'out') {\n            keyframes[keyframes.length - 1].time = element.duration - keyframes[keyframes.length - 1].duration;\n        }\n    }\n}\n\n/**\n * Remove all animations of a ceratin type\n */\nexport function removeAnimationsOfType(element: OneOfElementDataNodes, type: AnimationType): IAnimation[] {\n    return removeAnimations(element, ...element.animations.filter((animation: IAnimation) => animation.type === type));\n}\n\n/**\n * Remove a selection of animations from the array of animations\n * @param animations\n * @param animationsToRemove\n */\nexport function removeAnimations(element: OneOfElementDataNodes, ...animationsToRemove: IAnimation[]): IAnimation[] {\n    const removedAnimations: IAnimation[] = [];\n    const animations = element.animations;\n    for (let i = animations.length - 1; i >= 0; i--) {\n        const removeIndex = animationsToRemove.findIndex(remove => animations[i].id === remove.id);\n        if (removeIndex > -1) {\n            animationsToRemove.splice(removeIndex, 1);\n            removedAnimations.push(animations.splice(i, 1)[0]);\n        }\n    }\n    removeAnimationStates(element, removedAnimations);\n    return removedAnimations;\n}\n\n/**\n * Remove states not used by a set of animations\n * @param element\n * @param animationsToRemove\n */\nexport function removeAnimationStates(element: OneOfElementDataNodes, animationsToRemove: IAnimation[]): void {\n    if (animationsToRemove.length) {\n        const persistentAnimations = element.animations.filter(animation => !animationsToRemove.some(a => a === animation));\n        const persistentKeyframes = getAllKeyframes(persistentAnimations);\n        const keyframesToBeRemoved = getAllKeyframes(animationsToRemove);\n\n        const idsToRemove = keyframesToBeRemoved\n            .map(keyframe => keyframe.stateId)\n            .filter(id => id && !persistentKeyframes.some(keyframe => id === keyframe.stateId));\n\n        element.states = element.states.filter(state => !idsToRemove.some(id => state.id === id));\n    }\n}\n\nexport function removeKeyframes(element: OneOfElementDataNodes, keyframes: IAnimationKeyframe[]): void {\n\n    const statesToRemove = new Set<string>();\n\n    element.animations.forEach(animation => {\n        keyframes.forEach(keyframe => {\n            const keyframeToRemove = animation.keyframes.find(kf =>\n                kf === keyframe\n            );\n\n            if (keyframeToRemove) {\n                statesToRemove.add(keyframeToRemove.stateId!);\n\n                animation.keyframes = animation.keyframes.filter(kf => kf !== keyframe);\n            }\n        });\n\n    });\n\n    element.states = element.states.filter(state => !statesToRemove.has(state.id!));\n}\n\n/**\n * Moive animation without changing the duration.\n * Remember that keyframe.time is relative to element.time.\n * @param animation\n * @param relativeTime\n */\nexport function moveAnimationTo(animation: IAnimation, relativeTime: number): number {\n    const dt = relativeTime - getAnimationTime(animation);\n    animation.keyframes.forEach(keyframe => keyframe.time += dt);\n    return relativeTime;\n}\n\n/**\n * Align an animation to end or start of an element.\n * @param animation\n * @param elementDuration\n * @param alignTo\n */\nexport function alignAnimation(animation: IAnimation, elementDuration: number, alignTo: TimelineResizeDirection): number {\n    const duration = getAnimationDuration(animation);\n    let origin = alignTo === 'both' ? 0.5 : 0;\n    if (alignTo === 'right') {\n        origin = 1;\n    }\n    const moveTo = origin * (elementDuration - duration);\n    return moveAnimationTo(animation, moveTo);\n}\n\n/**\n * Get duration of all in animations\n */\nexport function getInAnimationDuration(animations: IAnimation[]): number {\n    return getAnimationDurationOfType(animations, 'in');\n}\n\n/**\n * Get duration of all out animations\n */\nexport function getOutAnimationDuration(animations: IAnimation[]): number {\n    return getAnimationDurationOfType(animations, 'out');\n}\n\n\n/**\n * Get duration of all out animations\n */\nexport function getAnimationDurationOfType(animations: IAnimation[], type: AnimationType): number {\n    return getDurationOfAnimations(animations.filter((animation: IAnimation) => animation.type === type));\n}\n\n\n/**\n * Set the duration of all in animations\n * @param animations\n * @param duration\n */\nexport function setInDuration(element: OneOfElementDataNodes, duration: number): void {\n    setDurationOfType(element, duration, 'in');\n}\n\n\n/**\n * Set the duration of all out animations\n * @param animations\n * @param duration\n */\nexport function setOutDuration(element: OneOfElementDataNodes, duration: number): void {\n    setDurationOfType(element, duration, 'out');\n}\n\n/**\n * Helper to change duration from other anchorpoints than element.time\n */\nexport function getDirectionalDurationChange(current: ITimeAndDuration, newDuration: number, direction: TimelineResizeDirection = 'right', limit: { left?: number, right?: number} = {}): ITimeAndDuration {\n    const leftLimit = limit.left || 0;\n    const rightLimit = limit.right;\n\n    const { duration } = current;\n    let origin = direction === 'both' ? 0.5 : 0;\n    if (direction === 'left') {\n        origin = 1;\n    }\n    const durationDifference = newDuration - duration;\n    let newTime = current.time - durationDifference * origin;\n\n    if (newTime < leftLimit) {\n        newDuration += origin ? (newTime - leftLimit)  / origin : 0;\n        newTime = leftLimit;\n    }\n    if (typeof rightLimit === 'number') {\n        const overflow = newTime + newDuration - rightLimit;\n        if (overflow > 0) {\n            newDuration -= overflow - (overflow * origin);\n            newTime -= overflow * origin;\n        }\n    }\n\n    return {\n        time: newTime,\n        duration: newDuration\n    };\n}\n\nexport function setDurationOfElements(elements: OneOfElementDataNodes[], newDuration: number, direction: TimelineResizeDirection = 'right'): void {\n    newDuration = Math.max(newDuration, getMinDurationOfElements(...elements));\n\n    const current = getTimeAndDuration(...elements);\n    const directionalChange = getDirectionalDurationChange(current, newDuration, direction);\n    const timeDiff = directionalChange.time - current.time;\n    const durationDiff = directionalChange.duration - current.duration;\n\n    elements.forEach(element => {\n        setElementTimeAndDuration(element, element.time + timeDiff, element.duration + durationDiff);\n    });\n}\n\nexport function setElementDuration(element: OneOfElementDataNodes, newDuration: number, direction: TimelineResizeDirection = 'right'): void {\n\n    if (element.duration !== newDuration) {\n        newDuration = Math.max(getMinElementDuration(element), newDuration);\n        const { time, duration } = getDirectionalDurationChange(element, newDuration, direction);\n        const outAnimations = getAnimationsOfType(element, 'out');\n\n        outAnimations.forEach(animation => {\n            // Distance in seconds from \"end\"\n            const diff = element.duration - getAnimationTime(animation);\n            moveAnimationTo(animation, duration - diff);\n        });\n\n        const keyframeAnimations = getAnimationsOfType(element, 'keyframe');\n        // const keyframesDuration = getA\n        keyframeAnimations.forEach(animation => {\n            scaleAnimationToElementDuration(animation, element.duration, duration);\n        });\n        element.duration = duration;\n        element.time = time;\n        validateAnimations(element);\n    }\n}\n\nexport function setElementTimeAndDuration(element: OneOfElementDataNodes, time: number, duration: number): void {\n    setElementDuration(element, duration);\n    element.time = time;\n}\n\nexport function setDurationOfType(element: OneOfElementDataNodes, duration: number, type: AnimationType): void {\n    const animations = element.animations.filter((animation: IAnimation) => animation.type === type);\n    setDurationOfAnimations(element, animations, duration);\n}\n\nexport function moveElementToPlayhead(element: OneOfElementDataNodes, elements: ITimeAndDuration[], playheadTime: number): void {\n\n    // Exclude itself\n    elements = elements.filter(e => e !== element);\n\n    const timeAndDuration = getTimeAndDuration(...elements);\n    const creativeDuration = timeAndDuration.time + timeAndDuration.duration;\n\n    let newTime = Math.max(0, playheadTime - getInAnimationDuration(element.animations));\n\n    // With no elemets duration is 0\n    if (creativeDuration) {\n        newTime = clamp(newTime, 0, Math.max(0, creativeDuration - element.duration));\n    }\n    else {\n        newTime = 0;\n    }\n\n    element.time = newTime;\n}\n\n/**\n * Scale a bunch of animations so they \"cover\" the given duration\n * @param animations\n * @param duration\n */\nexport function setDurationOfAnimations(element: OneOfElementDataNodes, animations: IAnimation[], duration: number): void {\n\n    if (animations?.length) {\n\n        const { type } = animations[0];\n\n        // When scaling in and out animations make sure they don't overlap the opposite type animations\n        if (isTransitionType(type) && animations.every(a => a.type === type)) {\n            duration = Math.min(duration, getMaxAnimationDuration(element, animations[0]));\n        }\n\n        duration = Math.max(MIN_ANIMATION_DURATION, duration);\n\n        validateDuration(duration);\n\n        const currentDuration = getDurationOfAnimations(animations);\n        const scale = duration / currentDuration;\n\n        animations.forEach(animation => {\n            const animationDuration = getAnimationDuration(animation);\n\n            // Set to full duration if animation has no duration\n            const newDuration = (animationDuration || currentDuration) * scale;\n\n            if (!isNaN(scale)) {\n                if (animation.keyframes.length > 1) {\n                    setAnimationDuration(animation, newDuration);\n                }\n                else {\n                    scaleKeyframeAnimation(animation, scale);\n                }\n            }\n        });\n    }\n}\n\nexport function scaleAnimationToElementDuration(animation: IAnimation, oldDuration: number, newDuration: number): void {\n    const animationDuration = getAnimationDuration(animation);\n    const scale = newDuration / oldDuration;\n\n    // Only animations that have durations can be scaled\n    if (animationDuration) {\n        setAnimationDuration(animation, animationDuration * scale);\n    }\n    // Typically for animations with only one keyframe\n    else {\n        scaleKeyframeAnimation(animation, scale);\n    }\n}\n\n/**\n * Move all keyframes in an animations by a scale.\n * Note: setAnimationDuration should be the prefered method for this\n * since it can handle in/out animations.\n * @param animation\n * @param scale\n */\nexport function scaleKeyframeAnimation(animation: IAnimation, scale: number): void {\n    if (animation.type !== 'keyframe') {\n        throw new Error('Can only scale keyframe animations');\n    }\n    if (!scale) {\n        throw new Error('A positive scale must be provided');\n    }\n    animation.keyframes.forEach(k => {\n        k.time *= scale;\n        k.duration = k.duration * scale;\n    });\n}\n\n/**\n * Get the total duration of a group of animations.\n * Note: This is not returning just the longest duration.\n * So the duration of the in and out animation will be element.duration.\n */\nexport function getDurationOfAnimations(animations: IAnimation[]): number {\n    return getDuration(...getAllKeyframes(animations));\n}\n\nexport function getTimeOfAnimations(animations: IAnimation[]): number {\n    return getTime(...getAllKeyframes(animations));\n}\n\nexport function getTimeAndDurationOfAnimations(animations: IAnimation[]): ITimeAndDuration {\n    return getTimeAndDuration(...getAllKeyframes(animations));\n}\n\nexport function getAnimationKeyframesOfType(element: OneOfElementDataNodes, type: AnimationType): IAnimationKeyframe[] {\n    const animations = getAnimationsOfType(element, type);\n    return animations.reduce<IAnimationKeyframe[]>((acc, curr) => [...acc, ...curr.keyframes], []);\n}\n\n/**\n * TODO: SUPPORT MORE CASES THAN IN/OUT\n */\nexport function isElementInMainStateAtTime(element: OneOfElementDataNodes, time: number): boolean {\n    if (!isElementVisibleAtTime(element, time)) {\n        return false;\n    }\n    const inDuration = getInAnimationDuration(element.animations) || 0;\n    const outDuration = getOutAnimationDuration(element.animations) || 0;\n    const inTime = element.time + inDuration;\n    const outTime =  element.time + element.duration - outDuration;\n    const tolerance = 0.000001;\n\n    // Sometimes javascript gives you number like 7.6000000000000005 despite rounding.\n    if (Math.abs(inTime - time) < tolerance || Math.abs(outTime - time) < tolerance) {\n        return true;\n    }\n    // normal compare\n    else if (time < inTime || time > outTime) {\n        return false;\n    }\n\n    return true;\n}\n\nexport function validateKeyframeToStatesMapping(element: OneOfElementDataNodes | ISerializedDataElement): boolean {\n    const keyframes = getAllKeyframes(element);\n    for (const keyframe of keyframes) {\n        if (keyframe.stateId) {\n            if (!element.states?.some(state => state.id === keyframe.stateId)) {\n                throw new Error('Keyframe is missing corresponding state');\n            }\n        }\n    }\n    // TODO: Add more cases when actions etc is applied\n    if (element.states) {\n        for (const state of element.states) {\n            if (state.name) {\n                continue;\n            }\n\n            /**\n             * When creating animation keyframes, the state\n             * is initially always empty without references\n             */\n            const stateProps = Object.keys(state);\n            let emptyValidState = false;\n            if (stateProps.length === 1 && stateProps[0] === 'id') {\n                emptyValidState = true;\n            }\n\n            if ((!state.id) || !emptyValidState && !keyframes.some(keyframe => state.id === keyframe.stateId)) {\n                throw new Error('State without any references detected');\n            }\n        }\n    }\n    return true;\n}\n\n\nexport function getAnimationsOfType(element: OneOfElementDataNodes, type: AnimationType): IAnimation[] {\n    return (element.animations || []).filter(a => a.type === type);\n}\n\n\nexport function hasAnimationsOfType(element: OneOfElementDataNodes, type: AnimationType): boolean {\n    return getAnimationsOfType(element, type).length > 0;\n}\n\n\nexport function isElementVisibleAtTime(element: OneOfDataNodes, time: number): boolean {\n    return !isHidden(element) && isTimeAt(time, element);\n}\n\nexport function getAnimationTypeAtTime(element: OneOfElementDataNodes, time: number): 'in' | 'out' | 'keyframe' | undefined {\n    const animations = getAnimationsAtTime(element, time);\n    if (animations.length) {\n        const transition = animations.find(a => isTransitionType(a.type));\n        if (transition) {\n            return transition.type as 'in' | 'out';\n        }\n        return animations[0].type as 'keyframe';\n    }\n\n    return undefined;\n}\n\nexport function getAnimationsAtTime(element: OneOfElementDataNodes, absoluteTime: number): IAnimation[] {\n    const relativeTime = toRelativeTime(element, absoluteTime);\n\n    return element.animations.filter(animation =>\n        isTimeAt(relativeTime, getTimeAndDuration(...animation.keyframes))\n    );\n}\n\nexport function getTimelineOverlap(position1: ITimeAndDuration, position2: ITimeAndDuration): ITimeAndDuration | undefined {\n    const from = Math.max(position1.time, position2.time);\n    const to = Math.min(position1.time + position1.duration, position2.time + position2.duration);\n    const duration = to - from;\n    if (duration > 0) {\n        return {\n            time: from,\n            duration\n        };\n    }\n}\n\nexport function getMainStateOverlap(element1: OneOfElementDataNodes, element2: OneOfElementDataNodes): ITimeAndDuration | undefined {\n    return getTimelineOverlap(getMainStateTimelinePosition(element1), getMainStateTimelinePosition(element2));\n}\n\nexport function isTimelineOverlap(position1: ITimeAndDuration, position2: ITimeAndDuration): boolean {\n    return getTimelineOverlap(position1, position2) !== undefined;\n}\n\nexport function isMainStateOverlap(element1: OneOfElementDataNodes, element2: OneOfElementDataNodes): boolean {\n    return isTimelineOverlap(getMainStateTimelinePosition(element1), getMainStateTimelinePosition(element2));\n}\n\nexport function getMainStateTimelinePosition(element: OneOfElementDataNodes): ITimeAndDuration {\n    const inDuration = getInAnimationDuration(element.animations);\n    const outDuration = getOutAnimationDuration(element.animations);\n    return {\n        time: element.time + inDuration,\n        duration: element.duration - (inDuration + outDuration)\n    };\n}\n\nexport function getAnimationByKeyframe(element: OneOfElementDataNodes, keyframe: IAnimationKeyframe): IAnimation | undefined {\n    return element.animations.find(animation => animation.keyframes.some( k => k === keyframe));\n}\n\nexport function getAllKeyframes(elementOrAnimations: OneOfElementDataNodes | ISerializedDataElement | IAnimation[] | ISerializedAnimation[]): IAnimationKeyframe[] {\n    const animations = Array.isArray(elementOrAnimations) ? elementOrAnimations : elementOrAnimations.animations;\n    const keyframes: IAnimationKeyframe[] = [];\n    animations?.forEach(animation => keyframes.push(...animation.keyframes));\n    return keyframes;\n}\n\nexport function getElementOfAnimation(elements: ReadonlyArray<OneOfElementDataNodes>, animation: IAnimation): OneOfElementDataNodes | undefined {\n    return elements.find(el => el.animations.find(ani => ani === animation));\n}\n\nexport function getElementAndAnimationOfKeyframe(elements: ReadonlyArray<OneOfElementDataNodes>, keyframe: IAnimationKeyframe): { element: OneOfElementDataNodes, animation: IAnimation } | undefined {\n    for (const element of elements) {\n        const animation = getAnimationOfKeyframe(element, keyframe);\n        if (animation) {\n            return { element, animation };\n        }\n    }\n}\n\nexport function getAnimationOfKeyframe(elementOrAnimations: OneOfElementDataNodes | IAnimation[], keyframe: IAnimationKeyframe): IAnimation | undefined {\n    const animations = Array.isArray(elementOrAnimations) ? elementOrAnimations : elementOrAnimations.animations;\n    return animations.find(animation => animation.keyframes.some(k => k === keyframe));\n}\n\nexport function createKeyframe(options: ITime & Partial<IAnimationKeyframe>): IAnimationKeyframe {\n    const keyframe: IAnimationKeyframe = {\n        id: uuidv4(),\n        time: options.time,\n        stateId: options.stateId,\n        timingFunction: options.timingFunction || DEFAULT_TIMING_FUNCTION,\n        duration: options.duration || 0\n    };\n\n    return keyframe;\n}\n\n\nexport function addKeyframe(element: OneOfElementDataNodes, animation: IAnimation, options: ITime & Partial<IAnimationKeyframe>): IAnimationKeyframe | undefined {\n    const keyframe = createKeyframe({ ...options, time: -1 });\n\n    animation.keyframes.unshift(keyframe);\n\n    const time = moveKeyframeTo(element, animation, keyframe, options.time);\n\n    // Could not place the element\n    if (time === undefined) {\n        handleError('Could not place keyframe', {\n            level: 'warning'\n        });\n\n        animation.keyframes.shift();\n    }\n\n    return time === undefined ? undefined : keyframe;\n}\n\nexport function addKeyframeWithState(element: OneOfElementDataNodes, animation: IAnimation, properties: ITime & Partial<IState & IAnimationKeyframe>): KeyframeAndState | undefined {\n    const previousKeyframe = getPreviousTime(animation.keyframes, properties.time);\n    const { keyframes, states } = createKeyframesWithStates({\n        // If there is a previous timing function, duplicate that for the new keyframe\n        timingFunction: previousKeyframe?.timingFunction,\n        ...properties,\n    });\n\n    const keyframe = addKeyframe(element, animation, keyframes[0]);\n    if (!keyframe) {\n        console.warn('Cant add new keyframe');\n        return;\n    }\n    const state = states[0];\n    element.states.push(state);\n    return { state, keyframe };\n}\n\nexport function getClosestGap(time: ITime, elements: ITime[], totalDuration: number, minDistance = 0): number | undefined {\n    // Fastest way, no obstacles in the way from start\n    if (!elements.some(element => getTimeBetween(element, time) < minDistance)) {\n        return time.time;\n    }\n    // Do a more sophisticated calculation of the closest available position\n    else if (elements.length) {\n        const first = elements[0];\n        const last = elements[elements.length - 1];\n\n        // Get all gaps between keyframes that the keyframe to move can fit between\n        const availableGaps = elements\n            .slice(1)\n            .map((k, i) => ({\n                    time: elements[i].time + (elements[i].duration || 0) + minDistance,\n                    duration: getTimeBetween(elements[i], k) - minDistance * 2\n                }))\n            .filter(k => k.duration >= (time.duration || 0));\n\n        // Add available gap at start of element\n        if (first.time >= (time.duration || 0) + minDistance) {\n            availableGaps.unshift({\n                time: 0,\n                duration: first.time - minDistance\n            });\n        }\n        // Add available gap of the end of element\n        if (last.time + minDistance + (time.duration || 0) <= totalDuration) {\n            availableGaps.push({\n                time: last.time + (last.duration || 0) + minDistance,\n                duration: time.duration || 0\n            });\n        }\n\n        if (availableGaps.length) {\n            return availableGaps\n                // Convert to numeric time\n                .map(g => clamp(time.time, g.time, g.time + g.duration - (time.duration || 0)))\n                // Find position closest to relativeTime\n                .reduce((prev, curr) =>  (Math.abs(curr - time.time) < Math.abs(prev - time.time) ? curr : prev));\n        }\n    }\n\n}\n\nexport function moveKeyframeTo(element: OneOfElementDataNodes, animation: IAnimation, keyframe: IAnimationKeyframe, relativeTime: number): number | undefined {\n    const duration = keyframe.duration || 0;\n    const type = animation.type;\n    let keyframes = animation.keyframes;\n    const index = keyframes.indexOf(keyframe);\n    relativeTime = clamp(relativeTime, 0, element.duration - duration);\n\n    // Snap first keyframe to start\n    if (index === 0) {\n        relativeTime = relativeTime <= KEYFRAME_SNAP_DISTANCE ? 0 : relativeTime;\n    }\n    // Snap last keyframe to end\n    else if (index === keyframes.length - 1 && index !== -1) {\n        relativeTime = relativeTime >= element.duration - KEYFRAME_SNAP_DISTANCE ? element.duration : relativeTime;\n    }\n\n    // Make sure we're not allowing in/out animations to overlap\n    if (isTransitionType(type)) {\n        const minDuration = getMinAnimationDuration(animation);\n        const maxDuration = getMaxAnimationDuration(element, animation);\n        const reference = type === 'in' ? keyframes[0] : keyframes[keyframes.length - 1];\n        if (reference !== keyframe) {\n            const min = type === 'in' ? minDuration - duration : reference.time + reference.duration - maxDuration;\n            const max = type === 'in' ? reference.time + maxDuration : reference.time + reference.duration - minDuration;\n            relativeTime = clamp(relativeTime, min, max);\n        }\n    }\n\n    // Filter out the keyframe we want to move from the calculations\n    keyframes = keyframes.filter(k => k !== keyframe);\n\n    const newTime = getClosestGap(\n        { time: relativeTime, duration },\n        keyframes,\n        element.duration,\n        MIN_KEYFRAME_DISTANCE\n    );\n\n    if (typeof newTime === 'number') {\n        keyframe.time = toFixedDecimal(newTime, 2);\n        animation.keyframes.sort(sortByTime);\n    }\n    return newTime;\n}\n\nexport function setKeyframeDuration(element: OneOfElementDataNodes, animation: IAnimation, keyframe: IAnimationKeyframe, newDuration: number, direction: TimelineResizeDirection = 'right'): number {\n\n    if (keyframe.duration !== newDuration) {\n        newDuration = Math.min(newDuration, getMaxKeyframeDuration(element, animation, keyframe));\n        const keyframes = animation.keyframes.filter(k => k !== keyframe);\n        const next = getNextTime(keyframes, keyframe.time);\n        const prev = getPreviousTime(keyframes, keyframe.time);\n        const limit = {\n            left: prev ? prev.time + prev.duration + MIN_KEYFRAME_DISTANCE : 0,\n            right: next ? next.time - MIN_KEYFRAME_DISTANCE : element.duration\n        };\n        const { time, duration } = getDirectionalDurationChange(keyframe, newDuration, direction, limit);\n\n        keyframe.duration = duration;\n        keyframe.time = time;\n    }\n    return keyframe.duration;\n}\n\nexport function isEmptyKeyframe(element: OneOfElementDataNodes, keyframe: IAnimationKeyframe): boolean {\n    const state = getStateById(element, keyframe.stateId);\n    return !state || isEmptyState(state);\n}\n\nexport function keyframesHasEqualStates(element: OneOfElementDataNodes, ...keyframes: (IAnimationKeyframe | undefined)[]): boolean {\n    keyframes = keyframes.filter(k => k !== undefined) as IAnimationKeyframe[];\n\n\n    if (keyframes.length > 1) {\n\n        // At least one keyframe with a state, do a compare.\n        if (keyframes.some(k => k?.stateId)) {\n            const states = keyframes.map(k => getStateById(element, k!.stateId));\n            return isEqualStates(...states);\n        }\n        // This means all frames are default keyframes\n        return true;\n    }\n    return false;\n}\n\nexport function getKeyframesAtTime(time: number, element: OneOfElementDataNodes, animations?: IAnimation[], type?: AnimationType, tolerance?: number): IAnimationKeyframe[] {\n    animations = animations || element.animations;\n\n    if (type) {\n        animations = animations.filter(a => a.type === type);\n    }\n\n    const keyframes: IAnimationKeyframe[] = [];\n\n    animations.forEach(animation => {\n        keyframes.push(...getKeyframesOfAnimationAtTime(time, element, animation, tolerance));\n    });\n\n    return keyframes;\n}\n\nexport function getCustomKeyframes(element: OneOfElementDataNodes): IAnimationKeyframe[] {\n    const keyframes = getAllKeyframes(getAnimationsOfType(element, 'keyframe'))\n        .sort(sortByTime);\n\n    return keyframes;\n}\n\nexport function getPreviousTime<T extends ITime>(times: T[], time: ITime | number, tolerance: number = 0): T | undefined {\n    const t = numberToTime(time);\n    return times\n        .slice(0)\n        .sort(sortByTimeReversed)\n        .find(k => t !== k && k.time - tolerance <= t.time);\n}\n\nexport function getNextTime<T extends ITime>(times: T[], time: ITime | number, tolerance: number = 0): T | undefined {\n    const t = numberToTime(time);\n    return times\n        .slice(0)\n        .sort(sortByTime)\n        .find(k => t !== k && t.time <= k.time + tolerance);\n}\n\nexport function getSurroundingTimes(keyframes: IAnimationKeyframe[], absoluteTime: number, elementTime: number = 0, tolerance: number = 0): ISurroundingKeyframes {\n\n    const relativeTime = absoluteTime - elementTime;\n\n    return {\n        before: getPreviousTime(keyframes, relativeTime, tolerance),\n        after: getNextTime(keyframes, relativeTime, tolerance)\n    };\n}\n\nexport function getKeyframesOfAnimationAtTime(absoluteTime: number, element: OneOfElementDataNodes, animation: IAnimation, tolerance: number = 0.0001): IAnimationKeyframe[] {\n    const relativeTime = toRelativeTime(element, absoluteTime);\n    const keyframes = animation.keyframes.filter(keyframe =>\n        isTimeAt(relativeTime, keyframe, tolerance)\n    );\n\n    return keyframes;\n}\n\nexport function getKeyframeById(element: OneOfElementDataNodes, id: string): IAnimationKeyframe | undefined {\n    return getAllKeyframes(element).find(keyframe => keyframe.id === id);\n}\n\nexport function getKeyframeByStateId(element: OneOfElementDataNodes, stateId: string): IAnimationKeyframe | undefined {\n    return getAllKeyframes(element).find(keyframe => keyframe.stateId && keyframe.stateId === stateId);\n}\n\nexport function getAnimationByStateId(element: OneOfElementDataNodes, stateId: string): IAnimation | undefined {\n    for (const animation of element.animations) {\n        for (const keyframe of animation.keyframes) {\n            if (keyframe.stateId === stateId) {\n                return animation;\n            }\n        }\n    }\n}\n\nexport function isMainStateKeyframe(keyframe: IAnimationKeyframe): boolean {\n    return keyframe.stateId === undefined;\n}\n\nexport function getSettingsOfAnimations(animations: IAnimation[]): IAnimationSettings {\n    const settings: IAnimationSettings = {} as IAnimationSettings;\n    animations.forEach(a => {\n        if (a.settings) {\n            for (const key in a.settings) {\n                // TODO: duplicate or keep reference?\n                settings[key] = a.settings[key];\n            }\n        }\n    });\n    return settings;\n}\n\nexport function getNameOfAnimations(animations: IAnimation[]): string {\n    if (animations && animations.length) {\n        const names = animations.map(a => a.name).filter(name => name);\n        if (names.length) {\n            return names.join(', ');\n        }\n        const type = capitalize(animations[0].type || '');\n        return animations.length === 1 ? `${type} animation` : `${type} animations`;\n    }\n    return 'No animation';\n}\n\nexport function sortByTime(a: ITime, b: ITime): number {\n    return a.time - b.time || (a.duration || 0) - (b.duration || 0);\n}\n\nexport function sortByTimeReversed(a: ITime, b: ITime): number {\n    return b.time - a.time || (b.duration || 0) - (a.duration || 0);\n}\n\nexport function sortAnimations(a: IAnimation, b: IAnimation): number {\n    return getAnimationSortPrio(b) - getAnimationSortPrio(a);\n}\n\nfunction getAnimationSortPrio(animation: IAnimation): number {\n    if (animation.type === 'in') {\n        return 1;\n    }\n    if (animation.type === 'out') {\n        return 0;\n    }\n    return -1;\n}\n\nexport function validateAnimations(element: OneOfElementDataNodes): void {\n\n    let inDuration = 0;\n    let outDuration = 0;\n\n    element.animations.forEach((a) => {\n        const duration = getAnimationDuration(a);\n        const first = a.keyframes[0];\n        const last = a.keyframes[a.keyframes.length - 1];\n        const tolerance = 0.00001;\n\n        a.keyframes.forEach(k => {\n            if (!k.id) {\n                throw new Error('Keyframe is missing id');\n            }\n\n            if (k.time + k.duration > element.duration + 0.01 || k.time < 0) {\n                throw new Error('Invalid keyframe time');\n            }\n        });\n\n        if (a.type === 'out') {\n            if (Math.abs(first.time - (element.duration - duration)) > tolerance || Math.abs(element.duration - (last.time + last.duration)) > tolerance) {\n               handleError('Invalid out animation', {\n                    level: 'warning',\n                    contexts: {\n                        animation: a,\n                    }\n                });\n                fixTransitionKeyframesAlign(element, a);\n            }\n            outDuration = Math.max(outDuration, duration);\n        }\n        else if (a.type === 'in') {\n            if (first.time !== 0) {\n                handleError('Invalid in animation', {\n                    level: 'warning',\n                    contexts: {\n                        animation: a,\n                    }\n                });\n                fixTransitionKeyframesAlign(element, a);\n            }\n            inDuration = Math.max(inDuration, duration);\n        }\n    });\n\n    if (inDuration + outDuration > element.duration) {\n        throw new Error('Overlapping durations');\n    }\n}\n\nexport function validateDuration(duration: number): boolean {\n    if (typeof duration !== 'number' || !isFinite(duration) || duration < 0) {\n        throw new Error(`Invalid duration \"${duration}\"`);\n    }\n    return true;\n}\n\n/**\n * Get an absolute time, a value releative to time 0 of timeline.\n * Expects a time relative to an element to be passed as argument.\n * Like keyframe.time\n * @param element\n * @param relativeTime\n */\nexport function toAbsoluteTime(element: OneOfElementDataNodes, relativeTime: number): number {\n    return element.time + relativeTime;\n}\n\n/**\n * Get a relative time, a value releative to time of an element.\n * Expect a time relative to the start of timeline as argument.\n * Like element.time + keyframe.time\n * @param element\n * @param relativeTime\n */\nexport function toRelativeTime(element: OneOfElementDataNodes, absoluteTime: number): number {\n    return absoluteTime - element.time;\n}\n\n/**\n * Get \"leftmost\" point in time of multiple objects\n * @param times\n */\nexport function getTime(...times: ITime[]): number {\n    if (!times?.length) {\n        return 0;\n    }\n    return Math.min(...times.map(t => t.time));\n}\n\n/**\n * Get total duration from multiple objects. IE: \"rightmost\" - \"leftmost\")\n * @param times\n */\nexport function getDuration(...times: ITime[]): number {\n    if (!times?.length) {\n        return 0;\n    }\n    const from = getTime(...times);\n    const to = Math.max(...times.map(t => t.time + (t.duration || 0)));\n    return to - from;\n}\n\nexport function isTimeAt(time: ITime | number, target: ITime | number, tolerance: number = 0): boolean {\n    return isTimeBetween(time, target, target, tolerance);\n}\n\nexport function getEndTime(time: ITime): number {\n    return time.time + (time.duration || 0);\n}\n\nexport function isTimeBetween(time: ITime | number, t1: ITime | number, t2: ITime | number, tolerance: number = 0): boolean {\n    const t = toTimeAndDuration(time);\n    const from = toTimeAndDuration(t1);\n    const to = t1 === t2 ? from : toTimeAndDuration(t2);\n    return from.time - tolerance <= t.time && t.time + t.duration <= to.time + to.duration + tolerance;\n}\n\nexport function mergeOverlappingTimeAndDurations(times: ITime[], tolerance: number = 0): ITimeAndDuration[] {\n    return times\n        .sort(sortByTime)\n        .reduce((r: ITimeAndDuration[], timeSpan) => {\n            const last = r[r.length - 1];\n            const lastEnd = last && getEndTime(last);\n\n            // if (last && last.time <= timeSpan.time && timeSpan.time <= lastEnd) {\n            if (last && isTimeBetween(timeSpan.time, last.time, lastEnd, tolerance)) {\n                const end = getEndTime(timeSpan);\n                if (lastEnd < end) {\n                    last.duration = getDuration(last, timeSpan);\n                }\n                return r;\n            }\n            return r.concat(toTimeAndDuration(timeSpan));\n        }, [])\n        .sort(sortByTime);\n}\n\nexport function getTimeBetween(k1: ITime, k2: ITime): number {\n    const from = k1.time < k2.time ? k1 : k2;\n    const to = k1.time < k2.time ? k2 : k1;\n    return Math.max(0, to.time - (from.time + (from.duration || 0)));\n}\n\nfunction numberToTime(time: ITime | number): ITime {\n    return typeof time === 'number' ? { time } : time;\n}\n\nfunction toTimeAndDuration(time: ITime | number): ITimeAndDuration {\n    if (typeof time === 'number') {\n        return { time, duration: 0 };\n    }\n    if (time.duration === undefined) {\n        time.duration = 0;\n    }\n    return time as ITimeAndDuration;\n}\n\nexport function getMinDurationOfElements(...elements: OneOfElementDataNodes[]): number {\n\n    const totalDuration = getDuration(...elements);\n    const diff = Math.max(\n        ...elements.map(element => getMinElementDuration(element) - element.duration),\n        -totalDuration\n    );\n\n    return totalDuration + diff;\n}\n\nexport function getMinElementDuration(element: OneOfElementDataNodes): number {\n    const { animations } = element;\n\n    const keyframeAnimations = getAnimationsOfType(element, 'keyframe');\n    const inDuration = getInAnimationDuration(animations);\n    const outDuration = getOutAnimationDuration(animations);\n\n    const minInDuration = inDuration > 0 ? Math.max(MIN_ANIMATION_DURATION, inDuration) : 0;\n    const minOutDuration = outDuration > 0 ? Math.max(MIN_ANIMATION_DURATION, outDuration) : 0;\n    const minInOutDuration = minInDuration + minOutDuration > 0 ? minInDuration + IN_OUT_ANIMATION_GAP + minOutDuration : 0;\n\n    let minKeyframeDuration = 0;\n\n    if (keyframeAnimations.length) {\n        const scales = keyframeAnimations\n            .map(a => getMinAnimationDuration(a) / getAnimationDuration(a))\n            .filter(s => s > 0);\n\n        if (scales.length) {\n            minKeyframeDuration = element.duration * (Math.max(...scales) || 0);\n        }\n    }\n    return Math.max(minKeyframeDuration, minInOutDuration, MIN_ELEMENT_DURATION);\n}\n\nexport function getMinAnimationDuration(animation: IAnimation): number {\n    const { type, keyframes } = animation;\n    const duration  = getAnimationDuration(animation);\n    let min = isTransitionType(type) ? MIN_ANIMATION_DURATION : 0;\n\n    // Respect distancs between keyframes\n    if (keyframes.length > 1) {\n        const distances = keyframes\n            .slice(1)\n            .map((k, i) => getTimeBetween(keyframes[i], k));\n\n        const minDistance = Math.min(...distances);\n        if (minDistance) {\n            const scale = MIN_KEYFRAME_DISTANCE / minDistance;\n            min = Math.max(min, scale * duration);\n        }\n    }\n    return min;\n}\n\nexport function getMaxAnimationDuration(element: OneOfElementDataNodes, animation: IAnimation): number {\n    const { animations, duration } = element;\n    const { type } = animation;\n\n    if (isTransitionType(type)) {\n        return duration - (IN_OUT_ANIMATION_GAP + getAnimationDurationOfType(animations, invertInOutType(type)));\n    }\n    return duration;\n}\n\n/**\n * Get the available duration a certain keyframe might expand within.\n * Pass fromCurrentTime = true if you want to keep current keyframe.time\n */\nexport function getMaxKeyframeDuration(element: OneOfElementDataNodes, animation: IAnimation, keyframe: IAnimationKeyframe, fromCurrentTime?: boolean): number {\n\n        const keyframes = animation.keyframes.filter(k => k !== keyframe);\n        const time = keyframe.time;\n        const next = getNextTime(keyframes, time);\n        const prev = getPreviousTime(keyframes, time);\n        const to = next ? next.time - MIN_KEYFRAME_DISTANCE : element.duration;\n        let from = prev ? prev.time + prev.duration + MIN_KEYFRAME_DISTANCE : 0;\n\n        if (fromCurrentTime) {\n            from = keyframe.time;\n        }\n\n        return Math.max(0, to - from);\n}\n\n/**\n * Get timespans in which a property is animating\n * @param element\n * @param properties\n * @returns\n */\nexport function getTimePropertyIsAnimating(element: OneOfElementDataNodes, ...properties: OneOfStatePropertyKeys[]): ITimeAndDuration[] {\n    const times: ITimeAndDuration[] = [];\n\n    // No properties provided, => use all properties instead\n    if (!properties?.length) {\n        properties = [...animatableProperties];\n    }\n\n    element.animations.forEach(animation => {\n        const keyframes = animation.keyframes;\n        keyframes.forEach((keyframe, index) => {\n            const next = keyframes[index + 1];\n            if (next) {\n                const state = getStateById(element, keyframe.stateId) || {};\n                const nextState = getStateById(element, next.stateId) || {};\n                const change = properties.some(p => !deepEqual(state[p], nextState[p]));\n\n                if (change) {\n                    const duration = getTimeBetween(keyframe, next);\n                    times.push({ time: toAbsoluteTime(element, getEndTime(keyframe)), duration });\n                }\n            }\n        });\n    });\n\n    return mergeOverlappingTimeAndDurations(times);\n}\n\n/**\n * Get total time and duration from multiple objects.\n * Basically the bounding box\n * @param times\n */\nexport function getTimeAndDuration(...times: ITime[]): ITimeAndDuration {\n    return {\n        time: getTime(...times),\n        duration: getDuration(...times)\n    };\n}\n\nexport const inAnimationFilter = (animation: IAnimation): boolean => animation.type === 'in';\nexport const outAnimationFilter = (animation: IAnimation): boolean => animation.type === 'out';\nexport const transitionAnimationFilter = (animation: IAnimation): boolean => animation.type === 'out' || animation.type === 'in';\n\nexport function isTransitionAnimation(animation: IAnimation): boolean {\n    return isTransitionType(animation.type);\n}\n\nexport function isTransitionType(type?: AnimationType): type is 'in' | 'out' {\n    return type === 'in' || type === 'out';\n}\n\nexport function isTransitionEdgeKeyframe(animation: IAnimation, keyframe: IAnimationKeyframe): boolean {\n\n    const { type, keyframes } = animation;\n    if (isTransitionType(type)) {\n        const index = keyframes.indexOf(keyframe);\n        const edgeIndex = type === 'in' ? 0 : keyframes.length - 1;\n        return index === edgeIndex;\n    }\n\n    return false;\n}\n\nexport function isAnimation(animationOrKeyframe: IAnimation | IAnimationKeyframe | IAnimationKeyframe[]): animationOrKeyframe is IAnimation {\n    return 'keyframes' in animationOrKeyframe;\n}\n\nfunction invertInOutType(type: 'in' | 'out'): 'in' | 'out' {\n    if (type !== 'in' && type !== 'out') {\n        throw new Error('Can only invert in/out types');\n    }\n    return type === 'in' ? 'out' : 'in';\n}\n\nfunction filterKeyframePropertiesFromKeyframeTemplate(template: KeyframeTemplate): IState {\n    return omit(template, ...keyframeProperties);\n}\n\n\ninterface ISurroundingKeyframes {\n    after?: IAnimationKeyframe;\n    before?: IAnimationKeyframe;\n}\n","import { EventEmitter } from '@studio/utils/event-emitter';\nimport { inject, __inject } from '@studio/utils/di';\nimport { getInAnimationDuration, getOutAnimationDuration } from './animation.utils';\nimport { IAnimator } from './animator.header';\nimport { T } from './creative.container';\nimport { isSelectionVisibleAtTime } from '@creative/nodes/helpers';\nimport { CreativeDataNode } from '@creative/nodes/creative-data-node';\nimport { IRenderer } from './renderer.header';\n\n\nexport class Animator extends EventEmitter<AnimatorEventType> implements IAnimator {\n\n    /**\n     * Current time in seconds.\n     */\n    time = 0;\n\n    /**\n     * If the creative is playing or not.\n     */\n    isPlaying = false;\n\n    /**\n     * Loop currently playing. First loop has index 1.\n     */\n    loop = 1;\n\n    private _destroyed = false;\n\n    /**\n     * Duration of creative in seconds\n     */\n    get duration(): number {\n        return getCreativeAnimationDuration(this.creative);\n    }\n\n    private _preview = false;\n    private _startTimestamp = 0;\n    private _lastTime = 0;\n    private _requestId: number | undefined;\n    private _speed = 1;\n    private _elementsAnimationState = new Map<string, IElementState>();\n    /**\n     * Queue of events that has to occur after the current tick is completed.\n     * Required by e.g widgets to ensure that seeking happens after next (loop).\n     */\n    private _eventQueue: { fn: Function, value: any[] }[] = [];\n    private _isOmniRender = location.href.indexOf('isOmniRender') >= 0;\n\n    constructor(\n        @inject(T.CREATIVE_DATA) public creative: CreativeDataNode,\n        @inject(T.RENDERER) private _renderer: IRenderer\n    ) {\n        super();\n    }\n\n    /**\n     * Play the creative if not already playing\n     */\n    play(preview = false): Animator {\n        this._preview = preview;\n        if (!this.isPlaying && this.creative.elements.length > 0) {\n            if (this._preview && this.loop === 1) {\n                this.time = this._getStartTime();\n            }\n            this._lastTime = this.time * 1000;\n            this._requestId = requestAnimationFrame(this._tick);\n            this.isPlaying = true;\n            this._renderer.setPlaying_m(true);\n            this.emit('play', [this.time]);\n        }\n\n        return this;\n    }\n\n    /**\n     * Toggle between play and pause\n     */\n    toggle(): Animator {\n        this.isPlaying ? this.pause() : this.play();\n        return this;\n    }\n\n    /**\n     * Pause the creative if the creative is playing\n     */\n    pause(): Animator {\n        if (this.isPlaying) {\n            this._cancelAnimation();\n            this.isPlaying = false;\n            this._renderer.setPlaying_m(false);\n            this.emit('pause', [this.time]);\n        }\n        return this;\n    }\n\n    /**\n     * Stop the creative. Except from pausing the creative it will also seek to the stopTime.\n     * Defaults at duration - 1s\n     */\n    stop(): void {\n        // Don't allow omniRender to stop the creative.\n        if (!this._isOmniRender) {\n            const stopTime = this._getStopTime();\n            this.pause();\n            this.setTime_m(stopTime);\n        }\n        this.emit('stop', [this.time]);\n    }\n\n    /**\n     * Seek to a certain point in time in seconds.\n     */\n    seek(time: number): Animator {\n        time = Math.max(time, 0) || 0;\n        if (this.time !== time) {\n            this._lastTime = time * 1000;\n            this._startTimestamp = 0;\n            this.setTime_m(time);\n            this.emit('seek', [this.time]);\n        }\n        return this;\n    }\n\n    /**\n     * Jump to next loop.\n     * Will play from the beginning of the loop\n     */\n    next(replay: boolean = true, offset?: number): Animator {\n        const loop = this.loop + (offset || 1);\n\n        let exceededLimit = false;\n        if (this._renderer.feedStore) {\n            exceededLimit = this._renderer.feedStore.loop < 1;\n            if (exceededLimit) {\n                this._renderer.feedStore.setFeedLoop(offset || 1);\n            }\n        }\n\n        this.setLoop(loop, replay, !exceededLimit);\n\n        return this;\n    }\n\n    /**\n     * Jump to previous loop.\n     * Will play from the beginning of the loop\n     */\n    prev(replay: boolean = true, offset?: number, exceedLimit?: boolean): Animator {\n        const loop = this.loop - (offset || 1);\n\n        if (this._renderer.feedStore) {\n            this._renderer.feedStore.setFeedLoop(this._renderer.feedStore.loop - (offset || 1), exceedLimit);\n        }\n\n        this.setLoop(loop, replay, false);\n\n        return this;\n    }\n\n    /**\n     * Replay current loop from beginning.\n     */\n    replay(): Animator {\n        this.seek(0);\n        this.emit('replay', [this.loop]);\n        return this;\n    }\n\n    /**\n     * Restart creative. Loops and time will be reset.\n     */\n    restart(): Animator {\n        if (this._renderer.feedStore) {\n            this._renderer.feedStore.resetIndexState();\n            this._renderer.feedStore.skipNextIndexUpdate();\n        }\n        this.setLoop(1);\n        this.play();\n        this.emit('restart', [this.loop]);\n        return this;\n    }\n\n    /**\n     * Updates values on DOM\n     */\n    render_m(time?: number, forceUpdate?: boolean): void {\n        this._updateElementsState();\n        this._renderer.setAllViewElementsValues_m(typeof time === 'number' ? time : this.time, forceUpdate);\n    }\n\n    useCreative_m(creative: CreativeDataNode): void {\n        this.creative = creative;\n    }\n\n    setTime_m(time: number, forceUpdate?: boolean): void {\n        this.time = time;\n        this.render_m(this.time, forceUpdate);\n    }\n\n    setLoop(loop: number, replay: boolean = true, setFeedLoop: boolean = true): void {\n\n        if (this._renderer.feedStore) {\n            if (setFeedLoop) {\n                this._renderer.feedStore.setFeedLoop(this._renderer.feedStore.loop < 0 ? this._renderer.feedStore.loop : loop);\n            }\n            this._renderer.feedStore.updateElementsCurrentIndex();\n        }\n\n        if (replay) {\n            this._lastTime = 0;\n            this._startTimestamp = 0;\n            this.setTime_m(0, /* forceUpdate */ true);\n        }\n        else {\n            this.render_m(this.time, /* forceUpdate */ true);\n        }\n\n        this.loop = Math.max(1, loop);\n\n        if (this.loop === 1) {\n            this.time = this._getStartTime();\n        }\n\n        if (!this._isOmniRender) {\n            this.emit('loop', [this.loop]);\n        }\n    }\n\n    addToQueue(fn: Function, value: any[] = []): void {\n        if (this.isPlaying) {\n            this._eventQueue.push({ fn: fn.bind(this), value });\n        }\n        else {\n            fn.bind(this)(...value);\n        }\n    }\n\n    /**\n     * Keeps track of the current state of all elements and emits events based on what changes\n     * Tracks what kind of animation that latest ran, e.g the \"in\" or \"out\" part of the In transition\n     */\n    private _updateElementsState(): void {\n        if (!this.isPlaying) {\n            return;\n        }\n        for (let i = 0; i < this.creative.elements.length; i++) {\n            const element = this.creative.elements[i];\n            const animations = element.animations;\n            if (!this._elementsAnimationState.has(element.id)) {\n                this._elementsAnimationState.set(element.id, { visible: false });\n            }\n\n            const currentState = this._elementsAnimationState.get(element.id)!;\n            let animationState: animationStateTypes = 'none';\n\n            const inDuration = getInAnimationDuration(animations);\n            const outDuration = getOutAnimationDuration(animations);\n\n            if (inDuration) {\n                if (this.time > element.time &&\n                    this.time < inDuration + element.time) {\n                    animationState = 'inTransitionIn';\n                }\n                else if (currentState.animationState === 'inTransitionIn' &&\n                    (this.time <= element.time ||\n                        this.time >= inDuration + element.time)) {\n                    animationState = 'inTransitionOut';\n                }\n            }\n\n            if (outDuration) {\n\n                const outDurationStart = element.time + element.duration - outDuration;\n\n                if (this.time > outDurationStart &&\n                    this.time < element.time + element.duration) {\n                    animationState = 'outTransitionIn';\n                }\n                else if (currentState.animationState === 'outTransitionIn' &&\n                    (this.time < outDurationStart ||\n                        this.time >= element.duration + element.time)) {\n                    animationState = 'outTransitionOut';\n                }\n            }\n\n            if (isSelectionVisibleAtTime(element, this.time)) {\n                this._elementsAnimationState.set(element.id, { visible: true, animationState: animationState });\n            }\n            else {\n                this._elementsAnimationState.set(element.id, { visible: false, animationState: animationState });\n            }\n\n            const isAtStartOfElement = this.time === 0 && element.time === 0;\n            const isAtEndOfElement = this.time === element.duration + element.time;\n\n            const state = this._elementsAnimationState.get(element.id)!;\n\n            if (currentState.visible !== state.visible\n                || isAtStartOfElement\n                || isAtEndOfElement) {\n                if (((state.visible && !isAtEndOfElement) || isAtStartOfElement) && currentState.animationState !== 'animationStarted') {\n                    state.animationState = 'animationStarted';\n                    this.emit('animation_start', [element]);\n                }\n                else if (((!state.visible && !isAtStartOfElement) || isAtEndOfElement)\n                    && (currentState.animationState !== 'animationEnded' && (currentState.animationState !== 'none' || outDuration === 0))) {\n                    state.animationState = 'animationEnded';\n                    this.emit('animation_end', [element]);\n                }\n            }\n\n            if (currentState.animationState !== this._elementsAnimationState.get(element.id)!.animationState) {\n                switch (this._elementsAnimationState.get(element.id)!.animationState) {\n                    case 'inTransitionOut':\n                        this.emit('in_transition_end', [element]);\n                        break;\n                    case 'outTransitionIn':\n                        this.emit('out_transition_start', [element]);\n                        break;\n                }\n            }\n        }\n    }\n\n    private _tick = (t: number): void => {\n\n        /**\n         * We need to force-cancel if isPlaying is false as it seems\n         * that if animator is paused from the Widget API then it occurs on a\n         * different tick causing everything to go haywire\n         */\n        if (this._destroyed || !this.isPlaying) {\n            this._cancelAnimation();\n            return;\n        }\n\n        if (!this._startTimestamp) {\n            this._startTimestamp = t;\n        }\n\n        const stopTime = this._getStopTime();\n        const loops = this.creative.loops;\n        const timeDiff = (t - this._startTimestamp) * this._speed;\n        const timeInSeconds = (this._lastTime + timeDiff) / 1000;\n\n\n        if (!this._infinite() && this.loop >= loops && timeInSeconds >= stopTime && !this._isOmniRender) {\n            this.stop();\n            return;\n        }\n\n        if (this._isOmniRender && timeInSeconds >= this.duration) {\n            this.setTime_m(this.duration);\n            this.pause();\n            return;\n        }\n\n        if (timeInSeconds < this.duration) {\n            this.setTime_m(timeInSeconds);\n        }\n        else if (timeInSeconds >= this.duration) {\n            this.setTime_m(this.duration);\n            this.next();\n        }\n\n        while (this._eventQueue.length) {\n            const event = this._eventQueue.pop()!;\n            event.fn(...event.value);\n        }\n\n        this.emit('tick', [this.time]);\n\n        this._requestId = requestAnimationFrame(this._tick);\n    };\n\n    private _getStartTime(): number {\n        return typeof this.creative.startTime === 'number' ? this.creative.startTime : 0;\n    }\n\n    private _getStopTime(): number {\n        return typeof this.creative.stopTime === 'number' ? this.creative.stopTime : this.duration - 1;\n    }\n\n    private _cancelAnimation(): void {\n        this._lastTime = 0;\n        this._startTimestamp = 0;\n        if (this._requestId) {\n            cancelAnimationFrame(this._requestId);\n            this._requestId = undefined;\n        }\n    }\n\n    private _infinite(): boolean {\n        if (this._renderer.env_m.ANIMATED_CREATIVE_JS || this._preview) {\n            return !this.creative.loops;\n        }\n        return true;\n    }\n\n    destroy(): void {\n        this._destroyed = true;\n        this.clearEvents();\n        this._cancelAnimation();\n    }\n\n}\n\n__inject(T.CREATIVE_DATA, {}, Animator, 'creative', 0);\n__inject(T.RENDERER, {}, Animator, '_renderer', 1);\n\nexport function getCreativeAnimationDuration(creative: CreativeDataNode): number {\n    let latestAnimationEnd = 0;\n    for (const element of creative.elements) {\n        if (element.time + element.duration > latestAnimationEnd) {\n            latestAnimationEnd = element.time + element.duration;\n        }\n    }\n    return latestAnimationEnd;\n}\n\ninterface IElementState {\n    visible: boolean;\n    animationState?: animationStateTypes;\n}\n\ntype animationStateTypes = 'none' | 'animationStarted' | 'animationEnded' | 'inTransitionIn' | 'inTransitionOut' | 'outTransitionIn' | 'outTransitionOut';\n\nexport type AnimatorEventType =\n    'play' |\n    'pause' |\n    'stop' |\n    'loop' |\n    'restart' |\n    'replay' |\n    'seek' |\n    'tick' |\n    AnimationEvents;\n\ntype AnimationEvents =\n    'animation_start' |\n    'animation_end' |\n    'in_transition_end' |\n    'out_transition_start';\n","import { parseColor, RGBToHSL, toRGBA, toLinearGradient } from '@creative/color.utils';\nimport { IPosition, IColor, IColorStop, ColorType } from '@studio/domain';\n\nexport class Color implements IColor {\n\n    /**\n     * Value between 0 and 255\n     */\n    red: number;\n\n    /**\n     * Value between 0 and 255\n     */\n    green: number;\n\n    /**\n     * Value between 0 and 255\n     */\n    blue: number;\n    hue: number;\n    saturation: number;\n    lightness: number;\n\n    /**\n     * Value between 0 and 100\n     */\n    alpha: number;\n\n    type: ColorType = ColorType.Solid;\n\n    stops: IColorStop[] = [];\n\n    constructor(color?: IColor) {\n        if (color) {\n            this.setColor(color);\n        } else {\n            this.red = 0;\n            this.green = 0;\n            this.blue = 0;\n            this.hue = this.saturation = this.lightness = 0;\n            this.alpha = 100;\n\n            const hsl = RGBToHSL(this.red, this.green, this.blue);\n            this.hue = hsl.h;\n            this.saturation = hsl.s;\n            this.lightness = hsl.l;\n        }\n    }\n\n    get angle(): number {\n        if (this.stops.length > 1) {\n            const angle = Math.atan2(\n                this.end.position!.y - this.start.position!.y,\n                this.end.position!.x - this.start.position!.x\n            ) * 180 / Math.PI;\n\n            return Math.round((90 + angle) % 360);\n        }\n        return 0;\n    }\n\n    get start(): IColorStop {\n        return this.stops[0];\n    }\n\n    get end(): IColorStop {\n        return this.stops[this.stops.length - 1];\n    }\n\n    copy(): Color {\n        return new Color(this);\n    }\n\n    /**\n     * This makes colors output nicely when using JSON.stringify\n     */\n    toJSON(): string {\n        return this.toString();\n    }\n\n    toString(): string {\n        switch (this.type) {\n            case ColorType.Solid:\n                return toRGBA(this);\n            case ColorType.LinearGradient:\n                return toLinearGradient(this);\n        }\n    }\n\n    addColorStop(color: IColor, offset: number, position?: IPosition): void {\n        this.stops.push({\n            color,\n            offset,\n            position\n        });\n    }\n\n    setColor(color: IColor): IColor {\n        this.type = color.type;\n\n        if (color.type === 'solid') {\n            this.red = color.red;\n            this.green = color.green;\n            this.blue = color.blue;\n            this.alpha = color.alpha;\n            this.saturation = color.saturation;\n            this.lightness = color.lightness;\n            this.hue = color.hue;\n        } else {\n            this.alpha = color.alpha;\n            // this.angle = color.angle;\n            this.stops = color.stops.map(stop => ({\n                color: parseColor(stop.color),\n                offset: stop.offset,\n                position: stop.position ? { ...stop.position } : undefined\n            }));\n        }\n\n        return this;\n    }\n\n    /**\n     * Parse color string into a color object. If not a recognized pattern\n     * return color based on default value\n     * @param color\n     * @param defaultValue\n     */\n    static parse(color: string | Color, defaultValue: string = '#FFFFFF'): Color {\n        return parseColor(color, defaultValue);\n    }\n}\n","import { Color } from '@creative/color';\nimport { IColor, ColorType, IPosition } from '@studio/domain';\nimport { SimpleCache } from '@studio/utils/simple-cache';\nimport { clamp, decimal } from '@studio/utils/utils';\n\nexport const HEX_COLOR_PATTERN = /^#[0-9a-fA-F]{3}$|^#[0-9a-fA-F]{6}$/;\nexport const IMPLICIT_HEX_COLOR_PATTERN = /^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{6}$/;\nexport const RGBA_COLOR_PATTERN = /^rgba\\((0|255|25[0-4]|2[0-4]\\d|1\\d\\d|0?\\d?\\d),(0|255|25[0-4]|2[0-4]\\d|1\\d\\d|0?\\d?\\d),(0|255|25[0-4]|2[0-4]\\d|1\\d\\d|0?\\d?\\d),(0?(\\.\\d+)?|1(\\.0)?)\\)$/;\nexport const RGB_COLOR_PATTERN = /^rgb\\(\\s*(0|255|25[0-4]|2[0-4]\\d|1\\d\\d|0?\\d?\\d)\\s*,\\s*(0|255|25[0-4]|2[0-4]\\d|1\\d\\d|0?\\d?\\d)\\s*,\\s*(0|255|25[0-4]|2[0-4]\\d|1\\d\\d|0?\\d?\\d)\\s*\\)$/;\n\n\n/**\n * Test if string is a valid color or not\n * @param color\n */\nexport function validateColor(color: string): boolean {\n    return HEX_COLOR_PATTERN.test(color) || RGBA_COLOR_PATTERN.test(color) || RGB_COLOR_PATTERN.test(color) || IMPLICIT_HEX_COLOR_PATTERN.test(color);\n}\n\n/**\n * Return a color if color string is a valid color.\n */\nexport function parseColorIfValid(color: string): Color | undefined {\n    if (validateColor(color)) {\n        return parseColor(color);\n    }\n}\n\n/**\n * Parse color string into a color object. If not a recognized pattern\n * return color based on default value\n * @param color\n * @param defaultValue\n */\nexport function parseColor(color: string | Color, defaultValue: string = '#FFFFFF'): Color {\n\n    if (color instanceof Color) {\n        return new Color(color);\n    }\n\n    const cachedColor = SimpleCache.get<Color>(color);\n\n    if (cachedColor) {\n        return cachedColor;\n    }\n\n    // Parsers can't handle spaces after commas\n    color = typeof color === 'string' ? color.replace(/,\\s+/gi, ',') : color;\n\n    let value: Color;\n\n    if (HEX_COLOR_PATTERN.test(color) || IMPLICIT_HEX_COLOR_PATTERN.test(color)) {\n        value = fromHEX(color);\n    } else if (RGBA_COLOR_PATTERN.test(color)) {\n        value = fromRGBAstring(color);\n    } else if (RGB_COLOR_PATTERN.test(color)) {\n        value = fromRGBstring(color);\n    } else if (color.indexOf('linear-gradient') === 0) {\n        value = fromLinearGradient(color);\n    } else {\n        value = parseColor(defaultValue);\n    }\n\n    SimpleCache.set<Color>(color, value);\n\n    return value;\n}\n\n\nexport function fromHSV(h: number, s: number, v: number): IColor {\n    const color = new Color();\n    let r!: number;\n    let g!: number;\n    let b!: number;\n    const i = Math.floor(h * 6);\n    const f = h * 6 - i;\n    const p = v * (1 - s);\n    const q = v * (1 - f * s);\n    const t = v * (1 - (1 - f) * s);\n\n    switch (i % 6) {\n        case 0:\n            r = v;\n            g = t;\n            b = p;\n            break;\n        case 1:\n            r = q;\n            g = v;\n            b = p;\n            break;\n        case 2:\n            r = p;\n            g = v;\n            b = t;\n            break;\n        case 3:\n            r = p;\n            g = q;\n            b = v;\n            break;\n        case 4:\n            r = t;\n            g = p;\n            b = v;\n            break;\n        case 5:\n            r = v;\n            g = p;\n            b = q;\n            break;\n    }\n\n    color.red = Math.round(r * 255);\n    color.green = Math.round(g * 255);\n    color.blue = Math.round(b * 255);\n\n    const hsl = RGBToHSL(r, g, b);\n    color.hue = hsl.h;\n    color.saturation = hsl.s;\n    color.lightness = hsl.l;\n\n    return color;\n}\n\nexport function fromRGBA(r: number, g: number, b: number, a: number = 1): Color {\n    const color = new Color();\n\n    if (a > 1 || a < 0) {\n        throw new Error('invalid alpha');\n    }\n\n    color.red = r;\n    color.green = g;\n    color.blue = b;\n    color.alpha = Math.round(a * 100);\n\n    const hsl = RGBToHSL(r, g, b);\n    color.hue = hsl.h;\n    color.saturation = hsl.s;\n    color.lightness = hsl.l;\n\n    return color;\n}\n\nexport function fromHSL(h: number, s: number, l: number, a: number = 1): Color {\n    const color = new Color();\n    color.hue = h;\n    color.saturation = s;\n    color.lightness = l;\n    color.alpha = Math.round(a * 100);\n\n    const rgb = HSLToRGB(h, s, l);\n    color.red = rgb.r;\n    color.green = rgb.g;\n    color.blue = rgb.b;\n\n    return color;\n}\n\nexport function fromHEX(hex: string): Color {\n    if (hex[0] === '#') {\n        hex = hex.substring(1, hex.length);\n    }\n    const color = new Color();\n    if (hex.length === 3) {\n        color.red = parseInt(hex.substring(0, 1) + hex.substring(0, 1), 16);\n        color.green = parseInt(hex.substring(1, 2) + hex.substring(1, 2), 16);\n        color.blue = parseInt(hex.substring(2, 3) + hex.substring(2, 3), 16);\n    } else if (hex.length === 6) {\n        color.red = parseInt(hex.substring(0, 2), 16);\n        color.green = parseInt(hex.substring(2, 4), 16);\n        color.blue = parseInt(hex.substring(4, 6), 16);\n    } else {\n        color.red = 255;\n        color.green = 255;\n        color.blue = 255;\n    }\n    const hsl = RGBToHSL(color.red, color.green, color.blue);\n    color.hue = hsl.h;\n    color.saturation = hsl.s;\n    color.lightness = hsl.l;\n\n    return color;\n}\n\nexport function fromRGBstring(rgb: string): Color {\n    const color = new Color();\n\n    const matchColors = /rgb\\((\\d{1,3}),(\\d{1,3}),(\\d{1,3})\\)/;\n    const match = matchColors.exec(rgb.replace(/\\s/g, ''));\n\n    if (match) {\n        color.red = parseInt(match[1], 10);\n        color.green = parseInt(match[2], 10);\n        color.blue = parseInt(match[3], 10);\n    }\n\n    const hsl = RGBToHSL(color.red, color.green, color.blue);\n    color.hue = hsl.h;\n    color.saturation = hsl.s;\n    color.lightness = hsl.l;\n\n    return color;\n}\n\nexport function fromRGBAstring(rgba: string): Color {\n    const color = new Color();\n    const matchColors = /^rgba\\(([^,]+),([^,]+),([^,]+),([^,]+)\\)$/g;\n    const match = matchColors.exec(rgba.replace(/\\s/g, ''));\n    if (match) {\n        color.red = parseInt(match[1], 10);\n        color.green = parseInt(match[2], 10);\n        color.blue = parseInt(match[3], 10);\n        color.alpha = Math.round(parseFloat(match[4]) * 100);\n    }\n\n    const hsl = RGBToHSL(color.red, color.green, color.blue);\n    color.hue = hsl.h;\n    color.saturation = hsl.s;\n    color.lightness = hsl.l;\n\n    return color;\n}\n\n/**\n * Takes 2 colors and returns a color in between. Position 0 will give first color, 0.5 the average and 1 the second color.\n */\nexport function mixColor(baseColor: Color, ...colors: { color: IColor, amount: number }[]): Color {\n    return tintColor(new Color(baseColor), ...colors);\n}\n\n/**\n * Takes another color and applies that tinted on the target color instance.\n * amount = 0 will not affect the color, 0.5 the average and 1 the second color completely.\n */\nexport function tintColor(targetColor: IColor, ...colors: { color: IColor, amount: number }[]): IColor {\n\n    let redOffset = 0;\n    let greenOffset = 0;\n    let blueOffset = 0;\n    let alphaOffset = 0;\n    const startPositionOffset = { x: 0, y: 0 };\n    const endPositionOffset = { x: 0, y: 0 };\n    let startOffset = 0;\n    let endOffset = 0;\n\n    colors.forEach(c => {\n        const color = c.color;\n        const amount = clamp(c.amount, 0, 1);\n        const stops = color.type !== 'solid' ? [...color.stops] : [];\n\n        redOffset += (color.red - targetColor.red) * amount;\n        greenOffset += (color.green - targetColor.green) * amount;\n        blueOffset += (color.blue - targetColor.blue) * amount;\n        alphaOffset += (color.alpha - targetColor.alpha) * amount;\n\n        // Gradient color\n        if (stops?.length) {\n\n            if (stops.length !== 2) {\n                throw new Error('Tinting gradients with more than 2 stops is not supported currently');\n            }\n\n            // Turn default state to gradient if it's a solid\n            if (!targetColor.stops?.length) {\n                targetColor.stops = [];\n                stops.forEach((s, index) => {\n                    const y = index === 0 ? 0 : 1;\n                    targetColor.stops.push({\n                        color: new Color(targetColor), // Same color as the solid\n                        position: s.position ? { ...s.position } : { x: 0.5, y },\n                        offset: s.offset\n                    });\n                });\n                targetColor.type = c.color.type;\n            }\n\n            startOffset += (stops[0].offset - targetColor.start.offset) * amount;\n            endOffset += (stops[1].offset - targetColor.end.offset) * amount;\n\n            if (stops[0].position && targetColor.start.position && stops[1].position && targetColor.end.position) {\n                startPositionOffset.x += (stops[0].position.x - targetColor.start.position.x) * amount;\n                startPositionOffset.y += (stops[0].position.y - targetColor.start.position.y) * amount;\n                endPositionOffset.x += (stops[1].position.x - targetColor.end.position.x) * amount;\n                endPositionOffset.y += (stops[1].position.y - targetColor.end.position.y) * amount;\n            }\n        }\n    });\n\n    if (targetColor.stops.length) {\n        targetColor.start.offset += startOffset;\n        targetColor.end.offset += endOffset;\n\n        targetColor.start.position = {\n            x: startPositionOffset.x + targetColor.start.position!.x,\n            y: startPositionOffset.y + targetColor.start.position!.y\n        };\n        targetColor.end.position = {\n            x: endPositionOffset.x + targetColor.end.position!.x,\n            y: endPositionOffset.y + targetColor.end.position!.y\n        };\n\n        const startColors = colors.map(c => {\n            let color = c.color.type === 'linear-gradient' ? new Color(c.color.start?.color) : undefined;\n            if (!color) {\n                color = fromRGBA(c.color.red, c.color.green, c.color.blue, c.color.alpha / 100);\n            }\n            return { color, amount: c.amount };\n        });\n\n        const endColors = colors.map(c => {\n            let color = c.color.type === 'linear-gradient' ? new Color(c.color.end?.color) : undefined;\n            if (!color) {\n                color = fromRGBA(c.color.red, c.color.green, c.color.blue, c.color.alpha / 100);\n            }\n            return { color, amount: c.amount };\n        });\n\n        targetColor.start.color = mixColor(targetColor.start.color, ...startColors);\n        targetColor.end.color = mixColor(targetColor.end.color, ...endColors);\n        targetColor.alpha += alphaOffset;\n    } else {\n        targetColor.red += redOffset;\n        targetColor.green += greenOffset;\n        targetColor.blue += blueOffset;\n        targetColor.alpha += alphaOffset;\n    }\n\n    return targetColor;\n}\n\nfunction extractColorStopPositionFromAngle(offset: number, cos: number, sin: number): IPosition {\n    const offsetX = 0.5;\n    const offsetY = 1 - offset / 100;\n    const x = (cos * (offsetX - 0.5)) - (sin * (offsetY - 0.5)) + 0.5;\n    const y = (cos * (offsetY - 0.5)) + (sin * (offsetX - 0.5)) + 0.5;\n    return { x, y };\n}\n\nfunction createGradientFromString(splitStr: string[], angle: number | undefined): Color {\n    const color = new Color();\n    color.type = ColorType.LinearGradient;\n    const rad = Math.PI * (angle || 0) / 180;\n    const cos = Math.cos(rad);\n    const sin = Math.sin(rad);\n\n    for (let i = 0; i < splitStr.length; i++) {\n        const data = splitStr[i].split(' ');\n        let colorStr: string;\n        let offset: number;\n        let position: IPosition | undefined;\n        // CSS format: linear-gradient(0deg,#000000 0%,#ffffff 100%)\n        if (angle !== undefined) {\n            colorStr = data[0].trim();\n            offset = parseInt(data[1], 10);\n            if (i === 0 || i === splitStr.length - 1) {\n                position = extractColorStopPositionFromAngle(offset, cos, sin);\n            }\n        } else {\n            colorStr = data[data.length - 1];\n            offset = i === 0 ? 0 : 100;\n\n            if (data.length === 3) {\n                position = {\n                    x: parseFloat(data[0]),\n                    y: parseFloat(data[1])\n                };\n            } else {\n                offset = parseFloat(data[0]);\n            }\n        }\n        color.addColorStop(parseColor(colorStr), offset, position);\n    }\n    return color;\n}\n\nexport function fromLinearGradient(linearGradient: string): Color {\n    const str = linearGradient.substring(linearGradient.indexOf('(') + 1, linearGradient.lastIndexOf(')'));\n    const splitStr = str.split(/,(?![^(]*\\))(?![^\"']*[\"'](?:[^\"']*[\"'][^\"']*[\"'])*[^\"']*$)/);\n    let angle: number | undefined;\n    if (splitStr[0].indexOf('deg') > -1) {\n        angle = parseInt(splitStr.shift() || '0', 10);\n    }\n\n    return createGradientFromString(splitStr, angle);\n}\n\n/**\n * Checks if a two color instances has the same color value\n */\nexport function isSameColor(color1?: Color, color2?: Color): boolean {\n    if (!color1 && !color2) {\n        return true;\n    } else if (!color1 || !color2) {\n        return false;\n    } else {\n        return toRGBA(color1) === toRGBA(color2);\n    }\n}\n\n\n/**\n * Calculates HSL Color\n * RGB must be normalized\n * Must be executed in a Color object context\n * http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript\n */\nexport function RGBToHSL(r: number, g: number, b: number): { h: number, s: number, l: number } {\n    r = r / 255;\n    g = g / 255;\n    b = b / 255;\n    const max = Math.max(r, g, b);\n    const min = Math.min(r, g, b);\n    let h!: number;\n    let s!: number;\n    const l = (max + min) / 2;\n    if (max === min) {\n        h = s = 0; // achromatic\n    } else {\n        const d = max - min;\n        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n        switch (max) {\n            case r:\n                h = (g - b) / d + (g < b ? 6 : 0);\n                break;\n            case g:\n                h = (b - r) / d + 2;\n                break;\n            case b:\n                h = (r - g) / d + 4;\n                break;\n        }\n        h /= 6;\n    }\n\n    return { h: h, s: s, l: l };\n}\n\n/**\n * Calculates RGB color (normalized)\n * HSL must be normalized\n * Must be executed in a Color object context\n * http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript\n */\nexport function HSLToRGB(h: number, s: number, l: number): { r: number, g: number, b: number } {\n    let r: number;\n    let g: number;\n    let b: number;\n    const hue2rgb = (p: number, q: number, t: number): number => {\n        if (t < 0) {\n            t += 1;\n        }\n        if (t > 1) {\n            t -= 1;\n        }\n        if (t < 1 / 6) {\n            return p + (q - p) * 6 * t;\n        }\n        if (t < 1 / 2) {\n            return q;\n        }\n        if (t < 2 / 3) {\n            return p + (q - p) * (2 / 3 - t) * 6;\n        }\n        return p;\n    };\n    if (s === 0) {\n        r = g = b = l;\n    } else {\n        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n        const p = 2 * l - q;\n        r = hue2rgb(p, q, h + 1 / 3);\n        g = hue2rgb(p, q, h);\n        b = hue2rgb(p, q, h - 1 / 3);\n    }\n\n    return { r: r * 255, g: g * 255, b: b * 255 };\n}\n\n\n/**\n * Round color channel and limit value between 0 and 255\n */\nexport function roundChannel(channel: number): number {\n    return clamp(channel, 0, 255) >>> 0;\n}\n\n/**\n * Take a number between 0 and 255 and turn it into\n * a two digit hex string like: \"0F\", \"FF\" and \"99\"\n */\nexport function channelToHex(channel: number): string {\n    channel = roundChannel(channel);\n    return (channel < 16 ? '0' : '') + channel.toString(16).toUpperCase();\n}\n\n\nexport function isColorTransparent(color: IColor): boolean {\n    if (color.type === ColorType.Solid) {\n        return color.alpha < 100;\n    }\n    return color.stops.some(s => isColorTransparent(s.color));\n}\n\nexport function toHSV(color: IColor): { h: number, s: number, v: number } {\n    if (color.type !== 'solid') {\n        throw new Error('Cannot convert a none solid color to HSV format.');\n    }\n\n    let rr: number;\n    let gg: number;\n    let bb: number;\n    const r = color.red / 255;\n    const g = color.green / 255;\n    const b = color.blue / 255;\n    let h: number;\n    let s: number;\n    const v = Math.max(r, g, b);\n    const diff = v - Math.min(r, g, b);\n    const diffc = (c: number): number => (v - c) / 6 / diff + 1 / 2;\n\n    if (diff === 0) {\n        h = s = 0;\n    } else {\n        s = diff / v;\n        rr = diffc(r);\n        gg = diffc(g);\n        bb = diffc(b);\n\n        if (r === v) {\n            h = bb - gg;\n        } else if (g === v) {\n            h = (1 / 3) + rr - bb;\n        } else if (b === v) {\n            h = (2 / 3) + gg - rr;\n        }\n        if (h! < 0) {\n            h! += 1;\n        } else if (h! > 1) {\n            h! -= 1;\n        }\n    }\n\n    return { h: h!, s, v };\n}\n\nexport function toHEX(color: IColor): string {\n    if (color.type !== ColorType.Solid) {\n        throw new Error('Cannot convert a none solid color to HEX format.');\n    }\n\n    return '#' + channelToHex(color.red) + channelToHex(color.green) + channelToHex(color.blue);\n}\n\n\nexport function toRGB(color: IColor): string {\n    if (color.type !== ColorType.Solid) {\n        throw new Error('Cannot convert a none solid color to RGB format.');\n    }\n\n    return `rgb(${ roundChannel(color.red) },${ roundChannel(color.green) },${ roundChannel(color.blue) })`;\n}\n\nexport function toRGBA(color: IColor): string {\n    if (color.type !== ColorType.Solid) {\n        throw new Error('Cannot convert a none solid color to RGBA format.');\n    }\n    return `rgba(${ roundChannel(color.red) },${ roundChannel(color.green) },${ roundChannel(color.blue) },${ decimal(color.alpha / 100) })`;\n}\n\nexport function toLinearGradientCSS(color: IColor): string {\n    return `linear-gradient(${ color.angle }deg, ${ color.stops.map(stop => {\n        const stopColor = parseColor(stop.color);\n        stopColor.alpha = Math.round(stopColor.alpha * (color.alpha / 100));\n        return `${ toRGBA(stopColor) } ${ stop.offset }%`;\n    }).join(',') })`;\n}\n\nexport function toLinearGradient(color: IColor): string {\n    return `linear-gradient(${ color.stops.map(stop => {\n        const stopColor = parseColor(stop.color);\n        stopColor.alpha = stopColor.alpha * (color.alpha / 100);\n\n        let positionOrOffset = '';\n        if (stop.position) {\n            positionOrOffset = `${ decimal(stop.position.x) } ${ decimal(stop.position.y) }`;\n        } else if (stop.offset) {\n            positionOrOffset = decimal(stop.offset) + '';\n        }\n\n        return `${ positionOrOffset } ${ toRGBA(stopColor) }`;\n    }).join(',') })`;\n}\n\nexport function toCSS(color: IColor): string {\n    switch (color.type) {\n        case ColorType.Solid:\n            return toRGBA(color);\n        case ColorType.LinearGradient:\n            return toLinearGradientCSS(color);\n    }\n}\n","import { isTextNode, isWidgetNode } from '@creative/nodes/helpers';\nimport { FeedType, IElementProperty, IFeed, IVersionProperty, IWidgetElementProperty, OneOfElementDataNodes } from '@studio/domain';\nimport { isVariableSpan } from '../rich-text/text-nodes';\n\nexport function encodeFeedPath(path: string): string {\n    return path.replace(/\\s/g, '%20');\n}\n\nexport function decodeFeedPath(path: string): string {\n    return path.replace(/%20/g, ' ');\n}\n\nexport function createFeed(id: string, path?: string, type: FeedType = 'text'): IFeed {\n    const feed: IFeed = {\n        id: id,\n        path: encodeFeedPath(path ?? ''),\n        step: {\n            occurrence: 'loop',\n            size: 1,\n            start: 1\n        },\n        fallback: '',\n        type: type\n    };\n    return feed;\n}\n\nexport function isFeedValue(value: any): value is IFeed {\n    if (typeof value !== 'object') {\n        return false;\n    }\n\n    if ('id' in value && 'path' in value && 'step' in value) {\n        return true;\n    }\n\n    return false;\n}\n\nexport function isVersionedFeed(property: IVersionProperty | IElementProperty | IWidgetElementProperty): property is IVersionProperty<IFeed> {\n    if (isFeedValue(property.value)) {\n        return true;\n    }\n\n    return false;\n}\n\nexport function hasFeededContent(element: OneOfElementDataNodes): boolean {\n    if (element.feed) {\n        return true;\n    }\n\n    if (isTextNode(element)) {\n        const content = element.__dirtyContent?.spans || element.content.spans;\n        for (const span of content) {\n            if (isVariableSpan(span)) {\n                return true;\n            }\n        }\n    }\n\n    if (isWidgetNode(element)) {\n        for (const property of element.customProperties) {\n            if (property.unit === 'feed' && JSON.parse(property.value as string).id) {\n                return true;\n            }\n        }\n    }\n\n    return false;\n}\n\nexport function isFeedpathProperty(property: IElementProperty): boolean {\n    return property.name.indexOf('feedPath') > -1;\n}\n","import { deserializeVersionedText, serializeVersionedText } from '../../serialization/text-serializer';\nimport { IPadding, IShadow, IFontStyle, IVersionedText, ITextSpan, textProperties, OneOfVersionableProperties, IVersionProperty, IWidgetElementProperty, IStyleIndexMaps, OneOfViewNodes } from '@studio/domain';\nimport { cloneDeep } from '../../../utils/clone';\nimport { omit, crc32, deepEqual } from '../../../utils/utils';\nimport { IText, IRenderedSpans, OneOfRenderedSpans, SpanType, HorizontalAlignment, VerticalAlignment, OneOfEditableSpans, OneOfContentSpans, ISpans, ISpan, IStyleIdMap, ISpanProperties, ICharacterProperties, PreviousStyleIdType, IContentSpan, ITextElementProperties, IVariableSpan, VARIABLE_PREFIX, TextDirection } from '../../../domain/text';\nimport { Color } from '../../color';\nimport { decodeFeedPath } from '../feed/feeds.utils';\nimport { createDefaultTextProperties, isTextNode } from '../../nodes/helpers';\nimport { serializeCharacterProperties } from '../../serialization/character-properties-serializer';\nimport { deserializePropertyValue, serializePropertyValue } from '../../serialization/property-value-serializer';\n\nexport const enum CharacterCode {\n    At = 0x40,\n    LineFeed = 0x0A,              // \\n\n    CarriageReturn = 0x0D,        // \\r\n    LineSeparator = 0x2028,\n    ParagraphSeparator = 0x2029,\n    NextLine = 0x0085,\n\n    // Unicode 3.0 space characters\n    Space = 0x0020,   // \" \"\n    NonBreakingSpace = 0x00A0,   //\n    EnQuad = 0x2000,\n    EmQuad = 0x2001,\n    EnSpace = 0x2002,\n    EmSpace = 0x2003,\n    ThreePerEmSpace = 0x2004,\n    FourPerEmSpace = 0x2005,\n    SixPerEmSpace = 0x2006,\n    FigureSpace = 0x2007,\n    PunctuationSpace = 0x2008,\n    ThinSpace = 0x2009,\n    HairSpace = 0x200A,\n    ZeroWidthSpace = 0x200B,\n    NarrowNoBreakSpace = 0x202F,\n    IdeographicSpace = 0x3000,\n    MathematicalSpace = 0x205F,\n    Ogham = 0x1680,\n\n    ZeroWidthNonJoiner = 0x200C,\n    ZeroWidthJoiner = 0x200D,\n\n    // Other white space\n    Backspace = 0x08,             // \\b\n    FormFeed = 0x0C,              // \\f\n    ByteOrderMark = 0xFEFF,\n    Tab = 0x09,                   // \\t\n    VerticalTab = 0x0B,           // \\v\n}\n\nexport function isSpaceLikeCharacter(ch: number): boolean {\n    return ch === CharacterCode.Space ||\n        ch === CharacterCode.Tab ||\n        ch === CharacterCode.VerticalTab ||\n        ch === CharacterCode.FormFeed ||\n        ch === CharacterCode.NextLine ||\n        ch === CharacterCode.Ogham ||\n        ch >= CharacterCode.EnQuad && ch <= CharacterCode.ZeroWidthSpace ||\n        ch === CharacterCode.MathematicalSpace ||\n        ch === CharacterCode.IdeographicSpace ||\n        ch === CharacterCode.ByteOrderMark;\n}\n\nfunction replaceSpaceAndNewLineChars(str: string): string {\n    let sanitizedString = '';\n    for (let i = 0; i < str.length; i++) {\n        const ch = str.charCodeAt(i);\n\n        if (isNewlineLikeCharacter(ch)) {\n            sanitizedString += '\\n';\n            continue;\n        }\n\n        if (isSpaceLikeCharacter(ch)) {\n            sanitizedString += '\\u0020';\n            continue;\n        }\n\n        sanitizedString += String.fromCharCode(ch);\n    }\n\n    return sanitizedString;\n}\n\n\nexport function sanitizeText(value: string): string {\n    return replaceSpaceAndNewLineChars(value)\n        .normalize('NFC')\n        .replace(/\"/gi, '\\\"');\n}\n\nexport function isVariableSpan(span?: OneOfRenderedSpans): span is IVariableSpan {\n    return span !== undefined && span.type === SpanType.Variable;\n}\n\nexport function isContentSpan(span?: OneOfRenderedSpans): span is OneOfContentSpans {\n    return span !== undefined && (span.type === SpanType.Word || span.type === SpanType.Space || span.type === SpanType.Newline || span.type === SpanType.Variable);\n}\n\nexport function isVersionedTextContentSpan(span: ITextSpan): boolean {\n    return span.type === SpanType.Word || span.type === SpanType.Space || span.type === SpanType.Newline || span.type === SpanType.Variable;\n}\n\nexport function isNewlineLikeCharacter(ch: number): boolean {\n    return ch === CharacterCode.LineFeed\n        || ch === CharacterCode.CarriageReturn\n        || ch === CharacterCode.LineSeparator\n        || ch === CharacterCode.ParagraphSeparator\n        || ch === CharacterCode.NextLine;\n}\n\nexport function forEachSpan(text: IRenderedSpans, callback: (textNode: OneOfRenderedSpans, index: number) => void): void {\n    if (text && text.spans && text.spans.length > 0) {\n        let lastIndex = text.spans.length - 1;\n        if (text.spans[lastIndex].type === SpanType.End) {\n            lastIndex--;\n        }\n        for (let i = 0; i < text.spans.length; i++) {\n            callback(text.spans[i], i);\n        }\n    }\n}\n\nexport function styleIdsAreEqual(source: IStyleIdMap, target: IStyleIdMap): boolean {\n    if (source.size !== target.size) {\n        return false;\n    }\n    for (const [documentId, sourceStyleId] of source.entries()) {\n        const targetStyleId = target.get(documentId);\n        if (sourceStyleId !== targetStyleId) {\n            return false;\n        }\n    }\n    return true;\n}\n\nexport function toStringFromText(): string {\n    return '';\n}\n\nexport function getHorizontalFlexAlignment(horizontalAlignment: HorizontalAlignment): string {\n    switch (horizontalAlignment) {\n        case 'left':\n            return 'flex-start';\n        case 'center':\n            return 'center';\n        case 'right':\n            return 'flex-end';\n        case 'justify':\n            return 'flex-start';\n    }\n}\n\nexport function getVerticalFlexAlignment(verticalAlignment: VerticalAlignment): string {\n    switch (verticalAlignment) {\n        case 'top':\n            return 'flex-start';\n        case 'middle':\n            return 'center';\n        case 'bottom':\n            return 'flex-end';\n    }\n}\n\nexport function createRichTextFromString(str: string): IText {\n    return {\n        style: createDefaultTextProperties(),\n        spans: createSpansFromString(str).concat([{ type: SpanType.End, content: 'END', top: 0, left: 0, width: 0, height: 0, lineHeight: 0, attributes: {}, dir: TextDirection.Ltr }]),\n    };\n}\n\nexport function createRichTextVariableFromString(str: string, attributes: ISpanProperties = {}, style?: Partial<ICharacterProperties>): IText {\n    return {\n        style: createDefaultTextProperties(),\n        spans: createSpansFromString(str, attributes, style)\n            .concat([{ type: SpanType.End, content: 'END', top: 0, left: 0, width: 0, height: 0, lineHeight: 0, attributes: {}, dir: TextDirection.Ltr }]),\n    };\n}\n\nexport function createSpansFromString(str: string, properties: ISpanProperties = {}, style?: Partial<ICharacterProperties>, copyStyleFn?: (style: Partial<ICharacterProperties>) => Partial<ICharacterProperties>, styleId?: string, styleIds?: IStyleIdMap, previousStyleIds?: (string | PreviousStyleIdType)[], previousStyleIdToHistoryIndexMap?: Map<string, number>): OneOfEditableSpans[] {\n    const spans: OneOfEditableSpans[] = [];\n    let currentTextSpan: OneOfEditableSpans | undefined;\n    let lastSpanType: SpanType | undefined;\n    str = (typeof str === 'number' ? (str as number).toString() : str);\n\n    /**\n     * Make sure variable artifacts are treated as a whole word\n     * It's reverted after the spans has been assembled\n     * Should only get in here when creating a new feeded element\n     */\n    if (style?.variable && str === VARIABLE_PREFIX + decodeFeedPath(style.variable.path)) {\n        str = str.replace(/\\s/g, '&nbsp;');\n    }\n\n    for (let i = 0; i < str.length; i++) {\n        const ch = str.charCodeAt(i);\n        if (isSpaceLikeCharacter(ch)) {\n            if (lastSpanType === SpanType.Space) {\n                (currentTextSpan as ISpan).content += String.fromCharCode(ch);\n            }\n            else {\n                currentTextSpan = {\n                    top: 0,\n                    left: 0,\n                    type: SpanType.Space,\n                    content: String.fromCharCode(ch),\n                    attributes: cloneDeep(properties.attributes || {}),\n                    style: style ? copyStyleFn!(style) : {},\n                    width: 0,\n                    height: 0,\n                    lineHeight: 0,\n                    styleIds: styleIds || new Map<string, string>(),\n                    styleId,\n                    __previousStyleIds: [...previousStyleIds || []],\n                    __previousStyleIdToHistoryIndexMap: new Map<string, number>(previousStyleIdToHistoryIndexMap || []),\n                };\n                spans.push(currentTextSpan);\n                lastSpanType = SpanType.Space;\n            }\n        }\n        else if (isNewlineLikeCharacter(ch)) {\n            currentTextSpan = {\n                top: 0,\n                left: 0,\n                type: SpanType.Newline,\n                content: String.fromCharCode(ch),\n                width: 0,\n                height: 0,\n                lineHeight: 0,\n                style: style ? copyStyleFn!(style) : {},\n                attributes: cloneDeep(properties.attributes || {}),\n                styleIds: styleIds || new Map<string, string>(),\n                styleId,\n                __previousStyleIds: [...previousStyleIds || []],\n                __previousStyleIdToHistoryIndexMap: new Map<string, number>(previousStyleIdToHistoryIndexMap || []),\n            };\n            spans.push(currentTextSpan);\n            lastSpanType = SpanType.Newline;\n        }\n        else {\n            if (lastSpanType === SpanType.Word || lastSpanType === SpanType.Variable) {\n                (currentTextSpan as ISpan).content += String.fromCharCode(ch);\n            }\n            else {\n                if (style && style.variable) {\n                    let newStyle = {};\n\n                    newStyle = copyStyleFn ? copyStyleFn!(style) : style;\n\n                    currentTextSpan = {\n                        type: SpanType.Variable,\n                        content: String.fromCharCode(ch),\n                        style: newStyle,\n                        top: 0,\n                        left: 0,\n                        width: 0,\n                        height: 0,\n                        lineHeight: 0,\n                        attributes: cloneDeep(properties.attributes || {}),\n                        styleIds: styleIds || new Map<string, string>(),\n                        styleId,\n                        __previousStyleIds: [...previousStyleIds || []],\n                        __previousStyleIdToHistoryIndexMap: new Map<string, number>(previousStyleIdToHistoryIndexMap || []),\n                    };\n                }\n                else {\n                    currentTextSpan = {\n                        type: SpanType.Word,\n                        content: String.fromCharCode(ch),\n                        style: style ? copyStyleFn!(style) : {},\n                        top: 0,\n                        left: 0,\n                        width: 0,\n                        height: 0,\n                        lineHeight: 0,\n                        attributes: cloneDeep(properties.attributes || {}),\n                        styleIds: styleIds || new Map<string, string>(),\n                        styleId,\n                        __previousStyleIds: [...previousStyleIds || []],\n                        __previousStyleIdToHistoryIndexMap: new Map<string, number>(previousStyleIdToHistoryIndexMap || []),\n                    };\n                }\n                spans.push(currentTextSpan);\n                lastSpanType = style && style.variable ? SpanType.Variable : SpanType.Word;\n            }\n        }\n    }\n\n    for (const span of spans) {\n        if (isVariableSpan(span)) {\n            span.content = span.content.replace(/\\&nbsp\\;/gi, ' ');\n        }\n        span.attributes.shouldRenderNumber = false;\n    }\n\n    return spans;\n}\n\nexport function escapeSpanContent(content: string): string {\n    return content\n        .replace(/\\n/g, '\\\\n')\n        .replace(/\"/g, '\\\\\"')\n        .replace(/'/g, `\\\\'`)\n        .replace(/&/g, '\\\\&')\n        .replace(/\\r/g, '\\\\r')\n        .replace(/\\t/g, '\\\\t')\n        .replace(/\\f/g, '\\\\f')\n        .replace(/(\\\\)(?!n|\"|'|&|r|t|f|u\\d)/g, '\\\\\\\\') // Escape backslashes, if it's not unicode/metachar\n\n        // Legacy: Some documents have newline characters that are not supported. Old Chrome browser cannot handle raw newline characters.\n        // They will be converted next time they edit the text. But for now document.js is invalid with these characters.\n        .replace(/\\u2028/g, '\\\\u2028') // Line Separator\n        .replace(/\\u2029/g, '\\\\u2029') // Paragraph Separator\n        .replace(/\\u0085/g, '\\\\u0085'); // Next Line\n}\n\nexport function remapStyles(text: IVersionedText, oldDocumentId: string, newDocumentId: string): IVersionedText {\n    if (newDocumentId === oldDocumentId) {\n        return text;\n    }\n    for (const span of text.styles) {\n        const oldStyleIds = new Map([...span.styleIds]);\n        for (const [documentId, styleId] of oldStyleIds) {\n            if (documentId === oldDocumentId) {\n                span.styleIds.set(newDocumentId, styleId);\n                span.styleIds.delete(oldDocumentId);\n            }\n        }\n    }\n    return text;\n}\n\nexport function isVersionedText(property: IVersionProperty | IWidgetElementProperty | undefined): property is IVersionProperty<IVersionedText> {\n\n    const propertyValue = property?.value;\n    if (!propertyValue) {\n        return false;\n    }\n\n    if (typeof propertyValue === 'string') {\n        try {\n            const parsed = JSON.parse(propertyValue) as IVersionedText;\n            if (parsed.text !== undefined && parsed.styles !== undefined) {\n                return true;\n            }\n        }\n        // eslint-disable-next-line no-empty\n        catch (e) { }\n    }\n    else {\n        try {\n            if (typeof propertyValue === 'object' && 'text' in propertyValue && propertyValue.text !== undefined && propertyValue.styles !== undefined) {\n                return true;\n            }\n        }\n        // eslint-disable-next-line no-empty\n        catch (e) { }\n    }\n\n    return false;\n}\n\nexport function hasSameStyleIds(source: IStyleIdMap, target: IStyleIdMap): boolean {\n    if (source.size !== target.size) {\n        return false;\n    }\n    for (const [sourceDesignId, sourceStyleId] of source.entries()) {\n        if (!(target.has(sourceDesignId) && target.get(sourceDesignId) === sourceStyleId)) {\n            return false;\n        }\n    }\n    return true;\n}\n\nexport function copyVersionPropertyValue(property: IVersionProperty): OneOfVersionableProperties {\n    const value = property.value;\n    if (isVersionedText(property)) {\n        return deserializeVersionedText(serializeVersionedText(property.value));\n    }\n    else {\n        return deserializePropertyValue(property.name, serializePropertyValue(property.name, value)!)! as OneOfVersionableProperties;\n    }\n}\n\n/**\n * Get raw string from IText (without formatting)\n * @param text\n * @param tw\n */\nexport function getTextContent(text: ISpans): string {\n    let str = '';\n    outer: for (const span of text.spans) {\n        switch (span.type) {\n            case SpanType.Newline:\n                str += '\\n';\n                break;\n            case SpanType.Space:\n            case SpanType.Word:\n                str += span.content;\n                break;\n            case SpanType.Variable:\n                str += span.content;\n                break;\n            case SpanType.End:\n                break outer;\n            default:\n                throw new Error('Unknown span type.');\n        }\n    }\n    return str;\n}\n\nexport function textSpanIsMergeable(source: ITextSpan, target: ITextSpan, checkPreviousStyles: boolean): boolean {\n    if (source.type === SpanType.Newline || source.type === SpanType.End || source.type === SpanType.Variable) {\n        return false;\n    }\n    if (source.type !== target.type) {\n        return false;\n    }\n    if (!hasSameStyleIds(source.styleIds, target.styleIds)) {\n        return false;\n    }\n    if (checkPreviousStyles) {\n        if (!deepEqual(source.__previousStyleIds, target.__previousStyleIds)) {\n            return false;\n        }\n    }\n    return true;\n}\n\nexport function isSubStyleOf(source: Partial<ICharacterProperties>, target: Partial<ICharacterProperties>): boolean {\n    const sourceStyle = omit(source, 'variable');\n    const targetStyle = omit(target, 'variable');\n    if (Object.keys(sourceStyle).length < Object.keys(targetStyle).length) {\n        return false;\n    }\n    for (const property in targetStyle) {\n        if (!hasSameStyleProperty(property as keyof ICharacterProperties, targetStyle, sourceStyle)) {\n            return false;\n        }\n    }\n    return true;\n}\n\nexport function hasSameStyle(source: Partial<ICharacterProperties>, target: Partial<ICharacterProperties>): boolean {\n    const sourceStyle = omit(source, 'variable', '__fontFamilyId');\n    const targetStyle = omit(target, 'variable', '__fontFamilyId');\n    if (Object.keys(sourceStyle).length !== Object.keys(targetStyle).length) {\n        return false;\n    }\n    for (const property in sourceStyle) {\n        if (!hasSameStyleProperty(property as keyof ICharacterProperties, sourceStyle, targetStyle)) {\n            return false;\n        }\n    }\n    return true;\n}\n\nexport function hasSameStyleProperty(property: string, source: Partial<ICharacterProperties>, target: Partial<ICharacterProperties>, treatMissingAsFalse: boolean = true): boolean {\n    const targetValue = target[property];\n    if (targetValue === '$mixed') {\n        return false;\n    }\n    const sourceValue = source[property]!;\n    switch (property) {\n        case 'uppercase':\n        case 'underscore':\n        case 'strikethrough':\n\n            // We need to distinguish between 'missing' and 'false' values sometimes. An example, is when we want to promote commonly\n            // styled properties across whole text to element styles. A 'uppercase: false' is not the same as 'uppercase: undefined'.\n            // If we have in the first span 'uppercase: false' and all the rest of the spans has 'uppercase: undefined'. We don't want\n            // to promote 'uppercase: false' to element style.\n            if (!treatMissingAsFalse) {\n                return sourceValue === targetValue;\n            }\n            return !!sourceValue === !!targetValue;\n\n        case 'font': {\n            const targetStyle = targetValue as IFontStyle;\n            const sourceStyle = sourceValue as IFontStyle;\n            if (sourceStyle === targetStyle) {\n                return true;\n            }\n            if (targetStyle === undefined || sourceStyle === undefined) {\n                return false;\n            }\n            return targetStyle.id === sourceStyle.id &&\n                targetStyle.fontFamilyId === sourceStyle.fontFamilyId &&\n                targetStyle.style === sourceStyle.style &&\n                targetStyle.weight === sourceStyle.weight &&\n                targetStyle.src === sourceStyle.src;\n        }\n        case 'textColor':\n            if (sourceValue === targetValue) {\n                return true;\n            }\n            if (sourceValue === undefined || targetValue === undefined) {\n                return false;\n            }\n            if (!(sourceValue instanceof Color && targetValue instanceof Color)) {\n                throw new Error(`Neither 'targetValue' nor 'sourceValue' is of type Color.`);\n            }\n            return sourceValue.toString() === targetValue!.toString();\n        case 'padding':\n            const targetPadding = targetValue as IPadding;\n            const sourcePadding = sourceValue as IPadding;\n            if (sourcePadding === targetPadding) {\n                return true;\n            }\n            if (targetPadding === undefined || sourcePadding === undefined) {\n                return false;\n            }\n            return targetPadding.top === sourcePadding.top &&\n                targetPadding.bottom === sourcePadding.bottom &&\n                targetPadding.left === sourcePadding.left &&\n                targetPadding.right === sourcePadding.right;\n\n        case 'textShadows': {\n            const sourceShadows = sourceValue as IShadow[];\n            const targetShadows = targetValue as IShadow[];\n            if (typeof targetShadows !== typeof sourceShadows) {\n                return false;\n            }\n            if (targetShadows === sourceShadows) {\n                return true;\n            }\n            if (targetShadows.length !== sourceShadows.length) {\n                return false;\n            }\n            for (let i = 0; i < sourceShadows.length; i++) {\n                const sourceShadow = sourceShadows[i];\n                const targetShadow = targetShadows[i];\n                const isSame = sourceShadow.blur === targetShadow.blur &&\n                    sourceShadow.color === targetShadow.color &&\n                    sourceShadow.offsetX === targetShadow.offsetX &&\n                    sourceShadow.offsetY === targetShadow.offsetY &&\n                    sourceShadow.spread === targetShadow.spread;\n\n                if (!isSame) {\n                    return false;\n                }\n            }\n            return true;\n        }\n        default:\n            return sourceValue === targetValue;\n    }\n}\n\nexport function getMaxIndexFromStyleMap(styleIndexMap: Map<string, number>): number {\n    let maxIndex = 0;\n    for (const index of styleIndexMap.values()) {\n        if (index > maxIndex) {\n            maxIndex = index;\n        }\n    }\n    return maxIndex;\n}\n\nexport function createStyleIndexMap(text: IVersionedText, existingStyleIndexMap?: IStyleIndexMaps): IStyleIndexMaps {\n    const styleHashToIndexMap = existingStyleIndexMap && existingStyleIndexMap.styleHashToIndexMap || new Map<string, number>();\n    const indexToStyleIdsMap = existingStyleIndexMap && existingStyleIndexMap.indexToStyleIdsMap || new Map<number, Map<string, string>>();\n    let currentStyleIndex = existingStyleIndexMap\n        ? getMaxIndexFromStyleMap(existingStyleIndexMap.styleHashToIndexMap)\n        : 0;\n\n    for (let i = 0; i < text.styles.length; i++) {\n        const span = text.styles[i];\n        switch (span.type) {\n            case SpanType.Word:\n            case SpanType.Space:\n            case SpanType.Variable:\n                if (span.styleIds.size === 0) {\n                    continue;\n                }\n                let styleIndex: number | undefined;\n                const sequencedStyleIds = sequenceStyleIds(span.styleIds);\n                styleIndex = styleHashToIndexMap.get(sequencedStyleIds);\n                if (styleIndex === undefined) {\n                    currentStyleIndex++;\n                    styleIndex = currentStyleIndex;\n                }\n                indexToStyleIdsMap.set(styleIndex, new Map<string, string>(span.styleIds));\n                styleHashToIndexMap.set(sequencedStyleIds, styleIndex);\n                continue;\n        }\n    }\n\n    return { styleHashToIndexMap, indexToStyleIdsMap };\n}\n\nexport function sequenceStyleIds(styleIds: IStyleIdMap): string {\n    let serializedStyle = '';\n    const sortedStyleIds = Array.from(styleIds.values()).sort();\n    for (const styleId of sortedStyleIds) {\n        serializedStyle += styleId;\n    }\n    return serializedStyle;\n}\n\nexport function getHashFromStyle(style: Partial<ICharacterProperties>): string {\n    return crc32(sequenceStyle(style));\n}\n\nexport function getCommonStyledPropertiesFromUniqueOnes(uniquelyStyledProperties: Set<string>, style: Partial<ICharacterProperties>): Set<string> {\n    return new Set(Object.keys(style)\n        .filter(property => !uniquelyStyledProperties.has(property)));\n}\n\nexport function sequenceStyle(style: Partial<ICharacterProperties>): string {\n    let styleSequencedString = '';\n    for (const property of textProperties) {\n        if (!style) {\n            continue;\n        }\n        if (property === '__fontFamilyId') {\n            continue;\n        }\n        const styleValue = style[property];\n        if (styleValue === undefined) {\n            continue;\n        }\n        if (property === 'font') {\n            styleSequencedString += property + (typeof styleValue === 'string' ? styleValue : (styleValue as IFontStyle).id);\n        }\n        else if (styleValue !== undefined) {\n            styleSequencedString += property + JSON.stringify(serializeCharacterProperties({ [property]: styleValue })[property]);\n        }\n    }\n    return styleSequencedString;\n}\n\nexport function copySpans(spans: OneOfEditableSpans[]): OneOfEditableSpans[] {\n    const result: OneOfEditableSpans[] = [];\n    for (const span of spans) {\n        result.push(copySpan(span));\n    }\n    return result;\n}\n\nexport function copySpan<T extends OneOfEditableSpans>(span: T): T {\n    const copy = { ...span };\n    if (isContentSpan(span)) {\n        const contentSpanCopy = copy as IContentSpan;\n        contentSpanCopy.styleId = span.styleId;\n        contentSpanCopy.style = cloneDeep(span.style);\n        contentSpanCopy.styleIds = new Map([...(span.styleIds || [])]);\n        if (span.__previousStyleIdToHistoryIndexMap) {\n            contentSpanCopy.__previousStyleIdToHistoryIndexMap = new Map([...span.__previousStyleIdToHistoryIndexMap]);\n        }\n        contentSpanCopy.__previousStyleIds = cloneDeep(span.__previousStyleIds);\n    }\n    return copy;\n}\n\nexport function copyStyle<T extends Partial<ICharacterProperties & ITextElementProperties>>(style: T): T {\n    const styleCopy = {} as T;\n    for (const property in style) {\n        if (style[property] === undefined) {\n            continue;\n        }\n        switch (property) {\n            case 'textColor':\n                styleCopy[property] = (style[property] as any).copy();\n                break;\n            case 'fontSize':\n                styleCopy[property] = style[property];\n                break;\n            default:\n                styleCopy[property] = cloneDeep(style[property]);\n                break;\n        }\n    }\n    return styleCopy;\n}\n\nexport function resolveElementTextStyle<T extends OneOfViewNodes>(element: T): T {\n    if (isTextNode(element)) {\n        const text = element.__richTextRenderer.editor_m!.styleResolver.getResolvedText();\n        for (const property in text.style) {\n            if (!textProperties.includes(property as any)) {\n                continue;\n            }\n            element[property] = element.__data[property] = text.style[property];\n        }\n        if (element.__dirtyContent) {\n            element.__dirtyContent.spans = text.spans;\n        }\n    }\n    return element;\n}\n","export enum WidgetEvent {\n\n    /** Event that occurs when the widget's view node has changed. */\n    ViewNodeChanged = 'viewNodeChange',\n\n    /** Event that occurs when the widget's custom properties has changed. */\n    PropertyChanged = 'propertyChanged',\n\n    /** Event that occurs when the widget size has changed. */\n    Resize = 'resize',\n\n    /** Event that occurs when the widget position has changed. */\n    Move = 'move',\n\n    // Mouse events\n    /** Event that occurs when the widget is clicked. */\n    Click = 'click',\n\n    /** Event that occurs when mouse movement happens in the widget. */\n    MouseMove = 'mousemove',\n\n    /** Event that occurs when mouse pointer enters the widget. */\n    MouseOver = 'mouseover',\n\n    /** Event that occurs when mouse pointer leaves the widget. */\n    MouseOut = 'mouseout',\n\n    /** Event that occurs when mouse button is pressed inside the widget. */\n    MouseDown = 'mousedown',\n\n    /** Event that occurs when mouse button is released inside the widget after mouse down. */\n    MouseUp = 'mouseup',\n\n\n    // Animations\n    /** Event that occurs when the widget's animation starts on the timeline. */\n    AnimationStart = 'animation_start',\n\n    /** Event that occurs when the widget's animation ends on the timeline. */\n    AnimationEnd = 'animation_end',\n\n    /** Event that occurs when the widget's In Transition ends on the timeline. */\n    InTransitionEnd = 'in_transition_end',\n\n    /** Event that occurs when the widget's Out Transition starts on the timeline. */\n    OutTransitionStart = 'out_transition_start',\n\n    /** Event that occurs when the tcdata is resolved. */\n    TCData = 'tcdata',\n\n    /** Event that occurs when clicking show preload image */\n    ShowPreloadImage = 'show_preload_image'\n}\n\nexport enum CreativeEvent {\n\n    // Mouse events\n    /** Event that occurs when the creative is clicked. */\n    Click = 'click',\n\n    /** Event that occurs when mouse movement happens in the creative. */\n    MouseMove = 'mousemove',\n\n    /** Event that occurs when mouse pointer enters the creative. */\n    MouseOver = 'mouseover',\n\n    /** Event that occurs when mouse pointer leaves the creative. */\n    MouseOut = 'mouseout',\n\n    /** Event that occurs when mouse button is pressed inside the creative. */\n    MouseDown = 'mousedown',\n\n    /** Event that occurs when mouse button is released inside the creative after mouse down. */\n    MouseUp = 'mouseup',\n}\n\nexport enum TimelineEvent {\n    /** Event that occurs when timeline starts playing. */\n    Play = 'play',\n\n    /** Event that occurs when timeline pauses. */\n    Pause = 'pause',\n\n    /** Event that occurs when timeline stops. */\n    Stop = 'stop',\n\n    /** Event that occurs when timeline skips to the next loop. */\n    Loop = 'loop',\n\n    /** Event that occurs when timeline restarts from the beginning. */\n    Restart = 'restart',\n\n    /** Event that occurs when timeline replays from the current loop. */\n    Replay = 'replay',\n\n    /** Event that occurs when seeking in the timeline. */\n    Seek = 'seek',\n\n    /** Event that occurs when the timeline skips to the next loop. */\n    Tick = 'tick'\n}\n","import { distinctString, fixedEncodeURIComponent, trimEmojis } from '@studio/utils/utils';\n\nexport const FONT_SERVICE_TEXT_PARAMETER = '&t=';\n\nexport interface IFontServiceParams {\n    textParams: string;\n    distinctText: string;\n}\n\nexport const getFontServiceParamsFromString = (text: string): IFontServiceParams => {\n    const distinctText = distinctString(trimEmojis(text));\n    return {\n        textParams: FONT_SERVICE_TEXT_PARAMETER + fixedEncodeURIComponent(distinctText),\n        distinctText\n    };\n};\n\n","import { IBaseDataNode, INodeWithChildren, NodeKind, NodeKindWithChildren, OneOfDataNodes, OneOfElementDataNodes } from '../../domain/nodes';\nimport { isGroupDataNode, toFlatElementNodeList } from './helpers';\nimport { CreativeDataNode } from './creative-data-node';\nimport { GroupDataNode } from './group-data-node';\n\n/**\n * These base classes should be used for all data node types\n * eventually\n */\nexport abstract class BaseDataNode<Kind extends NodeKind> implements IBaseDataNode {\n    id: string;\n    kind: Kind;\n    name: string;\n    locked = false;\n    hidden = false;\n    __rootNode?: CreativeDataNode;\n    __parentNode?: GroupDataNode;\n    cidIndex?: number;\n    parentId?: string;\n}\n\nexport abstract class BaseDataNodeWithChildren<Kind extends NodeKindWithChildren> extends BaseDataNode<Kind> implements INodeWithChildren<Kind> {\n    private _elements: OneOfElementDataNodes[] = [];\n    get elements(): OneOfElementDataNodes[] {\n        return Object.freeze(this._elements) as OneOfElementDataNodes[];\n    }\n    private _nodes: OneOfDataNodes[] = [];\n    get nodes(): OneOfDataNodes[] {\n        return Object.freeze(this._nodes) as OneOfDataNodes[];\n    }\n    protected get _duration(): number {\n        let latestAnimationEnd = 0;\n        for (const element of this.elements) {\n            if (isGroupDataNode(element)) {\n                continue;\n            }\n\n            if (element.time + element.duration > latestAnimationEnd) {\n                latestAnimationEnd = element.time + element.duration;\n            }\n        }\n        // Rounding workaround due to floating points\n        return Math.round(latestAnimationEnd * 100) / 100;\n    }\n\n    constructor(input: IBaseDataNodeWithChildrenInput) {\n        super();\n        this.id = input.id;\n\n        if (typeof this.id === 'undefined') {\n            throw new Error(`No id was set when creating node ${this.name}`);\n        }\n\n        this.kind = input.kind as Kind;\n\n        if (input.nodes) {\n            this.setNodes_m(input.nodes);\n        }\n    }\n\n    setNodes_m(nodes: OneOfDataNodes[]): void {\n        this._nodes = nodes.slice();\n        this._nodes.forEach(node => this._applyParentToNode(node));\n\n        this._setFlatViewElementsList(nodes);\n    }\n\n    private _setFlatViewElementsList(nodes: OneOfDataNodes[]): void {\n        this._elements = toFlatElementNodeList(nodes);\n\n        const closestAncestor = this.__parentNode || this.__rootNode;\n\n        closestAncestor?._setFlatViewElementsList(closestAncestor.nodes);\n    }\n\n\n    *nodeIterator_m(includeGroups = false, group?: INodeWithChildren): IterableIterator<OneOfElementDataNodes | OneOfDataNodes> {\n        if (!group) {\n            group = this;\n        }\n\n        const nodes = group.nodes;\n\n        switch (group.kind) {\n            case NodeKind.Creative:\n            case NodeKind.Group:\n                for (const node of nodes) {\n                    switch (node.kind) {\n                        case NodeKind.Group:\n                            if (includeGroups) {\n                                yield node;\n                            }\n                            for (const n of this.nodeIterator_m(includeGroups, node)) {\n                                yield n;\n                            }\n                            break;\n                        default:\n                            yield node;\n                    }\n                }\n                break;\n            default:\n                throw new Error('Unknown group element.');\n        }\n    }\n\n    private _applyParentToNode(node: OneOfDataNodes): void {\n        if (isGroupDataNode(this)) {\n            node.__parentNode = this;\n        }\n        else if(this instanceof CreativeDataNode) {\n            node.__rootNode = this;\n            node.__parentNode = undefined;\n        }\n    }\n\n    protected _reverseNodes(): BaseDataNodeWithChildren<Kind> {\n        const nodeWithChildren = this;\n        nodeWithChildren.setNodes_m(this.nodes.slice().reverse());\n\n        for (const node of nodeWithChildren.nodes) {\n            if (node instanceof BaseDataNodeWithChildren) {\n                node.setNodes_m((node as BaseDataNodeWithChildren<Kind>)._reverseNodes().nodes);\n            }\n        }\n\n        return nodeWithChildren;\n    }\n\n    addNode_m(node: OneOfDataNodes, atIndex?: number): void {\n        const newNodeList = this.nodes.slice();\n        atIndex = atIndex ?? this.nodes.length;\n\n        this._applyParentToNode(node);\n\n        newNodeList.splice(atIndex, 0, node);\n\n        this.setNodes_m(newNodeList);\n    }\n\n    remove_m(): void {\n        if (isGroupDataNode(this)) {\n            const parent = (this.__parentNode || this.__rootNode);\n            const parentNodeIndex = parent?.nodes\n                .findIndex(node => node.id === this.id) || 0;\n\n            this.nodes.forEach((node, i) => {\n                parent?.addNode_m(node, parentNodeIndex + i);\n                this.removeNodeById_m(node.id);\n            });\n        }\n    }\n\n    /**\n     * Recursively find a node in the tree\n     */\n    findNodeById_m(nodeId: string, includeGroups?: boolean): OneOfDataNodes | undefined {\n        for (const node of this.nodeIterator_m(includeGroups)) {\n            if (node.id === nodeId) {\n                return node;\n            }\n        }\n    }\n\n    removeNodeById_m(nodeId: string): void {\n        const newNodeTree: OneOfDataNodes[] = [];\n        const nodes = this.nodes;\n\n        for (const node of nodes) {\n            if (node.id === nodeId) {\n                continue;\n            }\n\n            if (isGroupDataNode(node)) {\n                node.removeNodeById_m(nodeId);\n            }\n\n            newNodeTree.push(node);\n        }\n\n        this.setNodes_m(newNodeTree);\n    }\n}\n\nexport interface IBaseDataNodeInput {\n    id: string;\n    kind: NodeKind;\n}\n\nexport interface IBaseDataNodeWithChildrenInput extends IBaseDataNodeInput {\n    nodes?: OneOfDataNodes[];\n}\n\n\n","import { ISize, NodeKind, IColor, IGuideline, IGifExport, IPreloadImage, ChangeEventCallback, IBorder, ICreativeSocialGuide } from '@studio/domain';\nimport { BaseDataNodeWithChildren, IBaseDataNodeWithChildrenInput } from './base-data-node';\nimport { fromRGBAstring } from '@creative/color.utils';\n\n/* webpack-strip-block:removed */\n\nexport class CreativeDataNode extends BaseDataNodeWithChildren<NodeKind.Creative> implements ISize {\n    /**\n     * These properites are obsolete for the\n     * creative data node but gets inherited from the base\n     * They are deleted in the constructor\n     */\n    name: any;\n    locked: any;\n    hidden: any;\n    /** ----- */\n\n    fill: IColor;\n    loops = 0;\n    stopTime?: number;\n    startTime?: number;\n    border?: IBorder<IColor>;\n    width: number;\n    height: number;\n    noEmit = false;\n    callbacks: ChangeEventCallback[] = [];\n    guidelines: IGuideline[] = [];\n    preloadImage: IPreloadImage;\n    gifExport: IGifExport;\n    textColor: IColor;\n    socialGuide?: ICreativeSocialGuide;\n\n    get duration(): number {\n        return this._duration;\n    }\n\n    constructor(creative: ICreativeInput) {\n        super({ ...creative, kind: NodeKind.Creative, nodes: creative.nodes });\n        delete this.hidden;\n        delete this.locked;\n        delete this.name;\n        this.width = creative.width;\n        this.height = creative.height;\n        this.fill = creative.fill || fromRGBAstring('rgba(255, 255, 255, 1)');\n        this.textColor = creative.textColor || fromRGBAstring('rgba(0, 0, 0, 1)');\n        this.loops = creative.loops || 0;\n        this.stopTime = creative.stopTime;\n        this.startTime = creative.startTime;\n        this.guidelines = creative.guidelines || [];\n        this.gifExport = {\n            frames: [],\n            show: false,\n            ...creative.gifExport\n        };\n        this.preloadImage = {\n            quality: 70,\n            format: 'jpg',\n            frames: [],\n            ...creative.preloadImage\n        };\n        this.socialGuide = creative.socialGuide;\n    }\n\n    /* webpack-strip-block:removed */\n\n    getFirstPreloadImageFrame(): number {\n        if (this.preloadImage.frames.length > 0) {\n            return this.preloadImage.frames[0];\n        }\n        return 1;\n    }\n\n    getStopTime_m(): number {\n        if (typeof this.stopTime === 'number') {\n            return this.stopTime;\n        }\n        else {\n            return this.duration - 1;\n        }\n    }\n\n    subscribe_m(callback: ChangeEventCallback): void {\n        this.callbacks.push(callback);\n    }\n\n    unsubscribe_m(callback?: ChangeEventCallback): void {\n        if (!callback) {\n            this.callbacks = [];\n            return;\n        }\n        const index = this.callbacks.indexOf(callback);\n        if (index !== -1) {\n            this.callbacks.splice(index, 1);\n        }\n    }\n\n    destroy_m(): void {\n        this.callbacks = [];\n    }\n}\n\n\nexport interface ICreativeInput extends Omit<IBaseDataNodeWithChildrenInput, 'kind'> {\n    width: number;\n    height: number;\n    fill?: IColor;\n    textColor?: IColor;\n    loops?: number;\n    startTime?: number;\n    stopTime?: number;\n    guidelines?: IGuideline[];\n    preloadImage?: IPreloadImage;\n    gifExport?: IGifExport;\n    socialGuide?: ICreativeSocialGuide;\n}\n","import { Creativeset, Element } from '@studio/data/collections/creativeset.data';\nimport { characterProperties, IBoundingBox, IBounds, IChangeEvent, ICharacterProperties, ICharacterStylesMap, ICollection, IElement, IElementDataNode, IElementPropertyValues, IElementValues, IElementViewNode, IEndSpan, IFontFamily, IGroupElementDataNode, IGroupViewElement, IImageElementDataNode, IInlinedStyledTextSpan, IInlineStyledText, INewlineSpan, INodeWithChildren, IPosition, ISpaceSpan, IState, ISVGBackgroundNode, IText, ITextDataNode, ITextProperties, ITextSpan, IVersionedText, IVersionProperty, IWordSpan, NodeKind, NodeKindIcon, NodeWithKind, OneOfDataNodes, OneOfEditableSpans, OneOfElementDataNodes, OneOfGroupDataNodes, OneOfGroupViewNodes, OneOfSelectableElements, OneOfTextDataNodes, OneOfViewNodes, SpanType, VARIABLE_PREFIX } from '@studio/domain';\nimport { cloneDeep, cloneMapDeep } from '@studio/utils/clone';\nimport { isElementVisibleAtTime } from '../animation.utils';\nimport { isVersionedText } from '../elements/rich-text/text-nodes';\nimport { getFontStyleById, tryGetFontStyleById } from '../font-families.utils';\nimport { serializePropertyValue } from '../serialization/property-value-serializer'; // attention: dont change this import to alias, breaks the script build\nimport { serializeVersionedText } from '../serialization/text-serializer';\nimport { CreativeDataNode } from './creative-data-node';\nimport { hasHiddenAncestor } from './data-node.utils';\n\nexport function getKindAsString(kind: NodeKind | 'feeds'): string {\n    switch (kind) {\n        case NodeKind.Text:\n            return 'texts';\n        case NodeKind.Button:\n            return 'buttons';\n        case NodeKind.Rectangle:\n            return 'shapes';\n        case NodeKind.Ellipse:\n            return 'shapes';\n        case NodeKind.Image:\n            return 'images';\n        case NodeKind.Video:\n            return 'videos';\n        case NodeKind.Widget:\n            return 'widgets';\n        case NodeKind.Video:\n            return 'video';\n        case NodeKind.AnyElement:\n            return 'elements';\n        case 'feeds':\n            return 'feeds';\n        case NodeKind.Selection:\n            return 'selection';\n    }\n    throw new Error('Unknown element kind');\n}\n\nexport function getKindTitleAsString(kind: NodeKind | 'feeds'): string {\n    switch (kind) {\n        case NodeKind.Text:\n            return 'Text Tool';\n        case NodeKind.Button:\n            return 'Button Tool';\n        case NodeKind.Rectangle:\n            return 'Rectangle Tool';\n        case NodeKind.Ellipse:\n            return 'Ellipse Tool';\n        case NodeKind.Image:\n            return 'Images';\n        case NodeKind.Video:\n            return 'Videos';\n        case NodeKind.Widget:\n            return 'Widgets';\n        case NodeKind.Video:\n            return 'Video';\n        case NodeKind.AnyElement:\n            return 'Brand Library';\n        case 'feeds':\n            return 'Dynamic Content';\n        case NodeKind.Selection:\n            return '';\n    }\n    throw new Error('Unknown element kind');\n}\n\nexport function getKindMessageAsString(kind: NodeKind | 'feeds'): string {\n    switch (kind) {\n        case NodeKind.Text:\n            return 'Click/drag on canvas to\\ncreate a new text area';\n        case NodeKind.Button:\n            return 'Click/drag on canvas to\\ncreate a new button';\n        case NodeKind.Rectangle:\n            return 'Click/drag on canvas to\\ncreate a new rectangle';\n        case NodeKind.Ellipse:\n            return 'Click/drag on canvas to\\ncreate a new ellipse';\n        case NodeKind.Image:\n            return 'Drag in or upload an image\\n to store it here';\n        case NodeKind.Video:\n            return 'Drag in or upload an video\\n to store it here';\n        case NodeKind.Widget:\n            return 'Import a stock widget or\\ncreate a new one from scratch';\n        case NodeKind.Video:\n            return 'Drag in or upload an video\\n to store it here';\n        case NodeKind.AnyElement:\n            return 'Store elements that you\\nwant to reuse across\\ncreative sets in the library';\n        case 'feeds':\n            return 'Dynamic feed variables\\nwill show up here';\n        case NodeKind.Selection:\n            return '';\n    }\n    throw new Error('Unknown element kind');\n}\n\nconst SEARCH_PLACEHOLDER_MAP: Partial<Record<NodeKind | 'feeds' | 'library', string>> = {\n    [NodeKind.Text]: 'Search text elements',\n    [NodeKind.Button]: 'Search buttons',\n    [NodeKind.Rectangle]: 'Search rectangles',\n    [NodeKind.Ellipse]: 'Search ellipses',\n    [NodeKind.Image]: 'Search images',\n    [NodeKind.Widget]: 'Search widgets',\n    [NodeKind.Video]: 'Search videos',\n    feeds: 'Search dynamic content',\n    library: 'Search in library'\n};\n\nexport function getSearchPlaceholderAsString(kind?: NodeKind | 'feeds'): string {\n    return SEARCH_PLACEHOLDER_MAP[kind || 'library'] || SEARCH_PLACEHOLDER_MAP.library!;\n}\n\nexport function mergeWidgetKind(kind: NodeKind): NodeKind {\n    if (isWidgetNode({ kind })) {\n        return NodeKind.Widget;\n    }\n    return kind;\n}\n\n// Helper function to in order to make typing easier\nfunction isNodeWithKind<Element extends NodeWithKind<Kind>, Kind extends NodeKind = NodeKind>(element: Element | undefined | {}): element is Element {\n    return Boolean(element && 'kind' in element);\n}\n\nfunction buildIsNodeKind<Kinds extends NodeKind[]>(...kinds: Kinds) {\n    return function <Element extends NodeWithKind<NodeKind> | {}>\n        (node?: Element): node is Extract<Element, { kind: Kinds[number] }> {\n        if (!isNodeWithKind(node)) {\n            return false;\n        }\n        return kinds.findIndex(testKind => node.kind === testKind) !== -1;\n    };\n}\n\nexport const isTextNode = buildIsNodeKind(NodeKind.Button, NodeKind.Text);\nexport const isEllipseNode = buildIsNodeKind(NodeKind.Ellipse);\nexport const isRectangleNode = buildIsNodeKind(NodeKind.Rectangle);\nexport const isCreativeViewNode = buildIsNodeKind(NodeKind.Creative);\nexport const isSelection = buildIsNodeKind(NodeKind.Selection);\nexport const isVideoNode = buildIsNodeKind(NodeKind.Video);\nexport const isImageNode = buildIsNodeKind(NodeKind.Image);\nexport function isGroupDataNode(element?: OneOfDataNodes | OneOfViewNodes | INodeWithChildren): element is IGroupElementDataNode {\n    return !!element && buildIsNodeKind(NodeKind.Group)(element);\n}\nexport const isWidgetNode = buildIsNodeKind(\n    NodeKind.Widget,\n    NodeKind.BannerflowLibraryWidget,\n    NodeKind.BannerflowLibraryWidgetInstance\n);\n\nexport function isVideoElement(element?: IElement): boolean {\n    return element !== undefined && element.type === NodeKind.Video;\n}\nexport function isImageElement(element?: IElement): boolean {\n    return element !== undefined && element.type === NodeKind.Image;\n}\n\nexport function isTextDataElement<Kind extends NodeKind>(node?: Partial<OneOfSelectableElements | IElementViewNode<Kind> | OneOfElementDataNodes | IElementDataNode<Kind>>): node is ITextDataNode<Kind> {\n    return node !== undefined && (node.kind === NodeKind.Button || node.kind === NodeKind.Text) && !isViewElementNode(node);\n}\n\nexport function isWidgetElement(element?: IElement): boolean {\n    return element !== undefined && [\n        NodeKind.Widget,\n        NodeKind.BannerflowLibraryWidget,\n        NodeKind.BannerflowLibraryWidgetInstance\n    ].includes(element.type);\n}\n\nexport function isCustomWidgetElement(element?: IElement): boolean {\n    return element !== undefined && element.type === NodeKind.Widget;\n}\n\nexport function isTextElement(element?: IElement): boolean {\n    return element !== undefined && [\n        NodeKind.Text,\n        NodeKind.Button,\n    ].includes(element.type);\n}\n\nexport function isViewElementNode(node: OneOfSelectableElements | Partial<OneOfViewNodes> | Partial<ISVGBackgroundNode> | OneOfElementDataNodes): node is IElementViewNode {\n    if (node === undefined || !('kind' in node)) {\n        return false;\n    }\n\n    return (node.kind !== NodeKind.Creative\n        && node.kind !== NodeKind.AnyElement\n        && node.kind !== NodeKind.Selection\n        && node.kind !== NodeKind.Group\n        && node['__data']);\n}\n\nexport function isSelectionVisibleAtTime(element: OneOfDataNodes, time: number): boolean {\n    return !isHidden(element) && time >= element.time\n        && time <= (element.time + element.duration);\n}\n\nexport function isState(element: OneOfElementDataNodes | IState | undefined): element is IState {\n    if (!element) {\n        return false;\n    }\n    return !('kind' in element) || typeof element.kind !== 'string';\n}\n\nexport function isElementDataNode(element: OneOfDataNodes | IState | OneOfViewNodes): element is OneOfElementDataNodes {\n    return !isState(element) && !isViewElementNode(element);\n}\n\nexport function createDefaultTextProperties(): ITextProperties {\n    const properties = {\n        padding: { top: 0, left: 0, right: 0, bottom: 0 },\n        verticalAlignment: 'top',\n        maxRows: Infinity,\n        textOverflow: 'expand',\n        characterSpacing: 0,\n        lineHeight: 1.3,\n        __fontFamilyId: '',\n    } as ITextProperties;\n    return properties;\n}\n\nconst characters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];\nlet currentCidIndex = 1;\n\nexport function createElementCid(): string {\n    const position = currentCidIndex++;\n    return getNumberSystemEncoding(position);\n}\n\nexport function getNumberSystemEncoding(position: number): string {\n    const numberSystem = characters.length;\n    if (position <= numberSystem) {\n        return characters[position - 1];\n    }\n    const numerals: string[] = [];\n    let currentNumber = position;\n    while (currentNumber >= numberSystem) {\n        const remainder = currentNumber % numberSystem;\n        currentNumber = (currentNumber - remainder) / numberSystem;\n        numerals.push(characters[remainder]);\n    }\n    numerals.push(characters[currentNumber - 1]);\n    return numerals.reverse().join('');\n}\n\nexport function resetNodeCid(): void {\n    currentCidIndex = 1;\n}\n\nexport function getCurrentCidIndex(): number {\n    return currentCidIndex;\n}\n\nexport function forEachElement<Element extends OneOfViewNodes>(group: OneOfGroupViewNodes, callback: (node: Element, group: IGroupViewElement | undefined, index: number) => void, atTime?: number, reverse?: boolean): void {\n    forEachNode(group, callback, atTime, reverse);\n}\n\nexport function forEachDataElement<Node extends OneOfElementDataNodes>(group: OneOfGroupDataNodes | OneOfDataNodes[], callback: (element: Node, group: IGroupElementDataNode | undefined, index: number) => void, atTime?: number, reverse?: boolean): void {\n    forEachNode(group, callback, atTime, reverse);\n}\n\nfunction forEachNode<\n    T extends OneOfViewNodes | OneOfElementDataNodes,\n    Group extends IGroupElementDataNode | IGroupViewElement>\n    (\n        group: OneOfGroupDataNodes | OneOfDataNodes[] | OneOfGroupViewNodes,\n        callback: (node: T, group: Group | undefined, index: number) => void,\n        atTime?: number,\n        reverse?: boolean\n    ): void {\n\n    let nodes: OneOfDataNodes[] | OneOfViewNodes[] = [];\n\n    if (isNodeWithKind(group)) {\n        switch (group.kind) {\n            case NodeKind.Creative:\n            case NodeKind.Group:\n                nodes = group.nodes;\n                break;\n            default:\n                throw new Error('Unknown group element.');\n        }\n    }\n    else {\n        nodes = group;\n    }\n\n    if (reverse) {\n        nodes = nodes.slice().reverse();\n    }\n\n    let i = 0;\n    for (const node of nodes) {\n        if (isGroupDataNode(node)) {\n            forEachNode(node, groupNode => {\n                callback(groupNode as T, node as Group, i);\n            }, atTime, reverse);\n        }\n        else {\n            if (typeof atTime !== 'number' || isElementVisibleAtTime(node as OneOfElementDataNodes, atTime)) {\n                callback(node as T, undefined, i);\n            }\n        }\n\n        i++;\n    }\n}\n\n/**\n * @returns Returns a flat nodelist of element nodes. Groups are excluded.\n */\nexport function toFlatElementNodeList(nodes: OneOfGroupDataNodes | OneOfDataNodes[]): OneOfElementDataNodes[] {\n    const flatNodeList: OneOfElementDataNodes[] = [];\n\n    forEachDataElement(nodes, element => {\n        if (isGroupDataNode(element)) {\n            return;\n        }\n        flatNodeList.push(element);\n    });\n\n    return flatNodeList;\n}\n\n/**\n * @returns Returns a completely flattened array of all nodes, including groups.\n */\nexport function toFlatNodeList(nodes: OneOfGroupDataNodes | OneOfDataNodes[]): OneOfDataNodes[] {\n\n    if (Array.isArray(nodes) && nodes.every(node => !isGroupDataNode(node))) {\n        return nodes;\n    }\n\n    const flatNodeListArr: OneOfDataNodes[] = [];\n    const nodeArr = 'nodes' in nodes\n        ? nodes.nodes\n        : nodes;\n\n    for (const node of nodeArr.slice().reverse()) {\n        if (isGroupDataNode(node)) {\n            flatNodeListArr.unshift(node);\n            flatNodeListArr.unshift(...toFlatNodeList(node));\n        }\n        else if (flatNodeListArr.indexOf(node) === -1) {\n            flatNodeListArr.unshift(node);\n        }\n    }\n\n    return flatNodeListArr;\n}\n\nexport function isHidden(node: OneOfDataNodes): boolean {\n    return node.hidden || hasHiddenAncestor(node);\n}\n\n/**\n * @param  {OneOfDataNodes|undefined} node\n * @param  {(parent:IGroupElementDataNode)=>boolean|void} callback\n * Return true to break loop\n */\nexport function forEachParentNode(node: OneOfDataNodes | undefined, callback: (parent: IGroupElementDataNode) => boolean | void): void {\n\n    if (!node) {\n        return;\n    }\n\n    let parentNode = node.__parentNode;\n    while (parentNode) {\n        const cancel = callback(parentNode);\n        if (cancel) {\n            return;\n        }\n        parentNode = parentNode.__parentNode;\n    }\n}\n\nexport function positionIsInBounds(position: IPosition, bounds: IBounds | IBoundingBox, tolerance: IPosition = { x: 0, y: 0 }): boolean {\n    let checkLeftBound: boolean;\n    let checkTopBound: boolean;\n    let checkRightBound: boolean;\n    let checkBottomBound: boolean;\n    if ('scaleX' in bounds && bounds.scaleX) {\n        checkLeftBound = position.x >= bounds.x + (bounds.width / 2) - ((bounds.width * bounds.scaleX) / 2);\n        checkRightBound = position.x <= bounds.x + (bounds.width / 2) + ((bounds.width * bounds.scaleX) / 2);\n    } else {\n        const minX = bounds.x - tolerance.x;\n        const maxX = bounds.x + bounds.width + tolerance.x;\n        checkLeftBound = position.x >= minX;\n        checkRightBound = position.x <= maxX;\n    }\n    if ('scaleY' in bounds && bounds.scaleY) {\n        checkTopBound = position.y >= bounds.y + (bounds.height / 2) - ((bounds.height * bounds.scaleY) / 2);\n        checkBottomBound = position.y <= bounds.y + (bounds.height / 2) + ((bounds.height * bounds.scaleY) / 2);\n    } else {\n        const minY = bounds.y - tolerance.y;\n        const maxY = bounds.y + bounds.height + tolerance.y;\n        checkTopBound = position.y >= minY;\n        checkBottomBound = position.y <= maxY;\n    }\n    if (checkLeftBound && checkRightBound) {\n        if (checkTopBound && checkBottomBound) {\n            return true;\n        }\n    }\n    return false;\n}\n\nexport function isNumberBetween(origin: number, num2: number, margin: number = 5): boolean {\n    return (origin - num2 - margin) * (origin - num2 + margin) <= 0;\n}\n\nexport function getElementTextProperties(data: OneOfTextDataNodes): Partial<ICharacterProperties> {\n    const style: Partial<ICharacterProperties> = {};\n    for (const characterProperty of characterProperties) {\n        const value = data[characterProperty];\n        if (value !== undefined) {\n            style[characterProperty] = value as any; // TODO: WHY I HAVE TO DO THIS?\n        }\n    }\n    return style;\n}\n\nexport function getElementIndex(element: OneOfDataNodes): number {\n    return element.__rootNode!.elements.findIndex(e => e.id === element.id);\n}\n\nexport function getElementIdentifier(elementOrSelection: OneOfSelectableElements): string {\n    if (elementOrSelection.kind === NodeKind.Selection) {\n        if (elementOrSelection.length === 1) {\n            const element = elementOrSelection.element!;\n            return `${element.kind}:${element.id}`;\n        }\n        else {\n            return `${elementOrSelection.kind}:${elementOrSelection.length}`;\n        }\n    }\n    else {\n        const element = elementOrSelection;\n        return `${element.kind}:${element.id}`;\n    }\n}\n\nexport function createViewElement(element: OneOfElementDataNodes): OneOfViewNodes {\n    if (isGroupDataNode(element)) {\n        throw new Error('View elements can not be created from a group node.');\n    }\n\n    const viewElement = {\n        kind: element.kind,\n        __data: element,\n        get '__dirtyContent'() {\n            return viewElement.__data['__dirtyContent'];\n        }\n    } as OneOfViewNodes;\n\n    viewElement.elementCid = createElementCid();\n    viewElement.cidIndex = getCurrentCidIndex();\n    viewElement.id = element.id;\n    viewElement.name = element.name;\n    viewElement.ratio = element.ratio;\n\n    viewElement.time = element.time;\n    viewElement.duration = element.duration;\n\n    if (isTextNode(viewElement) && isTextNode(element)) {\n        viewElement.font = element.font;\n        viewElement.content = element.content;\n    }\n    else if (isImageNode(element) && isImageNode(viewElement)) {\n        viewElement.feed = element.feed;\n    }\n    else if (isWidgetNode(viewElement) && isWidgetNode(element)) {\n        viewElement.customProperties = element.customProperties;\n    }\n\n    return viewElement;\n}\n\nexport function createDataElement<T extends OneOfDataNodes>(element: T): T {\n\n    if (isTextDataElement(element)) {\n        if (element.content) {\n            element.__content = element.content;\n        }\n\n        Object.defineProperty(element, 'content', {\n            set(value: IText) {\n                element.__content = value;\n                for (const callback of element.__rootNode!.callbacks) {\n                    callback(element, {\n                        property: 'content',\n                        value,\n                    });\n                }\n            },\n            get() {\n                return element.__content;\n            },\n            enumerable: true\n        });\n    }\n\n    return element;\n}\n\nexport function initializeElements(\n    creative: CreativeDataNode,\n    elements: ICollection<IElement> | IElement[],\n    values: IElementValues): void {\n    for (const node of creative.nodeIterator_m(true)) {\n        const globalElement = (elements as IElement[]).find(el => el.id === node.id);\n\n        if (!globalElement) {\n            throw new Error(`Could not find global element with id '${node.id}'.`);\n        }\n\n        if (isGroupDataNode(node)) {\n            node.name = globalElement.name;\n            continue;\n        }\n        node.name = globalElement.name;\n\n        initializeElementProperties(node,\n            {\n                elementProperties: globalElement.properties,\n                versionProperties: values.versionProperties,\n                originalVersionProperties: values.originalVersionProperties,\n                fontFamilies: values.fontFamilies,\n                images: values.images,\n            }\n        );\n    }\n}\n\nexport function initializeFonts<Kind extends NodeKind>(textElement: ITextDataNode<Kind>, fontFamilies: Readonly<IFontFamily[]>): void {\n    for (const style of textElement.characterStyles.values()) {\n        if (style.font) {\n            if (typeof style.font === 'string') {\n                try {\n                    const fontStyle = getFontStyleById(fontFamilies, style.font);\n                    style.font = {\n                        id: fontStyle!.id,\n                        src: fontStyle!.fontUrl,\n                        weight: fontStyle!.weight,\n                        style: fontStyle!.italic ? 'italic' : 'normal',\n                        fontFamilyId: fontStyle!.fontFamilyId!,\n                    };\n                }\n                catch (err) {\n                    console.error(err);\n                    delete style.font;\n                }\n            }\n        }\n    }\n}\n\nexport function initializeElementProperties(\n    element: OneOfElementDataNodes,\n    values: IElementPropertyValues): void {\n    const { elementProperties, versionProperties: versionValues, originalVersionProperties: originalVersionValues } = values;\n\n    if (isTextNode(element)) {\n        const fontStyleId = element.font?.id || element.__fontStyleId;\n        const fontStyle = tryGetFontStyleById(values.fontFamilies, fontStyleId || '');\n        element.font = undefined;\n        if (fontStyle) {\n            // Note: font is undefined before initialization, we just store the font style id as a reference.\n            element.font = {\n                id: fontStyle.id,\n                src: fontStyle.fontUrl,\n                weight: fontStyle.weight,\n                style: fontStyle.italic ? 'italic' : 'normal',\n                fontFamilyId: fontStyle.fontFamilyId!,\n            };\n        }\n    }\n\n    for (const property of elementProperties) {\n        if (property.versionPropertyId) {\n            let versionValue = versionValues.find(v => v.id === property.versionPropertyId);\n            if (!versionValue) {\n                if (!originalVersionValues) {\n                    throw new Error(`Could not find version property value 'property.versionPropertyId'.`);\n                }\n                versionValue = originalVersionValues.find(e => e.id === property.versionPropertyId);\n            }\n            if (!versionValue) {\n                throw new Error('Could not find value from global elements, selected version or original.');\n            }\n            const name = property.name;\n            if (name === 'content' && isTextNode(element) && isVersionedText(versionValue)) {\n                initializeFonts(element, values.fontFamilies);\n                element[name] = createTextFromVersionedText(element, versionValue.value, element.characterStyles);\n            }\n            else if (isWidgetNode(element)) {\n                const versionProperty = element.customProperties\n                    .find(prop => prop.versionPropertyId === property.versionPropertyId);\n                if (versionProperty) {\n                    if (isVersionedText(versionValue)) {\n                        versionProperty.value = serializeVersionedText(versionValue.value);\n                    }\n                    else {\n                        versionProperty.value = serializePropertyValue(versionProperty.unit, versionValue.value)!;\n                    }\n                }\n            }\n            else {\n                element[name] = versionValue.value;\n            }\n        }\n        else {\n            element[property.name] = property.value;\n        }\n    }\n}\n\nexport function createVersionedTextFromText(text: IText): IVersionedText {\n    let position = 0;\n    const textSpans: ITextSpan[] = [];\n    let _text = '';\n    for (const span of text.spans) {\n        if (span.type === SpanType.End) {\n            break;\n        }\n        const length = span.type === SpanType.Variable ? span.style.variable!.path.length + 1 : span.content.length;\n        textSpans.push({\n            position,\n            length,\n            type: span.type,\n            styleIds: new Map([...(span.styleIds || [])]),\n            variable: span.style.variable,\n            __previousStyleIds: [...span.__previousStyleIds || []],\n            __previousStyleIdToHistoryIndexMap: new Map(span.__previousStyleIdToHistoryIndexMap || [])\n        });\n        position += length;\n        _text += span.type === SpanType.Variable ? VARIABLE_PREFIX + span.style.variable!.path : span.content;\n    }\n    return {\n        text: _text,\n        styles: textSpans,\n    };\n}\n\nexport function createInlineStyledTextFromText(text: IText): IInlineStyledText {\n    let position = 0;\n    const textSpans: IInlinedStyledTextSpan[] = [];\n    let _text = '';\n\n    const copyText = JSON.parse(JSON.stringify(text));\n\n    for (const span of copyText.spans) {\n        if (span.type === SpanType.End) {\n            break;\n        }\n\n        const length = span.content.length;\n        textSpans.push({\n            position,\n            length,\n            type: span.type,\n            style: span.style,\n            variable: span.style.variable\n        });\n        position += length;\n        _text += span.content;\n    }\n    return {\n        text: _text,\n        styles: textSpans,\n    };\n}\n\nexport function createTextFromInlineStyledText(inlineStyledText: IInlineStyledText, textProperties?: ITextProperties): IText {\n    const text = inlineStyledText.text;\n    const spans: OneOfEditableSpans[] = [];\n    for (const span of inlineStyledText.styles) {\n        switch (span.type) {\n            case SpanType.Word:\n            case SpanType.Variable:\n            case SpanType.Space: {\n                spans.push({\n                    type: span.type,\n                    attributes: {},\n                    top: 0,\n                    left: 0,\n                    width: 0,\n                    height: 0,\n                    lineHeight: 0,\n                    content: text.substr(span.position, span.length),\n                    style: cloneDeep(span.style),\n                    styleIds: new Map(),\n                    __previousStyleIds: [],\n                    __previousStyleIdToHistoryIndexMap: new Map<string, number>(),\n                } as IWordSpan | ISpaceSpan);\n                break;\n            }\n            case SpanType.Newline: {\n                spans.push({\n                    type: span.type,\n                    attributes: {},\n                    top: 0,\n                    left: 0,\n                    width: 0,\n                    height: 0,\n                    lineHeight: 0,\n                    content: '\\n',\n                    style: cloneDeep(span.style),\n                    styleIds: new Map(),\n                    __previousStyleIds: [],\n                    __previousStyleIdToHistoryIndexMap: new Map<string, number>(),\n                } as INewlineSpan);\n                break;\n            }\n            default:\n                throw new TypeError(`Expected span of type 'word', 'space' 'newline', instead got '${span.type}'.`);\n        }\n    }\n\n    spans.push({\n        type: SpanType.End,\n        content: 'END',\n    } as IEndSpan);\n\n    return {\n        style: textProperties ?? createDefaultTextProperties(),\n        spans,\n    };\n}\n\nexport function createTextFromVersionedText(element: OneOfElementDataNodes, versionedText: IVersionedText, elementsCharacterStyles: ICharacterStylesMap): IText {\n    // This should hopefully not be a problem since the types have been updated, but I'll leave it here\n    // just in case\n    if (!element.__rootNode) {\n        throw new Error(`Expected versioned text with root node, received '${typeof element.__rootNode}'`);\n    }\n\n    const text = versionedText.text;\n    const spans: OneOfEditableSpans[] = [];\n    for (const span of versionedText.styles) {\n        switch (span.type) {\n            case SpanType.Variable: {\n                const styleId = span.styleIds.get(element.__rootNode.id)!;\n                spans.push({\n                    type: span.type,\n                    attributes: {},\n                    top: 0,\n                    left: 0,\n                    width: 0,\n                    height: 0,\n                    lineHeight: 0,\n                    content: VARIABLE_PREFIX + span.variable!.path,\n                    style: Object.assign(cloneDeep(elementsCharacterStyles.get(styleId) || {}), {\n                        variable: span.variable,\n                    }),\n                    styleIds: cloneMapDeep(span.styleIds),\n                    styleId,\n                    __previousStyleIds: [...span.__previousStyleIds || []],\n                    __previousStyleIdToHistoryIndexMap: new Map(span.__previousStyleIdToHistoryIndexMap || [])\n                });\n                break;\n            }\n            case SpanType.Word:\n            case SpanType.Space: {\n                const styleId = span.styleIds.get(element.__rootNode.id)!;\n                spans.push({\n                    type: span.type,\n                    attributes: {},\n                    top: 0,\n                    left: 0,\n                    width: 0,\n                    height: 0,\n                    lineHeight: 0,\n                    content: text.substr(span.position, span.length),\n                    style: cloneDeep(elementsCharacterStyles.get(styleId) || {}),\n                    styleIds: cloneMapDeep(span.styleIds),\n                    styleId,\n                    __previousStyleIds: [...span.__previousStyleIds || []],\n                    __previousStyleIdToHistoryIndexMap: new Map(span.__previousStyleIdToHistoryIndexMap || [])\n                } as IWordSpan | ISpaceSpan);\n                break;\n            }\n            case SpanType.Newline: {\n                const styleId = span.styleIds.get(element.__rootNode.id)!;\n                spans.push({\n                    type: span.type,\n                    attributes: {},\n                    top: 0,\n                    left: 0,\n                    width: 0,\n                    height: 0,\n                    lineHeight: 0,\n                    content: '\\n',\n                    style: cloneDeep(elementsCharacterStyles.get(span.styleIds.get(element.__rootNode.id)!) || {}),\n                    styleIds: cloneMapDeep(span.styleIds),\n                    styleId,\n                    __previousStyleIds: [...span.__previousStyleIds || []],\n                    __previousStyleIdToHistoryIndexMap: new Map(span.__previousStyleIdToHistoryIndexMap || [])\n                } as INewlineSpan);\n                break;\n            }\n            default:\n                throw new TypeError(`Expected span of type 'word', 'space' 'newline', instead got '${span.type}'.`);\n        }\n    }\n\n    spans.push({\n        type: SpanType.End,\n        content: 'END',\n    } as IEndSpan);\n\n    return {\n        style: createDefaultTextProperties(),\n        spans,\n    };\n}\n\nexport function bindDataChangesToSharedElementsOrVersionedValues(dataTree: CreativeDataNode, elements: ICollection<IElement>, _currentVersionId: string, versionedValues: IVersionProperty[], _originalVersionValues?: IVersionProperty[]): (dataNode: CreativeDataNode, changes: any) => void {\n    const callback = (dataNode, changes): void => applyElementChanges(dataNode, changes, elements, versionedValues);\n    dataTree.subscribe_m(callback);\n    return callback;\n}\n\nexport function isBannerFlowLibraryWidget(element: IElement): boolean {\n    // If the type is of bannerflowLibraryWidget then it's imported\n    return element.type === NodeKind.BannerflowLibraryWidget || !!(element.properties && element.properties.find(prop => prop.name === 'bannerflowLibraryWidgetReference'));\n}\n\nexport function isOriginalBannerFlowLibraryWidget(element: IElement): boolean {\n    // If the type is of bannerflowLibraryWidget then it's imported\n    return !!(isCustomWidgetElement(element) && element.properties && element.properties.find(prop => prop.name === 'bannerflowLibraryWidgetReference'));\n}\n\nfunction applyElementChanges(dataNode: IElementViewNode, change: IChangeEvent, elements: ICollection<IElement>, versionValues: IVersionProperty[]): void {\n    const element = elements.find(e => e.id === dataNode.id)!;\n    if (!element) {\n        throw new Error(`Could not find element with id '${dataNode.id}'.`);\n    }\n    const property = element.properties.find(p => p.name === change.property);\n    if (!property || !property.versionPropertyId) {\n        return;\n    }\n    const value = typeof change.value !== 'undefined' ? change.value : undefined;\n    const versionElementPropertyValue = versionValues.find(e => e.id === property.versionPropertyId);\n    if (!versionElementPropertyValue) {\n        versionValues.push({\n            id: property.versionPropertyId,\n            name: 'content',\n            value: createVersionedTextFromText(value as IText),\n        });\n        return;\n    }\n    versionElementPropertyValue.value = createVersionedTextFromText(value as IText);\n}\n\nexport function nodeKindToIcon(kind: NodeKind): NodeKindIcon | undefined {\n    let icon: NodeKindIcon | undefined;\n    Object.keys(NodeKind).forEach(key => {\n        if (NodeKind[key] === kind) {\n            icon = NodeKindIcon[key];\n        }\n    });\n\n    return icon;\n}\n\nexport function getTextElements(creative: CreativeDataNode): OneOfTextDataNodes[] {\n    const result: OneOfTextDataNodes[] = [];\n    forEachDataElement(creative, (element) => {\n        if (isTextNode(element)) {\n            result.push(element);\n        }\n    });\n    return result;\n}\n\nexport function isOrphanElement(element: Element, creativeset: Creativeset): boolean {\n    for (const design of creativeset.designs) {\n        if (design.hasElement(element)) {\n            return false;\n        }\n    }\n    return true;\n}\n\n\nexport function ratioLockSvgElement(url: string, imageNode: IImageElementDataNode): void {\n    const isSvg = /(\\.(svg))(\\/?(\\?.*)?)$/gi;\n\n    if ((url || '').match(isSvg)) {\n        imageNode.ratio = imageNode.width / imageNode.height;\n    }\n}\n","import { IBoundingBox, IGroupElementDataNode, IPosition, ISize, OneOfDataNodes, ITimelineNode, OneOfGroupDataNodes } from '../../domain';\nimport { forEachParentNode, isGroupDataNode } from './helpers';\nimport { ElementSelection } from './selection';\n\nexport function cloneNodes(nodes: OneOfDataNodes[]): OneOfDataNodes[] {\n    return nodes.map(node => {\n        if (isGroupDataNode(node)) {\n            return node.copy(true);\n        }\n        return node;\n    });\n}\n\nexport function hasLockedAncestor(node: OneOfDataNodes): boolean {\n    let hasLockedParent = false;\n\n    forEachParentNode(node, parent => {\n        if (parent.locked) {\n            hasLockedParent = true;\n            return true;\n        }\n    });\n\n    return hasLockedParent;\n}\n\nexport function hasHiddenAncestor(node: OneOfDataNodes): boolean {\n    let hasHiddenParent = false;\n\n    forEachParentNode(node, parent => {\n        if (parent.hidden) {\n            hasHiddenParent = true;\n            return true;\n        }\n    });\n\n    return hasHiddenParent;\n}\n\n/**\n * Looks for the first expanded ancestor of node\n */\nexport function findExpandedAncestor(\n    node: OneOfDataNodes,\n    nodeList: ITimelineNode[]\n): IGroupElementDataNode | undefined {\n    let ancestor: IGroupElementDataNode | undefined;\n\n    forEachParentNode(node, parent => {\n        const isParentExpanded = nodeList.some(tl => tl.node.__parentNode?.id === parent.id && !tl.collapsed);\n        if (isGroupDataNode(parent) && isParentExpanded) {\n            ancestor = parent;\n            return true;\n        }\n    });\n\n    return ancestor;\n}\n\n/**\n * Checks if parent of node is selected\n */\nexport function isParentNodeSelected(\n    node: OneOfDataNodes,\n    selection: ElementSelection\n): boolean {\n    return selection.nodes.some(n => isGroupDataNode(n) && node.__parentNode?.id === n.id);\n}\n\n\nexport function getBoundingBoxOfGroup(node: IGroupElementDataNode): IBoundingBox {\n    let x1, y1, x2, y2;\n    node.elements.forEach(element => {\n        if (x1 === undefined || element.x < x1) {\n            x1 = element.x;\n        }\n        if (y1 === undefined || element.y < y1) {\n            y1 = element.y;\n        }\n        if (x2 === undefined || element.x + element.width > x2) {\n            x2 = element.x + element.width;\n        }\n        if (y2 === undefined || element.y + element.height > y2) {\n            y2 = element.y + element.height;\n        }\n    });\n\n    return {\n        x: x1,\n        y: y1,\n        width: x2 - x1,\n        height: y2 - y1\n    };\n}\n\nexport function getSizeAndPositionOfNode(node: OneOfDataNodes): ISize & IPosition {\n    if (isGroupDataNode(node)) {\n        const box = getBoundingBoxOfGroup(node);\n        const { x, y, width, height } = box;\n        return { x, y, width, height };\n    } else {\n        const { x, y, width, height } = node;\n        return { x, y, width, height };\n    }\n}\n\nexport function hasMaximumGroupNesting(currentParent: OneOfGroupDataNodes): boolean {\n    const MAX_NESTED_GROUPS = 7;\n    let parent: OneOfGroupDataNodes | undefined = currentParent;\n    let parentAmount = 0;\n\n    while (parent && isGroupDataNode(parent) && parent !== parent.__parentNode) {\n        parent = parent.__parentNode;\n        parentAmount++;\n    }\n\n    return parentAmount >= MAX_NESTED_GROUPS;\n}\n","import { ISize, IPosition, IAnimationSettings, AnimatableProperty, OneOfElementDataNodes, Formula } from '../../domain';\nimport { getBoundingRectangleOfRotatedBox } from '../../utils/geom';\nimport { deepEqual, roundToNearestMultiple } from '../../utils/utils';\nimport { SafeEval } from '../../utils/safe-eval';\n\n/**\n * Detect if string is a formula.\n * Currently the rule is that it should contain an '@'\n */\nexport function isFormulaValue(value?: number | string): value is Formula {\n    if (typeof value === 'string' && value.indexOf('@') >= 0) {\n        return true;\n    }\n    return false;\n}\n\nexport function formulaToValue(formula: Formula, dependencies: IFormulaDependecies): undefined | number | string {\n    // Formula is just @value (default value). TODO: SHOULDN't be the case anymore\n    if (formula === '@value') {\n        return undefined;\n    }\n    // Value is a formula\n    else if (isFormulaValue(formula)) {\n\n        // Reuse already resolved formulas if nothing have changed\n        const cache = getCachedEval(formula, dependencies);\n        if (typeof cache === 'number') {\n            return cache;\n        }\n\n        const { settings, canvasSize, element } = dependencies;\n        const mainValue = dependencies.propertyName && element[dependencies.propertyName];\n\n        const {\n            x,\n            y,\n            width,\n            height,\n            rotationX,\n            rotationY,\n            rotationZ\n        } = element;\n\n        const boundingBox = getBoundingRectangleOfRotatedBox({\n            x: 0,\n            y: 0,\n            width,\n            height,\n            rotationZ\n        });\n\n        // Exposed properties and method\n        const props: any = {\n            x,\n            y,\n            rotationX,\n            rotationY,\n            rotationZ,\n            width: boundingBox.width,\n            height: boundingBox.height,\n            creativeWidth: canvasSize.width,\n            creativeHeight: canvasSize.height,\n            edgePoint: (angle: number) => {\n                const edge = getEdgePointBasedOnAngle(\n                    { x, y },\n                    boundingBox,\n                    angle,\n                    canvasSize\n                );\n                edge.x -= x;\n                edge.y -= y;\n                return edge;\n            },\n            transition: {},\n            settings: {}\n        };\n\n        // Let us use \"@value\" inside the transition formula\n        props.value = mainValue;\n\n        if (settings) {\n            for (const key in settings) {\n                props.settings[key] = settings[key].value;\n                props.transition[key] = settings[key].value; // Deprecated\n            }\n        }\n\n        const expression = formulaToEvalExpression(formula);\n        const parsedValue = SafeEval.eval(expression, props);\n\n        // Detect any errors early in the chain to not pass around NaN values\n        if (isNaN(parsedValue)) {\n            throw new Error(`Could not resolve formula: ${formula}`);\n        }\n\n        // Store value in chache\n        evalCacheValueMap.set(getCacheValidationKey(element, formula), parsedValue);\n\n        return parsedValue;\n    }\n    // Not a formula but can be converted to a number. TODO: TOO NICE?\n    else if (typeof formula === 'string' && !isNaN(+formula)) {\n        return +formula;\n    }\n    // TODO: SHOULD WE EVEN COME HERE?\n    else {\n        return formula;\n    }\n}\n\nconst evalCacheValidationMap = new Map<string, any>();\nconst evalCacheValueMap = new Map<string, any>();\n\nfunction getCachedEval(formula: Formula, dependencies: IFormulaDependecies): number | undefined {\n\n    const validation = getCacheValidationObject(dependencies);\n    const key = getCacheValidationKey(dependencies.element, formula);\n    const cache = evalCacheValidationMap.get(key);\n\n    if (cache && deepEqual(cache, validation)) {\n        return evalCacheValueMap.get(key);\n    }\n    else {\n        evalCacheValidationMap.set(key, validation);\n        evalCacheValueMap.delete(key);\n    }\n}\n\nfunction getCacheValidationKey(element: OneOfElementDataNodes, formula: string): string {\n    return `${element.id}:${formula}`;\n}\n\nfunction getCacheValidationObject(dependencies: IFormulaDependecies): any {\n    const { settings, canvasSize, element } = dependencies;\n    const value = dependencies.propertyName && element[dependencies.propertyName];\n\n    const {\n        x,\n        y,\n        width,\n        height,\n        rotationX,\n        rotationY,\n        rotationZ\n    } = element;\n    return {\n        x,\n        y,\n        width,\n        height,\n        rotationX,\n        rotationY,\n        rotationZ,\n        value,\n        settings,\n        creativeWidth: canvasSize.width,\n        creativeHeight: canvasSize.height\n    };\n}\n\nfunction formulaToEvalExpression(formula: Formula): string {\n    return formula.replace(/\\@/g, '');\n}\n\n\nfunction getEdgePointBasedOnAngle(position: IPosition, elementSize: ISize, angle: number, canvasSize: ISize): IPosition {\n    angle = (angle - 90) * (Math.PI / 180);\n    const roundTo = 0.00001;\n    const dx = roundToNearestMultiple(Math.cos(angle), roundTo);\n    const dy = roundToNearestMultiple(Math.sin(angle), roundTo);\n    const d = dy / dx;\n    const vertical = dx === 0;\n    const horizontal = dy === 0;\n\n    // Left border\n    if (dx < 1.0e-16 && !vertical) {\n        const y = (position.x) * d + (canvasSize.height - position.y);\n        if (y >= -elementSize.height && y <= canvasSize.height + elementSize.height) {\n            return {\n                x: -elementSize.width,\n                y: canvasSize.height - y - elementSize.height * -(dy * 0.5)\n            };\n        }\n    }\n\n    // Right border\n    if (dx > 1.0e-16 && !vertical) {\n        const y = (canvasSize.width - position.x) * d + position.y;\n        if (y >= -elementSize.height && y <= canvasSize.height + elementSize.height) {\n            return {\n                x: canvasSize.width,\n                y: y + elementSize.height * (dy * 0.5)\n            };\n        }\n    }\n\n    // Top border\n    if (dy < 1.0e-16 && !horizontal) {\n        const x = (position.y) * dx / dy + (canvasSize.width - position.x);\n\n        if (x >= -elementSize.width && x <= canvasSize.width + elementSize.width) {\n            return {\n                x: canvasSize.width - x - elementSize.width * -(dx * 0.5),\n                y: -elementSize.height\n            };\n        }\n    }\n\n    // Bottom border\n    if (dy > 1.0e-16 && !horizontal) {\n        const x = (canvasSize.height - position.y) * dx / dy + position.x;\n        if (x >= -elementSize.width && x <= canvasSize.width + elementSize.width) {\n            return {\n                x: x + elementSize.width * (dx * 0.5),\n                y: canvasSize.height\n            };\n        }\n    }\n\n    return position;\n}\n\nexport interface IFormulaDependecies {\n    element: OneOfElementDataNodes;\n    canvasSize: ISize;\n    settings?: IAnimationSettings;\n    propertyName: AnimatableProperty | string;\n}\n","import { IState, OneOfStatePropertyKeys, StateProperties, propertyToUnitMap, OneOfElementPropertyKeys, textPropertyToUnitMap, ScalableProperties, IAnimation, IAnimationKeyframe, ITime, IRadius } from '@studio/domain';\nimport { IElementDataNode, FILTER_MAP, animatableProperties, AnimatableProperty, ISize, IBorder, OneOfElementDataNodes, ITextElementDataNode, IShadow, ITextShadow, IColor, IBoundingBox, AnimatablePropertyValue, statePropertyToUnitMap, propertyMinValues, propertyMaxValues, IActionOperation, IAction, IFilterMap, IPadding } from '../../domain';\nimport { getBoundsOfScaledRectangle } from '../../utils/geom';\nimport { deepEqual, isUUID, lerp, omit, uuidv4 } from '../../utils/utils';\nimport { isReservedAction } from '../actions/actions.utils';\nimport { getAllKeyframes, getNextTime, getPreviousTime, isTimeAt, toRelativeTime } from '../animation.utils';\nimport { Color } from '../color';\nimport { parseColor, mixColor } from '../color.utils';\nimport { getTimingFunctionFromKeyframe, getTimingFunctionValueBetween } from '../timing-functions';\nimport { isFormulaValue, formulaToValue } from './formula.utils';\n\nconst AdditiveProperties = [ 'x', 'y', 'rotationX', 'rotationY', 'rotationZ' ];\n\nexport const DEFAULT_EMPTY_STATE: Readonly<IState> = Object.freeze({\n    ratio: 1,\n});\n\nexport function createEmptyState(name?: string): IState {\n    const state: IState = {\n        ...DEFAULT_EMPTY_STATE,\n        id: uuidv4()\n    };\n\n    if (name !== undefined) {\n        state.name = name;\n    }\n\n    return state;\n}\n\nexport function isEmptyState(state: IState): boolean {\n    return getPropertyKeysInStates(state).length === 0;\n}\n\n/**\n * Merges all states with current element values\n * @param timeStates\n * @param element\n */\nexport function mergeStates(timeStates: ITimeState[], element: IElementDataNode, lerpAdditive?: boolean): IState {\n    const merged: IState = {};\n\n    // Last states will overwrite previous states so reverse the array to prio actions and animation order...\n    timeStates.forEach(timeState => {\n        const state = timeState.state;\n        const ratio = timeState.rate !== undefined ? timeState.rate : 1;\n\n        if (ratio === 0) {\n            return;\n        }\n\n        for (const property in state) {\n            if (animatableProperties.some(p => p === property)) {\n\n                let currentValue = merged[property];\n                const unit = propertyToUnitMap[property];\n                const value = state[property];\n                const currentOrElementValue = currentValue !== undefined ? currentValue : element[property];\n\n                if (value !== undefined) {\n\n                    if (unit === 'number') {\n                        // Different default values depending on if it's an additive property or a state property\n                        if (currentValue === undefined) {\n                            currentValue = isAdditiveProperty(property) ? 0 : element[property];\n                        }\n                        merged[property] = mergeNumbers(property as AnimatableProperty, currentValue, value, ratio, lerpAdditive);\n                    }\n                    else {\n                        merged[property] = mergeProperty(property as AnimatableProperty, currentOrElementValue, value, ratio);\n                    }\n                }\n            }\n            else {\n                merged[property] = state[property];\n            }\n        }\n    });\n    return merged;\n}\n\nexport function mergeProperty<T extends AnimatablePropertyValue>(property: AnimatableProperty, from: T | undefined, to: T | undefined, ratio: number): AnimatablePropertyValue | undefined {\n    const unit = propertyToUnitMap[property];\n\n    switch (unit) {\n        case 'number':\n            // Different default values depending on if it's an additive property or a state property\n            // if (currentValue === undefined) {\n            //     // currentValue = isAdditiveProperty(property) ? 0 : element[property];\n            // }\n            return mergeNumbers(property, from as number, to as number, ratio);\n        case 'Radius':\n            return mergeRadius(from as IRadius, to as IRadius, ratio);\n        case 'Color':\n            return mergeColors(from as IColor, to as IColor, ratio);\n        case 'Shadow[]':\n        case 'TextShadow[]':\n            return mergeShadows(from as IShadow[], to as IShadow[], ratio);\n        case 'FilterMap':\n            return mergeFilters(ratio, from as IFilterMap, to as IFilterMap);\n        case 'Border':\n            return mergeBorders(from as IBorder, to as IBorder, ratio);\n        default:\n            // For non numerical values, only set value when rate is 1\n            if (ratio === 1) {\n                return to;\n            }\n            break;\n    }\n}\n\n/**\n * Merge two shadows with eachother. Amount control where they should meet.\n * @param fromShadows\n * @param toShadows\n * @param amount\n */\nfunction mergeShadows(fromShadows: IShadow[], toShadows: IShadow[], amount: number): ITextShadow[] | IShadow[] {\n\n    const shadows: IShadow[] | ITextShadow[] = [];\n\n    // Total amount of shadows\n    const length = Math.max(fromShadows?.length || 0, toShadows?.length || 0);\n\n    for (let i = 0; i < length; i++) {\n        let from = fromShadows && fromShadows[i] as IShadow | undefined;\n        let to = toShadows && toShadows[i] as IShadow | undefined;\n\n        const fromColor = from?.color;\n        const toColor = to?.color;\n\n        if (!from) {\n            from = { ...to! };\n        }\n        if (!to) {\n            to = { ...from! };\n        }\n\n        shadows[i] = {\n            blur: Math.max(0, lerp(from.blur, to.blur, amount)),\n            offsetX: lerp(from.offsetX, to.offsetX, amount),\n            offsetY: lerp(from.offsetY, to.offsetY, amount),\n            color: mergeColors(fromColor, toColor, amount)\n        };\n\n        if (from.spread !== undefined) {\n            (shadows[i] as IShadow).spread = Math.max(0, lerp((from as IShadow).spread, (to as IShadow).spread, amount));\n        }\n    }\n\n    return shadows;\n}\n\nfunction mergeFilters(amount: number, from: IFilterMap = {}, to: IFilterMap = {}): IFilterMap {\n    const filterKeySet = new Set([...Object.keys(from), ...Object.keys(to)]) as Set<keyof IFilterMap>;\n\n    return [...filterKeySet]\n        .filter(key => from[key] !== undefined || to[key] !== undefined)\n        .reduce((memo, key) => {\n            const filter = FILTER_MAP[key];\n            return {\n                ...memo,\n                [key]: {\n                    value: lerp(\n                        from[key]?.value ?? (filter?.default || 0),\n                        to[key]?.value   ?? (filter?.default || 0),\n                        amount\n                    )\n                }\n            };\n        }, {});\n}\n\nfunction mergeBorders(from: IBorder | undefined, to: IBorder | undefined, amount: number): IBorder | undefined {\n\n    if (from || to) {\n\n        from = from || { ...to!, thickness: 0 };\n        to = to || { ...from!, thickness: 0 };\n\n        if (to && from) {\n            return {\n                thickness: Math.max(0, lerp(from.thickness, to.thickness, amount)),\n                style: amount === 1 ? to.style : from.style, // Swap style when 100% in\n                color: mixColor(from.color, { color: to.color, amount }),\n            };\n        }\n    }\n}\n\nfunction mergeColors(from: IColor | undefined, to: IColor | undefined, amount: number): IColor {\n\n    if (!to) {\n        to = parseColor(from!);\n        to.alpha = 0;\n    }\n    if (!from) {\n        from = parseColor(to);\n        from.alpha = 0;\n    }\n    const tint = { color: to, amount };\n    return mixColor(from, tint);\n}\n\nfunction mergeRadius(from: IRadius | undefined, to: IRadius | undefined, amount: number): IRadius | undefined {\n    if (to && from) {\n        return {\n            type: to.type,\n            topLeft: mergeNumbers('radius', from.topLeft, to.topLeft, amount),\n            topRight: mergeNumbers('radius', from.topRight, to.topRight, amount),\n            bottomLeft: mergeNumbers('radius', from.bottomLeft, to.bottomLeft, amount),\n            bottomRight: mergeNumbers('radius', from.bottomRight, to.bottomRight, amount),\n        };\n    }\n}\n\nfunction mergeNumbers(property: AnimatableProperty, from: number | undefined, to: number | undefined, ratio: number, lerpAdditive: boolean = false): number {\n    if (typeof to !== 'number') {\n        if (typeof from === 'number') {\n            return from;\n        }\n        throw new Error ('Can only merge numeric values');\n    }\n    // Additive properties like x, y, rotations\n    if (isAdditiveProperty(property) && !lerpAdditive) {\n        if (typeof from !== 'number') {\n            from = 0;\n        }\n        return limitNumberProperty(property, from + to * ratio);\n    }\n    // Average properties like scale etc\n    else {\n        if (typeof from !== 'number') {\n            from = 1;\n        }\n        return limitNumberProperty(property, lerp(from, to, ratio));\n    }\n}\n\nfunction limitNumberProperty(property: AnimatableProperty, value: number): number {\n    const min = propertyMinValues[property];\n    const max = propertyMaxValues[property];\n    if (typeof min === 'number') {\n        value = Math.max(min, value);\n    }\n    if (typeof max === 'number') {\n        value = Math.min(max, value);\n    }\n    return value;\n}\n\n/**\n * Resolve values so they can be rendered.\n * Typically turn any formulas into numbers\n * @param element\n * @param animation\n * @param canvasSize\n * @param property\n * @param value\n */\nexport function resolveStateFormulaValue(element: OneOfElementDataNodes, animation: IAnimation, canvasSize: ISize, property: AnimatableProperty | string, value: any, ): StateProperties {\n\n    const unit = propertyToUnitMap[property];\n\n    switch (unit) {\n        case 'number':\n            if ((typeof value === 'number' && !isNaN(value)) || value === undefined) {\n                return value;\n            }\n            else if (typeof value === 'object' && value.type === 'number') {\n                return value.value;\n            }\n            else if (isFormulaValue(value)) {\n                return formulaToValue(value, {\n                    element,\n                    propertyName: property,\n                    settings: animation.settings,\n                    canvasSize\n                });\n            }\n            else if (typeof value === 'string' && !isNaN(+value)) {\n                return +value;\n            }\n            throw new Error('Unexpected number value.');\n    }\n    return value;\n}\n\nexport function getValueFromKeyframe(property: AnimatableProperty | string, keyframe: IAnimationKeyframe, animation: IAnimation, element: OneOfElementDataNodes, canvasSize: ISize): StateProperties {\n    const state = getStateById(element, keyframe.stateId);\n    const value = state && state[property];\n    return resolveStateFormulaValue(element, animation, canvasSize, property, value);\n}\n\nexport function getViewElementProperty(property: OneOfElementPropertyKeys, element: IElementDataNode, mergedState: IState = {}, scale: number = 1): any {\n    const unit = propertyToUnitMap[property];\n    const value = element[property];\n    const stateValue = mergedState[property];\n    const stateValueOrValue = stateValue !== undefined ? stateValue : value;\n\n    if (stateValueOrValue !== undefined) {\n        if (unit === 'number') {\n            const numericValue = getNumericPropertyValue(property, value, stateValue, stateValueOrValue);\n\n            if (isScalableProperty(property)) {\n                return scaleNumericValue(numericValue, scale);\n            }\n            return numericValue;\n        }\n        else if (unit === 'Color') {\n            return new Color(stateValueOrValue);\n        }\n        else if (unit === 'Border') {\n            return getViewElementBorder(stateValueOrValue, scale);\n        }\n        else if (unit === 'Shadow[]' || unit === 'TextShadow[]') {\n            return stateValueOrValue.map(shadow => getShadowPropertyValue(unit, shadow, scale));\n        }\n        else if (unit === 'ImageAsset') {\n            return { ...stateValueOrValue };\n        }\n        else if (unit === 'ImageSettings') {\n            return { ...stateValueOrValue };\n        }\n        else if (unit === 'Padding') {\n            return getViewElementPadding(stateValueOrValue, scale);\n        }\n        else if (unit === 'Radius') {\n            return {\n                ...stateValueOrValue,\n                topLeft: stateValueOrValue.topLeft * scale,\n                topRight: stateValueOrValue.topRight * scale,\n                bottomLeft: stateValueOrValue.bottomLeft * scale,\n                bottomRight: stateValueOrValue.bottomRight * scale,\n            };\n        }\n    }\n    return stateValueOrValue;\n}\n\nfunction isScalableProperty(property: OneOfElementPropertyKeys): boolean {\n    return ScalableProperties.includes(property);\n}\n\nfunction getNumericPropertyValue(property: OneOfElementPropertyKeys, value: any, stateValue: any, stateValueOrValue: any): number {\n    if (typeof stateValue !== 'number') {\n        return value;\n    } else if (isAdditiveProperty(property)) {\n        return value + (stateValue || 0);\n    } else {\n        return stateValueOrValue;\n    }\n}\n\nfunction scaleNumericValue(value: number, scale: number): number {\n    return value * scale;\n}\n\nexport function getShadowPropertyValue(unit, shadow: IShadow | ITextShadow, scale: number): IShadow | ITextShadow {\n    const newShadow = { ...shadow };\n    if (unit === 'Shadow[]') {\n        newShadow.offsetX! *= scale;\n        newShadow.offsetY! *= scale;\n        (newShadow as IShadow).spread *= scale;\n        newShadow.blur! *= scale;\n    } else if (unit === 'TextShadow[]') {\n        newShadow.offsetX! *= scale;\n        newShadow.offsetY! *= scale;\n        newShadow.blur! *= scale;\n    }\n    return newShadow;\n}\n\n\nfunction getViewElementBorder(stateValueOrValue: any, scale: number): IBorder  {\n    return {\n        thickness: stateValueOrValue.thickness * scale,\n        color: stateValueOrValue.color,\n        style: stateValueOrValue.style,\n    };\n}\n\nfunction getViewElementPadding(stateValueOrValue: any, scale: number): IPadding {\n    return {\n        bottom: stateValueOrValue.bottom * scale,\n        top: stateValueOrValue.top * scale,\n        right: stateValueOrValue.right * scale,\n        left: stateValueOrValue.left * scale,\n    };\n}\n/**\n * Merge an animation to a \"relative\" state. Pass extra states to show states not added by timeline\n */\nexport function animationsToState(element: OneOfElementDataNodes, canvasSize: ISize, time: number = 0, states: ITimeState[] = []): IState {\n\n    // Merge states from actions\n    states = mergeActionStates(element, states);\n\n    if (element.animations) {\n        element.animations\n            .filter(animation => !animation.hidden)\n            .forEach((animation) => {\n                const animationStates = animationToStates(element, animation, canvasSize, time)\n                    .filter(state => !states.some(s => state.state === s.state)); // Make sure we don't render states twice\n\n                states.unshift(...animationStates);\n            });\n    }\n\n    const merged = mergeStates(states, element);\n\n    return merged;\n}\n\nexport function mergeActionStates(element: OneOfElementDataNodes, states: ITimeState[]): ITimeState[] {\n    if (states.length > 1) {\n        const maxRate = Math.max(...states.map(s => s.rate), 0);\n\n        // No need to spend cpu on when completely \"faded\" out\n        if (maxRate === 0) {\n            return [];\n        }\n\n        // States scaled so highest rate is 1\n        const normalizedStates = states.map(s => {\n            // Later all values will be scaled by maxRate so compensate for that\n            const rate = s.rate / maxRate;\n            return {\n                rate,\n                state: s.state\n            };\n        });\n        const state = mergeStates(normalizedStates, element, true);\n        return [{rate: maxRate, state}];\n    }\n\n    // Return shallow clone to not overwrite original\n    return states.slice(0);\n}\n\nexport function getStateById(element: OneOfElementDataNodes, id?: string): IState | undefined {\n    if (element.states?.length && id) {\n        return element.states.find(state => state.id === id);\n    }\n}\n\nexport function resolveFormulasOnKeyframe(keyframe: IAnimationKeyframe, animation: IAnimation, element: OneOfElementDataNodes, canvasSize: ISize): IState {\n\n    const state = getStateById(element, keyframe.stateId);\n\n    if (state) {\n        const resolvedState: IState = {\n            id: state.id,\n        };\n        for (const property in state) {\n            // Ignore properties like id, absolute etc.\n            if (animatableProperties.some(p => p === property)) {\n                resolvedState[property] = getValueFromKeyframe(property, keyframe, animation, element, canvasSize);\n            }\n            else {\n                resolvedState[property] = state[property];\n            }\n        }\n        return resolvedState;\n    }\n    throw new Error('No state to resolve');\n}\n\nexport function cloneState(state: IState): IState {\n    const clone = {};\n    for (const property in state) {\n        const value = state[property];\n        const type = typeof value;\n\n        if (type === 'string' || type === 'number' || type === 'object') {\n            clone[property] = value;\n        }\n    }\n    return clone;\n}\n\n/**\n * Calulate a state of an animation at a certain point in time.\n * Note: Don't use this to render element\n */\nexport function calculateStateFromAnimationAtTime(element: OneOfElementDataNodes, animation: IAnimation, canvasSize: ISize, time: number = 0): IState {\n    const states = animationToStates(element, animation, canvasSize, time);\n    return omit(mergeStates(states, element), 'id');\n}\n\n/**\n * Get a combination of all states until that point of time\n * @param element\n * @param animation\n * @param relativeTime\n */\nexport function getMergedStateAtTime(element: OneOfElementDataNodes, animation: IAnimation, relativeTime: number, canvasSize: ISize): IState | undefined {\n    const mergedState: IState = {};\n\n    const keyframes = animation.keyframes\n        .filter(k => k.time <= relativeTime);\n\n    // Find index of last default state visible (from end)\n    const index = keyframes\n        .slice()\n        .reverse()\n        .findIndex(k => !k.stateId);\n\n    // Remove all states before last default state since they are irrelevant\n    if (index > -1) {\n        keyframes.splice(0, keyframes.length - index);\n    }\n\n    const states = keyframes.filter(k => k.stateId).map(k => getStateById(element, k.stateId!));\n\n    if (!states.length) {\n        return;\n    }\n\n    // Last property will prevail\n    states.forEach((state) => {\n        for (const key in state) {\n            if (state[key] !== undefined && animatableProperties.indexOf(key as AnimatableProperty) > -1) {\n                mergedState[key] = state[key];\n            }\n        }\n    });\n\n    // Resolve any formulas\n    return resolveStateFormulas(element, animation, canvasSize, mergedState);\n}\n\n/**\n * Go through all properties in a state and resolve any formulas found\n * @param element\n * @param animation\n * @param canvasSize\n * @param state\n * @returns\n */\nfunction resolveStateFormulas(element: OneOfElementDataNodes, animation: IAnimation, canvasSize: ISize, state: IState): IState<number> {\n    const resolvedState: IState<number> = {};\n    // Resolve any formulas\n    for (const key in state) {\n        resolvedState[key] = resolveStateFormulaValue(element, animation, canvasSize, key, state[key]);\n    }\n    return resolvedState;\n}\n\n/**\n * Get all states from an animation with a \"rate\"\n * which is how much from 0 to 1 that this state should be \"visible\"\n */\nexport function animationToStates(element: OneOfElementDataNodes, animation: IAnimation, canvasSize: ISize, absoluteTime: number = 0): ITimeState[] {\n    const states: ITimeState[] = [];\n    const { keyframes } = animation;\n    if (!keyframes || !keyframes.length || !isTimeAt(absoluteTime, element)) {\n        return states;\n    }\n\n    const time = toRelativeTime(element, absoluteTime);\n    const tolerance = 0.000001;\n\n    const prev      = getPreviousTime(keyframes, time, tolerance);\n    const next      =     getNextTime(keyframes, time, tolerance);\n    const prevState = prev?.stateId && { ...resolveStateFormulas(element, animation, canvasSize, getStateById(element, prev.stateId)!) };\n    const nextState = next?.stateId && { ...resolveStateFormulas(element, animation, canvasSize, getStateById(element, next.stateId)!) };\n\n    // Should only happen if no keyframes is defined\n    if (!prev && !next) {\n        throw new Error('Animation has no keyframes');\n    }\n    // When within the duration of a keyframe,\n    else if (prev === next || !next || (prev && isTimeAt(time, prev))) {\n\n        // Ignore double default state case\n        if (prevState) {\n            states.push({state: prevState, rate: 1 });\n        }\n    }\n    // In between two states => apply easing\n    else if (prev && next) {\n        const timingFunction = getTimingFunctionFromKeyframe(animation, next);\n        const rate = getTimingFunctionValueBetween(time, prev, next, timingFunction);\n\n        // Inverted rate when animating to the default state.\n        // Between states the previous value should always be at 100%\n        if (prevState) {\n\n            // Both states defined\n            if (nextState) {\n                const props = getPropertyKeysInStates(prevState, nextState);\n\n                // Make sure both states have the same values\n                props.forEach(p => {\n\n                    const defaultValue = isAdditiveProperty(p) ? 0 : element[p];\n\n                    if (prevState[p] === undefined && defaultValue !== undefined) {\n                        prevState[p] = defaultValue as any;\n                    }\n                    if (nextState[p] === undefined) {\n                        nextState[p] = defaultValue !== undefined ? defaultValue : mergeProperty(p, prevState[p], defaultValue, 1) as any;\n                    }\n                });\n\n                const additive = getAdditiveStateProperties(prevState);\n                const nonAdditive = getNonAdditiveStateProperties(prevState);\n                if (nonAdditive) {\n                    states.push( {state: nonAdditive, rate: 1 } );\n                }\n                if (additive) {\n                    states.push( {state: additive, rate: 1 - rate } );\n                }\n            }\n            else {\n                states.push( {state: prevState, rate: 1 - rate } );\n            }\n        }\n        if (nextState) {\n            states.push({state: nextState, rate });\n        }\n    }\n    return states;\n}\n\n\nexport function getStateAtTime(element: OneOfElementDataNodes, relativeTime: number | ITime, tolerance: number = 0): IState | undefined {\n    for (const animation of element.animations) {\n        const keyframe = animation.keyframes.find(kf =>\n            isTimeAt(kf, relativeTime, tolerance)\n        );\n\n        if (keyframe?.stateId) {\n            return getStateById(element, keyframe.stateId!)!;\n        }\n    }\n}\n\nexport function setNewPropertyIds(originalElement: OneOfElementDataNodes, newElement: OneOfElementDataNodes): Map<string, string> {\n\n    const idChangeMap = new Map<string, string>();\n    function isActionOperation(value: any): value is IActionOperation {\n        return typeof value === 'object'\n            && 'target' in value\n            && 'method' in value;\n    }\n\n    function setNewIdOnItem(item: IAction | IActionOperation | IState | IAnimation | IAnimationKeyframe): void {\n        const newId = uuidv4();\n        let oldId: string | undefined;\n\n        if (isActionOperation(item)) {\n            oldId = item.value;\n            item.value = newId;\n        }\n        else {\n            oldId = item.id;\n            item.id = newId;\n        }\n\n        idChangeMap.set(oldId!, newId);\n    }\n    const stateIdsMap = {};\n    for (const state of newElement.states) {\n        const oldId = state?.id;\n        if (oldId) {\n            setNewIdOnItem(state);\n            stateIdsMap[oldId] = state.id;\n        }\n    }\n    for (const animation of newElement.animations) {\n        setNewIdOnItem(animation);\n        for (const keyframe of animation.keyframes) {\n            setNewIdOnItem(keyframe);\n            /**\n             * Migrated IDs (e.g keyframe-0) may be the same\n             * on mulitple elements hence we need to set the stateId\n             * reference here right away. The ID patching is otherwise\n             * done in designView.patchPropertyIds.\n             * This can probably be removed once all design elements\n             * has been migrated.\n             */\n            const keyframeStateId = keyframe?.stateId;\n            if (keyframeStateId && stateIdsMap[keyframeStateId] && !isUUID(keyframeStateId)) {\n                keyframe.stateId = stateIdsMap[keyframeStateId];\n            }\n        }\n    }\n\n    for (const action of newElement.actions) {\n        setNewIdOnItem(action);\n    }\n\n    /**\n     * Validate that all ids are unique\n    */\n\n    const idSet = new Set<string>();\n\n    const properties: OneOfElementPropertyKeys[] = ['animations', 'actions', 'states'];\n\n    const recursiveFindIds = (object: any): void => {\n        if (typeof object !== 'object') {\n            return;\n        }\n\n        if (idSet.has(object.id)) {\n            throw new Error('Duplicate IDs found.');\n        }\n\n        if (object.id) {\n            idSet.add(object.id);\n        }\n\n        if (Array.isArray(object)) {\n            for (const prop of object) {\n                recursiveFindIds(prop);\n            }\n        }\n        else {\n            for (const prop in object) {\n                recursiveFindIds(object[prop]);\n            }\n        }\n    };\n\n    for (const key of Object.keys(originalElement) as OneOfElementPropertyKeys[]) {\n        if (!properties.includes(key)) {\n            continue;\n        }\n        recursiveFindIds(originalElement[key]);\n        recursiveFindIds(newElement[key]);\n    }\n\n    return idChangeMap;\n}\n\nexport function isStateProperty(property: string): property is OneOfStatePropertyKeys {\n    return !!property && Object.keys(statePropertyToUnitMap).indexOf(property) > -1;\n}\n\nexport function isTextState(state: IState | OneOfElementDataNodes, property: OneOfElementPropertyKeys): state is IState & ITextElementDataNode {\n    return property in textPropertyToUnitMap;\n}\n\nexport function isActionState(element: OneOfElementDataNodes, state: IState): boolean {\n    return element.actions.some(action =>\n        !isReservedAction(action) && action.operations.some(op => op.value === state.id)\n    );\n}\n\nexport function isReservedActionState(element: OneOfElementDataNodes, state: IState): boolean {\n    return element.actions.some(action =>\n        isReservedAction(action) && action.operations.some(op => op.value === state.id)\n    );\n}\n\nexport function isAnimationState(element: OneOfElementDataNodes, state: IState): boolean {\n    if (!state.id) {\n        return false;\n    }\n    return getAllKeyframes(element).some(keyframe =>\n        keyframe.stateId === state.id\n    );\n}\n\n/**\n * Check if all bounds provided have the same size & position\n * @param bounds\n */\nexport function isEqualStates(...states: (IState | undefined)[]): boolean {\n\n    if (!states || states.length < 2) {\n        throw new Error('2 or more states must be passed to compare them');\n    }\n\n    // Id is irrelevant\n    states = states.map(s => s && omit(s, 'id'));\n\n    const first = states[0];\n    const toCompare = states.slice(1);\n\n    if (toCompare.some(s => !deepEqual(first, s))) {\n        return false;\n    }\n    return true;\n}\n\nexport function getReservedStates(element: OneOfElementDataNodes): IState[] {\n    return element.states\n        .filter(state =>\n            isReservedActionState(element, state)\n        );\n}\n\n/**\n * Custom states that are states that are not related to\n * reserved States (actions) and not related to any keyframe animation\n */\nexport function getCustomStates(element: OneOfElementDataNodes): IState[] {\n    return element.states\n        .filter(state =>\n            !isAnimationState(element, state) && !isReservedActionState(element, state)\n        );\n}\n\nexport function getBoundingBoxOfElementWithState(element: IBoundingBox | OneOfElementDataNodes, state: IState = {}, includeScale?: boolean): IBoundingBox {\n\n    const scaleX = 'scaleX' in element && typeof element.scaleX === 'number' ? element.scaleX : 1;\n    const scaleY = 'scaleY' in element && typeof element.scaleY === 'number' ? element.scaleY : 1;\n    const originX = 'originX' in element && typeof element.originX === 'number' ? element.originX : 0.5;\n    const originY = 'originY' in element && typeof element.originY === 'number' ? element.originY : 0.5;\n\n    const box = {\n        x: element.x + (typeof state.x === 'number' ? state.x : 0),\n        y: element.y + (typeof state.y === 'number' ? state.y : 0),\n        scaleX: scaleX * (typeof state.scaleX === 'number' ? state.scaleX : 1),\n        scaleY: scaleY * (typeof state.scaleY === 'number' ? state.scaleY : 1),\n        originX: typeof state.originX === 'number' ? state.originX : originX,\n        originY: typeof state.originY === 'number' ? state.originY : originY,\n        // Note state shouldn't have width and height ATM\n        width: element.width,\n        height: element.height,\n        rotationZ: (element.rotationZ || 0) + (typeof state.rotationZ === 'number' ? state.rotationZ : 0)\n    };\n\n    if (includeScale) {\n        return getBoundsOfScaledRectangle(box);\n    }\n\n    return box;\n}\n\nexport function getPropertyKeysInStates(...states: (IState | undefined)[]): AnimatableProperty[] {\n    const keys: AnimatableProperty[] = [];\n    states.forEach(state => {\n        for (const k in state) {\n            const key = k as AnimatableProperty;\n            if (state[key] !== undefined && keys.indexOf(key) === -1 && animatableProperties.indexOf(key) > -1) {\n                keys.push(key);\n            }\n        }\n    });\n    return keys;\n}\n\nexport function statePropertyFormulaToValue(value: number | string | undefined): number {\n    if (typeof value === 'string') {\n        return 0;\n    }\n    else {\n        return value || 0;\n    }\n}\n\nexport function isAdditiveProperty(property: string): boolean {\n    return AdditiveProperties.indexOf(property) > -1;\n}\n\nexport function getAdditiveStateProperties(state: IState): IState | undefined {\n    const additive: IState = {};\n\n    for (const key in state) {\n        if (isAdditiveProperty(key)) {\n            additive[key] = state[key];\n        }\n    }\n    return !isEmptyState(additive) ? additive : undefined;\n}\n\nexport function getNonAdditiveStateProperties(state: IState): IState | undefined {\n    const nonAdditive: IState = {};\n\n    for (const key in state) {\n        if (!isAdditiveProperty(key)) {\n            nonAdditive[key] = state[key];\n        }\n    }\n    return Object.keys(nonAdditive).length ? nonAdditive : undefined;\n}\n\nexport interface ITimeState {\n    /**\n     * How much from 0-1 this states is active.\n     * Note that when elastic easings are in use this number may be a bit over 1.\n     */\n    rate: number;\n\n    /**\n     *\n     */\n    state: IState;\n}\n","import { isUrl } from '@ad/utils/url';\nimport { IVersionProperty, IFontStyle, IPadding, IBorder, IShadow, ITextShadow, IFeed, IImageAsset, OneOfElementPropertyKeys, WidgetPropertyKeys, PropertyValue, propertyToUnitMap, widgetPropertyToUnitMap } from '@studio/domain';\nimport { Color } from '../color';\nimport { parseColor } from '../color.utils';\nimport { deserializeVersionedText, serializeInlineStyledText, serializeVersionedText } from './text-serializer';\n\n/**\n * Clone value by serializing and deserializing. Compared to a deep clone this will also work with color properties\n * @param propertyName\n * @param value\n */\nexport function clonePropertyValue(propertyName: string, value: any): PropertyValue | undefined {\n    return deserializePropertyValue(propertyName, serializePropertyValue(propertyName, value));\n}\n\nexport function deserializePropertyValue(propertyName: OneOfElementPropertyKeys | WidgetPropertyKeys | string, value: any, isKeyFrame: boolean = false): PropertyValue | undefined {\n\n    const unit = propertyToUnitMap[propertyName] || widgetPropertyToUnitMap[propertyName];\n\n    if (value === null) {\n        value = undefined;\n    }\n\n    // Should maybe not affect all types?\n    if (typeof value === 'string' && isKeyFrame) {\n        return value;\n    }\n    switch (unit) {\n        case 'angle':\n            return parseFloat(value!) * Math.PI / 180;\n        case 'integer':\n            return parseInt(value, 10);\n        case 'number':\n        case 'px':\n            return parseFloat(value!);\n        case 'boolean':\n            return typeof value === 'string'\n                ? value.toLowerCase() === 'true'\n                : value;\n        case 'FontStyle':\n            if (value === undefined) {\n                return undefined;\n            }\n            const fontStyle = value.split(' ') as IFontStyle;\n            let src = fontStyle[3];\n            try {\n\n                // Support old font url that where encoded with base64 without data prefix.\n                //\n                // Note: that exported HTML creatives can have base64 encoded fonts which begins with data prefix.\n                if (!src.startsWith('data') && !isUrl(src)) {\n                    if (typeof window !== 'undefined') {\n                        src = atob(src);\n                    }\n                    else {\n                        src = Buffer.from(src, 'base64').toString();\n                    }\n                }\n            }\n            // eslint-disable-next-line no-empty\n            catch { }\n\n            return {\n                id: fontStyle[0],\n                weight: parseInt(fontStyle[1], 10),\n                style: fontStyle[2],\n                src,\n                fontFamilyId: fontStyle[4],\n            };\n        case 'ImageAsset':\n            const imageAsset = value.split(' ');\n            return {\n                id: imageAsset[0],\n                url: imageAsset[1],\n                width: parseInt(imageAsset[2], 10),\n                height: parseInt(imageAsset[3], 10)\n            };\n        case 'Padding':\n            const padding = value!.split(' ') || [];\n            return {\n                top: padding[0] ? parseFloat(padding[0]) : 0,\n                right: padding[1] ? parseFloat(padding[1]) : 0,\n                bottom: padding[2] ? parseFloat(padding[2]) : 0,\n                left: padding[3] ? parseFloat(padding[3]) : 0,\n            } as IPadding;\n        case 'Border':\n            const border = value!.split(' ');\n            return border.length > 1 ? {\n                thickness: parseInt(border[0], 10),\n                style: border[1],\n                color: border[2]\n            } as IBorder : undefined;\n        case 'Radius':\n            return JSON.parse(value);\n        case 'Shadow[]':\n            const shadows = value ? value!.split(/,(?![^\\(]*\\))/) : undefined;\n            return shadows ? shadows.map(s => {\n                const shadow = s.split(' ');\n                return {\n                    offsetX: parseInt(shadow[0], 10),\n                    offsetY: parseInt(shadow[1], 10),\n                    blur: parseInt(shadow[2], 10),\n                    spread: parseInt(shadow[3], 10),\n                    color: parseColor(shadow[4])\n                } as IShadow;\n            }) : undefined;\n        case 'TextShadow[]':\n            if (Array.isArray(value)) {\n                return value;\n            }\n            const textShadows = value ? value!.split(/,(?![^\\(]*\\))/) : undefined;\n            return textShadows ? textShadows.map(s => {\n                const shadow = s.split(' ');\n                return {\n                    offsetX: parseInt(shadow[0], 10),\n                    offsetY: parseInt(shadow[1], 10),\n                    blur: parseInt(shadow[2], 10),\n                    color: parseColor(shadow[3])\n                } as ITextShadow;\n            }) : undefined;\n        case 'Color':\n            return parseColor(value);\n        case 'Feed':\n        case 'variable':\n\n            try {\n                const feed = JSON.parse(value);\n                if (!('path' in feed)) {\n                    // Continue to old deserialization\n                    throw new Error();\n                }\n\n                return feed;\n            }\n            catch (_) {\n                const feed = value.split(' ');\n                return {\n                    id: feed[0],\n                    path: feed[1] ?? '',\n                    step: {\n                        start: parseInt(feed[2] ?? 1, 10),\n                        size: parseInt(feed[3] ?? 1, 10),\n                        occurrence: feed[4] ?? 'loop'\n                    },\n                    fallback: feed[5] ?? ''\n                } as IFeed;\n            }\n        case 'string[]':\n        case 'CustomProperty[]':\n            let decodedValue;\n            if (typeof window !== 'undefined') {\n                decodedValue = JSON.parse(atob(value));\n            }\n            else {\n                decodedValue = Buffer.from(value, 'base64').toString();\n            }\n            return decodedValue;\n        case 'FilterMap':\n        case 'ImageSettings':\n        case 'Transition':\n        case 'State[]':\n        case 'Animation[]':\n        case 'VideoAsset':\n        case 'VideoSettings':\n        case 'Action[]':\n            if (typeof Array.isArray(value)) {\n                return value.length\n                    ? JSON.parse(value)\n                    : value;\n            }\n            return JSON.parse(value);\n        case 'text': {\n\n            // Elements doesn't have \"content\" and value will instead be fetched from Version.properties\n            if (value === undefined) {\n                return undefined;\n            }\n            return deserializeVersionedText(value);\n        }\n        default:\n            return value;\n    }\n}\n\n/**\n * Serialize propertyValue to a string\n * @param propertyName\n * @param value\n */\nexport function serializePropertyValue(propertyName: string, value: any): string | undefined {\n    let unit = propertyToUnitMap[propertyName] || widgetPropertyToUnitMap[propertyName];\n\n    if (propertyName === 'id' ||\n        propertyName === 'kind' ||\n        propertyName === 'feededImageReference'\n    ) {\n        unit = 'string';\n    }\n\n    switch (unit) {\n        case 'angle':\n            return `${Math.round(value * 180 / Math.PI)}`;\n        case 'number':\n            return `${value}`;\n        case 'integer':\n            return value;\n        case 'string':\n        case 'enum':\n            return value;\n        case 'boolean':\n            return value.toString();\n        case 'FontStyle':\n            const fontStyle = value as IFontStyle;\n            const src = fontStyle.src;\n            return `${fontStyle.id} ${fontStyle.weight} ${fontStyle.style} ${src} ${fontStyle.fontFamilyId}`;\n        case 'ImageAsset':\n            const imageAsset = value as IImageAsset;\n            return `${imageAsset.id} ${imageAsset.url} ${imageAsset.width} ${imageAsset.height}`;\n        case 'Border':\n            const border = value as IBorder;\n            return border ? `${border.thickness} ${border.style} ${border.color}` : '';\n        case 'Padding':\n            const padding = value as IPadding;\n            return `${padding.top} ${padding.right || ''} ${padding.bottom || ''} ${padding.left || ''}`;\n        case 'Shadow[]':\n            const shadows = value as IShadow[];\n            return shadows ? shadows.map(s => `${s.offsetX} ${s.offsetY} ${s.blur} ${s.spread} ${s.color}`).join(',') : '';\n        case 'TextShadow[]':\n            return value ? value.map((s) => `${s.offsetX}px ${s.offsetY}px ${s.blur}px ${s.color}`).join(',') : '';\n        case 'Color':\n            const color = value as Color;\n            if (!color) {\n                return '';\n            } else {\n                return color.toString();\n            }\n        case 'inline-styled-text':\n            return serializeInlineStyledText(value);\n        case 'text':\n            return serializeVersionedText(value);\n        case 'variable':\n        case 'Feed':\n            if (typeof value === 'object') {\n                return JSON.stringify(value);\n            }\n            return value;\n        case 'string[]':\n        case 'CustomProperty[]':\n            let encodedValue;\n            if (typeof window !== 'undefined') {\n                encodedValue = btoa(JSON.stringify(value));\n            }\n            else {\n                encodedValue = Buffer.from(value).toString('base64');\n            }\n            return encodedValue;\n        case 'Transition':\n        case 'FilterMap':\n        case 'State[]':\n        case 'Animation[]':\n        case 'Action[]':\n        case 'ImageSettings':\n        case 'VideoSettings':\n        case 'VideoAsset':\n        case 'Radius':\n            return JSON.stringify(value);\n        default:\n            return value;\n    }\n}\n\nexport function deserializeVersionProperties(epv: IVersionProperty[] = []): IVersionProperty[] {\n    const properties = epv.map(p => {\n        const prop: any = {\n            id: p.id as string,\n            name: p.name as string,\n            value: deserializePropertyValue(p.name, p.value)\n        };\n        return prop;\n    });\n    return properties;\n}\n\nexport function serializeVersionProperties(vp: IVersionProperty[] = []): any[] {\n    const properties = vp.map(p => ({\n        id: p.id as string,\n        name: p.name as string,\n        value: serializePropertyValue(p.name, p.value)\n    }));\n    return properties;\n}\n","import { serializePropertyValue, deserializePropertyValue } from '@creative/serialization/property-value-serializer';\nimport { IVersionedText, IStyleIdMap, IInlineStyledText, SpanType, IVariable, ICharacterProperties, OneOfCharacterProperty, IFontStyle, IColor, ITextShadow } from '@studio/domain';\n\ninterface ISerializedStyleMap {\n    documentId: string;\n    styleId: string;\n}\n\ninterface ISerializedTextSpan {\n    type: SpanType;\n    position: number;\n    length: number;\n    styleIds: ISerializedStyleMap[];\n    variable?: IVariable;\n}\n\ninterface ISerializedInlineStyledTextSpan {\n    type: SpanType;\n    position: number;\n    length: number;\n    style: string;\n}\n\ninterface ISerializedInlineStyledText {\n    text: string;\n    styles: ISerializedInlineStyledTextSpan[];\n}\n\ninterface ISerializedVersionedText {\n    text: string;\n    styles: ISerializedTextSpan[];\n}\n\n\nexport function deserializeVersionedText(text: string): IVersionedText {\n    let versionedText: ISerializedVersionedText;\n\n    // Try to serialize\n    try {\n        versionedText = JSON.parse(text) as ISerializedVersionedText;\n    } catch (e) {\n        const msg = `Could not deserialize text: '${ text }'`;\n\n        // JSON is provided but could not parse anyway\n        if (text !== undefined && text.charAt(0) === '{' || text.charAt(0) === '<') {\n            throw new Error(msg);\n        } else if (process.env.STUDIO_JS) {\n            if (typeof (self as any).TrackerService !== 'undefined') {\n                (self as any).TrackerService.captureError(msg);\n            }\n        }\n        versionedText = { text: text, styles: [] };\n    }\n    const remappedSpans = versionedText.styles.map((span) => {\n        const styleIdMap: IStyleIdMap = new Map<string, string>();\n        for (const style of span.styleIds) {\n            styleIdMap.set(style.documentId, style.styleId);\n        }\n        return {\n            ...span,\n            styleIds: styleIdMap\n        };\n    });\n    return {\n        text: versionedText.text,\n        styles: remappedSpans\n    };\n}\n\nexport function serializeStyle(style: Partial<ICharacterProperties>): string {\n    const styleText: string[] = [];\n    for (const property in style) {\n        if (property === '__fontFamilyId') {\n            continue;\n        }\n        const value = style[property];\n        if (value !== undefined) {\n            styleText.push(`${ property }:${ serializePropertyValue(property === 'variable' ? 'feed' : property, value) }`);\n        }\n    }\n    return styleText.sort().join(';');\n}\n\nexport function deserializeStyle(text: string): Partial<ICharacterProperties> {\n    const properties: [string, string][] = text.split(';').filter(p => p.includes(':')).map(p => {\n        // Handle links which includes 'http://'.\n        const propertyLastIndex = p.indexOf(':');\n        return [p.substring(0, propertyLastIndex), p.substring(propertyLastIndex + 1)];\n    }) as [string, string][];\n    const style: Partial<ICharacterProperties> = {};\n    for (const property of properties) {\n        style[property[0]] = deserializePropertyValue(property[0] === 'variable' ? 'feed' : property[0], property[1]);\n    }\n    return style;\n}\n\nexport function deserializeElementStyle(element: HTMLElement): Partial<ICharacterProperties> {\n    const propertiesToUse = element.dataset.studioValues ? element.dataset.studioValues.split(' ') : [];\n\n    const style: Partial<ICharacterProperties> = {};\n    for (const property of propertiesToUse) {\n        switch (property as OneOfCharacterProperty) {\n            case 'font':\n                const font = deserializePropertyValue('font', element.dataset.font) as IFontStyle;\n                style.font = font;\n                break;\n            case 'textColor':\n                style.textColor = deserializePropertyValue('color', element.style.color) as IColor;\n                break;\n            case 'fontSize':\n                style.fontSize = deserializePropertyValue('number', element.style.fontSize) as number;\n                break;\n            case 'strikethrough':\n            case 'underline':\n                if (element.style.textDecoration!.indexOf('line-through') > -1) {\n                    style.strikethrough = true;\n                }\n                if (element.style.textDecoration!.indexOf('underline') > -1) {\n                    style.underline = true;\n                }\n                break;\n            case 'uppercase':\n                style.uppercase = element.style.textTransform!.indexOf('uppercase') > -1;\n                break;\n            case 'characterSpacing':\n                style.characterSpacing = deserializePropertyValue('number', element.style.letterSpacing) as number;\n                break;\n            case 'lineHeight':\n                style.lineHeight = deserializePropertyValue('number', element.style.lineHeight) as number;\n                break;\n            case 'textShadows':\n                style.textShadows = deserializePropertyValue('textShadows', element.style.textShadow) as ITextShadow[];\n                break;\n            case 'variable':\n                style.variable = deserializePropertyValue('feed', element.dataset.variable) as IVariable;\n        }\n    }\n    return style;\n}\n\nexport function serializeInlineStyledText(text: IInlineStyledText): string {\n    const spans: ISerializedInlineStyledTextSpan[] = [];\n    for (const span of text.styles) {\n        if (span.type === SpanType.End) {\n            break;\n        }\n        spans.push({\n            type: span.type,\n            length: span.length,\n            position: span.position,\n            style: serializeStyle(span.style)\n        });\n    }\n    return JSON.stringify({ text: text.text, styles: spans } as ISerializedInlineStyledText);\n}\n\nexport function serializeVersionedText(text: IVersionedText): string {\n    const spans: ISerializedTextSpan[] = [];\n    for (const span of text.styles) {\n        if (span.type === SpanType.End) {\n            break;\n        }\n        if (span.type === SpanType.Composition) {\n            continue;\n        }\n        const styleIds: ISerializedStyleMap[] = [];\n        for (const [documentId, styleId] of span.styleIds.entries()) {\n            styleIds.push({ documentId, styleId });\n        }\n\n        spans.push({\n            type: span.type,\n            length: span.length,\n            position: span.position,\n            styleIds: styleIds.sort((a, b) => {\n                if (a.documentId > b.documentId) {\n                    return 1;\n                } else if (a.documentId < b.documentId) {\n                    return -1;\n                } else if (a.styleId > b.styleId) {\n                    return 1;\n                } else if (a.styleId < b.styleId) {\n                    return -1;\n                }\n                throw new Error('StyleId is not unique');\n            }),\n            variable: span.variable\n        });\n    }\n    return JSON.stringify({ text: text.text, styles: spans });\n}\n\nexport function deserializeInlineStyledText(text: string): IInlineStyledText {\n    const inlineStyledText = JSON.parse(text) as ISerializedInlineStyledText;\n    const remappedSpans = inlineStyledText.styles.map((span) => ({\n        ...span,\n        style: deserializeStyle(span.style)\n    }));\n    return {\n        text: inlineStyledText.text,\n        styles: remappedSpans\n    };\n}\n","import { clamp } from '../utils/utils';\nimport { IAnimation, IAnimationKeyframe, ITime } from '../domain/animation';\nimport { ITimingFunction, TimingFunctionKey, TimingFunctionFn, TimingFunctionKeyMacro } from '../domain/timing-functions';\nimport { getTimeBetween, isTimeAt } from './animation.utils';\n\nexport const DEFAULT_TIMING_FUNCTION: TimingFunctionKey = 'easeInOutCubic';\n\nexport function getTimingFunctionValueBetween(time: number, before: ITime, after: ITime, timingFunction: TimingFunctionFn): number {\n\n    const duration = getTimeBetween(before, after);\n    const startTime = before.time + (before.duration || 0);\n\n    // No time between before after\n    if (!duration) {\n        return isTimeAt(time, before) ? 1 : 0;\n    }\n\n    // Progress of animation between two times/keyframes (between 0 and 1)\n    const progress =  clamp((time - startTime) / duration, 0, 1);\n\n    // Apply timing function on that value\n    return timingFunction(progress);\n}\n\nexport function getTimingFunctionFromKeyframe(animation: IAnimation, keyframe: IAnimationKeyframe): TimingFunctionFn {\n    let key = keyframe.timingFunction;\n    if (key === '@timingFunction') {\n        key = animation.timingFunction;\n    }\n    return getTimingFunctionByKey(key);\n}\n\nexport function getTimingFunctionByKey(key: TimingFunctionKey = 'linear'): TimingFunctionFn {\n    return timingFunctions[key].func;\n}\n\n/**\n * easeOutBack should become easeInBack and vice versa. easeInOut should stay the same\n * @param timing\n */\nexport function getOppositeTimingFunctionKey(timing: TimingFunctionKey | TimingFunctionKeyMacro): TimingFunctionKey {\n\n    if (timing.indexOf('InOut') === -1 && timing.indexOf('@') === -1) {\n        let reverse: string | undefined;\n        if (timing.indexOf('In') > -1) {\n            reverse = timing.replace(/In/g, 'Out');\n        }\n        else if (timing.indexOf('Out') > -1) {\n            reverse = timing.replace(/Out/g, 'In');\n        }\n\n        if (reverse !== undefined && timingFunctions[reverse]) {\n            return reverse as TimingFunctionKey;\n        }\n    }\n\n    return timing as TimingFunctionKey;\n}\n\nexport const timingFunctions: {[key in TimingFunctionKey]: ITimingFunction} = {\n    linear: {\n        name: 'Linear',\n        type: 'none',\n        func: (t: number) => t\n    },\n    easeInExpo: {\n        name: 'InExpo',\n        type: 'in',\n        func: (t: number) => (t === 0) ? 0 : Math.pow(2, 10 * (t - 1))\n    },\n    easeOutExpo: {\n        name: 'OutExpo',\n        type: 'in',\n        func: (t: number) => (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1\n    },\n    easeInOutExpo: {\n        name: 'InOutExpo',\n        type: 'inout',\n        func: (t: number) => {\n            if (t === 0) {\n                return 0;\n            }\n            if (t === 1) {\n                return 1;\n            }\n            if ((t /= 0.5) < 1) {\n                return 0.5 * Math.pow(2, 10 * (t - 1));\n            }\n            return 0.5 * (-Math.pow(2, -10 * --t) + 2);\n        }\n    },\n    easeInQuad: {\n        name: 'InQuad',\n        type: 'in',\n        func: (t: number) => t * t\n    },\n    easeOutQuad: {\n        name: 'OutQuad',\n        type: 'out',\n        func: (t: number) => t * (2 - t)\n    },\n    easeInOutQuad: {\n        name: 'InOutQuad',\n        type: 'inout',\n        func: (t: number) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t\n    },\n    easeInCubic: {\n        name: 'InCubic',\n        type: 'in',\n        func: (t: number) => t * t * t\n    },\n    easeOutCubic: {\n        name: 'OutCubic',\n        type: 'out',\n        func: (t: number) => (--t) * t * t + 1\n    },\n    easeInOutCubic: {\n        name: 'InOutCubic',\n        type: 'inout',\n        func: (t: number) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1\n    },\n    easeInQuart: {\n        name: 'InQuart',\n        type: 'in',\n        func: (t: number) => t * t * t * t\n    },\n    easeOutQuart: {\n        name: 'OutQuart',\n        type: 'out',\n        func: (t: number) => 1 - (--t) * t * t * t\n    },\n    easeInOutQuart: {\n        name: 'InOutQuart',\n        type: 'inout',\n        func: (t: number) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * (--t) * t * t * t\n    },\n    easeInQuint: {\n        name: 'InQuint',\n        type: 'in',\n        func: (t: number) => t * t * t * t * t\n    },\n    easeOutQuint: {\n        name: 'OutQuint',\n        type: 'out',\n        func: (t: number) => 1 + (--t) * t * t * t * t\n    },\n    easeInOutQuint: {\n        name: 'InOutQuint',\n        type: 'inout',\n        func: (t: number) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (--t) * t * t * t * t\n    },\n    easeInElastic: {\n        name: 'InElastic',\n        type: 'in',\n        func: (t: number) => {\n            if (t === 1) {\n                return 1;\n            }\n            return .04 * t / (--t) * Math.sin(25 * t);\n        }\n    },\n    easeOutElastic: {\n        name: 'OutElastic',\n        type: 'out',\n        func: (t: number) => {\n            if (t === 0) {\n                return 0;\n            }\n            return (.04 - .04 / t) * Math.sin(25 * t) + 1;\n        }\n    },\n    easeInOutElastic: {\n        name: 'InOutElastic',\n        type: 'inout',\n        func: (t: number) => {\n            if (t === 0.5) {\n                return 0.5;\n            }\n            return (t -= .5) < 0 ? (.02 + .01 / t) * Math.sin(50 * t) : (.02 - .01 / t) * Math.sin(50 * t) + 1;\n        }\n    },\n    easeInBack: {\n        name: 'InBack',\n        type: 'in',\n        func: (t: number) => { let overshoot = 1; if (!overshoot && overshoot !== 0) { overshoot = 1.70158; } return 1 * t * t * ( (overshoot + 1) * t - overshoot ); }\n    },\n    easeOutBack: {\n        name: 'OutBack',\n        type: 'out',\n        func: (t: number) => { let overshoot = 1; if (!overshoot && overshoot !== 0) { overshoot = 1.70158; } t = t - 1; return t * t * ((overshoot + 1) * t + overshoot) + 1; }\n    },\n    easeInOutBack: {\n        name: 'InOutBack',\n        type: 'inout',\n        func: (t: number) => { let overshoot = 1; if (overshoot === undefined) { overshoot = 1.70158; } if ((t /= .5) < 1) { return .5 * (t * t * (((overshoot *= (1.525)) + 1) * t - overshoot)); } return .5 * ((t -= 2) * t * (((overshoot *= (1.525)) + 1) * t + overshoot) + 2); }\n    },\n    easeInBounce: {\n        name: 'InBounce',\n        type: 'in',\n        func: (t: number) => 1 - bounce(1 - t)\n    },\n    easeOutBounce: {\n        name: 'OutBounce',\n        type: 'out',\n        func: (t: number) => bounce(t)\n    },\n    easeInOutBounce: {\n        name: 'InOutBounce',\n        type: 'inout',\n        func: (t: number) => { if (t < 0.5) { return bounce(t * 2) * 0.5; } return bounce(t * 2 - 1) * 0.5 + 1 * 0.5; }\n    }\n};\n\n\nfunction bounce(t: number): number {\n    if (t < 0.36363636363636365) {\n        return 7.5625 * t * t;\n    } else if (t < 0.7272727272727273) {\n    t = t - 0.5454545454545454;\n        return 7.5625 * t * t + 0.75;\n    } else if (t < 0.9090909090909091) {\n    t = t - 0.8181818181818182;\n        return 7.5625 * t * t + 0.9375;\n    } else {\n    t = t - 0.9545454545454546;\n        return 7.5625 * t * t + 0.984375;\n    }\n}\n","import { TimingFunctionKey } from './timing-functions';\n\nexport interface IAction {\n    id: string;\n    triggers: ActionTrigger[];\n    operations: IActionOperation[];\n    conditions: IActionCondition[];\n    disabled: boolean;\n    preventClickThrough?: boolean;\n    templateId?: ReservedActionId;\n}\n\nexport interface IActionCondition {\n    operator: ActionConditionOperator;\n    property: ActionConditionProperty;\n    value: number;\n}\n\nexport interface IActionOperation {\n    /**\n     * SET_STATE and REMOVE_STATE always require a state id as value.\n     *\n     * If set to CLEAR_STATES, then operation value is `undefined`\n     */\n    method: ActionOperationMethod;\n    /**\n     * State ID, url (`string`) or `undefined`\n     *\n     * Setting the state to `undefined` removes all applied States (`CLEAR_STATES`)\n     * */\n    value: ActionOperationValue;\n    delay?: number;\n    /** DataElement ID or undefined. Should always be available if value is a state ID */\n    target?: string;\n    animation?: {\n        timingFunction: TimingFunctionKey;\n        duration: number;\n    };\n}\n\nexport type ActionConditionOperator =\n    | '<'\n    | '<='\n    | '='\n    | '>'\n    | '>=';\n\nexport type ActionConditionProperty =\n    | 'creative.width'\n    | 'ceative.height';\n\nexport type ActionOperationValue = string | undefined;\n\nexport enum ActionOperationMethod {\n    SetState = 'SET_STATE',\n    RemoveState = 'REMOVE_STATE',\n    ClearStates = 'CLEAR_STATES',\n    OpenUrl = 'OPEN_URL'\n}\n\nexport enum ActionTrigger {\n    Click = 'click',\n    MouseDown = 'mousedown',\n    MouseUp = 'mouseup',\n    MouseEnter = 'mouseenter',\n    MouseLeave = 'mouseleave',\n    TouchStart = 'touchstart',\n    TouchEnd = 'touchend',\n    // TouchMove = 'touchmove',\n    TouchCancel = 'touchcancel',\n}\n\nexport type ReservedActionId =\n    | 'reserved-pressed'\n    | 'reserved-hover';\n\nexport interface IActionListener {\n    trigger: ActionTrigger;\n    event: (event: MouseOrTouchEvent, forceClearStates?: boolean) => void;\n    action: IAction;\n}\n\nexport type MouseOrTouchEvent = MouseEvent | TouchEvent;\n","import { IState } from './state';\nimport { TimingFunctionKey, TimingFunctionKeyMacro } from './timing-functions';\n\nexport interface ITime {\n    time: number;\n    duration?: number;\n}\n\nexport interface ITimeAndDuration extends ITime {\n    duration: number;\n}\n\nexport enum AnimationTypes {\n    in,\n    out,\n    repeating,\n    action,\n    keyframe\n}\n\n\n// This is equivalent to:\n// export type AnimationType = 'in' | 'out' | 'repeating' | 'action' | 'keyframe';\nexport type AnimationType = keyof typeof AnimationTypes;\n\nexport interface IAnimation {\n    name: string;\n    id: string;\n    templateId?: string;\n    type?: AnimationType;\n    keyframes: IAnimationKeyframe[];\n    timingFunction: TimingFunctionKey;\n    hidden?: boolean;\n    /**\n     * Inherited from old transition. TODO: Should we use the same\n     */\n    settings?: IAnimationSettings;\n\n}\n\nexport interface IAnimationTemplate {\n    id: string;\n    name: string;\n    type: AnimationType;\n    keyframes: IAnimationTemplateKeyframe[];\n    timingFunction: TimingFunctionKey;\n    settings?: IAnimationSettings;\n}\n\nexport interface IAnimationTemplateKeyframe extends ITime {\n    id?: string;\n\n    /**\n     * How much of the state should be visible.\n     * Defaults to 1 if not set which means that the full state should be visible\n     */\n    value?: number;\n\n    /**\n     * Template of a a state. Undefined means that this refers to main state.\n     * If color etc is needed, turn this to a ISerializedState\n     */\n    state?: IState;\n\n    /**\n     * Function returning value between 0-1 (some like Elastic will be over 1).\n     * The value decides how much of the keyframe that should be visible.\n     * \"@timingFunction\" means that it should inherit the value from the animation\n     */\n    timingFunction?: TimingFunctionKeyMacro | TimingFunctionKey;\n}\n\nexport interface IAnimationKeyframe extends ITimeAndDuration {\n    id: string;\n\n    /**\n     * Time of the keyframe. Note that this is relative to the time of the element.\n     */\n    time: number;\n\n    /**\n     * How much of the state should be visible.\n     * Defaults to 1 if not set which means that the full state should be visible\n     */\n    value?: number;\n\n    /**\n     * Reference to a state. Undefined means that this refers to main state.\n     */\n    stateId?: string;\n\n    /**\n     * Function returning value between 0-1 (some like Elastic will be over 1).\n     * The value decides how much of the keyframe that should be visible.\n     * \"@timingFunction\" means that it should inherit the value from the animation\n     */\n    timingFunction?: TimingFunctionKeyMacro | TimingFunctionKey;\n}\n\nexport const keyframeProperties: (keyof IAnimationKeyframe)[] = [\n    'time',\n    'value',\n    'timingFunction',\n    'id',\n    'stateId',\n    'duration'\n];\n\nexport type IAnimationSettings = {\n    direction?: IAnimationSetting;\n    distance?: IAnimationSetting;\n};\n\nexport interface IAnimationSetting {\n    name?: string;\n    value?: number | string;\n}\n","import { IPosition } from './dimension';\n\nexport enum ColorType {\n    Solid = 'solid',\n    LinearGradient = 'linear-gradient'\n}\n\nexport interface IColor {\n\n    /**\n     * Value between 0 and 255\n     */\n    red: number;\n\n    /**\n     * Value between 0 and 255\n     */\n    green: number;\n\n    /**\n     * Value between 0 and 255\n     */\n    blue: number;\n    hue: number;\n    saturation: number;\n    lightness: number;\n\n    /**\n     * Value between 0 and 100\n     */\n    alpha: number;\n\n    type: ColorType;\n\n    stops: IColorStop[];\n\n    angle: number;\n\n    start: IColorStop;\n\n    end: IColorStop;\n\n    copy: () => IColor;\n\n    toJSON: () => string;\n\n    toString: () => string;\n\n    addColorStop: (color: IColor, offset: number, position?: IPosition) => void;\n\n    setColor: (color: IColor) => IColor;\n\n}\n\nexport interface IColorStop {\n\n    /**\n     * Color of stop\n     */\n    color: IColor;\n\n    /**\n     * Percentage (100 = end of element)\n     */\n    offset: number;\n\n    /**\n     * Position of point relative to the element ({ x: 0.5, y: 0.5 } = center).\n     * Only applies to start and en position.\n     */\n    position?: IPosition;\n}\n","import { ITime } from './animation';\n\nexport enum ApprovalStatus {\n    None = '',\n    NoStatus = 'No status',\n    NotApproved = 'Not approved',\n    InProgress = 'In progress',\n    ForReview = 'For review',\n    Approved = 'Approved',\n}\n\nexport enum CreativeType {\n    Animated\n}\n\nexport interface IPreloadImage {\n    frames: number[];\n    format: 'jpg' | 'gif' | 'png';\n    quality: number;\n}\n\nexport interface IGifExport {\n    frames: ITime[];\n    show: boolean;\n}\n","\nexport interface IImageAsset {\n    id: string;\n    url: string;\n    __loading?: boolean;\n    width?: number;\n    height?: number;\n}\n\nexport interface IImageSettings {\n\n    /**\n     * How the image should be rendered in size.\n     * Similar to the CSS \"background-size\" property\n     */\n    sizeMode: ImageSizeMode;\n\n    /**\n     * A decimal value of the image position when \"cropping\" or \"containing\" the image.\n     * Ranges from 0 to 1. Simliar to the CSS background-position property.\n     * 0 = left, 0.5 = center, 1 = right\n     */\n    x: number;\n\n    /**\n     * A decimal value of the image position when \"cropping\" or \"containing\" the image.\n     * Ranges from 0 to 1. Simliar to the CSS background-position property.\n     * 0 = top, 0.5 = left, 1 = bottom\n     */\n    y: number;\n\n    /**\n     * Quality on image from 0 to 100. Undefined means that no optimization should be done\n     */\n    quality?: number;\n\n     /**\n      * Enable retina resolution for devices supporting it.\n      * Defaults to false if not provided\n      */\n    highDpi?: boolean;\n\n}\n\nexport const imageSettingsPropertyToUnitMap = {\n    'sizeMode': 'enum',\n    'x': 'number',\n    'y': 'number',\n    'quality': 'number',\n    'highDpi': 'boolean'\n};\n\nexport const imageSettingsProperties = Object.keys(imageSettingsPropertyToUnitMap);\nexport type ImageSettingsKeys = keyof typeof imageSettingsPropertyToUnitMap;\n\nexport enum ImageSizeMode {\n    Fit = 'fit',\n    Stretch = 'stretch',\n    Crop = 'crop'\n}\n\n/**\n * Deprecated, use ImageSizeMode\n */\nexport type ImageFitOption = 'contain' | 'distort' | 'cover';\n\n\nexport const DEFAULT_IMAGE_QUALITY = 85;\n\nexport const DEFAULT_IMAGE_SETTINGS: Readonly<IImageSettings> = {\n    x: 0.5,\n    y: 0.5,\n    quality: DEFAULT_IMAGE_QUALITY,\n    sizeMode: ImageSizeMode.Fit,\n    highDpi: false\n};\n","import { ITextElementDataNode, IVideoLibraryAsset } from './index';\nimport { omit } from '@studio/utils/utils';\nimport { ICollection } from './array';\nimport { IAsset, IImageLibraryAsset } from './asset';\nimport { IColor } from './color';\nimport { IElementProperty } from './element';\nimport { IFeed } from './feed';\nimport { IFontStyle } from './font';\nimport { IFontFamily, IFontFamilyStyle } from './font-families';\nimport { IImageAsset } from './image';\nimport { IElementDataNode, IImageElementDataNode, IVideoElementDataNode, NodeKind } from './nodes';\nimport { IBorder, IFilterMap, IPadding, IRadius, IShadow, ITextShadow } from './style';\nimport { IText, ITextElementCharacterProperties, ITextElementProperties } from './text';\nimport { IVersion, IVersionedText, IVersionProperty } from './version';\nimport { IWidgetLibraryAsset } from './widget';\nimport { IVideoAsset } from '@creative/elements/video/video';\n\nexport interface IProperty {\n    id: string;\n    name: string;\n    value?: OneOfElementPropertyValue;\n    label?: string;\n}\n\nexport interface IElementValues {\n    versionProperties: IVersionProperty[];\n    originalVersionProperties: IVersionProperty[];\n    images?: ICollection<IImageAsset> | IImageLibraryAsset[];\n    videos?: ICollection<IVideoAsset> | IVideoLibraryAsset[];\n    fontFamilies: IFontFamily[];\n}\n\nexport interface IElementPropertyValues extends IElementValues {\n    elementProperties: ICollection<IElementProperty>;\n    newOriginalVersionId?: string;\n}\n\nexport interface IElementPropertyCopyValues {\n    versions: ICollection<IVersion>;\n    elementProperties: ICollection<IElementProperty>;\n    originalVersionProperties: IVersionProperty[];\n    newOriginalVersionId?: string;\n    images?: ICollection<IImageAsset>;\n    videos?: ICollection<IVideoAsset>;\n    fontFamilies: IFontFamily[];\n}\n\nexport type OneOfElementPropertyValue = IFontFamilyStyle\n    | IAsset\n    | string\n    | IVersionedText\n    | IText\n    | IFeed;\nexport type WidgetPropertyKeys = keyof typeof widgetPropertyToUnitMap;\n// This is the thing\nexport type OneOfElementPropertyKeys = keyof typeof propertyToUnitMap;\nexport type OneOfTextElementPropertyKeys = keyof typeof textPropertyToUnitMap;\nexport type OneOfImageElementPropertyKeys = keyof typeof imagePropertyToUnitMap;\nexport type OneOfViewNodesSharedPropertyKeys = keyof typeof sharedPropertyToUnitMap;\n\nexport interface ICustomProperty extends IElementProperty { }\n\n// This should probably be all type of the properties added together\n// export type PropertyValueTyped = Exclude<ITextElementCharacterProperties[keyof ITextElementCharacterProperties], undefined>;\n\nexport type PropertyValue =\n    string |\n    number |\n    boolean |\n    IColor |\n    IShadow[] |\n    ITextShadow[] |\n    IFilterMap |\n    IBorder |\n    IFontStyle |\n    IImageAsset |\n    IPadding |\n    IWidgetLibraryAsset |\n    ICustomProperty[] |\n    IFeed |\n    IRadius |\n    IVersionedText;\n\nexport const characterPropertyToUnitMap: Record<keyof ITextElementCharacterProperties, string> = {\n    'font': 'FontStyle',\n    'textColor': 'Color',\n    'fontSize': 'number',\n    'lineHeight': 'number',\n    'characterSpacing': 'number',\n    'uppercase': 'boolean',\n    'underline': 'boolean',\n    'strikethrough': 'boolean',\n    'textShadows': 'TextShadow[]',\n    'variable': 'Feed',\n\n    // A helper property to display, font family in dropdown, when font style is undefined.\n    '__fontFamilyId': 'string'\n};\n\nconst textPropertiesOnlyToUnitMap: Record<keyof ITextElementProperties, string> = {\n    'maxRows': 'integer',\n    'padding': 'Padding',\n    'textOverflow': 'enum',\n    'horizontalAlignment': 'enum',\n    'verticalAlignment': 'enum',\n};\n\nexport const textPropertyToUnitMap = {\n    ...characterPropertyToUnitMap,\n    ...textPropertiesOnlyToUnitMap\n};\n\nfunction getObjectKeys<O extends {}>(object: O): (keyof O)[] {\n    return Object.keys(object) as (keyof O)[];\n}\n\n\nexport const textProperties = getObjectKeys(textPropertyToUnitMap);\n\nexport const characterProperties = getObjectKeys(omit(characterPropertyToUnitMap, '__fontFamilyId'));\n\nexport const widgetPropertyToUnitMap = {\n    'js': 'string',\n    'ts': 'string',\n    'html': 'string',\n    'css': 'string',\n    'customProperties': 'CustomProperty[]',\n    'widgetReference': 'string',\n    'bannerflowLibraryWidgetReference': 'string',\n    'select': 'CustomProperty[]',\n    'number': 'number',\n    'image': 'ImageAsset',\n    'boolean': 'boolean',\n    'color': 'Color',\n    'widgetAsset': 'WidgetAsset',\n};\n\n// The keyframe types stuff is a bit weird, is this really how it's supposed to be constructed?\ntype ImagePropertyMap =\n    { imageReference: 'string' } &\n    Pick<\n        IImageElementDataNode,\n        'imageAsset' | 'imageSettings'\n    >;\nconst imagePropertyToUnitMap: Record<keyof ImagePropertyMap, string> | 'imageReference' = {\n    'imageReference': 'string',\n    'imageAsset': 'ImageAsset',\n    'imageSettings': 'ImageSettings',\n};\n\ntype VideoPropertyMap = Pick<IVideoElementDataNode, 'videoAsset' | 'videoSettings'>;\nconst videoPropertyToUnitMap: Record<keyof VideoPropertyMap, string> = {\n    'videoAsset': 'VideoAsset',\n    'videoSettings': 'VideoSettings'\n};\n\n// Seems to have some types from states, why?\ntype SharedPropertyMap = Omit<\n    IElementDataNode<NodeKind>,\n    | 'name'\n    | 'imageAsset'\n    | '__rootNode'\n    | '__parentNode'\n    | 'elementCid'\n    | 'cidIndex'\n    | 'parentId'\n    | 'id'\n    | 'kind'>\n    & { 'fontReference': 'string' }\n    & Pick<ITextElementDataNode, 'textColor' | 'content'>;\n\nexport const sharedPropertyToUnitMap: Record<keyof SharedPropertyMap, string> = {\n    'x': 'number',\n    'y': 'number',\n    'width': 'number',\n    'height': 'number',\n    'duration': 'number',\n    'fill': 'Color',\n    'textColor': 'Color',\n    'originX': 'number',\n    'originY': 'number',\n    'rotationX': 'number',\n    'rotationY': 'number',\n    'rotationZ': 'number',\n    'radius': 'Radius',\n    'opacity': 'number',\n    'shadows': 'Shadow[]',\n    'filters': 'FilterMap',\n    'border': 'Border',\n    'hidden': 'boolean',\n    'locked': 'boolean',\n    'mirrorX': 'boolean',\n    'mirrorY': 'boolean',\n    'scaleX': 'number',\n    'scaleY': 'number',\n    'ratio': 'number',\n    'feed': 'Feed',\n    'states': 'State[]',\n    'animations': 'Animation[]',\n    'actions': 'Action[]',\n    'time': 'number',\n    // TODO: SHOULD NOT BE IN SHARED\n    'fontReference': 'string',\n    'content': 'text'\n};\n\nexport const statePropertyToUnitMap = {\n    ...omit(sharedPropertyToUnitMap,\n        'states',\n        'animations',\n        'actions',\n        'feed',\n        'time',\n        'duration',\n        'hidden',\n        'locked',\n        'width',\n        'height',\n        // Currently not supported\n        'fontReference',\n        'content'\n    ),\n    'name': 'enum'\n};\n\nexport const propertyToUnitMap = {\n    ...textPropertyToUnitMap,\n    ...widgetPropertyToUnitMap,\n    ...imagePropertyToUnitMap,\n    ...videoPropertyToUnitMap,\n    ...sharedPropertyToUnitMap,\n    ...statePropertyToUnitMap\n};\n\nexport const properties = getObjectKeys(propertyToUnitMap);\nexport const sharedProperties = getObjectKeys(sharedPropertyToUnitMap);\n\n/**\n * Element properties that need to be scaled in order to scale a creative to any particular size\n */\nexport const ScalableProperties = ['x', 'y', 'width', 'height', 'scaleX', 'scaleY', 'fitPositionX', 'fitPositionY', 'radius', 'border', 'fontSize', 'padding', 'shadows', 'textShadows'];\n\nexport function isElementProperty(key: string): key is OneOfElementPropertyKeys {\n    return properties.some(p => key === p);\n}\n\nexport const propertyMaxValues = {\n    opacity: 1\n};\n\nexport const propertyMinValues = {\n    radius: 0,\n    opacity: 0,\n    scaleX: 0,\n    scaleY: 0,\n};\n","import { Color } from '../creative/color';\nimport { IColor } from './color';\nimport { ISize } from './dimension';\n\nexport type AppearenceStyles = Partial<IAppearence & ISize>;\n\nexport interface IAppearence {\n    fill: IColor;\n    fillSize: string;\n    radius: IRadius;\n    opacity: number;\n    border: IBorder;\n    shadows: IShadow[];\n}\n\nexport enum RadiusType {\n    Joint = 'joint',\n    Separate = 'separate'\n}\n\nexport interface IRadius {\n    type: RadiusType;\n    topLeft: number;\n    topRight: number;\n    bottomRight: number;\n    bottomLeft: number;\n}\n\nexport type BorderStyle = 'solid' | 'dotted' | 'dashed';\n\nexport interface IBorder<T = IColor> {\n    thickness: number;\n    color: T;\n    style: BorderStyle;\n}\n\nexport interface IShadow<T = Color> {\n    offsetX: number;\n    offsetY: number;\n    blur: number;\n    spread: number;\n    color: T;\n}\nexport interface ITextShadow {\n    offsetX?: number;\n    offsetY?: number;\n    blur?: number;\n    color: Color;\n}\n\nexport interface IPadding {\n    top: number;\n    right: number;\n    bottom: number;\n    left: number;\n}\n\nexport enum FilterType {\n    Blur = 'blur',\n    Contrast = 'contrast',\n    Invert = 'invert',\n    Grayscale = 'grayscale',\n    Saturation = 'saturate',\n    Sepia = 'sepia'\n}\n\nexport enum FilterUnit {\n    Length = 'px',\n    Percentage = '%',\n}\n\nexport interface IFilter {\n    value?: number;\n}\n\nexport type IFilterMap = Partial<Record<FilterType, IFilter | undefined>>;\n\nexport interface FilterInfo {\n    id: FilterType,\n    name: string,\n    icon: string,\n    unit: FilterUnit,\n    max: number,\n    default?: number\n}\n\nexport const FILTER_MAP: Record<FilterType, Omit<FilterInfo, 'id'>> = {\n    [FilterType.Blur]:       { name: 'Blur',       icon: 'filter-blur',      unit: FilterUnit.Length,     max: 100               },\n    [FilterType.Contrast]:   { name: 'Contrast',   icon: 'filter-contrast',  unit: FilterUnit.Percentage, max: 200, default: 100 },\n    [FilterType.Invert]:     { name: 'Invert',     icon: 'filter-invert',    unit: FilterUnit.Percentage, max: 100               },\n    [FilterType.Grayscale]:  { name: 'Grayscale',  icon: 'filter-grayscale', unit: FilterUnit.Percentage, max: 100               },\n    [FilterType.Saturation]: { name: 'Saturation', icon: 'filter-saturate',  unit: FilterUnit.Percentage, max: 200, default: 100 },\n    [FilterType.Sepia]:      { name: 'Sepia',      icon: 'filter-sepia',     unit: FilterUnit.Percentage, max: 100               },\n};\n\n// Construct an array of FilterInfos with added ids for easy lookup and rendering.\nexport const FILTER_LIST = (Object.entries(FILTER_MAP) as ReadonlyArray<[FilterType, typeof FILTER_MAP[keyof typeof FILTER_MAP]]>)\n    .reduce(\n        (memo: ReadonlyArray<FilterInfo>, [key, filter]) => [\n            ...memo,\n            { id: key, ...filter },\n        ],\n        []\n    );\n","export type SocialPlacement = MetaPlacement | TiktokPlacement;\n\nexport enum MetaPlacement {\n    Instagram = 'meta-instagram',\n    Facebook = 'meta-facebook',\n    Messenger = 'meta-messenger',\n    FacebookReels = 'meta-facebookreels',\n    InstagramReels = 'meta-instagramreels',\n}\n\nexport enum TiktokPlacement {\n    Default = 'tiktok-default',\n    After9s = 'tiktok-after-9s',\n    After9sWithCard = 'tiktok-after-9s-with-card'\n}\n\nexport enum SocialNetworkType {\n    Meta = 'meta',\n    TikTok = 'tiktok'\n}\n\nexport interface ISocialPlacement {\n    type: SocialPlacement;\n    text: string;\n    position: PlacementPostion;\n}\n\nexport interface ISocialNetwork {\n    type: SocialNetworkType;\n    text: string;\n    icon: string;\n    placements: ISocialPlacement[];\n    placementText: string;\n    ratios: string[];\n}\n\nexport interface ISocialGuide {\n    network: ISocialNetwork;\n    placement: ISocialPlacement;\n    overlay: boolean;\n    guidelines: boolean;\n}\n\nexport interface ICreativeSocialGuide {\n    network: SocialNetworkType;\n    placement: SocialPlacement;\n    overlay: boolean;\n    guidelines: boolean;\n}\n\nexport interface PlacementPostion {\n    top: number;\n    bottom: number;\n    left?: number;\n    right?: number;\n}\n\nconst DEFAULT_PLACEMENT_POSITION: PlacementPostion = { top: 0.14, bottom: 0.14 };\n\nconst META_PLACEMENTS = [\n    {\n        type: MetaPlacement.Instagram,\n        text: 'Instagram Story',\n        position: DEFAULT_PLACEMENT_POSITION\n    },\n    {\n        type: MetaPlacement.Facebook,\n        text: 'Facebook Story',\n        position: DEFAULT_PLACEMENT_POSITION\n    },\n    {\n        type: MetaPlacement.Messenger,\n        text: 'Messenger Story',\n        position: DEFAULT_PLACEMENT_POSITION\n    },\n    {\n        type: MetaPlacement.FacebookReels,\n        text: 'Facebook Reels',\n        position: { top: 0.12, bottom: 0.21, left: 0.07, right: 0.14 }\n    },\n    {\n        type: MetaPlacement.InstagramReels,\n        text: 'Instagram Reels',\n        position: { top: 0.12, bottom: 0.21, left: 0.07, right: 0.13 }\n    }\n];\n\nconst TIKTOK_PLACEMENTS = [\n    {\n        type: TiktokPlacement.Default,\n        text: 'Default',\n        position: { top: 0.11, bottom: 0.17, left: 0.11, right: 0.15 }\n    },\n    {\n        type: TiktokPlacement.After9s,\n        text: 'After 9s',\n        position: { top: 0.11, bottom: 0.22, left: 0.11, right: 0.15 }\n    },\n    {\n        type: TiktokPlacement.After9sWithCard,\n        text: 'After 9s with card',\n        position: { top: 0.11, bottom: 0.25, left: 0.11, right: 0.15 }\n    },\n];\n\nexport const SOCIAL_PLACEMENTS = [\n    ...META_PLACEMENTS,\n    ...TIKTOK_PLACEMENTS\n];\n\nexport const SOCIAL_NETWORKS: ISocialNetwork[] = [\n    {\n        type: SocialNetworkType.Meta,\n        text: 'Meta',\n        icon: 'meta',\n        placementText: 'Placement',\n        placements: META_PLACEMENTS,\n        ratios: ['9:16']\n    },\n    {\n        type: SocialNetworkType.TikTok,\n        text: 'TikTok',\n        icon: 'tiktok',\n        placementText: 'CTA Style',\n        placements: TIKTOK_PLACEMENTS,\n        ratios: ['9:16']\n    }\n];\n","import { stringLiteralArray } from '@studio/utils/utils';\nimport { TimingFunctionKey } from './timing-functions';\nimport { IBorder, IFilterMap, IRadius, IShadow, ITextShadow } from './style';\nimport { IColor } from './color';\n\n\nexport interface ITransition {\n    id?: string;\n    type: 'in' | 'out';\n    name: string;\n    timingFunction?: TimingFunctionKey;\n    template?: string;\n    settings?: TransitionSettings;\n    __time?: number;\n}\n\nexport type TransitionSettings = { [key: string]: ITransitionSetting; };\n\nexport interface ITransitionSetting {\n    name: string;\n    value: any;\n}\n\nexport const animatableProperties = stringLiteralArray([\n    'x',\n    'y',\n    'originX',\n    'originY',\n    'rotationX',\n    'rotationY',\n    'rotationZ',\n    'opacity',\n    'scaleX',\n    'scaleY',\n    'fill',\n    'radius',\n    'shadows',\n    'filters',\n    'textColor',\n    'border'\n]);\nexport type AnimatableProperty = typeof animatableProperties[number];\n\nexport type AnimatablePropertyValue = IFilterMap | IColor | IShadow[] | ITextShadow[] | IBorder | IRadius | number;\n\nexport const transitionSettingPropertyToUnitMap = {\n    'direction': 'angle',\n    'distance': 'number',\n};\n\n","import { User as OidcUser} from 'oidc-client';\nexport interface ConnectedUser {\n    connectionId: string;\n    isActive: boolean;\n    name: string;\n    shortName: string;\n    color: string;\n}\n\nexport interface UserActivity {\n    action: string;\n    user: ConnectedUser;\n    timestamp: string;\n}\n\nexport interface UsersUpdate {\n    users: ConnectedUser[];\n}\n\nexport interface IUser {\n    isEmployee?: boolean;\n    permissions?: Permissions[];\n    user?: OidcUser;\n    role?: Role;\n}\n\nexport enum Role {\n    None = 0,\n    User = 1,\n    Admin = 2,\n    Owner = 3,\n    AccountAdmin = 4,\n    ExternalUser = 5,\n    TextEditor = 6,\n    Designer = 7,\n    TextEditorExtended = 8,\n    UserWithoutAccessOthersContent = 9,\n    Publisher = 10,\n    Analyzer = 11,\n    TextEditorWithAnalyzer = 12,\n    PublisherExtended = 13\n}\n\n/**\n * Permissions defined in AccountManager on an account level\n */\nexport type Permissions =\n    | 'AccessOthersContent'\n    | 'Actions'\n    | 'AdvancedFormats'\n    | 'AllowHeavyVideos'\n    | 'Analytics'\n    | 'AnalyticsDemoData'\n    | 'Analyzer'\n    | 'Approve'\n    | 'BannerflowLibrary'\n    | 'BannersetDoneMark'\n    | 'BannerSetDuplicate'\n    | 'CreativesetDoneMark'\n    | 'CreativesetDuplicate'\n    | 'Comments'\n    | 'ConversionTracking'\n    | 'Creator'\n    | 'CustomAssets'\n    | 'CustomBannerScript'\n    | 'CustomCreativecript'\n    | 'DeleteComments'\n    | 'DirectPublishing'\n    | 'DownloadButton'\n    | 'DuplicateTo'\n    | 'Editor'\n    | 'EditorKeyFrames'\n    | 'EmailMarketing'\n    | 'ExternalTranslations'\n    | 'Facebook'\n    | 'FallbackSharpness'\n    | 'Feeds'\n    | 'FeedsAutomated'\n    | 'FeedsLive'\n    | 'KeyframeAnimations'\n    | 'LandingPage'\n    | 'Lock'\n    | 'Marketplace'\n    | 'MediaBuyer'\n    | 'MediaBuyerPublish'\n    | 'MessageSystem'\n    | 'MultipleBrands'\n    | 'MultipleUsers'\n    | 'OpenApi'\n    | 'OutdoorFormats'\n    | 'Publisher'\n    | 'RequirePasswordForNewBrands'\n    | 'Scheduling'\n    | 'Settings'\n    | 'Share'\n    | 'SocialMedia'\n    | 'Store'\n    | 'Studio'\n    | 'TextEditor'\n    | 'ThemeEnterprise'\n    | 'TrackingPixels'\n    | 'VideoConverter'\n    | 'ExportHtmlFromStudio'\n    | 'StudioVideoLibrary'\n    | 'SocialCampaignManager';\n","import { WidgetPropertyKeys, OneOfElementPropertyKeys } from './index';\nimport { IColor } from './color';\nimport { IFontStyle } from './font';\nimport { IFeed, IFeedData } from './feed';\nimport { IElementViewNode, NodeKind, IElementDataNode } from './nodes';\nimport { Widget } from '../creative/elements/widget/widget';\nimport { IAsset } from './asset';\n\nexport interface ILibraryWidget {\n    id?: string;\n    name: string;\n    thumbnailUrl?: string;\n    comment: string;\n\n    // Should be WidgetProperty[] extends ElementProperties\n    properties: IWidgetElementProperty[];\n    exportable: boolean;\n    state?: LibraryWidgetState;\n    versionId?: number;\n    imported?: boolean;\n}\n\nexport interface IWidgetElementDataNode extends IElementDataNode<NodeKind.Widget> {\n    html: string;\n    js: string;\n    ts: string;\n    css: string;\n    customProperties: IWidgetCustomProperty[];\n    parentId?: string;\n    widgetReference?: string;\n    __widget?: Widget;\n}\n\nexport type WidgetProperties = keyof IWidgetElementDataNode;\n\n\nexport interface IWidgetViewElement extends IElementViewNode<NodeKind.Widget> {\n    widgetAsset: IWidgetLibraryAsset;\n    html: string;\n    js: string;\n    css: string;\n    customProperties?: IWidgetCustomProperty[];\n    parentId?: string;\n}\n\nexport interface IWidgetLibraryAsset {\n    thumbnail: string;\n    bannerflowLibraryId: string;\n}\n\n// New interface\nexport interface IWidgetElementProperty {\n    name: OneOfElementPropertyKeys | WidgetPropertyKeys | string;\n    label?: string;\n    value?: OneOfCustomPropertyValue;\n    unit?: WidgetUnits;\n\n    versionPropertyId?: string;\n}\n\nexport interface IWidgetImage extends Omit<Partial<IAsset>, 'width' | 'height'> {}\n\nexport type OneOfCustomPropertyValue =\n    string |\n    number |\n    boolean |\n    IWidgetSelectOption[] |\n    IColor |\n    IFontStyle |\n    IWidgetImage |\n    IFeed;\n\nexport interface IWidgetCustomProperty {\n    name: string;\n    label: string;\n    value?: OneOfCustomPropertyValue;\n    unit: WidgetUnits;\n    versionPropertyId?: string;\n    clientId?: string;\n}\n\nexport type WidgetCustomProperties = keyof IWidgetCustomProperty;\n\nexport enum LibraryWidgetState {\n    Active = 0,\n    Inactive = 1\n}\n\nexport interface IWidgetSelectOption {\n    value: string;\n    selected: boolean;\n}\n\nexport type WidgetUnits = 'number' | 'boolean' | 'select' | 'text' | 'color' | 'font' | 'feed' | 'image';\n\nexport interface IFeedHelper {\n    id: string;\n    /**\n    * Returns a promise which resolves with FeedData\n    */\n    load: () => Promise<IFeedData>;\n    data: IFeedData;\n    loaded: boolean;\n    change: (callback: FeedHelperCallback) => void;\n}\n\nexport type FeedHelperCallback = ((feedData: IFeedData) => void);\n\nexport const WIDGET_PROPERTY_PREFIX = 'custom:';\n","import { IResizeDirection, RotationLocation, IPosition } from './dimension';\nimport { IBTreeItem } from '@studio/utils/btree';\n\nexport const enum TransformMode {\n    None,\n    Resize,\n    Rotate,\n    Move,\n    TextEdit,\n    Select,\n    GradientEdit,\n    CreateElement,\n    Clone,\n    Zoom,\n    Guidelines,\n    PositionImage\n}\n\nexport enum LockedDirection {\n    VERTICAL,\n    HORIZONTAL,\n    NONE,\n}\n\nexport interface ITransformDirection {\n    resize?: IResizeDirection;\n    rotate?: RotationLocation;\n}\n\nexport interface IQueryPoint {\n    value: number;\n    offset: number;\n    crossValues: number[];\n}\n\nexport interface ISnapLine {\n    base: number;\n    start: number;\n    end: number;\n    circles: Set<number>;\n}\n\nexport interface ICrossValue {\n    crossValue: number;\n}\n\nexport interface IGuideline {\n    id: string;\n    position: IPosition;\n    type: 'horizontal' | 'vertical';\n    preview: boolean;\n    social?: boolean;\n}\nexport interface ISnapPoint {\n    position: number;\n    offset: number;\n}\n\nexport interface ISnapPoints {\n    x?: ISnapPoint;\n    y?: ISnapPoint;\n}\n\nexport interface ISnapLines {\n    vertical: ISnapLine[];\n    horizontal: ISnapLine[];\n}\n\nexport interface IPositionToCrossValuesMap {\n    xToCrossValuesMap: Map<number, IQueryPoint>;\n    yToCrossValuesMap: Map<number, IQueryPoint>;\n}\n\nexport interface IPointResult {\n    item: IBTreeItem<ICrossValue>;\n    point: IQueryPoint;\n}\n","import { CreativeDataNode } from '@creative/nodes/creative-data-node';\nimport { ElementSelection } from '@creative/nodes/selection';\nimport { RichText } from '@creative/elements/rich-text/rich-text';\nimport { SVGBackground } from '@creative/svg-background';\nimport { IVideoRenderer } from '@creative/elements/video/video-renderer.header';\nimport { IVideoAsset, IVideoSettings } from '@creative/elements/video/video';\nimport { IAction, IActionListener } from './action';\nimport { IAnimation } from './animation';\nimport { IColor } from './color';\nimport { IBounds, IPosition, ISize } from './dimension';\nimport { IFeed } from './feed';\nimport { IFontStyle } from './font';\nimport { IImageAsset, IImageSettings } from './image';\nimport { IState } from './state';\nimport { AppearenceStyles, IBorder, IFilter, IFilterMap, IPadding, IRadius, IShadow, ITextShadow } from './style';\nimport { HorizontalAlignment, ICharacterProperties, IText, ITextElementProperties, TextOverflow, VerticalAlignment } from './text';\nimport { IWidgetElementDataNode, IWidgetViewElement } from './widget';\nimport { IGuideline } from './workspace';\nimport { IPreloadImage, IGifExport } from './creative';\nimport { ICreativeSocialGuide } from './social';\n\nexport interface INodeId {\n    id: string;\n    cidIndex?: number;\n    parentId?: string;\n}\n\nexport interface IId {\n    id: string;\n}\n\n\nexport interface IBaseDataNode extends INodeId {\n    name: string;\n    locked: boolean;\n    hidden: boolean;\n    __rootNode?: CreativeDataNode;\n    __parentNode?: IGroupElementDataNode;\n}\n\ninterface IBaseViewNode<Kind extends NodeKind = NodeKind> extends INodeId {\n    /**\n     * The DOM-element of the element\n     */\n    __rootElement?: HTMLDivElement;\n    __data: Extract<OneOfElementDataNodes, { kind: Kind }>;\n}\n\nexport interface INewBaseNode extends IBounds {\n    parentId?: string;\n}\n\nexport interface ICreativeDataNode extends IRootDataNode, INodeWithChildren {\n    id: string;\n    kind: NodeKind.Creative;\n    fill?: IColor;\n    border?: IBorder;\n    width: number;\n    height: number;\n    guidelines?: IGuideline[];\n    startTime?: number;\n    stopTime?: number;\n    loops: number;\n    preloadImage?: IPreloadImage;\n    gifExport?: IGifExport;\n    socialGuide?: ICreativeSocialGuide;\n}\n\nexport interface ISVGBackground {\n    render_m: <Kind extends NodeKind>(element: ISVGBackgroundNode<Kind>, overrides?: AppearenceStyles) => Promise<void> | undefined;\n}\n\nexport interface IGroupViewElement extends NodeWithKind<NodeKind.Group>, IBaseViewNode, IChildren {}\n\nexport interface IRootDataNode extends INodeWithChildren<NodeKind.Creative> {}\n\nexport interface IChildren {\n    nodes: OneOfViewNodes[];\n}\n\nexport interface IDataNodeChildren {\n    nodes: OneOfDataNodes[];\n}\n\nexport enum NodeName {\n    Rectangle = 'Rectangle',\n    Ellipse = 'Ellipse',\n    Text = 'Text',\n    Button = 'Button',\n    Image = 'Image',\n    Widget = 'Widget',\n    Video = 'Video',\n    Group = 'Group'\n}\n\nexport enum NodeKind {\n    Creative = 'creative',\n    Rectangle = 'rectangle',\n    Text = 'text',\n    Image = 'image',\n    Video = 'video',\n    Group = 'group',\n    Selection = 'selection',\n    AnyElement = 'any',\n    Ellipse = 'ellipse',\n    Button = 'button',\n    Widget = 'widget',\n    BannerflowLibraryWidget = 'bannerflowLibraryWidget', // Only when bfl-widget is in bl\n    BannerflowLibraryWidgetInstance = 'bannerflowLibraryWidgetInstance', // Only when bfl-widget is on canvas\n}\n\nexport enum NodeKindIcon {\n    Creative = 'creative',\n    Rectangle = 'shape-rectangle',\n    Text = 'text',\n    Video = 'video',\n    Image = 'image',\n    Group = 'group',\n    Selection = 'selection',\n    AnyElement = 'any',\n    Ellipse = 'shape-oval',\n    Button = 'button',\n    Widget = 'widget',\n    BannerflowLibraryWidget = 'widget',\n    BannerflowLibraryWidgetInstance = 'widget'\n}\n\nexport type OneOfViewNodes =\n    IEllipseViewElement |\n    IRectangleViewElement |\n    IButtonViewElement |\n    ITextViewElement |\n    IImageViewElement |\n    IWidgetViewElement |\n    IVideoViewElement |\n    IAnyViewElement;\n\nexport type OneOfSelectableElements =\n    OneOfElementDataNodes |\n    ElementSelection;\n\nexport type OneOfSelectableNodes =\n    OneOfDataNodes |\n    ElementSelection;\n\n// Is this union type needed?\nexport type OneOfGroupViewNodes =\n    IGroupViewElement |\n    ICreativeViewNode;\n\nexport type OneOfGroupDataNodes =\n    IGroupElementDataNode |\n    IRootDataNode;\n\nexport type OneOfTextViewElements =\n    IButtonViewElement |\n    ITextViewElement;\n\nexport type OneOfTextDataNodes =\n    IButtonElementDataNode |\n    ITextElementDataNode;\n\nexport interface ICreativeViewNode extends IChildren, ISVGBackgroundNode<NodeKind.Creative>, ISize {\n}\n\nexport interface NodeWithKind<Kind extends NodeKind> {\n    readonly kind: Kind;\n}\n\nexport interface ISVGBackgroundNode<Kind extends NodeKind = NodeKind> extends ISize, NodeWithKind<Kind> {\n    fill?: IColor;\n    border?: IBorder;\n    shadows?: IShadow[];\n    filters?: IFilterMap;\n    radius?: IRadius;\n    rotationZ?: number;\n    __rootElement?: HTMLDivElement;\n    __svgBackground?: SVGBackground;\n}\n\n/**\n * The view element. I.E computed state of an element at a certain point in time\n * We should probably not explicitly set a nodekind here as that should be taken care of by the caller\n * it is however easier to do it this way since I can't be bothered to change all the places it exists\n */\nexport interface IElementViewNode<Kind extends NodeKind = NodeKind> extends INodeId, IPosition, ISize, ISVGBackgroundNode<Kind>, IBaseViewNode<Kind> {\n    name: string;\n    ratio?: number;\n    originX?: number;\n    originY?: number;\n    rotationX?: number;\n    rotationY?: number;\n    rotationZ?: number;\n    mirrorX?: boolean;\n    mirrorY?: boolean;\n    scaleX?: number;\n    scaleY?: number;\n    opacity?: number;\n    time: number;\n    duration: number;\n    perspective?: number;\n    filter?: IFilter[];\n    feed?: IFeed;\n    elementCid?: string;\n\n    /**\n     * Safari overlaps elements if they do not have their own stacking context.\n     * Only way to create this seems to be to create a parent div with transform: 'translate(0)'.\n     */\n    __safari3dElement?: HTMLDivElement;\n\n    /**\n     * The DOM-element of the element\n     */\n    __rootElement?: HTMLDivElement;\n    __actionListeners?: IActionListener[];\n}\n\nexport type OneOfElementDataNodes =\n    | IRectangleElementDataNode\n    | IEllipseElementDataNode\n    | ITextElementDataNode\n    | IButtonElementDataNode\n    | IImageElementDataNode\n    | IWidgetElementDataNode\n    | IVideoElementDataNode;\n\nexport type OneOfDataNodes =\n    | OneOfElementDataNodes\n    | IGroupElementDataNode;\n\nexport type NodeKindWithChildren = NodeKind.Creative | NodeKind.Group;\n\nexport interface INodeWithChildren<Kind extends NodeKindWithChildren = NodeKindWithChildren> extends NodeWithKind<Kind>, IDataNodeChildren, INodeId {\n    get elements(): OneOfElementDataNodes[];\n    setNodes_m(nodes: OneOfDataNodes[]): void;\n    addNode_m(node: OneOfDataNodes, atIndex?: number): void;\n    removeNodeById_m(nodeId: string): void;\n    findNodeById_m(nodeId: string, includeGroups?: boolean): OneOfDataNodes | undefined;\n    nodeIterator_m(includeGroups?: boolean, group?: INodeWithChildren): IterableIterator<OneOfElementDataNodes | OneOfDataNodes>;\n}\n\nexport interface IGroupElementDataNode extends IBaseDataNode, INodeWithChildren<NodeKind.Group> {\n    /** Calculated based on the child nodes of the group */\n    get time(): number;\n    /** Calculated based on the child nodes of the group */\n    get duration(): number;\n    copy(keepId: boolean): IGroupElementDataNode;\n}\n\n\nexport interface ITimelineNode {\n    node: OneOfDataNodes;\n    isGroup: boolean;\n    collapsed: boolean;\n}\n\n/**\n * Data node. I.E what's actually saved (all states on timeline)\n */\nexport interface IElementDataNode<Kind extends NodeKind = NodeKind> extends IBaseDataNode, NodeWithKind<Kind>, IBounds {\n    ratio?: number;\n    feed?: IFeed;\n    time: number;\n    duration: number;\n\n    // Animatable properties\n    radius: IRadius;\n    mirrorX: boolean;\n    mirrorY: boolean;\n    opacity: number;\n    originX: number;\n    originY: number;\n    rotationX: number;\n    rotationY: number;\n    rotationZ: number;\n\n    // Optional properties\n    fill?: IColor;\n    border?: IBorder;\n    shadows?: IShadow[];\n    filters?: IFilterMap;\n\n    states: IState[];\n    actions: IAction[];\n    animations: IAnimation[];\n\n    __rootNode?: CreativeDataNode;\n}\n\nexport type IInitializationElementNode = { -readonly [P in keyof IElementDataNode]: IElementDataNode[P] };\n\nexport interface ITextDataNode<Kind extends NodeKind = NodeKind> extends IElementDataNode<Kind> {\n    content: IText;\n    __content: IText;\n    textColor: IColor;\n    textShadows?: ITextShadow[];\n    uppercase: boolean;\n    underline: boolean;\n    strikethrough: boolean;\n    horizontalAlignment: HorizontalAlignment;\n    verticalAlignment: VerticalAlignment;\n    lineHeight: number;\n    characterSpacing: number;\n    fontSize?: number;\n    maxRows?: number;\n    padding?: IPadding;\n    textOverflow?: TextOverflow;\n    font?: IFontStyle;\n\n    characterStyles: Map<string, Partial<ICharacterProperties>>;\n    __styleHashMap: Map</* styleHash */string, /* styleId */string>;\n\n    // We have to store the deleted style's ids to refer to them if we happen to create new style\n    // with exact same styles.\n    __deletedStyleHashMap: Map</* styleHash */string, /* styleId */ string>;\n    __fontStyleId?: string;\n    __rootElement?: HTMLDivElement;\n    __backgroundElement?: SVGSVGElement;\n    __centerElement?: HTMLDivElement;\n    __textElement?: HTMLDivElement;\n\n    // We store the dirty content to enable global undo. Pls. check docs char-styles.md.\n    __dirtyContent?: IText;\n}\n\n\nexport interface IRectangleElementDataNode extends IElementDataNode<NodeKind.Rectangle> {}\nexport interface IEllipseElementDataNode extends IElementDataNode<NodeKind.Ellipse> {}\nexport interface ITextElementDataNode extends ITextDataNode<NodeKind.Text> {}\nexport interface IButtonElementDataNode extends ITextDataNode<NodeKind.Button> {}\n\nexport interface IImageElementDataNode extends IElementDataNode<NodeKind.Image> {\n    imageAsset?: IImageAsset;\n    feed?: IFeed;\n    imageSettings: IImageSettings;\n}\n\nexport interface IVideoElementDataNode extends IElementDataNode<NodeKind.Video> {\n    videoSettings: IVideoSettings;\n    videoAsset?: IVideoAsset;\n}\n\nexport type IMediaElementDataNode = IVideoElementDataNode | IImageElementDataNode;\n\nexport interface ITextNode<Kind extends NodeKind = NodeKind> extends ITextElementProperties, ICharacterProperties, IElementViewNode<Kind> {\n    content: IText;\n    horizontalAlignment: HorizontalAlignment;\n    verticalAlignment: VerticalAlignment;\n    maxRows: number;\n    padding: IPadding;\n    textOverflow: TextOverflow;\n    __rootElement?: HTMLDivElement;\n    __centerElement?: HTMLDivElement;\n    __textElement?: HTMLDivElement;\n    __richTextRenderer: RichText;\n    __dirtyContent?: IText;\n}\n\nexport interface ITextViewElement extends ITextNode<NodeKind.Text> {}\n\nexport interface IButtonViewElement extends ITextNode<NodeKind.Button> {}\n\nexport interface IEllipseViewElement extends IElementViewNode<NodeKind.Ellipse> {}\n\nexport interface IRectangleViewElement extends IElementViewNode<NodeKind.Rectangle> {}\n\nexport interface IAnyViewElement extends IElementViewNode<NodeKind.AnyElement> {}\n\nexport interface IImageViewElement extends IElementViewNode<NodeKind.Image> {\n    imageUrl?: string;\n\n    // Should view element have this property?\n    feed?: IFeed;\n}\n\nexport interface IVideoViewElement extends IElementViewNode<NodeKind.Video> {\n    __videoRenderer: IVideoRenderer;\n}\n","import { IColor } from './color';\nimport { ISize } from './dimension';\nimport { IFeed } from './feed';\nimport { IFontStyle } from './font';\nimport { IShadow, IPadding, ITextShadow } from './style';\n\nexport type HorizontalAlignment =\n    'left' |\n    'center' |\n    'right' |\n    'justify';\n\nexport type VerticalAlignment =\n    'top' |\n    'middle' |\n    'bottom';\n\nexport type TextOverflow =\n    'shrink' |\n    'truncate' |\n    'expand' |\n    'scroll';\n\nexport const enum TextNodeKind {\n    Root,\n    TextSpan,\n}\n\nexport const enum SpanType {\n    Word = 'word',\n    Space = 'space',\n    Newline = 'newline',\n    Ellipsis = 'ellipsis',\n    End = 'end',\n    Variable = 'variable',\n    Composition = 'composition', // Used for showing whats being written while composing a text (i.e. writting a Chinese character using Pinyin)\n}\n\nexport const enum RenderedLineKind {\n    AutoLine, // Overflowed line\n    ExplicitLine, // User typed newline\n}\n\nexport interface IContentLine {\n    dir: TextDirection;\n    lineHeight: number;\n    maxFontSize: number;\n    lineWidth: number;\n    // Trailing spaces are trailing character spacing, spaces, newlines\n    trailingSpaceWidth: number;\n    characterWidth: number;\n    endsWithNewline: boolean;\n    isLastLine: boolean;\n    spans: OneOfRenderedSpans[];\n}\n\nexport interface IText {\n    style: ITextProperties & Partial<ISize>;\n    spans: OneOfEditableSpans[];\n}\n\nexport interface ISpans {\n    spans: OneOfEditableSpans[];\n}\n\nexport interface IRenderedSpans {\n    spans: OneOfRenderedSpans[];\n}\n\n\nexport const enum JoinType {\n    None = 0,\n    ZeroWidthNoJoint = '\\u200C',\n    ZeroWidthJoint = '\\u200D',\n}\n\nexport interface ISpan {\n    top: number;\n    left: number;\n    type: SpanType;\n    content: string;\n    width: number;\n    height: number;\n    lineHeight: number;\n    attributes: ISpanAttributes;\n\n    // JoinType are needed in arabic and hindi languages, where a join span can alter the glyph of a character.\n    startJoint?: JoinType;\n    endJoint?: JoinType;\n    __viewElement?: HTMLSpanElement;\n}\n\nexport interface ISpanProperties {\n    attributes?: ISpanAttributes;\n    styleIds?: IStyleIdMap;\n}\n\nexport interface ISpanAttributes {\n    styleIndex?: number;\n    shouldRenderNumber?: boolean;\n    [attribute: string]: any;\n}\n\nexport type StyleProperty =\n    'textColor';\n\nexport interface IStyle {\n    [property: string]: any;\n}\n\nexport type IStyleIdMap = Map</* documentId */string, /* styleId */string>;\n\nexport type ICharacterStylesMap = Map<string, Partial<ICharacterProperties>>;\n\nexport interface IElementIdToCharacterStylesMap {\n    [elementId: string]: ICharacterStylesMap;\n}\n\nexport const enum PreviousStyleIdType {\n    Undefined,\n    Unchanged,\n}\n\n\nexport const enum TextDirection {\n    // Infer from context, if it is first or last it is LTR, otherwise it infers it from the next sibling.\n    InferFromContext = 'infer',\n    // Only for special chars.\n    Previous = 'previous',\n    Ltr = 'ltr',\n    Rtl = 'rtl',\n    Both = 'both',\n}\n\n\nexport type ResolvedTextDirection = TextDirection.Ltr | TextDirection.Rtl;\n\nexport interface IContentSpan {\n    line?: number;\n    column?: number;\n    dir?: TextDirection;\n    style: Partial<ICharacterProperties>;\n    styleIds: IStyleIdMap;\n    styleId?: string;\n\n    // We resolve style changes on edit end. We have to keep track of the style before the text edit\n    // in situations where you clear styles and then reapply a different style, which should be the\n    // same as reapplying the styles directly.\n    __previousStyleIds?: (string | PreviousStyleIdType)[];\n    __previousStyleIdToHistoryIndexMap?: Map<string, number>;\n\n}\n\nexport interface ISpaceSpan extends IContentSpan, ISpan {\n    type: SpanType.Space;\n}\n\nexport interface IWordSpan extends IContentSpan, ISpan {\n    type: SpanType.Word;\n}\n\n\nexport interface ICompositionSpan extends IContentSpan, ISpan {\n    type: SpanType.Composition;\n    width: number;\n}\n\nexport interface IVariableSpan extends IContentSpan, ISpan {\n    type: SpanType.Variable;\n}\n\nexport interface INewlineSpan extends IContentSpan, ISpan {\n    type: SpanType.Newline;\n}\n\nexport interface IEndSpan extends ISpan {\n    type: SpanType.End;\n    dir: TextDirection;\n}\n\nexport interface IEllipsesSpan extends ISpan {\n    type: SpanType.Ellipsis;\n    style: Partial<ICharacterProperties>; // Takes the last span style before truncation\n    dir?: TextDirection;\n}\n\nexport type OneOfContentSpans = IWordSpan | ISpaceSpan | IVariableSpan | INewlineSpan | ICompositionSpan;\nexport type OneOfEditableSpans = OneOfContentSpans | IEndSpan;\nexport type OneOfRenderedSpans = OneOfEditableSpans | IEllipsesSpan;\n\n/**\n * Properties that can be changed by character styling\n */\nexport interface ICharacterProperties {\n    textColor?: IColor;\n    fontSize?: number; /* relative */\n    font?: IFontStyle;\n    uppercase?: boolean;\n    underline?: boolean;\n    strikethrough?: boolean;\n    characterSpacing: number;\n    lineHeight: number;\n    textShadows?: ITextShadow[];\n    variable?: IVariable;\n    __fontFamilyId?: string;\n}\n\nexport type OneOfCharacterProperty = keyof ICharacterProperties;\n\nexport interface ITextElementProperties {\n    horizontalAlignment: HorizontalAlignment;\n    verticalAlignment: VerticalAlignment;\n    maxRows: number;\n    padding: IPadding;\n    textOverflow: TextOverflow;\n}\n\nexport interface IMixedCharacterProperties {\n    textColor?: IColor;\n    fontSize?: number;\n    font?: IFontStyle | '$mixed';\n    uppercase: boolean;\n    underline: boolean;\n    strikethrough: boolean;\n    characterSpacing: number;\n    lineHeight: number;\n    textShadows?: ITextShadow[];\n    variable?: IFeed;\n    __fontFamilyId: string | '$mixed';\n}\n\nexport interface ITextElementCharacterProperties {\n    textColor?: IColor;\n    fontSize?: number;\n    font?: IFontStyle;\n    uppercase?: boolean;\n    underline?: boolean;\n    strikethrough?: boolean;\n    characterSpacing: number;\n    lineHeight: number;\n    textShadows?: ITextShadow[];\n    variable?: IVariable;\n    __fontFamilyId?: string;\n}\n\nexport type ITextProperties = ITextElementProperties & ITextElementCharacterProperties;\n\nexport interface IVariable extends IFeed {\n    spanId?: string;\n}\nexport const VARIABLE_PREFIX = '@';\n\nexport interface ITextStyles {\n    color: IColor;\n    shadows: IShadow[];\n    transform: 'uppercase' | null;\n    decorations: string | null;\n    horizontalAlignment: HorizontalAlignment;\n    verticalAlignment: VerticalAlignment;\n    characterSpacing: number;\n    lineHeight: number;\n    fontSize: number;\n    maxRows?: number;\n    padding: IPadding;\n    textOverflow: TextOverflow;\n    fontStyle: IFontStyle;\n}\n\nexport interface IStyleIndexMaps {\n    styleHashToIndexMap: Map<string, number>;\n    indexToStyleIdsMap: Map<number, Map<string, string>>;\n}\n","export function cloneDeep<T>(value: T): T {\n    return cloneDeepHelper(value, new Map());\n}\n\nfunction cloneDeepHelper(val: any, seen: any): any {\n    switch (Object.prototype.toString.call(val)) {\n        case '[object Array]': {\n            if (seen.has(val)) {\n                return seen.get(val);\n            }\n            const copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach((child, i) => {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case '[object Object]': {\n            if (seen.has(val)) {\n                return seen.get(val);\n            }\n            const copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(key => {\n                if (key !== '__widget') {\n                    copy_2[key] = cloneDeepHelper(val[key], seen);\n                }\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n\nexport function cloneMapDeep<M extends Map<any, any> | undefined>(map?: M): M {\n    if (!map) {\n        return map as M;\n    }\n    const clonedMap = new Map<any, any>() as M;\n    for (const [key, value] of map.entries()) {\n        clonedMap!.set(key, cloneDeep(value));\n    }\n    return clonedMap;\n}\n\nexport function simpleClone<T>(value: T): T {\n    return JSON.parse(JSON.stringify(value));\n}\n","export interface IInjectionParameter<T> {\n    optional: boolean;\n    token: T;\n    forwardRef: boolean;\n}\n\nexport interface IChildContainerInjection {\n    parameterIndex: number;\n    target: new (...args: any[]) => any;\n}\n\nexport interface IInjectionOption {\n    optional?: boolean;\n    forwardRef?: boolean;\n}\n\nexport type ParameterMap<T> = Map<number, IInjectionParameter<T>>;\nexport type ContainerReferenceMap = Set<number>;\nexport type DecorationFactory = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;\n\nconst metadata = new Map<any, Map<string, any>>();\n\nexport function defineMetadata(name: string, value: any, target: any): void {\n    let decorations = metadata.get(target);\n    if (!decorations) {\n        decorations = new Map<string, any>();\n    }\n    decorations.set(name, value);\n    metadata.set(target, decorations);\n}\n\nexport function getOwnMetadata(name: string, target: any, _?: string | symbol): any {\n    const decorations = metadata.get(target);\n    if (!decorations) {\n        return undefined;\n    }\n    return decorations.get(name);\n}\n\n/**\n * USE TOGETHER WITH __inject\n *\n * Inject dependency to a class.\n *\n * @example\n * class RichText {\n *     constructor(@inject(T.RichTextSelection) selection: IRichTextSelection)\n * }\n */\nexport function inject<T>(token: T, option: IInjectionOption = {}): DecorationFactory {\n    return function(target: any, propertyKey: string | symbol, parameterIndex: number): void {\n        const parameterMap: ParameterMap<T> = getOwnMetadata('i', target, propertyKey) || new Map<Symbol, IInjectionParameter<T>>();\n        parameterMap.set(parameterIndex, {\n            token,\n            optional: option.optional ?? false,\n            forwardRef: option.forwardRef ?? false,\n        });\n        defineMetadata('i', parameterMap, target);\n    };\n}\n\n/**\n * Angular remove decorators. So we need this helper decorator.\n * https://github.com/angular/angular-cli/issues/9306\n */\nexport function __inject<T>(token: T, option: IInjectionOption = {}, target: any, propertyKey: string | symbol, parameterIndex: number): void {\n    const parameterMap: ParameterMap<T> = getOwnMetadata('i', target, propertyKey) || new Map<Symbol, IInjectionParameter<T>>();\n    parameterMap.set(parameterIndex, {\n        token,\n        optional: option.optional ?? false,\n        forwardRef: option.forwardRef ?? false,\n    });\n    defineMetadata('i', parameterMap, target);\n}\n\n/**\n * USE TOGETHER WITH __parent\n *\n * Inject parent to a class.\n *\n * @example\n * class RichText {\n *     constructor(@parent() text: IRichText)\n * }\n */\nexport function parent(): DecorationFactory {\n    return function(target: Object, propertyKey: string | symbol, parameterIndex: number): void {\n        defineMetadata('p', parameterIndex, target);\n    };\n}\n\n/**\n * Angular remove decorators. So we need this helper decorator.\n * https://github.com/angular/angular-cli/issues/9306\n */\nexport function __parent(target: any, propertyKey: string | symbol, parameterIndex: number): void {\n    defineMetadata('p', parameterIndex, target);\n}\n\n\nexport function DIContainer(): DecorationFactory {\n    return function(target: any, propertyKey: string | symbol, parameterIndex: number): void {\n        defineMetadata('c', parameterIndex, target);\n    };\n}\n\n/**\n * Angular remove decorators. So we need this helper decorator.\n * https://github.com/angular/angular-cli/issues/9306\n */\nexport function __container(target: any, propertyKey: string | symbol, parameterIndex: number): void {\n    defineMetadata('c', parameterIndex, target);\n}\n","export * from './di.decorators';\nimport { ParameterMap, getOwnMetadata } from './di.decorators';\n\ninterface IConstructorMetadataStore<T> {\n    parameterMap: ParameterMap<T>;\n    parentParameterIndex?: number;\n    containerParameterIndex?: number;\n    target: Function | any;\n}\n\ninterface IParentParameterResolvement {\n    parentParameterIndex?: number;\n    target?: any;\n}\n\ninterface IRecursiveItemResolvment<T extends MetadataType> {\n    item: T extends MetadataType.Metadata ? IConstructorMetadataStore<any> :\n        T extends MetadataType.Factory ? | ((...args: any[]) => any) : object;\n    container: Container<any>;\n}\ninterface IChildWithParent {\n    target: any;\n    parentParameterIndex: number;\n}\n\nconst enum MetadataType {\n    Metadata,\n    Factory,\n    Object,\n    ParentInjection,\n    ContainerRef,\n}\n\nexport class Container<T> {\n    private _constructorMetadataMap = new Map<T | Function, IConstructorMetadataStore<T>>();\n    private _objectMap = new Map<T | Function, any>();\n    private _instanceMap = new Map<T, any>();\n    private _factoryMap = new Map<T | Function, (...args: any[]) => any>();\n\n    constructor(public parent?: Container<T>) { }\n\n    register_m(token: T, target: any): void {\n        const parameterMap = getOwnMetadata('i', target) as ParameterMap<T>;\n        const parentParameterIndex = getOwnMetadata('p', target) as number;\n        const containerParameterIndex = getOwnMetadata('c', target) as number;\n        if (target instanceof Function) {\n            const constructorMetadata = {\n                target,\n                parameterMap,\n                parentParameterIndex,\n                containerParameterIndex,\n            };\n            this._constructorMetadataMap.set(token, constructorMetadata);\n        }\n        else {\n            this._objectMap.set(token, target);\n        }\n    }\n\n    unregister_m(token: T): void {\n        this._constructorMetadataMap.delete(token);\n        this._objectMap.delete(token);\n        this._factoryMap.delete(token);\n    }\n\n    maybeResolve<R>(token: T): R | undefined {\n        const { target } = this._recursivelyResolve(token, true);\n        return target;\n    }\n\n    clear(): void {\n        this._instanceMap.clear();\n    }\n\n    resolve<R>(token: T, isOptional: boolean = false): R {\n        const { target } = this._recursivelyResolve(token, isOptional);\n        if (!target) {\n            throw new Error(`Could not resolve token '${token}'.`);\n        }\n        return target;\n    }\n\n    registerFactory_m<R>(token: T, context: (container: Container<T>) => R): void {\n        this._factoryMap.set(token, context);\n    }\n\n    private _recursivelyResolve(token: T, isOptional: boolean): IParentParameterResolvement {\n        const metadata = this._recursivelyGetMetadata(token, MetadataType.Metadata);\n        const args: any[] = [];\n        if (metadata) {\n            const item = metadata.item;\n            if (typeof item.target === 'function') {\n                const cachedInstance = metadata.container._instanceMap.get(token);\n                if (cachedInstance) {\n                    return { target: cachedInstance, parentParameterIndex: undefined };\n                }\n                const childrenWithParent: IChildWithParent[] = [];\n                if (item.parameterMap) {\n                    for (const [index, parameter] of item.parameterMap.entries()) {\n                        const { target, parentParameterIndex } = this._recursivelyResolve(parameter.token, parameter.optional || isOptional);\n                        if (!target) {\n                            if (!isOptional && !parameter.optional) {\n                                throw new Error(`Could not resolve symbol '${parameter.token}'.`);\n                            }\n                            continue;\n                        }\n                        args[index] = target;\n                        if (parentParameterIndex !== undefined) {\n                            childrenWithParent.push({\n                                target,\n                                parentParameterIndex,\n                            });\n                        }\n                    }\n                }\n                if (item.containerParameterIndex !== undefined) {\n                    args[item.containerParameterIndex] = this;\n                }\n                const instance = new item.target(...args);\n\n                for (const child of childrenWithParent) {\n                    let enumKeyIndex = 0;\n                    for (const key in child.target) {\n                        if (enumKeyIndex === child.parentParameterIndex) {\n                            child.target[key] = instance;\n                        }\n                        enumKeyIndex++;\n                    }\n                }\n                metadata.container._instanceMap.set(token, instance);\n                return { target: instance, parentParameterIndex: item.parentParameterIndex };\n            }\n        }\n        const object = this._recursivelyGetMetadata(token, MetadataType.Object);\n        if (object) {\n            return { target: object.item };\n        }\n        const factory = this._recursivelyGetMetadata(token, MetadataType.Factory);\n        if (factory) {\n            return { target: factory.item(factory.container) };\n        }\n        return { target: undefined };\n    }\n\n    private _recursivelyGetMetadata<M extends MetadataType >(token: T, type: M): IRecursiveItemResolvment<M> | undefined {\n        let container: Container<T> | undefined = this;\n        while (container) {\n            let item: any;\n            switch (type) {\n                case MetadataType.Metadata:\n                    item = container._constructorMetadataMap.get(token);\n                    break;\n                case MetadataType.Object:\n                    item = container._objectMap.get(token);\n                    break;\n                case MetadataType.Factory:\n                    item = container._factoryMap.get(token);\n                    break;\n            }\n            if (item !== undefined) {\n                return { item, container };\n            }\n            container = container.parent;\n        }\n        return undefined;\n    }\n}\n","class BaseError extends Error { }\n\nexport class BadRequestException extends BaseError {\n    statusCode = 400;\n}\n\nexport class NotFoundError extends BaseError {\n    statusCode = 404;\n    id?: number | string;\n}\n\nexport class ForbiddenError extends BaseError {\n    statusCode = 403;\n    constructor(public message: string) {\n        super();\n    }\n}\n\nexport class BadParameterException extends BaseError {\n    statusCode = 422;\n}\n\nexport class UnauthenticatedError extends Error {\n    errorMeta?: IUnauthenticatedErrorMeta; // seems obsolete to pass the window location around. Can just use it if we still need it for the signinRedirect\n    kind = 'autherror';\n\n    constructor(errorMeta?: IUnauthenticatedErrorMeta) {\n        super();\n        this.errorMeta = errorMeta;\n    }\n\n    /**\n     * UnauthenticatedError will be an instanceof \"Error\" in client so this is simply a better typecheck\n     */\n    static isInstanceOf(error: any): error is UnauthenticatedError {\n        return error instanceof UnauthenticatedError || (error instanceof Error && (error as UnauthenticatedError).kind === 'autherror');\n    }\n\n    static isUnauthenticated(error: any = {}): boolean {\n        error = getPrimaryError(error);\n        return UnauthenticatedError.isInstanceOf(error) || error.statusCode === 401 || error.message?.includes('login_required') /* Happens when IDP somehows generates mismatch between user_info.sub and current_sub */;\n    }\n}\n\nclass IUnauthenticatedErrorMeta {\n    locationUri: string;\n}\n\n\n/**\n * Sometimes errors are wrapped, return real error in those cases\n * @param error\n */\nexport function getPrimaryError(error: any): any {\n    if (error) {\n        // Promise rejection, use rejection instead\n        if (error.rejection) {\n            return error.rejection;\n        }\n        // Errors from graphql\n        else if (error.networkError) {\n            return error.networkError;\n        }\n        // Errors from express?\n        else if (error.originalError) {\n            return error.originalError;\n        }\n    }\n    return error || {};\n}\n\n\ninterface ErrorContext {\n    enabled?: boolean;\n    level?: string;\n    contexts?: { [key: string]: any; };\n}\n\nconst defaultErrorContext: ErrorContext = { enabled: true, level: 'error' };\n\nfunction isErrorContext(value: any): value is ErrorContext {\n    return !!(value && value.contexts);\n}\n\nexport function isNativeError(error: any): error is Error {\n    return error instanceof Error;\n}\n\nexport function handleError(message: string, context?: ErrorContext | unknown): void {\n    let errorContext: ErrorContext;\n\n    if (!isErrorContext(context)) {\n        errorContext = { ...defaultErrorContext, ...{ contexts: { context } } };\n    }\n    else {\n        errorContext = { ...defaultErrorContext, ...context };\n    }\n\n    const tracker = (window as any).TrackerService;\n\n    if (errorContext.enabled && tracker) {\n        tracker.captureMessage(message, errorContext.level, errorContext.contexts);\n    }\n\n    if (errorContext.level === 'error') {\n        console.error(message, errorContext.contexts);\n    } else {\n        console.warn(message, errorContext.contexts);\n    }\n}\n","\nexport type Callback = (...args: any[]) => any;\n\ninterface IEventCallbackStore {\n    [event: string]: Callback[];\n}\n\nexport interface IEventEmitter<T extends string = string> {\n    on(event: T, callback: Callback): this;\n    on(event: T, prop: string, callback: Callback): this;\n\n    once(event: T, callback: Callback): this;\n    once(event: T, prop: string, callback: Callback): this;\n\n    off(event: T): this;\n    off(event: T, callback: Callback): this;\n    off(event: T, prop: string, callback: Callback): this;\n\n    emit(event: T, args?: any[]): this;\n    emit(event: T, prop: string, args?: any[]): this;\n\n    clearEvents(): void;\n}\n\nexport class EventEmitter<T extends string> implements IEventEmitter<T> {\n    private _eventCallbacks: IEventCallbackStore = {};\n    private _thisArg = null;\n    protected skipEmission = false;\n\n    on(event: T, callback: Callback): this;\n    on(event: T, prop: string, callback: Callback): this;\n    on(event: T, propOrCallback: string | Callback, callback?: Callback): this;\n    on(event: T, propOrCallback: string | Callback, callback?: Callback): this {\n        if (typeof propOrCallback === 'string') {\n            event = event + ':' + propOrCallback as T;\n        }\n        else {\n            callback = propOrCallback;\n        }\n        if (!this._eventCallbacks[event]) {\n            this._eventCallbacks[event] = [];\n        }\n        if (this._eventCallbacks[event].indexOf(callback!) === -1) {\n            this._eventCallbacks[event].push(callback!);\n        }\n        return this;\n    }\n\n    once(event: T, callback: Callback): this;\n    once(event: T, prop: string, callback: Callback): this;\n    once(event: T, propOrCallback: string | Callback, callback?: Callback): this {\n        if (typeof propOrCallback === 'string') {\n            event = event + ':' + propOrCallback as T;\n        }\n        else {\n            callback = propOrCallback;\n        }\n        const temporary = (args: any[]): void => {\n            if (typeof callback === 'function') {\n                callback.apply(this._thisArg, [args]);\n            }\n            this.off(event, temporary);\n        };\n        this.on(event, temporary);\n        return this;\n    }\n\n    off(event: T, callback: Callback): this;\n    off(event: T, prop: string, callback: Callback): this;\n    off(event: T): this;\n    off(event: T, propOrCallback?: string | Callback, callback?: Callback): this {\n        if (typeof propOrCallback !== 'undefined') {\n            if (typeof propOrCallback === 'string') {\n                event = event + ':' + propOrCallback as T;\n            }\n            else {\n                callback = propOrCallback;\n            }\n        }\n        if (typeof event === 'undefined') {\n            this.clearEvents();\n            return this;\n        }\n        if (!callback) {\n            delete this._eventCallbacks[event];\n            return this;\n        }\n        const callbacks = this._eventCallbacks[event];\n        if (callbacks?.length) {\n            let i = callbacks.length;\n            // Do this way to make sure no index is skipped when reducing size of array\n            while (i-- > 0) {\n                if (callbacks[i] === callback) {\n                    callbacks.splice(i, 1);\n                }\n            }\n        }\n\n        return this;\n    }\n\n    emit(event: T, args?: any[]): this;\n    emit(event: T, prop: string, args?: any[]): this;\n    emit(event: T, propOrArgs?: string | any[], args?: any[]): this {\n        if (this.skipEmission) {\n            return this;\n        }\n        if (typeof propOrArgs === 'string') {\n            event = event + ':' + propOrArgs as T;\n        }\n        else {\n            args = propOrArgs;\n        }\n\n        // Clone array to make sure all events are fired even when reducing size of array (see this.once())\n        const callbacks = this._eventCallbacks[event]?.slice();\n        if (callbacks) {\n            for (const callback of callbacks) {\n                try {\n                    callback.apply(this._thisArg, args || []);\n                } catch (err: unknown) {\n                    console.error('CallbackError: ', err);\n                }\n            }\n        }\n\n        return this;\n    }\n\n    clearEvents(): void {\n        this._eventCallbacks = {};\n    }\n}\n","import { IPosition, IBoundingBox, IBoundingCorners, IBounds, IPointRect, ISize, IScale, IOrigin } from '../domain/dimension';\nimport { clamp, rotatePosition } from './utils';\nimport { Matrix } from './matrix';\n\nexport function getBoundingCorners(boundingBox: IBoundingBox, inset: number = 0, calculateCenter: boolean = false): IBoundingCorners {\n    const { x, y, width, height, rotationZ } = boundingBox;\n\n    const origin: IPosition = { x: x + width / 2, y: y + height / 2 };\n    let topLeft: IPosition = { x: x + inset, y: y + inset };\n    let topRight: IPosition = { x: x + width - inset, y: y + inset };\n    let bottomLeft: IPosition = { x: x + inset, y: y + height - inset };\n    let bottomRight: IPosition = { x: x + width - inset, y: y + height - inset };\n\n    if (typeof rotationZ !== 'undefined') {\n        topLeft = rotatePosition(topLeft, origin, -rotationZ);\n        topRight = rotatePosition(topRight, origin, -rotationZ);\n        bottomLeft = rotatePosition(bottomLeft, origin, -rotationZ);\n        bottomRight = rotatePosition(bottomRight, origin, -rotationZ);\n    }\n\n    const result: IBoundingCorners = {\n        topLeft,\n        topRight,\n        bottomLeft,\n        bottomRight,\n    };\n\n    if (calculateCenter) {\n        result.center = {\n            x: (Math.min(topLeft.x, topRight.x, bottomLeft.x, bottomRight.x) + Math.max(topLeft.x, topRight.x, bottomLeft.x, bottomRight.x)) / 2,\n            y: (Math.min(topLeft.y, topRight.y, bottomLeft.y, bottomRight.y) + Math.max(topLeft.y, topRight.y, bottomLeft.y, bottomRight.y)) / 2,\n        };\n    }\n\n    return result;\n}\n\nexport function getBoundingRectangleOfRotatedBox(boundingBox: IBoundingBox): IBounds {\n    const corners = getBoundingCorners(boundingBox);\n\n    const minX = Math.min(...[corners.topLeft.x, corners.bottomLeft.x, corners.topRight.x, corners.bottomRight.x]);\n    const minY = Math.min(...[corners.topLeft.y, corners.bottomLeft.y, corners.topRight.y, corners.bottomRight.y]);\n    const maxX = Math.max(...[corners.topLeft.x, corners.bottomLeft.x, corners.topRight.x, corners.bottomRight.x]);\n    const maxY = Math.max(...[corners.topLeft.y, corners.bottomLeft.y, corners.topRight.y, corners.bottomRight.y]);\n\n    return {\n        x: minX,\n        y: minY,\n        width: maxX - minX,\n        height: maxY - minY\n    };\n}\n\nexport function withinImageBounds(fitX: number, fitY: number, imageWidth: number, width: number, imageHeight: number, height: number): { fitX: number, fitY: number, percentX: number, percentY: number } {\n    const maxY = Math.round(imageHeight - height);\n    const minY = Math.round(-Math.abs(maxY));\n    const maxX = Math.round(imageWidth - width);\n    const minX = Math.round(-Math.abs(maxX));\n\n    if (fitX > maxX) {\n        fitX = maxX;\n    }\n    if (fitX < minX) {\n        fitX = minX;\n    }\n    if (fitY > maxY) {\n        fitY = maxY;\n    }\n    if (fitY < minY) {\n        fitY = minY;\n    }\n\n    function getPercentage(startpos: number, endpos: number, currentpos: number): number {\n        const posDistance = endpos - startpos;\n        const displacement = currentpos - startpos;\n        return (displacement / posDistance);\n    }\n\n    return { fitX, fitY, percentX: getPercentage(maxX, minX, fitX), percentY: getPercentage(maxY, minY, fitY) };\n}\n\n\nexport function imageScaleFactor(imageWidth: number, boxWidth: number, imageHeight: number, boxHeight: number): { scale: number, width: number, height: number } {\n    const scale = Math.max(boxWidth / imageWidth, boxHeight / imageHeight);\n    const width = imageWidth * scale;\n    const height = imageHeight * scale;\n\n    return { scale, width, height };\n}\n\n/**\n * Get a new IBounds covering all of the IBounds provided\n * @param bounds\n */\nexport function getOuterBounds(...bounds: IBounds[]): IBounds {\n    let left = Infinity;\n    let top = Infinity;\n    let right = -Infinity;\n    let bottom = -Infinity;\n\n    for (const b of bounds) {\n        left = Math.min(b.x, left);\n        top = Math.min(b.y, top);\n        right = Math.max(b.x + b.width, right);\n        bottom = Math.max(b.y + b.height, bottom);\n    }\n    return {\n        x: left,\n        y: top,\n        width: right - left,\n        height: bottom - top,\n    };\n}\n\nexport function getBoundsOfScaledRectangle(rect: IBoundingBox & IScale & IOrigin): IBoundingBox {\n\n    const originX = 'originX' in rect && rect.originX !== undefined ? rect.originX : 0.5;\n    const originY = 'originY' in rect && rect.originY !== undefined ? rect.originY : 0.5;\n    const scaleX = rect?.scaleX !== undefined ? Math.abs(rect.scaleX) : 1;\n    const scaleY = rect?.scaleY !== undefined ? Math.abs(rect.scaleY) : 1;\n\n    return {\n        x: rect.x - rect.width * (scaleX - 1) * originX,\n        y: rect.y - rect.height * (scaleY - 1) * originY,\n        width: rect.width * scaleX,\n        height: rect.height * scaleY,\n        rotationZ: rect.rotationZ\n    };\n}\n\nconst compareSize = (a: ISize, b: ISize): boolean => a.width === b.width && a.height === b.height;\n\nconst comparePosition = (a: IPosition, b: IPosition): boolean => a.x === b.x && a.y === b.y;\n\nconst compareRotation = (a: IBoundingBox, b: IBoundingBox): boolean => a.rotationZ === b.rotationZ;\n\n/**\n * Check if all boxes provided have the same size, position and rotation as the first box\n * @param comparativeBox a box object that should be compared with\n * @param boxes the boxes that should be compared with the comparativeBox\n */\nexport function isSameBoundsAndRotation(comparativeBox: IBoundingBox, ...boxes: IBoundingBox[]): boolean {\n    return boxes.every(box =>\n        compareSize(comparativeBox, box) &&\n        comparePosition(comparativeBox, box) &&\n        compareRotation(comparativeBox, box)\n    );\n}\n/**\n * Check if all bounds provided have the same size and position as the first bounds\n * @param comparativeBound a bound object that should be compared with\n * @param bounds the bounds that should be compared with the comparativeBound\n */\nexport function isSameBounds(comparativeBound: IBounds, ...bounds: IBounds[]): boolean {\n    return bounds.every(bound =>\n        compareSize(comparativeBound, bound) &&\n        comparePosition(comparativeBound, bound)\n    );\n}\n\nexport function isSameSize(comparativeSize: ISize, ...sizes: ISize[]): boolean {\n    return sizes.every(size => compareSize(comparativeSize, size));\n}\n\nexport function isSamePosition(comparativePosition: IPosition, ...positions: IPosition[]): boolean {\n    return positions.every(position => comparePosition(comparativePosition, position));\n}\n\n/**\n * Get distance between two points as a vector (x, y).\n * @param from\n * @param to\n * @param absolute\n */\nexport function distance2D(from: IPosition, to: IPosition, absolute?: boolean): IPosition {\n    const abs = absolute\n        ? Math.abs\n        : (n: number): number => n;\n\n    return {\n        x: abs(to.x - from.x),\n        y: abs(to.y - from.y)\n    };\n}\n\n/**\n * Cypress and old browsers doesn't support event.x so fallback on clientX\n */\nexport function eventToPosition(event: MouseEvent): IPosition {\n    return {\n        x: typeof event.x === 'number' ? event.x : event.clientX,\n        y: typeof event.y === 'number' ? event.y : event.clientY,\n    };\n}\n\n/**\n * Get the diagonal by using pythagoras.\n * @param width\n * @param height\n */\nexport function diagonal(width: number, height: number): number {\n    return Math.sqrt(Math.pow(width, 2) + Math.pow(height, 2));\n}\n\n/**\n * Get distance between two points as a positive number\n * @param from\n * @param to\n */\nexport function distance(from: IPosition, to: IPosition): number {\n    const dist = distance2D(from, to);\n    return diagonal(dist.x, dist.y);\n}\n\nexport function normalizeAngleDegrees(degrees: number): number {\n    degrees = (degrees % 360 + 360) % 360;\n\n    // force into the minimum absolute value residue class, so that -180 < angle <= 180\n    if (degrees > 180) {\n\n        degrees -= 360;\n    }\n    return degrees;\n}\n\nexport function getCenter(bounds: ISize | IBounds): IPosition {\n\n    const box = sizeToBounds(bounds) as IBounds;\n\n    return {\n        x: box.x + box.width / 2,\n        y: box.y + box.height / 2,\n    };\n}\n\n/**\n * Angle between positions in radians\n * @param from\n * @param to\n */\nexport function pointsToAngle(from: IPosition, to: IPosition): number {\n    return Math.atan2(to.y - from.y, to.x - from.x);\n}\n\n/**\n * Get the intersecting rectangle of two rectangles\n * @param r1\n * @param r2\n */\nexport function getIntersectingRectangle(rect1: IBounds | ISize, rect2: IBounds | ISize): IBounds | undefined {\n\n\n    const r1 = boundsToPointRect(sizeToBounds(rect1));\n    const r2 = boundsToPointRect(sizeToBounds(rect2));\n\n    const noIntersect = r2.x1 > r1.x2 || r2.x2 < r1.x1 ||\n        r2.y1 > r1.y2 || r2.y2 < r1.y1;\n\n    return noIntersect ? undefined : pointRectToBounds({\n        x1: Math.max(r1.x1, r2.x1), // _[0] is the lesser,\n        y1: Math.max(r1.y1, r2.y1), // _[1] is the greater\n        x2: Math.min(r1.x2, r2.x2),\n        y2: Math.min(r1.y2, r2.y2)\n    });\n}\n\nexport function coversHorizontally(element: IBounds | ISize, container: IBounds | ISize, tolerance: number = 1): boolean {\n    const intersection = getIntersectingRectangle(element, container);\n    return !!intersection && Math.abs(intersection.width - container.width) <= tolerance * 2 && intersection.x <= tolerance;\n}\n\nexport function coversVertically(element: IBounds | ISize, container: IBounds | ISize, tolerance: number = 1): boolean {\n    const intersection = getIntersectingRectangle(element, container);\n    return !!intersection && Math.abs(intersection.height - container.height) <= tolerance * 2 && intersection.y <= tolerance;\n}\n\n/**\n * How much much of an element covers the container (from 0 to 1)\n * @param element\n * @param container\n */\nexport function intersectionFactor(element: IBounds | ISize, container: IBounds | ISize): number {\n    const elementBounds = sizeToBounds(element);\n    const containerBounds = sizeToBounds(container);\n    const intersectionRect = getIntersectingRectangle(elementBounds, containerBounds);\n    if (intersectionRect) {\n        return areaRelation(intersectionRect, element);\n    }\n    return 0;\n}\n\nexport function sizeToBounds(size: IBounds | ISize): IBounds {\n    return {\n        x: 0,\n        y: 0,\n        ...size\n    };\n}\n\n/**\n * Get relation between area of two object. >1 means that the first object is bigger\n * @param size\n * @param reference\n */\nexport function areaRelation(size: ISize, reference: ISize): number {\n    return (size.width * size.height) / (reference.width * reference.height);\n}\n\nexport function isHorizontallyCentered(element: IBounds, container: IBounds, tolerance: number = 0.5): boolean {\n    return Math.abs((element.x + element.width / 2) - (container.x + container.width / 2)) <= tolerance;\n}\n\nexport function isVerticallyCentered(element: IBounds, container: IBounds, tolerance: number = 0.5): boolean {\n    return Math.abs((element.y + element.height / 2) - (container.y + container.height / 2)) <= tolerance;\n}\n\n\nexport function boundsToPointRect(bounds: IBounds): IPointRect {\n    return {\n        x1: bounds.x,\n        y1: bounds.y,\n        x2: bounds.x + bounds.width,\n        y2: bounds.y + bounds.height\n    };\n}\n\nexport function pointRectToBounds(rect: IPointRect): IBounds {\n    return {\n        x: Math.min(rect.x1, rect.x2),\n        y: Math.min(rect.y1, rect.y2),\n        width: Math.abs(rect.x1 - rect.x2),\n        height: Math.abs(rect.y1 - rect.y2),\n    };\n}\n\nexport function scaleRectWithinBounds(element: IBoundingBox, bounds: IBounds): IBoundingBox {\n    if (!element.rotationZ) {\n        return { ...bounds };\n    }\n\n    const originalRotatedBoundingBox = getBoundingRectangleOfRotatedBox(element);\n\n    const scaleX = bounds.width / originalRotatedBoundingBox.width;\n    const scaleY = bounds.height / originalRotatedBoundingBox.height;\n    const center = getCenter(bounds);\n    const matrix = new Matrix();\n\n    // 1. Move the 1x1 \"pixel\" to the center of new bounding box\n    matrix.translate_m(center.x, center.y);\n    // 2. Set width and height to the original element size\n    matrix.scale_m(element.width, element.height);\n    // 3. Rotate original\n    matrix.rotateZ_m(element.rotationZ);\n    // 4. Scale rotated element to the size of new bounding box\n    matrix.scale_m(scaleX, scaleY);\n    // 5. Rotate back to get the right x & y\n    matrix.rotateZ_m(-element.rotationZ);\n\n    // TODO: Also return skew to be fully accurate\n    return {\n        x: matrix.getTranslateX_m() - matrix.getScaleX_m() / 2,\n        y: matrix.getTranslateY_m() - matrix.getScaleY_m() / 2,\n        width: matrix.getScaleX_m(),\n        height: matrix.getScaleY_m(),\n        rotationZ: element.rotationZ\n    };\n}\n\nexport function aspectRatioScale(element: ISize | IBounds, bounds: ISize | IBounds, fit: 'cover' | 'contain' = 'contain', rounding?: NumberRoundingFn): IBounds {\n    const scaleFn = fit === 'cover' ? Math.max : Math.min;\n    const roundFn = getRoundingFn(rounding);\n    const scale = scaleFn(bounds.width / element.width, bounds.height / element.height);\n    const width = roundFn(element.width * scale);\n    const height = roundFn(element.height * scale);\n\n    // Return with centered position\n    return alignWithinBounds({ width, height }, bounds, 'center', 'center', rounding);\n}\n\nexport function alignWithinBounds(element: ISize, bounds: ISize | IBounds, horizontalAlign: HorizontalAlign = 'center', verticalAlign: VerticalAlign = 'center', rounding?: NumberRoundingFn): IBounds {\n    const roundFn = getRoundingFn(rounding);\n    const x = roundFn(alignHorizontallyWithinBounds(element.width, bounds, horizontalAlign));\n    const y = roundFn(alignVerticallyWithinBounds(element.height, bounds, verticalAlign));\n    return { x, y, width: element.width, height: element.height };\n}\n\nexport function alignHorizontallyWithinBounds(width: number, bounds: { x?: number, width: number }, horizontalAlign: HorizontalAlign = 'center'): number {\n\n    const alignX = alignToNumber(horizontalAlign);\n    return (bounds.x || 0) - (width - bounds.width) * alignX;\n}\n\nexport function alignVerticallyWithinBounds(height: number, bounds: { y?: number, height: number }, verticalAlign: VerticalAlign = 'center'): number {\n    const alignY = alignToNumber(verticalAlign);\n    return (bounds.y || 0) - (height - bounds.height) * alignY;\n}\n\nexport function roundBounds(bounds: IBounds, rounding: NumberRoundingFn = 'round'): IBounds {\n    return {\n        ...bounds,\n        ...roundPosition(bounds, rounding),\n        ...roundSize(bounds, rounding),\n    };\n}\n\nexport function roundSize(bounds: ISize, rounding: NumberRoundingFn = 'round'): ISize {\n    const roundFn = getRoundingFn(rounding);\n    const { width, height } = bounds;\n    return {\n        width: typeof width === 'number' ? roundFn(width) : width,\n        height: typeof height === 'number' ? roundFn(height) : height\n    };\n}\n\nexport function roundPosition(bounds: IPosition, rounding: NumberRoundingFn = 'round'): IPosition {\n    const roundFn = getRoundingFn(rounding);\n    const { x, y } = bounds;\n    return {\n        x: typeof x === 'number' ? roundFn(x) : x,\n        y: typeof y === 'number' ? roundFn(y) : y,\n    };\n}\n\nfunction getRoundingFn(rounding?: NumberRoundingFn): (num: number) => number {\n    return rounding && rounding !== 'none'\n        ? Math[rounding]\n        : (num: number): number => num;\n}\n\n/**\n * Converts an alignment to a number between 0 and 1\n * @param align\n */\nexport function alignToNumber(align: HorizontalAlign | VerticalAlign): number {\n    if (typeof align === 'number') {\n        return clamp(align, 0, 1);\n    }\n    switch (align) {\n        case 'center':\n            return 0.5;\n        case 'left':\n        case 'top':\n            return 0;\n        case 'right':\n        case 'bottom':\n            return 1;\n    }\n    throw new Error(`Could not convert align '${align}' to number`);\n}\n\nexport function getRatio(width: number, height: number): number {\n    if (width === 0 && height === 0) {\n        return 1;\n    }\n    if (height === 0) {\n        return Number.MAX_VALUE;\n    }\n    return width / height;\n}\n\nexport function getBoundingboxWithinBoundary(\n    box: ISize,\n    maxBoundaries: ISize,\n    position?: IPosition\n): IBoundingBox {\n    let ratio = 1;\n    if (box.width > maxBoundaries.width) {\n        ratio = getRatio(maxBoundaries.width, box.width);\n    }\n\n    if ((box.height * ratio) > maxBoundaries.height) {\n        ratio = getRatio(maxBoundaries.height, box.height);\n    }\n\n    const width = box.width * ratio;\n    const height = box.height * ratio;\n    const centerX = width / 2;\n    const centerY = height / 2;\n    const centerBoundaryX = maxBoundaries.width / 2;\n    const centerBoundaryY = maxBoundaries.height / 2;\n\n    const x = position\n        ? position.x - centerX\n        : centerBoundaryX - width / 2;\n\n    const y = position\n        ? position.y - centerY\n        : centerBoundaryY - height / 2;\n\n    return {\n        x,\n        y,\n        width,\n        height,\n    };\n}\n\nexport function getAspectRatio(width: number, height: number): string {\n    function gcd(a: number, b: number): number {\n        return (b === 0) ? a : gcd(b, a % b);\n    }\n    const r = gcd(width, height);\n    const w = width / r;\n    const h = height / r;\n    return `${w}:${h}`;\n}\n\nexport type HorizontalAlign = 'left' | 'center' | 'right' | number;\nexport type VerticalAlign = 'top' | 'center' | 'bottom' | number;\ntype NumberRoundingFn = 'ceil' | 'floor' | 'round' | 'none';\n","\nexport const IdentityMatrix = [\n    1, 0, 0, 0,\n    0, 1, 0, 0,\n    0, 0, 1, 0,\n    0, 0, 0, 1\n];\n\n/**\n * Class to mimic the behaviour of transform and output a matrix3d\n * Useful resources on understanding matrix3d:\n * https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Matrix_math_for_the_web\n * https://dev.opera.com/articles/understanding-the-css-transforms-matrix/\n * https://github.com/jlmakes/rematrix\n * https://drafts.csswg.org/css-transforms-2/#decomposing-a-3d-matrix\n * https://www.senocular.com/flash/tutorials/transformmatrix/\n */\n\nconst cos = Math.cos;\nconst sin = Math.sin;\nconst tan = Math.tan;\nconst sqrt = Math.sqrt;\nconst pow = Math.pow;\n\nexport class Matrix {\n\n    private _matrix: number[];\n\n    constructor(matrix?: string) {\n        if (matrix) {\n            this.parse_m(matrix);\n        }\n        else {\n            // Set default matrix\n            this._matrix = this._getIdentityMatrix();\n        }\n    }\n\n    parse_m(matrixString: string): Matrix {\n        const c = matrixString.split(/\\s*[(),]\\s*/).slice(1, -1);\n\n        if (c.length === 6) {\n            // 'matrix()' (3x2)\n            this._matrix = [\n                +c[0], +c[2],    0,  +c[4],\n                +c[1], +c[3],    0,  +c[5],\n                    0,     0,    1,     0,\n                    0,     0,    0,     1\n            ];\n        }\n        // matrix3d() (4x4)\n        else if (c.length === 16) {\n            this._matrix = [\n                +c[0], +c[4], +c[8],  +c[12],\n                +c[1], +c[5], +c[9],  +c[13],\n                +c[2], +c[6], +c[10], +c[14],\n                +c[3], +c[7], +c[11], +c[15]\n            ];\n        }\n        // handle 'none' or invalid values.\n        else {\n            this._getIdentityMatrix();\n        }\n        return this;\n    }\n\n    /**\n     * Get matrix as a CSS-transform\n     */\n    toCSS_m(): string {\n        return `matrix3d(${this._matrix.join(',')})`;\n    }\n\n    /**\n     * Multiply current matrix with another matrix\n     * @param factorMatrix\n     */\n    multiply_m(factorMatrix: number[]): Matrix {\n        this._matrix = this._multiplyMatrices(this._matrix, factorMatrix);\n\n        return this;\n    }\n\n    /**\n     * Rotate on the x,y and z axis. Values are in radians.\n     * @param x\n     * @param y\n     * @param z\n     * @returns\n     */\n    rotate_m(x: number = 0, y: number = 0, z: number = 0): Matrix {\n        const sinX = sin(x);\n        const cosX = cos(x);\n        const sinY = sin(y);\n        const cosY = cos(y);\n        const sinZ = sin(z);\n        const cosZ = cos(z);\n\n        const rotationMatrixX = [\n            1,        0,         0,     0,\n            0,     cosX,     -sinX,     0,\n            0,     sinX,      cosX,     0,\n            0,        0,         0,     1\n        ];\n\n        const rotationMatrixY = [\n            cosY,   0,  sinY,   0,\n               0,   1,     0,   0,\n           -sinY,   0,  cosY,   0,\n               0,   0,     0,   1\n       ];\n\n       const rotationMatrixZ = [\n             cosZ,  sinZ,    0,    0,\n            -sinZ,  cosZ,    0,    0,\n                0,     0,    1,    0,\n                0,     0,    0,    1\n        ];\n\n        const m = this._multiplyMatrices(this._multiplyMatrices(rotationMatrixX, rotationMatrixY), rotationMatrixZ);\n\n        return this.multiply_m(m);\n    }\n\n    /**\n     * Rotate around the x axis.\n     * @param radians\n     * @returns\n     */\n    rotateX_m(radians: number): Matrix {\n        const s = sin(radians);\n        const c = cos(radians);\n\n        return this.multiply_m([\n            1,       0,        0,     0,\n            0,     c,     -s,     0,\n            0,     s,      c,     0,\n            0,       0,        0,     1\n        ]);\n    }\n\n    /**\n     * Rotate around the y axis\n     * @param radians\n     * @returns\n     */\n    rotateY_m(radians: number): Matrix {\n        const s = sin(radians);\n        const c = cos(radians);\n\n        return this.multiply_m([\n             c,   0,  s,   0,\n               0,   1,    0,   0,\n            -s,   0,  c,   0,\n               0,   0,    0,   1\n        ]);\n    }\n\n    /**\n     * Rotate around the z axis\n     * @param radians\n     * @returns\n     */\n    rotateZ_m(radians: number): Matrix {\n        const s = sin(radians);\n        const c = cos(radians);\n\n        return this.multiply_m([\n             c,  s,    0,    0,\n             -s,  c,    0,    0,\n               0,    0,    1,    0,\n               0,    0,    0,    1\n        ]);\n    }\n\n    skew_m(x: number, y: number): Matrix {\n        const tanX = tan(x);\n        const tanY = tan(y);\n\n        return this.multiply_m([\n            1,  tanX,   0,   0,\n         tanY,    1,   0,   0,\n            0,    0,   1,   0,\n            0,    0,   0,   1\n        ]);\n    }\n\n    translate_m(x: number, y: number, z: number = 0): Matrix {\n        return this.multiply_m([\n            1,    0,    0,   0,\n            0,    1,    0,   0,\n            0,    0,    1,   0,\n            x,    y,    z,   1\n        ]);\n    }\n\n    scale_m(x: number = 1, y: number = 1, z: number = 1): Matrix {\n        return this.multiply_m([\n            x,    0,    0,   0,\n            0,    y,    0,   0,\n            0,    0,    z,   0,\n            0,    0,    0,   1\n        ]);\n    }\n\n    getTranslateX_m(): number {\n        return this._getValue(1, 4);\n    }\n    getTranslateY_m(): number {\n        return this._getValue(2, 4);\n    }\n\n    /**\n     *\n     */\n    getTranslateZ_m(): number {\n        return this._getValue(3, 4);\n    }\n\n    getScaleX_m(): number {\n        return this._getVectorLength(this._getValue(1, 1), this._getValue(1, 2), this._getValue(1, 3));\n    }\n    getScaleY_m(): number {\n        return this._getVectorLength(this._getValue(2, 1), this._getValue(2, 2), this._getValue(2, 3));\n    }\n\n    perspective_m(distance: number): Matrix {\n        const matrix = this._getIdentityMatrix();\n        matrix[11] = -1 / distance;\n        return this.multiply_m(matrix);\n    }\n\n    isMirrorX_m(): boolean {\n        return this._getValue(1, 1) < 0;\n    }\n\n    isMirrorY_m(): boolean {\n        return this._getValue(2, 2) < 0;\n    }\n\n    // TODO: Skew\n    // getSkewX(): number {\n    //     return -atan2(this.getValue(1, 2), this.getValue(1, 1));\n\n\n    //     // var my_matrix = my_mc.transform.matrix;\n\n    //     // var px = new flash.geom.Point(0, 1);\n    //     // px = my_matrix.deltaTransformPoint(px);\n    //     // var py = new flash.geom.Point(1, 0);\n    //     // py = my_matrix.deltaTransformPoint(py);\n\n    //     // return -atan2(this.getValue(1, 2), this.getValue(1, 1));\n\n    //     // trace(\"x skew: \" +((180/PI) * atan2(px.y, px.x) - 90));\n    //     // trace(\"y skew: \" +((180/PI) * atan2(py.y, py.x)));\n    // }\n\n    // getSkewY(): number {\n\n\n    //     // return -atan2(this.getValue(1, 1), this.getValue(1, 2));\n\n\n    //     // var my_matrix = my_mc.transform.matrix;\n\n    //     // var px = new flash.geom.Point(0, 1);\n    //     // px = my_matrix.deltaTransformPoint(px);\n    //     // var py = new flash.geom.Point(1, 0);\n    //     // py = my_matrix.deltaTransformPoint(py);\n\n    //     // return -atan2(this.getValue(1, 2), this.getValue(1, 1));\n\n    //     // trace(\"x skew: \" +((180/PI) * atan2(px.y, px.x) - 90));\n    //     // trace(\"y skew: \" +((180/PI) * atan2(py.y, py.x)));\n    // }\n\n    // toFormattedString(matrix: number[] = this.matrix): string {\n    //     let str = '';\n    //     matrix.forEach((num, index) => {\n    //         if (index > 0) {\n    //             str += index % 4 === 0 ? '\\n' : '\\t';\n    //         }\n    //         str += `${ num.toFixed(2) },`;\n    //     });\n    //     return str;\n    // }\n\n    // print(matrix: number[] = this.matrix): void {\n    //     console.log(this.toFormattedString(matrix));\n    // }\n\n    private _multiplyMatrixAndPoint(matrix: number[], point: number[]): number[] {\n\n        // Give a simple variable name to each part of the matrix, a column and row number\n        const c0r0 = matrix[0];\n        const c1r0 = matrix[1];\n        const c2r0 = matrix[2];\n        const c3r0 = matrix[3];\n\n        const c0r1 = matrix[4];\n        const c1r1 = matrix[5];\n        const c2r1 = matrix[6];\n        const c3r1 = matrix[7];\n\n        const c0r2 = matrix[8];\n        const c1r2 = matrix[9];\n        const c2r2 = matrix[10];\n        const c3r2 = matrix[11];\n\n        const c0r3 = matrix[12];\n        const c1r3 = matrix[13];\n        const c2r3 = matrix[14];\n        const c3r3 = matrix[15];\n\n        // Now set some simple names for the point\n        const x = point[0] || 0;\n        const y = point[1] || 0;\n        const z = point[2] || 0;\n        const w = point[3] || 0;\n\n        // Multiply the point against each part of the 1st column, then add together\n        const resultX = (x * c0r0) + (y * c0r1) + (z * c0r2) + (w * c0r3);\n\n        // Multiply the point against each part of the 2nd column, then add together\n        const resultY = (x * c1r0) + (y * c1r1) + (z * c1r2) + (w * c1r3);\n\n        // Multiply the point against each part of the 3rd column, then add together\n        const resultZ = (x * c2r0) + (y * c2r1) + (z * c2r2) + (w * c2r3);\n\n        // Multiply the point against each part of the 4th column, then add together\n        const resultW = (x * c3r0) + (y * c3r1) + (z * c3r2) + (w * c3r3);\n\n        return [resultX, resultY, resultZ, resultW];\n    }\n\n    private _multiplyMatrices(matrixA: number[], matrixB: number[]): number[] {\n\n        // A faster implementation of this function would not create\n        // any new arrays. This creates arrays for code clarity.\n\n        // Slice the second matrix up into rows\n        const row0 = [matrixB[0], matrixB[1], matrixB[2], matrixB[3]];\n        const row1 = [matrixB[4], matrixB[5], matrixB[6], matrixB[7]];\n        const row2 = [matrixB[8], matrixB[9], matrixB[10], matrixB[11]];\n        const row3 = [matrixB[12], matrixB[13], matrixB[14], matrixB[15]];\n\n        // Multiply each row by the matrix\n        const result0 = this._multiplyMatrixAndPoint( matrixA, row0 );\n        const result1 = this._multiplyMatrixAndPoint( matrixA, row1 );\n        const result2 = this._multiplyMatrixAndPoint( matrixA, row2 );\n        const result3 = this._multiplyMatrixAndPoint( matrixA, row3 );\n\n        // Turn the results back into a single matrix\n        return [\n            result0[0], result0[1], result0[2], result0[3],\n            result1[0], result1[1], result1[2], result1[3],\n            result2[0], result2[1], result2[2], result2[3],\n            result3[0], result3[1], result3[2], result3[3],\n        ];\n    }\n\n    private _getValue(col: number, row: number): number {\n        return this._matrix[(row - 1) * 4 + (col - 1)];\n    }\n\n    private _getIdentityMatrix(): number[] {\n        return IdentityMatrix.slice();\n    }\n\n    private _getVectorLength(x: number, y: number, z: number): number {\n        return sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2));\n    }\n}\n\n","import { sanitizeUrl } from './sanitizer';\n\nexport function loadImagePromise(url: string): PromiseResolver<HTMLImageElement> {\n    return loadHtmlElement(new Image(), url);\n}\n\nexport function loadHtmlElement<T extends HTMLIFrameElement | HTMLImageElement | HTMLScriptElement>(element: T, url?: string): PromiseResolver<T> {\n    url = url && sanitizeUrl(url);\n    const resolver = new PromiseResolver<T>();\n    element.onload = (): void => {\n        resolver.resolve(element);\n    };\n    element.onerror = (e): void => {\n        resolver.reject(e);\n    };\n    if (typeof url === 'string') {\n        element.src = url;\n    }\n    return resolver;\n}\n\nexport function eventToPromise(element: HTMLElement, eventName: string): Promise<Event> {\n\n    const resolver = new PromiseResolver<Event>();\n    const options: AddEventListenerOptions = { once: true };\n\n    element.addEventListener(eventName, resolver.resolve, options);\n    return resolver.promise;\n}\n\nexport class PromiseResolver<T = void> {\n    resolve: (value: T | PromiseLike<T>) => void;\n    reject: any;\n    promise: Promise<T>;\n\n    constructor() {\n        this.promise = new Promise<T>((res, rej) => {\n            this.resolve = res;\n            this.reject = rej;\n        });\n    }\n}\n\nexport function requestAnimationFramePromise(): Promise<number> {\n    return new Promise<number>((resolve) => {\n        requestAnimationFrame((time: number) => {\n            resolve(time);\n        });\n    });\n}\n\nexport function sleep(milliseconds: number = 0): Promise<void> {\n    return new Promise((resolve) => {\n        setTimeout(resolve, milliseconds);\n    });\n}\n\n\n/**\n * Skip a number of animation frames.\n * 1 means that you skip the first and resolves on the second frame\n * @param frameToSkip\n */\nexport async function skipAnimationFrames(frameToSkip: number = 1): Promise<void> {\n    for (let i = 0; i < frameToSkip + 1; i++) {\n        await requestAnimationFramePromise();\n    }\n}\n","import { loadHtmlElement } from './promises';\nimport { getCookie } from './utils';\n\nlet iframe: HTMLIFrameElement | undefined;\nlet iframePromise: Promise<HTMLIFrameElement>;\n\ntype EvalWindow = Window & {\n    context: IEvalWindowContext,\n    evalMathExpression: Function\n};\n\ninterface IEvalWindowContext {\n    sin: (x: number) => number;\n    cos: (x: number) => number;\n    pi: number;\n    PI: number;\n    abs: (x: number) => number;\n    round: (x: number) => number;\n    ceil: (x: number) => number;\n    floor: (x: number) => number;\n    pow: (x: number, p: number) => number;\n    sqrt: (x: number) => number;\n    random: () => number;\n}\n\n// Always include math operations\nconst defaultContext: IEvalWindowContext = {\n    sin: Math.sin,\n    cos: Math.cos,\n    pi: Math.PI,\n    PI: Math.PI,\n    abs: Math.abs,\n    round: Math.round,\n    ceil: Math.ceil,\n    floor: Math.floor,\n    pow: Math.pow,\n    sqrt: Math.sqrt,\n    random: Math.random,\n};\n\nlet isSandboxed = false; // Checks whether in sandboxed(i.e <iframe sandbox>) environment\n// Needs to be string evaluated to get around 'use strict' restriction, because we have to use with-statements.\n/** Assign values in try-catch.\n * `context` is something not defined and throws error in strict mode\n * so we need to reassign the value to a hoisted variable then */\nconst evalMathExpressionFunctionBody = `\n    try {\n        context.eval = eval;\n        context.code = code;\n    } catch(e) {\n        var context = window.context || {};\n        context.eval = eval;\n        context.code = code;\n    }\n    const scopeProxy = new Proxy(context, {\n        has(prop) { return !(prop in context) },\n        get(target, prop) {\n            if (prop in target) {\n                return target[prop];\n            }\n            if (!(typeof prop === 'symbol')) {\n                throw new Error(\\`Unexpected token '\\${prop.toString()\\}'.\\`);\n            }\n        }\n    });\n    with (scopeProxy) {\n        return eval(code);\n    }`;\n\nconst evalMathExpression = new Function('code', evalMathExpressionFunctionBody);\nexport class SafeEval {\n\n    static eval(code: string, context: any = {}): number {\n        if (!iframe) {\n            SafeEval.init();\n        }\n\n        if (isSandboxed) {\n            (window as any).context = { ...defaultContext, ...context };\n            return evalMathExpression(code);\n        }\n\n        // Doesn't exist on when \"isSandboxed\"\n        const contentWindow = iframe?.contentWindow as EvalWindow | undefined | null;\n        const iframeEvalMathExpression = iframe?.contentDocument && contentWindow?.evalMathExpression;\n\n        if (!iframeEvalMathExpression || !contentWindow) {\n            throw new Error('Safe eval iframe is not initiated.');\n        }\n\n        contentWindow.context = { ...defaultContext, ...context };\n        return iframeEvalMathExpression(code);\n    }\n\n    /**\n     * @summary\n     * Initialize safe eval function for evaluating animation expressions.\n     *\n     * @description\n     * This function will determine whether to use a stricter iframe sandboxed approach.\n     * The stricter approach is mainly for safe-gaurding access to global state in the Studio client,\n     * but it's used whenever it can, even in published ads. The \"looser\" approach is used only when\n     * we are in a sandboxed(i.e. <iframe sandbox>) environment.\n     *\n     * Note, an iframe is needed because '({}).constructor === Object' and you can from there access\n     * all global state. An iframe creates a copy of all global objects including '({}).constructor'\n     * that is different from Studio client's. Thus, safe-guarding us from acessing Studio client's\n     * global state.\n     *\n     * Note, all published creatives will either be wrapped in an iframe or not. When they are\n     * wrapped in an iframe, they are safe. Published ads served through sandboxed iframes prohibits\n     * us from creating additional iframes. We don't need the iframe or use the stricter approach,\n     * since we already are inside an iframe.\n     */\n    static async init(isSandboxedIframe?: boolean): Promise<HTMLIFrameElement | void> {\n\n        if (iframePromise) {\n            return iframePromise;\n        }\n\n        if (!iframe && typeof window !== 'undefined') {\n            iframe = document.createElement('iframe');\n            const style = iframe.style;\n            style.position = 'absolute';\n            style.pointerEvents = 'none';\n            style.width = style.height = style.opacity = style.top = style.left = '0';\n            iframePromise = loadHtmlElement(iframe).promise;\n            document.body.appendChild(iframe);\n            await iframePromise;\n            const iframeDoc = iframe!.contentDocument;\n            if (isSandboxedIframe || !iframeDoc) {\n                isSandboxed = isSandboxedIframe || !iframeDoc;\n            }\n            else {\n                const STUDIO_JS = window?.process?.env?.STUDIO_JS;\n                const nonce: string | undefined = STUDIO_JS\n                    ? getCookie('script-nonce')\n                    : '';\n\n                try {\n                    const evalScript = document.createElement('script');\n                    const url = URL.createObjectURL(new Blob([`window.evalMathExpression = ${evalMathExpression.toString()}`]));\n                    evalScript.nonce = nonce;\n                    evalScript.src = url;\n                    const scriptPromise = loadHtmlElement(evalScript).promise;\n                    iframeDoc.head.appendChild(evalScript);\n                    await scriptPromise;\n                    URL.revokeObjectURL(url);\n                }\n                catch (_) {\n                    // Fallback to old injection which causes document.write warnings\n                    iframeDoc.open();\n                    iframeDoc.write(`<!DOCTYPE html><html><head><script nonce=\"${nonce}\">window.evalMathExpression = ${evalMathExpression.toString()}</script></head></html>`);\n                    iframeDoc.close();\n                }\n            }\n        }\n        return iframe;\n    }\n\n    static destroy(): void {\n        if (iframe) {\n            document.body.removeChild(iframe);\n            iframe = undefined;\n        }\n    }\n}\n","/**\n * Taken from angulars implementation: https://github.com/angular/angular/blob/master/packages/core/src/sanitization/url_sanitizer.ts\n */\n\nconst SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi;\n\n/** A pattern that matches safe data URLs. Only matches image, video and audio types. */\nconst DATA_URL_PATTERN = /^data:(?:image\\/(?:bmp|gif|jpeg|jpg|png|tiff|webp|svg\\+xml)|video\\/(?:mpeg|mp4|ogg|webm)|audio\\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+\\/]+=*$/i;\n\nexport function sanitizeUrl(url: string): string {\n    if (isSafeUrl(url)) {\n        return url;\n    }\n    throw new Error(`Error: unsafe URL value: \"${url}\" (see http://g.co/ng/security#xss)`);\n}\n\nexport function sanitizeSrcset(srcset: string): string {\n    return srcset.split(',').map((set) => sanitizeUrl(set.trim())).join(', ');\n}\n\n\nexport function isSafeUrl(url: string): boolean {\n    url = url.trim();\n    if (!url || url === '#' || url.match(SAFE_URL_PATTERN) || url.match(DATA_URL_PATTERN)) {\n        return true;\n    }\n    return false;\n}\n","import { cloneDeep } from './clone';\n\n/**\n * A simple cache to cache return values for primitive function inputs\n */\nexport class SimpleCache {\n    private static cache = new Map<string, any>();\n\n    static set<T>(key: string, value: T): T {\n        this.cache.set(key, cloneDeep(value));\n        return value;\n    }\n\n    static get<T>(key: string): T | undefined {\n        const value = this.cache.get(key);\n\n        return cloneDeep(value);\n    }\n\n    static clear(): void {\n        this.cache.clear();\n    }\n}\n","import { IPosition, ISize } from '@studio/domain';\nimport { v4, validate } from 'uuid';\nimport { sleep } from './promises';\nimport { Size } from '@data/collections/creativeset.data';\n\n/**\n * If passing optional as true and called in ACG the ID should return as undefined\n * as creation of new IDs should not occur due to discrepancies occuring when\n * generating the document and ad-data. Use Non-Null Operator (`!`) with caution!\n */\nexport function uuidv4(optional: true): string | undefined;\nexport function uuidv4(optional: false): string;\nexport function uuidv4(optional?: undefined): string;\nexport function uuidv4(optional?: boolean | undefined): string | undefined {\n    if (optional) {\n        return process.env.STUDIO_JS ? v4() : undefined;\n    }\n    return v4();\n}\n\nexport function isUUID(value?: string): boolean {\n    return validate(value || '');\n}\n\nexport interface IPosition3D extends IPosition {\n    z: number;\n}\n\nexport function clearArray(array: any[]): void {\n    array.splice(0, array.length);\n}\n\nexport function clamp(value: number, minValue: number = Number.MIN_SAFE_INTEGER, maxValue: number = Number.MAX_SAFE_INTEGER): number {\n    return Math.max(Math.min(value, maxValue), minValue);\n}\n\nexport function moveItemInArray(array: any[], oldIndex: number, newIndex: number): void {\n    if (newIndex >= array.length) {\n        throw new Error('New index out of array bounds');\n    }\n    array.splice(newIndex, 0, array.splice(oldIndex, 1)[0]);\n}\n\nexport function decimal(number: number): number {\n    return roundToNearestMultiple(number, 0.01);\n}\n\nexport function toFixedDecimal(n: number | string, pad: number = 3): number {\n    if (typeof n === 'string') {\n        n = parseFloat(n);\n    }\n\n    if (isNaN(n)) {\n        throw new Error('Could not convert value to a valid number.');\n    }\n\n    // Check if decimal\n    if (n % 1 !== 0) {\n        return parseFloat(n.toFixed(pad));\n    }\n\n    return n;\n}\n\nexport function createMapFromArray<T>(items: T[], property: keyof T): object {\n    const object = {} as object;\n    for (const item of items) {\n        object[item[property as string] as string] = omit(item, property);\n    }\n    return object;\n}\n\nexport function moveItemsInList<T>(list: T[], itemsToMove: T[], toIndex: number): T[] {\n    if (toIndex < 0 || toIndex > list.length - 1) {\n        throw new Error('Invalid index');\n    }\n    // const newArray =\n    const arrayItemPlaceholder = Symbol();\n    const cpy = ([] as any[]).concat(list);\n    itemsToMove.forEach((v) => cpy[cpy.indexOf(v)] = arrayItemPlaceholder);\n    const index = list.indexOf(itemsToMove[0]) >= toIndex\n        ? toIndex\n        : (toIndex + itemsToMove.length);\n    cpy.splice(index, 0, ...itemsToMove);\n    return cpy.filter((v) => v !== arrayItemPlaceholder);\n}\n\nexport function deleteItemInArray<T>(array: T[], item: T): void {\n    const index = array.indexOf(item);\n    if (index === -1) {\n        throw new Error('Could not find item in array.');\n    }\n    array.splice(index, 1);\n}\n\nexport function equalSets<Unit>(setA: Set<Unit>, setB: Set<Unit>): boolean {\n    if (setA.size !== setB.size) {\n        return false;\n    }\n    for (const a of setA) {\n        if (!setB.has(a)) {\n            return false;\n        }\n    }\n    return true;\n}\n\nexport function deepEqual(x: any, y: any): boolean {\n    return fastDeepEqual(x, y);\n}\n\n/*\nfunction deepEqualCheck(x: any, y: any): boolean {\n    if ((typeof x === 'object' && x !== null) && (typeof y === 'object' && y !== null)) {\n        if (Object.keys(x).length !== Object.keys(y).length) {\n            return false;\n        }\n\n        for (const prop in x) {\n            if (prop.startsWith('__')) {\n                continue;\n            }\n            if (y.hasOwnProperty(prop)) {\n                if (!deepEqualCheck(x[prop], y[prop])) {\n                    return false;\n                }\n            }\n            else {\n                return false;\n            }\n        }\n        return true;\n    }\n    else if (x !== y) {\n        return false;\n    }\n    return true;\n}\n*/\n\n/**\n * Taken from https://github.com/epoberezkin/fast-deep-equal\n * Way faster handling olors and more.\n * @param a\n * @param b\n */\nfunction fastDeepEqual(a: any, b: any): boolean {\n    if (a === b) {\n        return true;\n    }\n\n    if (a && b && typeof a === 'object' && typeof b === 'object') {\n        if (a.constructor !== b.constructor) {\n            return false;\n        }\n\n        let length: number;\n        let i: number;\n\n        if (Array.isArray(a)) {\n            length = a.length;\n            if (length !== b.length) {\n                return false;\n            }\n            for (i = length; i-- !== 0;) {\n                if (!fastDeepEqual(a[i], b[i])) {\n                    return false;\n                }\n            }\n            return true;\n        }\n\n        if (a.constructor === RegExp) {\n            return a.source === b.source && a.flags === b.flags;\n        }\n        if (a.valueOf !== Object.prototype.valueOf) {\n            return a.valueOf() === b.valueOf();\n        }\n        if (a.toString !== Object.prototype.toString) {\n            return a.toString() === b.toString();\n        }\n\n        const keys = Object.keys(a);\n        length = keys.length;\n        if (length !== Object.keys(b).length) {\n            return false;\n        }\n\n        for (i = length; i-- !== 0;) {\n            if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {\n                return false;\n            }\n        }\n\n        for (i = length; i-- !== 0;) {\n            const key = keys[i];\n\n            if (!key.startsWith('__') && !fastDeepEqual(a[key], b[key])) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    // true if both NaN, false otherwise\n    return a !== a && b !== b;\n}\n\nexport async function awaitAllInMap(promiseMap: any): Promise<Map<string, any>> {\n    const result = new Map<string, any>();\n    const promises: Promise<any>[] = [];\n    const keys: string[] = [];\n    for (const i in promiseMap) {\n        promises.push(promiseMap[i]);\n        keys.push(i);\n    }\n    const values = await Promise.all(promises);\n    let index = 0;\n    for (const k of keys) {\n        result.set(k, values[index]);\n        index++;\n    }\n    return result;\n}\n\nexport function has<T>(iter: Iterable<T>, value: T): boolean {\n    for (const i of iter) {\n        if (i === value) {\n            return true;\n        }\n    }\n    return false;\n}\n\nexport function pick<T, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K> {\n    const newObj = {} as Pick<T, K>;\n    for (const k of keys) {\n        if (obj[k] !== undefined) {\n            newObj[k] = obj[k];\n        }\n    }\n    return newObj;\n}\n\nexport function omit<T, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> {\n    const newObj = Object.assign({}, obj);\n    for (const key of keys) {\n        delete newObj[key];\n    }\n    return newObj;\n}\n\nexport function omitUndefined<T>(obj: T): T {\n    const newObj = Object.assign({}, obj);\n    for (const key in obj) {\n        if (newObj[key] === undefined) {\n            delete newObj[key];\n        }\n    }\n    return newObj;\n}\n\nexport function autobind(target: any, key: string, descriptor: TypedPropertyDescriptor<any>): TypedPropertyDescriptor<any> | void {\n    const fn = descriptor.value;\n\n    if (typeof fn !== 'function') {\n        throw new Error(`@autobind decorator can only be applied to methods not: ${typeof fn}`);\n    }\n\n    return {\n        configurable: true,\n        get(this: any): any {\n            if (this === target || this.hasOwnProperty(key)) {\n                return fn;\n            }\n\n            const boundFn = fn.bind(this);\n            Object.defineProperty(this, key, {\n                configurable: true,\n                writable: true,\n                enumerable: false,\n                value: boundFn\n            });\n            return boundFn;\n        }\n    };\n}\n\nexport function minutesToMilliseconds(minutes: number): number {\n    return minutes * 60000;\n}\n\nexport function checksum(str: string): string {\n    let hash = 0;\n    let i: number;\n    let chr: number;\n\n    if (str.length === 0) {\n        return hash + '';\n    }\n\n    for (i = 0; i < str.length; i++) {\n        chr = str.charCodeAt(i);\n        hash = ((hash << 5) - hash) + chr;\n        hash |= 0; // Convert to 32bit integer\n    }\n\n    return hash + '';\n}\n\nexport function filterObject(obj: any, predicate: (o: any) => {}): any {\n    const result = {};\n    for (const key in obj) {\n        if (obj.hasOwnProperty(key) && predicate(obj[key])) {\n            result[key] = obj[key];\n        }\n    }\n\n    return result;\n}\n\nconst zeroWidthEntities: { [index: string]: string; } = {\n    '\\u200D': '&zwj;',\n    '\\u200C': '&zwnj;'\n};\n\nconst xmlEntities: { [index: string]: string; } = {\n    '&': '&amp;',\n    '\"': '&quot;',\n    '<': '&lt;',\n    '>': '&gt;',\n};\n\nexport const charToXmlEntity: { [index: string]: string; } = {\n    ...xmlEntities,\n    ...zeroWidthEntities\n};\n\n\nexport const charToHtmlEntity: { [index: string]: string; } = {\n    ...charToXmlEntity,\n    // ' ': '&nbsp;',\n};\n\nexport function encodeXml(text: string): string {\n    if (typeof text !== 'string') {\n        return '';\n    }\n\n    for (const i in charToXmlEntity) {\n        if (i === '\\\\') {\n            text = text.replace(new RegExp('\\\\\\\\', 'g'), charToXmlEntity[i]);\n        }\n        else {\n            text = text.replace(new RegExp(i, 'g'), charToXmlEntity[i]);\n        }\n    }\n\n    return text;\n}\n\nexport function encodeHtml(text: string): string {\n    for (const i in charToHtmlEntity) {\n        text = text.replace(new RegExp(i, 'g'), charToHtmlEntity[i]);\n    }\n    return text;\n}\n\nexport function decodeXML(text: string): string {\n    for (const i in xmlEntities) {\n        text = text.replace(new RegExp(xmlEntities[i], 'g'), i);\n    }\n    text = text.replace(/\\\\n/g, '\\u000A');\n    text = text.replace(/\\\\r/g, '\\u000D');\n    return text;\n}\n\nexport function base64ToBlob(text: string, contentType: string): Blob {\n    const byteCharacters = atob(text);\n    const byteNumbers = new Array(byteCharacters.length);\n    for (let i = 0; i < byteCharacters.length; i++) {\n        byteNumbers[i] = byteCharacters.charCodeAt(i);\n    }\n    const byteArray = new Uint8Array(byteNumbers);\n    return new Blob([byteArray], { type: contentType });\n}\n\nexport function camelCaseToUnderscore(text: string): string {\n    return text.replace(/([A-Z])/g, (_, y) => '_' + y.toLowerCase());\n}\n\nexport function underscoreToCamelCase(text: string): string {\n    return text.replace(/(_[a-z])/g, (g) => g[1].toUpperCase());\n}\n\nexport function underscoreToPascalCase(text: string): string {\n    return text.charAt(0).toUpperCase() + text.substring(1).replace(/(_[a-z])/g, (g) => g[1].toUpperCase());\n}\n\nexport function stringToCamelCase(str: string): string {\n    return str.replace(/(?:^\\w|[A-Z]|\\b\\w|\\s+)/g, (match: any, index: number) => {\n        if (+match === 0) { return ''; } // or if (/\\s+/.test(match)) for white spaces\n        return index === 0 ? match.toLowerCase() : match.toUpperCase();\n    });\n}\n\nexport function pascalToCamelCase(o: object): object {\n    let newObj: object;\n    let origKey: string;\n    let newKey: string;\n    let value: any;\n\n    // NOSONAR\n    if (o instanceof Array) {\n        return o.map(function (val) {\n            if (typeof val === 'object') {\n                val = pascalToCamelCase(val);\n            }\n            return val;\n        });\n    } else {\n        newObj = {};\n        for (origKey in o) {\n            if (o.hasOwnProperty(origKey)) {\n                newKey = (origKey.charAt(0).toLowerCase() + origKey.slice(1) || origKey).toString();\n                value = o[origKey];\n                if (value instanceof Array || (value !== null && value.constructor === Object)) {\n                    value = pascalToCamelCase(value);\n                }\n                newObj[newKey] = value;\n            }\n        }\n    }\n    return newObj;\n}\n\n\nexport interface IReferenceContainer<T> {\n    value?: T;\n}\n\nfunction makeCRCTable(): number[] {\n    const crcTable: number[] = [];\n    let c: number;\n    for (let n = 0; n < 256; n++) {\n        c = n;\n        for (let k = 0; k < 8; k++) {\n            c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));\n        }\n        crcTable[n] = c;\n    }\n    return crcTable;\n}\n\nconst crcTable = makeCRCTable();\n\n// CRC 32 is a checksum method.\nexport function crc32(text: string): string {\n    let crc = 0 ^ (-1);\n\n    for (let i = 0; i < text.length; i++) {\n        crc = (crc >>> 8) ^ crcTable[(crc ^ text.charCodeAt(i)) & 0xFF];\n    }\n\n    const numberHash = (crc ^ (-1)) >>> 0;\n    const hex = ('00000000000000' + numberHash.toString(16).toUpperCase()).slice(-14);\n    return hex;\n}\n\nexport function getCookie(name: string): string | undefined {\n    const value = '; ' + document.cookie;\n    const parts = value.split('; ' + name + '=');\n    if (parts.length === 2) {\n        return parts.pop()!.split(';').shift();\n    }\n}\n\nexport function setCookie(name: string, value: string = '', days: number = 30): void {\n    let expires = '';\n    if (days) {\n        const date = new Date();\n        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));\n        expires = '; expires=' + date.toUTCString();\n    }\n    document.cookie = name + '=' + value  + expires + '; path=/';\n}\n\nexport function toDegrees(radians: number): number {\n    return radians * 180 / Math.PI;\n}\n\nexport function toRadians(degrees: number): number {\n    return degrees * Math.PI / 180;\n}\n\nexport function rotatePosition(position: IPosition, origin: IPosition, angle: number): IPosition {\n    const cos = Math.cos(-angle);\n    const sin = Math.sin(-angle);\n    const nx = (cos * (position.x - origin.x)) - (sin * (position.y - origin.y)) + origin.x;\n    const ny = (cos * (position.y - origin.y)) + (sin * (position.x - origin.x)) + origin.y;\n\n    return {\n        x: nx,\n        y: ny,\n    };\n}\n\nexport function rotatePosition3D(pos: IPosition | IPosition3D, angles: IPosition3D, origin: IPosition | IPosition3D = { x: 0, y: 0, z: 0 }): IPosition3D {\n\n    const origin3D = { z: 0, ...origin };\n    const pos3D = { z: 0, ...pos };\n\n    const x1 = pos3D.x - origin3D.x;\n    const y1 = pos3D.y - origin3D.y;\n    const z1 = pos3D.z - origin3D.z;\n    const angleX = angles.x / 2;\n    const angleY = angles.y / 2;\n    const angleZ = angles.z / 2;\n\n    const cr = Math.cos(angleX);\n    const cp = Math.cos(angleY);\n    const cy = Math.cos(angleZ);\n    const sr = Math.sin(angleX);\n    const sp = Math.sin(angleY);\n    const sy = Math.sin(angleZ);\n\n    const w = cr * cp * cy + -sr * sp * -sy;\n    const x = sr * cp * cy - (-cr) * sp * -sy;\n    const y = cr * sp * cy + sr * cp * sy;\n    const z = cr * cp * sy - (-sr) * sp * -cy;\n\n    const m0 = 1 - 2 * (y * y + z * z);\n    const m1 = 2 * (x * y + z * w);\n    const m2 = 2 * (x * z - y * w);\n\n    const m4 = 2 * (x * y - z * w);\n    const m5 = 1 - 2 * (x * x + z * z);\n    const m6 = 2 * (z * y + x * w);\n\n    const m8 = 2 * (x * z + y * w);\n    const m9 = 2 * (y * z - x * w);\n    const m10 = 1 - 2 * (x * x + y * y);\n\n    return {\n        x: x1 * m0 + y1 * m4 + z1 * m8 + origin3D.x,\n        y: x1 * m1 + y1 * m5 + z1 * m9 + origin3D.y,\n        z: x1 * m2 + y1 * m6 + z1 * m10 + origin3D.z\n    };\n}\n\nexport function getCenter(box: ISize & IPosition): IPosition {\n    return {\n        x: box.x + box.width / 2,\n        y: box.y + box.height / 2,\n    };\n}\n\nexport function getDelta(p1: IPosition, p2: IPosition): IPosition {\n    return {\n        x: p2.x - p1.x,\n        y: p2.y - p1.y,\n    };\n}\n\n\nexport function polygonIsIntersecting(polygon1: IPosition[], polygon2: IPosition[]): boolean {\n    for (const polygon of [polygon1, polygon2]) {\n        for (let i1 = 0; i1 < polygon.length; i1++) {\n            let min1 = Infinity;\n            let max1 = -Infinity;\n            let min2 = Infinity;\n            let max2 = -Infinity;\n            const i2 = (i1 + 1) % polygon.length;\n            const p1 = polygon[i1];\n            const p2 = polygon[i2];\n            const normal = {\n                x: p1.y - p2.y,\n                y: p2.x - p1.x,\n            };\n\n            for (const p of polygon1) {\n                const projected = normal.x * p.x + normal.y * p.y;\n                if (projected < min1) {\n                    min1 = projected;\n                }\n                if (projected > max1) {\n                    max1 = projected;\n                }\n            }\n\n            for (const p of polygon2) {\n                const projected = normal.x * p.x + normal.y * p.y;\n                if (projected < min2) {\n                    min2 = projected;\n                }\n                if (projected > max2) {\n                    max2 = projected;\n                }\n            }\n\n            if (max1! < min2! || max2! < min1!) {\n                return false;\n            }\n        }\n    }\n    return true;\n}\n\n/**\n * Check if number is a multiple of a certain value\n * isMultipleOf(32.4, 0.1) => true\n * isMultipleOf(32, 10) => false\n * @param value\n * @param multiple\n * @returns\n */\nexport function isMultipleOf(value: number, multiple: number): boolean {\n\n    // Numbers often provided like: 12.299999999999972, make sure these are rounded\n    value = roundToNearestMultiple(value / multiple, 0.0000001);\n    return value % 1 === 0;\n}\n\nexport function roundToNearestMultiple(value: number, multiple: number): number {\n    // 6 * 0.1 = 0.6000000000000001\n    // But 6 / (1 / 0.1) = 0.6\n    return Math.round(value / multiple) / (1 / multiple);\n}\n\nexport function floorToNearestMultiple(value: number, multiple: number): number {\n    return Math.floor(value / multiple) * multiple;\n}\n\nexport function isNumber(value: any): value is number {\n    return typeof value === 'number';\n}\n\n/**\n * Sort a list of creatives or formats based on their size. The sorting is grouped by width e.g:\n * 160x600, 300x250, 300x300, 468x60\n * Expects the objects to have { width: number, height: number }\n * @param  {[]} arr An array of objects\n * @param  {string} path Path to object key. E.g 'size' or 'creative.size'\n * @returns {[]} Returns the array of objects sorted by width\n */\nexport function sortByFormatSize<T1>(arr: T1[], path: string = ''): T1[] {\n    function sortFn(a: T1, b: T1): number {\n        if (typeof a === 'object') {\n            const aval = path.slice(0).split('.').reduce(index, a) || a;\n            const bval = path.slice(0).split('.').reduce(index, b) || b;\n            const aWidth = aval.width;\n            const aHeight = aval.height;\n            const bWidth = bval.width;\n            const bHeight = bval.height;\n            if (aWidth === bWidth && aHeight > bHeight) {\n                return 1;\n            }\n            else if (aWidth === bWidth && aHeight < bHeight) {\n                return -1;\n            }\n            else if (aWidth > bWidth) {\n                return 1;\n            }\n            else if (aWidth < bWidth) {\n                return -1;\n            }\n        }\n        return 0;\n    }\n\n    function index(obj: any, i: any): any {\n        return obj[i];\n    }\n\n    return arr.sort(sortFn);\n}\n\n/**\n * Inserts an element in an array and sorts it\n * @param  {T[]} arr An array of objects\n * @param  {T} element Object to be inserted\n * @param  {function} sortFn Funtion used for sorting\n */\nexport function pushSorted<T>(arr: T[], element: T, sortFn: (a: T, b: T) => number): void {\n    arr.push(element);\n    arr.sort(sortFn);\n}\n\nexport function alphaNumericSort(a: string | number, b: string | number): number {\n    if (a === b) {\n        return 0;\n    }\n    if (typeof a === typeof b) {\n        return a < b ? -1 : 1;\n    }\n    return typeof a < typeof b ? -1 : 1;\n}\n\nconst emojiRegex = /(?:[\\u2700-\\u27bf]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\u0023-\\u0039]\\ufe0f?\\u20e3|\\u3299|\\u3297|\\u303d|\\u3030|\\u24c2|\\ud83c[\\udd70-\\udd71]|\\ud83c[\\udd7e-\\udd7f]|\\ud83c\\udd8e|\\ud83c[\\udd91-\\udd9a]|\\ud83c[\\udde6-\\uddff]|[\\ud83c[\\ude01-\\ude02]|\\ud83c\\ude1a|\\ud83c\\ude2f|[\\ud83c[\\ude32-\\ude3a]|[\\ud83c[\\ude50-\\ude51]|\\u203c|\\u2049|[\\u25aa-\\u25ab]|\\u25b6|\\u25c0|[\\u25fb-\\u25fe]|\\u00a9|\\u2139|\\ud83c\\udc04|[\\u2600-\\u26FF]|\\u2b05|\\u2b06|\\u2b07|\\u2b1b|\\u2b1c|\\u2b50|\\u2b55|\\u231a|\\u231b|\\u2328|\\u23cf|[\\u23e9-\\u23f3]|[\\u23f8-\\u23fa]|\\ud83c\\udccf|\\u2934|\\u2935)/gi;\n\nexport function trimEmojis(text: string): string {\n    return text.replace(emojiRegex, '');\n}\n\nexport function distinctString(text: string): string {\n    return text\n        .normalize('NFC') // STUDIO-8808\n        .split('')\n        // Distinct the array of characters\n        .filter((v, i, s) => s.indexOf(v) === i)\n        // Sort by alphanumeric\n        .sort(alphaNumericSort)\n        .join('');\n}\n\n/**\n * Retries a promise, waiting between each retry. Useful when making external calls\n * and handling transient failures.\n *\n * @param getPromise function that returns the actual promise to retry\n * @param shouldRetry optional predicate that receives errors thrown during retries.\n *                    If it returns true for an error, the promise is retried. Useful\n *                    when deciding to retry if it is a transient error or something\n *                    more catastrophic\n * @param delays optional array of milliseconds to wait before subsequent retry attempts.\n *               Defaults to 1s, 5s, 10, 20s before throwing the last error\n */\nexport async function retryPromiseWithDelay<T>(\n    getPromise: () => Promise<T>,\n    shouldRetry: (...args: any[]) => boolean = (_error: any): boolean => true,\n    delays: Array<number> = [1000, 5000, 10000, 20000]): Promise<T> {\n    let err: any;\n    for (const delay of delays) {\n        try {\n            return await getPromise();\n        }\n        catch (error) {\n            err = error;\n            if (shouldRetry(error)) {\n                await sleep(delay);\n                continue;\n            }\n            else {\n                throw err;\n            }\n        }\n    }\n    throw err;\n}\n\nexport function getAspectRatioFit(srcWidth: number, srcHeight: number, maxWidth: number, maxHeight: number): { width: number, height: number, ratio: number } {\n    const ratio = Math.min(maxWidth / srcWidth, maxHeight / srcHeight);\n    return { width: srcWidth * ratio, height: srcHeight * ratio, ratio };\n}\n\nexport function generateUniqueName(name: string, listOfItemsWithName: { name: string }[]): string {\n    const design = listOfItemsWithName.find(version => version.name === name);\n    if (design) {\n        if (/\\(\\d+\\)$/.test(name)) {\n            const incrementedName = name.replace(/\\((\\d+?)\\)$/g, (_, n) => '(' + (Number(n) + 1) + ')');\n            return generateUniqueName(incrementedName, listOfItemsWithName);\n        }\n        else {\n            return generateUniqueName(`${name} (1)`, listOfItemsWithName);\n        }\n    }\n\n    return name;\n}\n\nexport function generateUniqueBrandName(name: string, listOfNames: string[]): string {\n    const value = listOfNames.find(current => current === name);\n    if (value) {\n        if (/\\(\\d+\\)$/.test(name)) {\n            const incrementedName = name.replace(/\\((.+?)\\)$/g, (_fullMatch, n) => '(' + (Number(n) + 1) + ')');\n            return generateUniqueBrandName(incrementedName, listOfNames);\n        }\n        else {\n            return generateUniqueBrandName(`${name} (1)`, listOfNames);\n        }\n    }\n\n    return name;\n}\n\nexport function angleToPoints(deg: number): any {\n    // In angle is -90 to 270 make it between 0 and 360\n    const rad = ((deg + 90) % 360) * Math.PI / 180;\n    const segment = Math.floor(rad / Math.PI * 2) + 2;\n    const diagonal = (1 / 2 * segment + 1 / 4) * Math.PI;\n    const op = Math.cos(Math.abs(diagonal - rad)) * Math.sqrt(2);\n    const x = op * Math.cos(rad);\n    const y = op * Math.sin(rad);\n\n    return {\n        x1: x < 0 ? 1 : 0,\n        y1: y < 0 ? 1 : 0,\n        x2: x >= 0 ? x : x + 1,\n        y2: y >= 0 ? y : y + 1\n    };\n}\n\n/**\n * Linear interpolation, calculate a value on the line between a and b.\n * t = 0 => a\n * t = 1 => b\n *\n * @param from\n * @param to\n * @param progress\n */\nexport function lerp(from: number, to: number, progress: number): number {\n    return from + progress * (to - from);\n}\n\n\nexport function sanitizeString(str: string): string {\n    if (!str) {\n        return '';\n    }\n    return str\n        .replace(/\\\\/gi, '\\\\\\\\')\n        .replace(/\"/gi, '\\\"')\n        .replace(/\\&/g, ';ampersand;')\n        .trim();\n}\n\nconst namespacedCharacters = {\n    '&': ';ampersand;'\n};\n\nexport function resolveNamespacedCharacters(str: string): string {\n    if (typeof str !== 'string') {\n        return str;\n    }\n\n    for (const char in namespacedCharacters) {\n        if (str.indexOf(namespacedCharacters[char]) === -1) {\n            continue;\n        }\n        const re = new RegExp(namespacedCharacters[char], 'g');\n        str = str.replace(re, char);\n    }\n\n    return str;\n}\n\nexport function stringLiteralArray<T extends string>(a: T[]): T[] {\n    return a;\n}\n\n/**\n * Regular btoa does not support non ASCII characters (outside latin1).\n */\nexport function b64EncodeUnicode(str: string): string {\n    // first we use encodeURIComponent to get percent-encoded UTF-8,\n    // then we convert the percent encodings into raw bytes which\n    // can be fed into btoa.\n    return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,\n        function toSolidBytes(match: string, p1: string): string {\n            // @ts-ignore\n            return String.fromCharCode('0x' + p1);\n    }));\n}\n\n/**\n * Regular atob does not support non ASCII characters (outside latin1).\n */\nexport function b64DecodeUnicode(str: string): string {\n    // Going backwards: from bytestream, to percent-encoding, to original string.\n    return decodeURIComponent(atob(str).split('').map(function(c: string): string {\n        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);\n    }).join(''));\n}\n\n/**\n * Default encodeURIComponent doesn't escape certain characters\n */\nexport function fixedEncodeURIComponent(str: string): string {\n    return encodeURIComponent(str).replace(/[!'()*]/g, function(c: string): string {\n      return '%' + c.charCodeAt(0).toString(16);\n    });\n}\n\n/*\n * We need this function for handling negative modulus.\n * @link https://web.archive.org/web/20090717035140if_/javascript.about.com/od/problemsolving/a/modulobug.htm\n */\nexport function mod(n: number, m: number): number {\n    return ((n % m) + m) % m;\n}\n\nexport const requestIdleCallback = ((callback: Function, timeout: number = 1000): NodeJS.Timeout | void | number => {\n    if ((window as any).requestIdleCallback) {\n        (window as any).requestIdleCallback(callback, { timeout });\n    }\n    else {\n        const start = Date.now();\n        return setTimeout(() => {\n            callback({\n                didTimeout: false,\n                timeRemaining: () => Math.max(0, 50 - (Date.now() - start))\n            });\n        }, 1);\n    }\n});\n\n\nexport function formatTime(timestamp: number, year = false): string {\n    const dt =  new Intl.DateTimeFormat('en-GB', {\n        year: year ? 'numeric' : undefined, month: year ? 'numeric' : undefined, day: year ? 'numeric' : undefined,\n        hour: 'numeric', minute: 'numeric', second: 'numeric',\n        hour12: false,\n    });\n\n    return dt.format(new Date(timestamp));\n}\n\nexport function decimalToPercentage(decimalNumber: number = 1): number {\n    return Math.round(decimalNumber * 100);\n}\n\n/**\n * Returns a diff between two objects by doing a shallow comparison of the values.\n * ```typescript\n * getObjectDifference({ a: 1, b: 2, c: 3 }, { a: 3, b: 2, d: 4 });\n * // returns { a: 3, c: undefined, d: 4 }\n * ```\n */\nexport function getObjectDifference<Obj extends {}>(a: Obj, b: Obj): Partial<Obj> {\n   const keys = Array.from(new Set([...Object.keys(a), ...Object.keys(b)]));\n\n   return keys\n      .filter((key) => a[key] !== b[key])\n      .reduce((memo: Partial<Obj>, key) => ({ ...memo, [key]: b[key] }), {});\n}\n\n\nexport function isRightClick(event: MouseEvent | undefined): boolean {\n    return event?.button === 2;\n}\n\nexport function mapSizeIdsToSizes(sizeIds: string[], sizes: Size[]): Size[] {\n    return sizes.filter(size => sizeIds.includes(size.id));\n}\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + {\"231\":\"feed\",\"263\":\"widget\",\"791\":\"video\"}[chunkId] + \".\" + {\"231\":\"56d9b57eebc669c4e083\",\"263\":\"835ef9d394a367f215d1\",\"791\":\"730ebb44f52e63b41bb4\"}[chunkId] + \".js\";\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.p = \"scripts/\";","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t139: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t} else installedChunks[chunkId] = 0;\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkIds[i]] = 0;\n\t}\n\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunkLIB\"] = self[\"webpackChunkLIB\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","import { IFontStyle, IFontFamilyStyle } from '@studio/domain';\nimport { replaceOrigin, getUrlParameters } from '../ad/utils/url';\n\nexport function isElementDescendantOfElement(parentElement: HTMLElement | Element | EventTarget | null, childElement: any): boolean {\n\n    if (!parentElement) {\n        return false;\n    }\n\n    if (parentElement === childElement) {\n        return true;\n    }\n\n    let node = childElement.parentNode;\n    while (node) {\n        if (node === parentElement) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n\n    return false;\n}\n\ninterface IUrlOption {\n    scheme?: 'http:' | 'https:';\n    host?: string;\n    port?: number;\n    pathPrefix?: string;\n    path?: string;\n}\n\nexport function formatUrl(option: IUrlOption): string {\n    const scheme = option.scheme || 'http:';\n    const host = option.host || 'localhost';\n    const port = option.port;\n    const pathPrefix = option.pathPrefix || '';\n    const path = option.path || '';\n\n    return scheme + '//' + host + (port ? ':' + port : '') + pathPrefix + path;\n}\n\nexport function isElementDescendantOfElementWithClass(element: any, className: string): boolean {\n    if (element.classList && element.classList.contains(className)) {\n        return true;\n    }\n    let node = element.parentNode;\n    while (node) {\n        if (node.classList && (node as HTMLElement).classList.contains(className)) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\nexport function isChildOfSelector(element: HTMLElement, parentSelector: string): boolean {\n    let node = element.parentNode as HTMLElement;\n    while (node) {\n        if (typeof node.matches !== 'undefined' && node.matches(parentSelector)) {\n            return true;\n        }\n        node = node.parentNode as HTMLElement;\n    }\n    return false;\n}\n\nexport function isFocused(el: HTMLElement): boolean {\n    return el === document.activeElement;\n}\n\nconst fontStyleMap = new Map<string, FontFace>();\nconst fontStyleURLMap = new Map<string, string>(); // Load font again if the URL are different (i.e.: diff characters in feed)\nexport async function injectFontFace(fontStyle: IFontStyle | IFontFamilyStyle, fontServiceOrigin?: string): Promise<FontFace> {\n    const fontURL = getFontURL(fontStyle, fontServiceOrigin);\n\n    let fontFace = fontStyleMap.get(fontStyle.id);\n    const preloadedFontURL = fontStyleURLMap.get(fontStyle.id);\n    if (fontFace && preloadedFontURL === fontURL) {\n        return await fontFace.load();\n    }\n\n    if (fontURL) {\n        fontFace = new FontFace('f-' + fontStyle.id, `url(${fontURL})`);\n    } else {\n        throw new Error('Unknown font style.');\n    }\n    fontStyleMap.set(fontStyle.id, fontFace);\n    fontStyleURLMap.set(fontStyle.id, fontURL);\n    return await fontFace.load();\n}\n\nexport function injectFontStyle(document: Document, fontStyle: IFontStyle | IFontFamilyStyle, fontServiceOrigin?: string): void {\n    const fontURL = getFontURL(fontStyle, fontServiceOrigin);\n    if (!fontURL) {\n        throw new Error('Failed to get URL of font style');\n    }\n\n    const fontFamily = 'f-' + fontStyle.id;\n    const fontType = getFontExtension(fontURL);\n    const fontStyleSheet = document.createElement('style');\n    const fontPreloadLink = document.createElement('link');\n    fontPreloadLink.rel = 'preload';\n    fontPreloadLink.href = fontURL;\n    fontPreloadLink.as = 'font';\n    fontPreloadLink.type = 'font/' + fontType;\n    fontPreloadLink.crossOrigin = '';\n\n    fontStyleSheet.textContent = `\n                        @font-face {\n                          font-family: '${fontFamily}';\n                          src: url(${fontURL}) format('${fontType}');\n                        }\n                      `;\n    document.head.appendChild(fontPreloadLink);\n    document.head.appendChild(fontStyleSheet);\n}\n\nexport function getFontExtension(url: string): string | undefined {\n    return getUrlParameters(url).u?.split('.').pop();\n}\n\nexport function getFontURL(fontStyle: IFontStyle | IFontFamilyStyle, fontServiceOrigin?: string): string {\n    let url = (fontStyle as IFontStyle).src || (fontStyle as IFontFamilyStyle).fontUrl;\n\n    if ((typeof process === 'undefined' || (!process.env.IN_TEST && process.env.STUDIO_JS)) && window.bfstudio) {\n        url = replaceOrigin(url, process.env.FONTS_AZURE_STORAGE_CDN_ORIGIN!);\n    }\n    if ((typeof process === 'undefined' || !process.env.IN_TEST) && fontServiceOrigin) {\n        // notice, url can be base64 and still work\n        url = replaceOrigin(url, fontServiceOrigin);\n    }\n    return url;\n}\n\n/**\n * Zero width joints are used for joining spans that are separated. In Arabic, Hindi and Emoji text, glyphs that are in separate\n * spans are rendered as separate instead of continous joined text. The glyphs changes a bit when they are separated vs joined.\n * In order to support Character Styles, we have to include zero-width joint character u+200D and zero-width-no-joint u+200C\n * character, to signal that a text is joined.\n */\nexport function getStringByExcludingZeroWidthJoints(node: Node): string {\n    return node.textContent!.replace(/\\u200C/g, '').replace(/\\u200D/g, '');\n}\n","export function _performanceMark(name: string): void {\n    if (!performance || !performance.mark) {\n        return;\n    }\n    performance.mark(name);\n}\n","import { IAd } from './ad';\n\nexport enum AdEvents {\n\n    /**\n     * When creative becomes visible (preload or creative)\n     */\n    Render = 'render',\n\n    /**\n     * When preload is done\n     */\n    Preload = 'preload',\n\n    /**\n     * When preload is done\n     */\n    CreativeLoad = 'creativeload',\n\n    /**\n     * Initialization of Ad script is done and API is available\n     */\n    Init = 'init',\n\n    /**\n     * Click on creative is triggered\n     */\n    Click = 'click',\n\n    /**\n     * Creative is scrolled in view (at least one pixel is shown)\n     */\n    ViewEnter = 'viewenter',\n\n    /**\n     * Creative is scrolled out of view (nothing of the creative is shown)\n     */\n    ViewLeave = 'viewleave',\n\n    /**\n     * Creative is scrolled in view according (30% or 50% depending on ad size)\n     */\n    IABViewEnter = 'iab_viewenter',\n\n    /**\n     * Creative is scrolled out of view (30% or 50% depending on ad size)\n     */\n    IABViewLeave = 'iab_viewleave',\n\n    /**\n     * Page is ready for us to load animated creative\n     */\n    PageReady = 'ready',\n\n    /**\n     * Something made the Ad crash\n     */\n    Error = 'error',\n\n    /**\n     * When add is removed and memory should be freed.\n     */\n    Destroy = 'destroy',\n\n    Play = 'play',\n\n    Stop = 'stop',\n\n    Seek = 'seek',\n\n    Loop = 'loop',\n\n    Pause = 'pause',\n\n    /**\n     * Transparency and Consensus data.\n     *\n     * @link\n     * https://bannerflow.atlassian.net/secure/RapidBoard.jspa?rapidView=40&modal=detail&selectedIssue=STUDIO-5168\n     */\n    TCData = 'tcdata',\n}\n\nexport type AdEventType =\n    AdEvents.Render |\n    AdEvents.Preload |\n    AdEvents.CreativeLoad |\n    AdEvents.Init |\n    AdEvents.Click |\n    AdEvents.ViewEnter |\n    AdEvents.ViewLeave |\n    AdEvents.IABViewEnter |\n    AdEvents.IABViewLeave |\n    AdEvents.PageReady |\n    AdEvents.Play |\n    AdEvents.Stop |\n    AdEvents.Loop |\n    AdEvents.Pause |\n    AdEvents.Seek |\n    AdEvents.Destroy |\n    AdEvents.TCData |\n    AdEvents.Error;\n\n\nexport interface IAdEventData {\n    loop: number;\n    time: number;\n    ad: IAd;\n}\n","// From https://stackoverflow.com/a/7193622/449132\nconst ARABIC_DIACRTIC_CHARS =\n`0651\n0652\n0670\n0640\n0627\n064C-065F`;\n\nexport const ARABIC_DIACRTIC_RANGE_MAP = decodeCharacterRangeMap(ARABIC_DIACRTIC_CHARS);\n\n// https://www.ietf.org/rfc/rfc3454.txt\nconst L_BIDI_CHARS =\n`0041-005A\n0061-007A\n00AA\n00B5\n00BA\n00C0-00D6\n00D8-00F6\n00F8-0220\n0222-0233\n0250-02AD\n02B0-02B8\n02BB-02C1\n02D0-02D1\n02E0-02E4\n02EE\n037A\n0386\n0388-038A\n038C\n038E-03A1\n03A3-03CE\n03D0-03F5\n0400-0482\n048A-04CE\n04D0-04F5\n04F8-04F9\n0500-050F\n0531-0556\n0559-055F\n0561-0587\n0589\n0903\n0905-0939\n093D-0940\n0949-094C\n0950\n0958-0961\n0964-0970\n0982-0983\n0985-098C\n098F-0990\n0993-09A8\n09AA-09B0\n09B2\n09B6-09B9\n09BE-09C0\n09C7-09C8\n09CB-09CC\n09D7\n09DC-09DD\n09DF-09E1\n09E6-09F1\n09F4-09FA\n0A05-0A0A\n0A0F-0A10\n0A13-0A28\n0A2A-0A30\n0A32-0A33\n0A35-0A36\n0A38-0A39\n0A3E-0A40\n0A59-0A5C\n0A5E\n0A66-0A6F\n0A72-0A74\n0A83\n0A85-0A8B\n0A8D\n0A8F-0A91\n0A93-0AA8\n0AAA-0AB0\n0AB2-0AB3\n0AB5-0AB9\n0ABD-0AC0\n0AC9\n0ACB-0ACC\n0AD0\n0AE0\n0AE6-0AEF\n0B02-0B03\n0B05-0B0C\n0B0F-0B10\n0B13-0B28\n0B2A-0B30\n0B32-0B33\n0B36-0B39\n0B3D-0B3E\n0B40\n0B47-0B48\n0B4B-0B4C\n0B57\n0B5C-0B5D\n0B5F-0B61\n0B66-0B70\n0B83\n0B85-0B8A\n0B8E-0B90\n0B92-0B95\n0B99-0B9A\n0B9C\n0B9E-0B9F\n0BA3-0BA4\n0BA8-0BAA\n0BAE-0BB5\n0BB7-0BB9\n0BBE-0BBF\n0BC1-0BC2\n0BC6-0BC8\n0BCA-0BCC\n0BD7\n0BE7-0BF2\n0C01-0C03\n0C05-0C0C\n0C0E-0C10\n0C12-0C28\n0C2A-0C33\n0C35-0C39\n0C41-0C44\n0C60-0C61\n0C66-0C6F\n0C82-0C83\n0C85-0C8C\n0C8E-0C90\n0C92-0CA8\n0CAA-0CB3\n0CB5-0CB9\n0CBE\n0CC0-0CC4\n0CC7-0CC8\n0CCA-0CCB\n0CD5-0CD6\n0CDE\n0CE0-0CE1\n0CE6-0CEF\n0D02-0D03\n0D05-0D0C\n0D0E-0D10\n0D12-0D28\n0D2A-0D39\n0D3E-0D40\n0D46-0D48\n0D4A-0D4C\n0D57\n0D60-0D61\n0D66-0D6F\n0D82-0D83\n0D85-0D96\n0D9A-0DB1\n0DB3-0DBB\n0DBD\n0DC0-0DC6\n0DCF-0DD1\n0DD8-0DDF\n0DF2-0DF4\n0E01-0E30\n0E32-0E33\n0E40-0E46\n0E4F-0E5B\n0E81-0E82\n0E84\n0E87-0E88\n0E8A\n0E8D\n0E94-0E97\n0E99-0E9F\n0EA1-0EA3\n0EA5\n0EA7\n0EAA-0EAB\n0EAD-0EB0\n0EB2-0EB3\n0EBD\n0EC0-0EC4\n0EC6\n0ED0-0ED9\n0EDC-0EDD\n0F00-0F17\n0F1A-0F34\n0F36\n0F38\n0F3E-0F47\n0F49-0F6A\n0F7F\n0F85\n0F88-0F8B\n0FBE-0FC5\n0FC7-0FCC\n0FCF\n1000-1021\n1023-1027\n1029-102A\n102C\n1031\n1038\n1040-1057\n10A0-10C5\n10D0-10F8\n10FB\n1100-1159\n115F-11A2\n11A8-11F9\n1200-1206\n1208-1246\n1248\n124A-124D\n1250-1256\n1258\n125A-125D\n1260-1286\n1288\n128A-128D\n1290-12AE\n12B0\n12B2-12B5\n12B8-12BE\n12C0\n12C2-12C5\n12C8-12CE\n12D0-12D6\n12D8-12EE\n12F0-130E\n1310\n1312-1315\n1318-131E\n1320-1346\n1348-135A\n1361-137C\n13A0-13F4\n1401-1676\n1681-169A\n16A0-16F0\n1700-170C\n170E-1711\n1720-1731\n1735-1736\n1740-1751\n1760-176C\n176E-1770\n1780-17B6\n17BE-17C5\n17C7-17C8\n17D4-17DA\n17DC\n17E0-17E9\n1810-1819\n1820-1877\n1880-18A8\n1E00-1E9B\n1EA0-1EF9\n1F00-1F15\n1F18-1F1D\n1F20-1F45\n1F48-1F4D\n1F50-1F57\n1F59\n1F5B\n1F5D\n1F5F-1F7D\n1F80-1FB4\n1FB6-1FBC\n1FBE\n1FC2-1FC4\n1FC6-1FCC\n1FD0-1FD3\n1FD6-1FDB\n1FE0-1FEC\n1FF2-1FF4\n1FF6-1FFC\n200E\n2071\n207F\n2102\n2107\n210A-2113\n2115\n2119-211D\n2124\n2126\n2128\n212A-212D\n212F-2131\n2133-2139\n213D-213F\n2145-2149\n2160-2183\n2336-237A\n2395\n249C-24E9\n3005-3007\n3021-3029\n3031-3035\n3038-303C\n3041-3096\n309D-309F\n30A1-30FA\n30FC-30FF\n3105-312C\n3131-318E\n3190-31B7\n31F0-321C\n3220-3243\n3260-327B\n327F-32B0\n32C0-32CB\n32D0-32FE\n3300-3376\n337B-33DD\n33E0-33FE\n3400-4DB5\n4E00-9FA5\nA000-A48C\nAC00-D7A3\nD800-FA2D\nFA30-FA6A\nFB00-FB06\nFB13-FB17\nFF21-FF3A\nFF41-FF5A\nFF66-FFBE\nFFC2-FFC7\nFFCA-FFCF\nFFD2-FFD7\nFFDA-FFDC\n10300-1031E\n10320-10323\n10330-1034A\n10400-10425\n10428-1044D\n1D000-1D0F5\n1D100-1D126\n1D12A-1D166\n1D16A-1D172\n1D183-1D184\n1D18C-1D1A9\n1D1AE-1D1DD\n1D400-1D454\n1D456-1D49C\n1D49E-1D49F\n1D4A2\n1D4A5-1D4A6\n1D4A9-1D4AC\n1D4AE-1D4B9\n1D4BB\n1D4BD-1D4C0\n1D4C2-1D4C3\n1D4C5-1D505\n1D507-1D50A\n1D50D-1D514\n1D516-1D51C\n1D51E-1D539\n1D53B-1D53E\n1D540-1D544\n1D546`;\n\nexport const L_BIDI_CHAR_RANGE_MAP = decodeCharacterRangeMap(L_BIDI_CHARS);\n\nconst R_AND_AL_BIDI_CHARS =\n`05BE\n05C0\n05C3\n05D0-05EA\n05F0-05F4\n061B\n061F\n0621-063A\n0640-064A\n066D-066F\n0671-06D5\n06DD\n06E5-06E6\n06FA-06FE\n0700-070D\n0710\n0712-072C\n0780-07A5\n07B1\n200F\nFB1D\nFB1F-FB28\nFB2A-FB36\nFB38-FB3C\nFB3E\nFB40-FB41\nFB43-FB44\nFB46-FBB1\nFBD3-FD3D\nFD50-FD8F\nFD92-FDC7\nFDF0-FDFC\nFE70-FE74\nFE76-FEFC`;\n\nexport const R_AND_AL_BIDI_CHAR_RANGE_MAP = decodeCharacterRangeMap(R_AND_AL_BIDI_CHARS);\n\nfunction decodeCharacterRangeMap(encodedMap: string): number[][] {\n    const map: number[][] = [];\n    const conditions = encodedMap.split('\\n');\n    for (const condition of conditions) {\n        const trimmedCondition = condition.trim();\n        if (trimmedCondition === '') {\n            continue;\n        }\n        const range = trimmedCondition.split('-');\n        if (range.length  === 1) {\n            map.push([parseInt(range[0], 16)]);\n        }\n        else {\n            map.push([parseInt(range[0], 16), parseInt(range[1], 16)]);\n        }\n    }\n    return map;\n}\n","import { isSafari } from '@ad/utils/browser';\nimport { characterPropertyToUnitMap, ICharacterProperties, IContentLine, ICreativeDataNode, IEndSpan, IFontFamily, IFontStyle, INewlineSpan, IOffset, ISpaceSpan, IText, ITextProperties, ITextShadow, IVariableSpan, IWordSpan, JoinType, OneOfContentSpans, OneOfEditableSpans, OneOfRenderedSpans, OneOfTextDataNodes, OneOfTextViewElements, SpanType, TextDirection, textPropertyToUnitMap, VARIABLE_PREFIX } from '@studio/domain';\nimport { cloneDeep, cloneMapDeep } from '@studio/utils/clone';\nimport { inject, __inject } from '@studio/utils/di.decorators';\nimport { injectFontFace } from '@studio/utils/dom-utils';\nimport { handleError } from '@studio/utils/errors';\nimport { EventEmitter } from '@studio/utils/event-emitter';\nimport { deepEqual, encodeHtml, mod, omit, pick } from '@studio/utils/utils';\nimport { hasActionPreventClickthrough, hasActionTargetUrl } from '../../actions/actions.utils';\nimport { Color } from '../../color';\nimport { parseColor, toRGBA } from '../../color.utils';\nimport { T as S } from '../../creative.container';\nimport { textShadowsCSSValue } from '../../css-styles';\nimport { IFeedStore } from '../feed/feed-store.header';\nimport { L_BIDI_CHAR_RANGE_MAP, R_AND_AL_BIDI_CHAR_RANGE_MAP } from './rich-text.bidi-chars';\nimport { IRichTextEditorService } from './rich-text.editor.header';\nimport { IRichText } from './rich-text.header';\nimport { TextSelection } from './rich-text.selection.text';\nimport { IContentSpanSplit, IEditorState } from './rich-text.types';\nimport { CharacterCode, copySpan, copySpans, copyStyle, createSpansFromString, forEachSpan, getHorizontalFlexAlignment, getVerticalFlexAlignment, hasSameStyleIds, hasSameStyleProperty, isContentSpan, isVariableSpan } from './text-nodes';\n\nexport const STYLE_INDEX_MARGIN_RIGHT = 4;\nexport const FALLBACK_FONT_FAMILY = 'Helvetica, Arial, Tahoma, \"Microsoft Yahei\", 微软雅黑, STXihei, 华文细黑, sans-serif';\n\ninterface ISize {\n    width: number;\n    height: number;\n}\n\nexport interface ITextRange {\n    startNode: Node;\n    startOffset: number;\n    endNode: Node;\n    endOffset: number;\n}\n\ninterface ISpanDistributionAbortSignal {\n    shouldAbort: boolean;\n}\n\nexport interface IRichTextRenderOption {\n    renderUnderscoreLayer?: boolean;\n    element?: OneOfTextDataNodes;\n    viewElement?: OneOfTextViewElements;\n    feedStore?: IFeedStore;\n    skipFontLoad?: boolean;\n    inDesignView?: boolean;\n    document?: ICreativeDataNode;\n    renderOverflowedText?: boolean;\n}\n\nexport type IStyle = Partial<ICharacterProperties>;\n\nexport class RichText extends EventEmitter<'selectionchange' | 'change' | 'variableselected' | 'hidevariablesettings' | 'focus' | 'blur' | 'interactionsStarted' | 'interactionsEnded' | 'destroyed' | 'historychange' | 'spanClicked'> implements IRichText {\n    style: ITextProperties & Partial<ISize>;\n    textElement_m: HTMLDivElement;\n    textLines_m: IContentLine[];\n    lineToTextLineElementMap_m: Map<number, HTMLDivElement>;\n    textLineElementToLineMap_m: WeakMap<HTMLDivElement, number>;\n    selectionSpanElements_m: HTMLSpanElement[] = [];\n    lineToSpanDecorationLineElementMap_m = new Map<number, HTMLDivElement>();\n    lineToSpanDecorationBackgroundLineElementMap_m = new Map<number, HTMLDivElement>();\n    fontSizeDiff_m: number;\n    reachedTruncationLine_m = false;\n    spans_m: OneOfEditableSpans[] = [];\n    lastVerticalMargin_m = 0;\n    wordWidth_m = 0;\n    variableSpanMap_m = new Map<string, { span: OneOfContentSpans, style: Partial<ICharacterProperties> }>();\n    rows_m = 0;\n    renderUnderscoreLayer_m?: boolean;\n    element_m?: OneOfTextDataNodes;\n    viewElement_m?: OneOfTextViewElements;\n    initTask_m: Promise<void>;\n    feedStore_m: IFeedStore;\n    blurSuspensionListeners_m: { element: HTMLElement, callback: (...args: any[]) => any }[] = [];\n    centerElement_m: HTMLDivElement;\n\n    /**\n     * Resized element font size is the scaled element font size and not the original. When we resize to fit\n     * text inside a box, we want to store the resized(scaled) element font size.\n     */\n    resizedElementFontSize_m: number;\n\n    private _centerElements: HTMLDivElement[] = [];\n    private _lastBreakIndex?: number;\n    private _previousSpanType?: SpanType;\n    private _scrollHeight: number;\n    private _currentContentLine?: IContentLine;\n    private _previousContentLine?: IContentLine;\n    private _scale = 1;\n    private _widestWord = 0;\n    private _longestLine: number;\n    private _currentLineWidth = 0;\n    private _skipFontLoad: boolean;\n    private _elementStyle: ITextProperties & Partial<ISize>;\n    private _calibratorElement: HTMLDivElement;\n    private _textIntrospecter: CanvasRenderingContext2D;\n\n    constructor(\n        public text_m: IText,\n        public rootElement_m: HTMLDivElement,\n        private _option: IRichTextRenderOption,\n        @inject(S.EDITOR_STATE, { optional: true })\n        public editorState_m?: IEditorState,\n        @inject(S.RICH_TEXT_EDITOR, { optional: true })\n        public editor_m?: IRichTextEditorService,\n        @inject(S.FONT_FAMILIES, { optional: true })\n        private _fontFamilies?: IFontFamily[]) {\n        super();\n\n        this.spans_m = copySpans(this.text_m.spans);\n        this.style = this._elementStyle = Object.assign({}, this.text_m.style);\n        this._syncProperties();\n        this._renderTextContainers();\n\n        this.renderUnderscoreLayer_m = _option.renderUnderscoreLayer;\n        this.element_m = _option.element;\n        this.viewElement_m = _option.viewElement;\n        this.feedStore_m = _option.feedStore!;\n        this._skipFontLoad = !!_option.skipFontLoad;\n    }\n\n    get textSelection_m(): TextSelection | undefined {\n        return this.editor_m?.selection.selection;\n    }\n    set textSelection_m(selection: TextSelection | undefined) {\n        if (this.editor_m) {\n            this.editor_m.selection.selection = selection;\n        }\n    }\n\n\n    get zoom_m(): number {\n        return this.editorState_m?.zoom || 1;\n    }\n\n    /**\n     * Returns all the selected characters. Or, if no selection, empty string.\n     * Without spaces.\n     */\n    get selectedCharacters(): string {\n        const selection = this.textSelection_m;\n        if (!selection) {\n            return '';\n        }\n        let text = '';\n        for (const span of this.spans_m) {\n            if (span.type === SpanType.Variable && span.style.variable) {\n                // Get all feeded characters\n                const feedData = this.feedStore_m.getFeed(span.style.variable.id);\n                const allTextsFromFeed = feedData?.data\n                    ?.map((feedElement) => feedElement[span.style.variable!.path || '']?.value || '')\n                    .join('');\n                text += allTextsFromFeed;\n                continue;\n            }\n            if (span.type !== SpanType.Word) { continue; }\n            // Selected text will be inside spans withoud a line/column defined\n            if (typeof span.line === 'undefined' || typeof span.column === 'undefined') {\n                text += span.content;\n            }\n        }\n        return text;\n    }\n\n    init_m(): void {\n        this.renderTextIntrospecter_m();\n        this.initTask_m = new Promise<void>(async (resolve) => {\n            await this._applyFontInRootElement();\n            this.runTextPipeline_m(/* normalize */ false);\n            resolve();\n        });\n    }\n\n    private _renderTextContainers(): void {\n        this.rootElement_m.style.backgroundColor = 'transparent';\n\n        this.centerElement_m = document.createElement('div');\n        this.centerElement_m.classList.add('center');\n        const style = this.centerElement_m.style;\n        style.width = '100%';\n        style.height = '100%';\n        style.display = 'flex';\n        style.alignItems = getVerticalFlexAlignment(this.style.verticalAlignment);\n        style.justifyContent = getHorizontalFlexAlignment(this.style.horizontalAlignment);\n\n        this.textElement_m = document.createElement('div');\n        this.textElement_m.classList.add('text-content');\n        this.textElement_m.style.outline = 'none';\n        this.textElement_m.style.position = 'relative';\n        this.textElement_m.style.width = '100%';\n\n        // For better sharpness\n        this.textElement_m.spellcheck = false;\n\n        this.centerElement_m.appendChild(this.textElement_m);\n        this.rootElement_m.appendChild(this.centerElement_m);\n    }\n\n    resetDirtyContent(element: OneOfTextDataNodes): void {\n        element.__dirtyContent = undefined;\n    }\n\n    setText(text: IText, keepSelection?: boolean, reinitialize?: boolean, keepStyle?: boolean): void {\n        /* webpack-strip-block:removed */\n        this.text_m = text;\n        this.spans_m = text.spans;\n        if (reinitialize) {\n            this.variableSpanMap_m = new Map();\n        }\n        else {\n            this.normalizeTextLineSpans_m();\n        }\n\n        if (!keepStyle) {\n            this.style = text.style;\n        }\n        this._syncProperties();\n        this.runTextPipeline_m(/* normalize */ !reinitialize);\n        this.emit('change', [this.getText_m()]);\n    }\n\n    // TODO: This is not fired when swapping language, potential memory leak.\n    destroy_m(): void {\n        if (this.editor_m?.inEditMode) {\n            this.editor_m.stopEdit(true);\n        }\n        this.blurSuspensionListeners_m = [];\n        for (const blurSuspension of this.blurSuspensionListeners_m) {\n            blurSuspension.element.removeEventListener('mousedown', blurSuspension.callback);\n        }\n        this._removeTextIntrospecter();\n        if (this.editor_m) {\n            window.removeEventListener('mouseup', this.editor_m.mouseBindings.onMouseUp);\n            window.removeEventListener('mousemove', this.editor_m.mouseBindings.onMouseMove);\n        }\n        this.emit('destroyed');\n        this.clearEvents();\n    }\n\n    private _syncProperties(): void {\n        const computedStyle = getComputedStyle(this.rootElement_m);\n        if (!this.style.fontSize) {\n            this.style.fontSize = parseInt(computedStyle.fontSize!, 10);\n        }\n        if (!this.style.textColor) {\n            this.style.textColor = parseColor(computedStyle.color);\n        }\n        if (!this.style.lineHeight) {\n            this.style.lineHeight = parseFloat(computedStyle.lineHeight!);\n        }\n        if (!this.style.padding) {\n            const padding: IOffset = { top: 0, left: 0, bottom: 0, right: 0 };\n            if (computedStyle.paddingTop) {\n                padding.top = parseInt(computedStyle.paddingTop!, 10);\n            }\n            if (computedStyle.paddingBottom) {\n                padding.bottom = parseInt(computedStyle.paddingBottom!, 10);\n            }\n            if (computedStyle.paddingLeft) {\n                padding.left = parseInt(computedStyle.paddingLeft!, 10);\n            }\n            if (computedStyle.paddingRight) {\n                padding.right = parseInt(computedStyle.paddingRight!, 10);\n            }\n            this.style.padding = padding;\n        }\n        if (!this.style.width || !this.style.height) {\n            const boundingRect = this.rootElement_m.getBoundingClientRect();\n            this.style.width = boundingRect.width;\n            this.style.height = boundingRect.height;\n        }\n\n        // Should default to the first character direction.\n        if (!this.style.horizontalAlignment) {\n            const firstChar = this.spans_m[0]?.content.charCodeAt(0);\n            const dir = RichText.getBidiDirection_m(firstChar);\n            if (dir === TextDirection.Ltr) {\n                this.style.horizontalAlignment = 'left';\n            }\n            else if (dir === TextDirection.Rtl) {\n                this.style.horizontalAlignment = 'right';\n            }\n            else {\n                this.style.horizontalAlignment = 'left';\n            }\n        }\n    }\n\n    private _recalibrateScale(): void {\n        this._scale = this._calibratorElement.getBoundingClientRect().height / 10;\n    }\n\n    async rerender(applyFontInRootElement: boolean = false, element?: OneOfTextViewElements): Promise<void> {\n        this._recalibrateScale();\n        await this.initTask_m;\n        if (applyFontInRootElement) {\n            await this._applyFontInRootElement();\n        }\n        if (element) {\n            this.style.width = element.width;\n            this.style.height = element.height;\n        }\n\n        if (this.textLineElementToLineMap_m) {\n            this.lineToTextLineElementMap_m.forEach(line => {\n                line.removeEventListener('click', this._onClick);\n                (Array.from(line.children) as HTMLElement[]).forEach((child) => {\n                    child.removeEventListener('click', this._onClick);\n                });\n            });\n        }\n\n        if (this.textSelection_m && this.editor_m?.inEditMode) {\n            this.editor_m.selection.storeSelectionCharacterPositions();\n        }\n        this.runTextPipeline_m(/* normalize */ false);\n        if (this.textSelection_m && this.editor_m?.inEditMode) {\n            this.editor_m.selection.reselectText();\n        }\n    }\n\n    runTextPipeline_m(normalize: boolean = true): void {\n        if (normalize) {\n            this.normalizeTextLineSpans_m();\n        }\n        let expandedSpans = this.spans_m;\n        if (!this.editor_m?.inEditMode && !this.renderUnderscoreLayer_m) {\n            expandedSpans = this.expandVariableSpans_m(expandedSpans);\n        }\n        expandedSpans = this._segmentBidiCharacters(expandedSpans);\n        this._applyJointCharacters(expandedSpans);\n        this.distributeAllSpansAcrossTextLines_m(expandedSpans);\n        if (this.style.textOverflow === 'shrink') {\n            this.resizeText(expandedSpans);\n        }\n        this._applyInferredTextDirections();\n        this._applyLeftToSpans();\n        this.renderTextWithDecorations_m();\n    }\n\n    private _applyLeftToSpans(): void {\n        const isLeftAligned = this.style.horizontalAlignment === 'left';\n        for (const textLine of this.textLines_m) {\n            let left = isLeftAligned ? 0 : this.style.width! - this.style.padding.left - this.style.padding.right;\n            let currentRtlSpans: OneOfRenderedSpans[] = [];\n            let currentLtrSpans: OneOfRenderedSpans[] = [];\n            for (const span of textLine.spans) {\n                if (span.dir === TextDirection.Rtl) {\n                    if (isLeftAligned) {\n                        span.left = left;\n                        let width = span.width;\n                        for (const s of currentRtlSpans) {\n                            s.left = left + width;\n                            width += s.width;\n                        }\n                        currentRtlSpans.unshift(span);\n                    }\n                    else {\n                        if (currentLtrSpans.length > 0) {\n                            const lastLtrSpan = currentLtrSpans.pop()!;\n                            left -= lastLtrSpan.left + lastLtrSpan.width;\n                        }\n                        left -= span.width;\n                        span.left = left;\n                        currentLtrSpans = [];\n                    }\n                }\n                else {\n                    if (isLeftAligned) {\n                        if (currentRtlSpans.length > 0) {\n                            const lastRtlSpan = currentRtlSpans.pop()!;\n                            left += lastRtlSpan.left + lastRtlSpan.width;\n                        }\n                        span.left = left;\n                        left += span.width;\n                        currentRtlSpans = [];\n                    }\n                    else {\n                        span.left = left;\n                        let width = span.width;\n                        for (const s of currentLtrSpans) {\n                            s.left = left - width;\n                            width -= s.width;\n                        }\n                        currentLtrSpans.unshift(span);\n                    }\n                }\n            }\n        }\n    }\n\n    private _applyInferredTextDirections(): void {\n        for (const textLine of this.textLines_m) {\n            let prevDir = TextDirection.Ltr;\n            let nextDir: TextDirection | undefined = TextDirection.Ltr;\n            for (let i = 0; i < textLine.spans.length; i++) {\n                nextDir = i + 1 < textLine.spans.length ? textLine.spans[i + 1].dir : undefined;\n                const span = textLine.spans[i];\n                const isFirstSpan = i === 0;\n                const isLastSpan = i === textLine.spans.length - (textLine.isLastLine ? 2 : 1);\n                if (span.dir === TextDirection.InferFromContext || span.dir === TextDirection.Previous) {\n                    if (isFirstSpan) {\n                        span.dir = TextDirection.Ltr;\n                        textLine.dir = TextDirection.Ltr;\n                    }\n                    else if (isLastSpan) {\n                        // Note, trailing space in LTR text are rendered like this 'wefصثب '. So it has to be LTR.\n                        // But, trailing space in RTL context is rendered like this ' صثب'.\n                        span.dir = textLine.dir;\n                    }\n                    else {\n                        span.dir = nextDir;\n                        if (span.type === SpanType.Space) {\n                            if ((prevDir === TextDirection.Rtl && (nextDir === TextDirection.Rtl || (nextDir === TextDirection.Ltr && textLine.dir === TextDirection.Rtl)))\n                                || (prevDir === TextDirection.Ltr && nextDir === TextDirection.Rtl && textLine.dir === TextDirection.Rtl)) {\n                                span.dir = TextDirection.Rtl;\n                            } else {\n                                span.dir = TextDirection.Ltr;\n                            }\n                        } else {\n                            span.dir = prevDir;\n                        }\n                    }\n                }\n                else {\n                    prevDir = span.dir!;\n                }\n            }\n        }\n    }\n\n    getSpanLength_m(span: OneOfRenderedSpans): number {\n        if (isContentSpan(span)) {\n            return span.content.length + (span.startJoint ? 1 : 0) + (span.endJoint ? 1 : 0);\n        }\n        return 0;\n    }\n\n    private _applyJointCharacters(spans: OneOfEditableSpans[]): void {\n        for (let i = 0; i < spans.length - 1; i++) {\n            const curSpan = spans[i];\n            const nextSpan = spans[i + 1];\n            if (curSpan.type === SpanType.Word && nextSpan.type === SpanType.Word && curSpan.dir === TextDirection.Rtl && nextSpan.dir === TextDirection.Rtl) {\n                curSpan.endJoint = JoinType.ZeroWidthJoint;\n                nextSpan.startJoint = JoinType.ZeroWidthJoint;\n            }\n            else {\n                curSpan.endJoint = JoinType.ZeroWidthNoJoint;\n            }\n        }\n    }\n\n    private _segmentBidiCharacters(spans: OneOfEditableSpans[]): OneOfEditableSpans[] {\n        const result: OneOfEditableSpans[] = [];\n        for (const span of spans) {\n            if (isContentSpan(span)) {\n                if (span.content.length === 0) {\n                    result.push(span);\n                    continue;\n                }\n                let currentSpan = span.type === SpanType.Variable ? span : copySpan(span);\n                if (span.type === SpanType.Word) {\n                    const charAtZero = span.content.charCodeAt(0);\n                    let currentDirection = RichText.getBidiDirection_m(charAtZero);\n                    currentSpan.content = String.fromCharCode(charAtZero);\n                    currentSpan.dir = currentDirection;\n                    for (let i = 1; i < span.content.length; i++) {\n                        const char = span.content.charCodeAt(i);\n                        const direction = RichText.getBidiDirection_m(char);\n                        if (currentDirection !== direction && direction !== TextDirection.Previous) {\n                            result.push(currentSpan);\n                            currentSpan = copySpan(span);\n                            currentSpan.content = String.fromCharCode(char);\n                            currentSpan.dir = currentDirection = direction;\n                        }\n                        else {\n                            currentSpan.content += String.fromCharCode(char);\n                        }\n                    }\n                }\n                else {\n                    currentSpan.dir = TextDirection.InferFromContext;\n                }\n                result.push(currentSpan);\n                continue;\n            }\n            else {\n                span.dir = TextDirection.Ltr;\n            }\n            result.push(span);\n        }\n        return result;\n    }\n\n    private _getSpansFromTextLines(): OneOfEditableSpans[] {\n        const spans: OneOfEditableSpans[] = [];\n        for (const textLine of this.textLines_m) {\n            for (const span of textLine.spans) {\n                if (span.type === SpanType.Ellipsis) {\n                    throw new Error('Ellipsis cannot exist in this stage.');\n                }\n                spans.push(span);\n            }\n        }\n        return spans;\n    }\n\n    private _linearlyScaleText(width: number, height: number): void {\n        const widthOccupation = this._longestLine !== 0 && this.style.width !== 0\n            ? this._longestLine / width\n            : 0;\n        const heightOccuptation = this._scrollHeight !== 0 && this.style.height !== 0\n            ? this._scrollHeight / height\n            : 0;\n        if (heightOccuptation > widthOccupation) {\n            this.resizedElementFontSize_m = this.resizedElementFontSize_m / heightOccuptation;\n            this._scaleTextLineMetadata(1 / heightOccuptation);\n        }\n        else {\n            this.resizedElementFontSize_m = this.resizedElementFontSize_m / widthOccupation;\n            this._scaleTextLineMetadata(1 / widthOccupation);\n        }\n    }\n\n    private _scaleTextLineMetadata(scale: number): void {\n        for (const textLine of this.textLines_m) {\n            textLine.lineHeight *= scale;\n            textLine.lineWidth *= scale;\n            textLine.trailingSpaceWidth *= scale;\n            for (const span of textLine.spans) {\n                span.width *= scale;\n                span.lineHeight *= scale;\n            }\n        }\n    }\n\n    private _getInlineContentArea(): number {\n        let area = 0;\n        for (const textLine of this.textLines_m) {\n            area += textLine.lineWidth * textLine.lineHeight;\n        }\n        return area;\n    }\n\n    resizeText(spans: OneOfEditableSpans[]): void {\n        const elementHeight = Math.max(this.style.height! - this.style.padding!.top! - this.style.padding!.bottom!, 0);\n        const elementWidth = Math.max(this.style.width! - this.style.padding!.left! - this.style.padding!.right!, 0);\n        const elementArea = elementWidth * elementHeight;\n\n        // Text resize doesn't work with too small element size.\n        if (elementHeight < 3 || elementWidth < 3) {\n            this.resizedElementFontSize_m = 0;\n            return;\n        }\n        const resizeOccupationFactors = new Map<number/* resizedElementFontSize */, number/* occupationFactor */>();\n\n        let inFirstLoop = true;\n        do {\n            const contentWidth = this._longestLine;\n            const contentHeight = this._scrollHeight || 0;\n            const widthOccupation = contentWidth / elementWidth;\n            const heightOccupation = contentHeight / elementHeight;\n            const contentArea = this._getInlineContentArea();\n            const noOverflow = contentWidth <= elementWidth && contentHeight <= elementHeight;\n\n            // Cancel resize when we hit a tolerance of 1% diff area. Or if it is in the first loop, because then it does not need resize to fit\n            if (noOverflow && inFirstLoop) {\n                this._resetResizeMetadata();\n                return;\n            }\n            if (inFirstLoop) {\n                const newResettedFontSize = 40;\n                this.resizedElementFontSize_m = newResettedFontSize;\n                this._resetResizeMetadata();\n                this.distributeAllSpansAcrossTextLines_m(spans, this.resizedElementFontSize_m);\n\n                this.fontSizeDiff_m = 1 / this.resizedElementFontSize_m;\n                this.resizedElementFontSize_m = 1;\n                this._redistributeAllSpansAcrossLines(spans, false);\n                inFirstLoop = false;\n                continue;\n            }\n\n            // We are taking 0.1 steps incrementally to find the optimal font size. Note, we tried to increase it faster\n            // in different tiers before, but the fallback we saw with that solution is that it often hits \"pockets\", where\n            // it cannot come out from.\n            const fontSizeDiffFactor = (this.resizedElementFontSize_m + 0.1) / this.resizedElementFontSize_m;\n\n            // Occupation factor defines how \"good\" a particular font size occupies the text. We use the ratio of areas and ratio of ratios\n            // as a measure. Since, having just one of these generates positive falses, and we want to filter them.\n            const areaRatio = contentArea / elementArea;\n            const ratioRatio = ((contentWidth / contentHeight) / (elementWidth / elementHeight));\n\n            // We want to construct an occupation factor which where the area ratio is weighted higher than ratio of ratio.\n            // We divide one by abs(1- area/ratio) to get an inverse propoprtion relation of the proximity of 1.\n            const areaRatioWeight = 0.9;\n            const ratioRatioWeight = 0.1;\n            const occupationFactor = (1 / Math.abs(1 - areaRatio) * areaRatioWeight) + (1 / Math.abs(1 - ratioRatio) * ratioRatioWeight);\n            if (noOverflow) {\n                resizeOccupationFactors.set(this.resizedElementFontSize_m, occupationFactor);\n            }\n            if (widthOccupation !== heightOccupation) {\n                this.fontSizeDiff_m = fontSizeDiffFactor;\n                this.resizedElementFontSize_m = this.resizedElementFontSize_m * fontSizeDiffFactor;\n                this._redistributeAllSpansAcrossLines(spans, false);\n            }\n            else {\n                this._resetResizeMetadata();\n                return;\n            }\n        }\n        while (this.resizedElementFontSize_m < this.style.fontSize!);\n\n        let bestOccupation = 0;\n        let bestFontSize = this.resizedElementFontSize_m;\n        for (const [fontSize, resizeOccupationFactor] of resizeOccupationFactors.entries()) {\n            if (resizeOccupationFactor > bestOccupation) {\n                bestOccupation = resizeOccupationFactor;\n                bestFontSize = fontSize;\n            }\n        }\n        this.fontSizeDiff_m = bestFontSize / this.resizedElementFontSize_m;\n        this.resizedElementFontSize_m = bestFontSize;\n\n        // Hack for Safari https://github.com/GoogleForCreators/web-stories-wp/issues/6323\n        if (isSafari) {\n            this.resizedElementFontSize_m = Math.floor(this.resizedElementFontSize_m);\n        }\n        this._redistributeAllSpansAcrossLines(spans, false);\n\n        this._linearlyScaleText(elementWidth, elementHeight);\n        this._resetResizeMetadata();\n    }\n\n    private _resetResizeMetadata(): void {\n        this.lastVerticalMargin_m = 0;\n    }\n\n    setStyle_m<K extends keyof ITextProperties>(property: K, value: ITextProperties[K], style: Partial<ITextProperties>): void {\n        if (hasSameStyleProperty(property, { [property]: value }, this.style)) {\n            if (style !== this.style) {\n                delete style[property];\n            }\n        }\n        else {\n            if (value === '$mixed') {\n                style[property] = value;\n                return;\n            }\n            const unit = textPropertyToUnitMap[property];\n            switch (unit) {\n                case 'Color':\n                    style.textColor = (value as Color).copy() as Color;\n                    break;\n                case 'FontStyle':\n                case 'Padding':\n                case 'Variable':\n                    style[property] = Object.assign({}, value);\n                    break;\n                case 'TextShadow[]':\n                    style.textShadows = value && (value as ITextShadow[]).map((item) => Object.assign({}, item));\n                    break;\n                case 'boolean':\n                    if (typeof value !== 'boolean') {\n                        delete style[property];\n                    }\n                    else {\n                        style[property] = value;\n                    }\n                    break;\n                default:\n                    style[property] = value;\n                    break;\n            }\n        }\n    }\n\n    getText_m(): IText {\n        return {\n            style: this.style,\n            spans: copySpans(this.spans_m),\n        };\n    }\n\n    splitSpan_m(span: OneOfContentSpans, column: number): IContentSpanSplit {\n        const preContent = span.type === SpanType.Variable ? '' : span.content.slice(0, column);\n        const postContent = span.type === SpanType.Variable ? span.content : span.content.slice(column);\n        const spans = {} as IContentSpanSplit;\n        spans.preContentSpan = {\n            type: span.type,\n            dir: span.dir,\n            content: preContent,\n            style: copyStyle(span.style),\n            attributes: span.attributes.styleIndex !== undefined ? { styleIndex: span.attributes.styleIndex, shouldRenderNumber: false } : { shouldRenderNumber: false },\n            styleIds: cloneMapDeep(span.styleIds),\n            styleId: span.styleId,\n            __previousStyleIds: span.__previousStyleIds && [...span.__previousStyleIds],\n            __previousStyleIdToHistoryIndexMap: span.__previousStyleIdToHistoryIndexMap && new Map(span.__previousStyleIdToHistoryIndexMap),\n        } as IWordSpan | ISpaceSpan;\n        spans.postContentSpan = {\n            type: span.type,\n            dir: span.dir,\n            content: postContent,\n            style: copyStyle(span.style),\n            attributes: span.attributes.styleIndex !== undefined ? { styleIndex: span.attributes.styleIndex, shouldRenderNumber: false } : { shouldRenderNumber: false },\n            styleIds: cloneMapDeep(span.styleIds),\n            styleId: span.styleId,\n            __previousStyleIds: span.__previousStyleIds && [...span.__previousStyleIds],\n            __previousStyleIdToHistoryIndexMap: span.__previousStyleIdToHistoryIndexMap && new Map(span.__previousStyleIdToHistoryIndexMap),\n        } as IWordSpan | ISpaceSpan;\n        return spans;\n    }\n\n    removeDecorationLayers_m(): void {\n        let centerElement: HTMLDivElement | undefined;\n        while (centerElement = this._centerElements.pop()) {\n            if (this.rootElement_m.contains(centerElement)) {\n                this.rootElement_m.removeChild(centerElement);\n            }\n        }\n    }\n\n    private async _applyFontInRootElement(): Promise<void> {\n        this.textLines_m = [];\n\n        // Don't try to preload fonts if there are no uploaded fonts\n        if (!this._skipFontLoad && this.style.font) {\n            try {\n                // @@remove STUDIO:START\n                if (process.env.STUDIO_JS) {\n                    const fontLoads: Promise<FontFace>[] = [];\n                    const fontStylesInSpans = this._getAllFontsInSpans().add(this.style.font.id);\n                    for (const fontStyleId of fontStylesInSpans.values()) {\n                        let foundFontStyle = false;\n                        for (const fontFamily of this._fontFamilies!) {\n                            const fontStyle = fontFamily.fontStyles.find(({ id }) => id === fontStyleId);\n                            if (fontStyle) {\n                                fontLoads.push(injectFontFace(fontStyle));\n                                foundFontStyle = true;\n                                break;\n                            }\n                        }\n                        if (!foundFontStyle) {\n                            throw new Error(`Did not find font style '${fontStyleId}'.`);\n                        }\n                    }\n                    const fontFaces = await Promise.all(fontLoads);\n                    for (const fontFace of fontFaces) {\n                        document.fonts.add(fontFace);\n                    }\n                }\n                // @@remove STUDIO:END\n            }\n            catch (e) {\n                handleError('Could not load font face', { enabled: !!process.env.STUDIO_JS, contexts: { fontFaceId: this.style.font.id } });\n            }\n        }\n\n        const element = this.rootElement_m;\n        // element.style.fontFamily = this._resolveCssFontFamily(this.style.font, element);\n        element.style.fontSize = this.style.fontSize ? this.style.fontSize + 'px' : '';\n    }\n\n    private _getAllFontsInSpans(): Set<string/* fontStyleId */> {\n        const fontStyleIds = new Set<string>();\n\n        const documentId = this.editorState_m?.document.id ?? this._option.document!.id;\n        for (const span of this.text_m.spans) {\n            if (isContentSpan(span)) {\n                const styleId = span.styleIds.get(documentId)!;\n                const style = this._option.element!.characterStyles.get(styleId)!;\n                if (style && style.font) {\n                    fontStyleIds.add(style.font.id);\n                }\n            }\n        }\n        return fontStyleIds;\n    }\n\n    renderTextIntrospecter_m(): void {\n        if (!this._textIntrospecter) {\n            this._calibratorElement = document.createElement('div');\n            this._calibratorElement.style.height = '10px';\n            this._calibratorElement.style.top = '-10000px';\n            this._calibratorElement.style.position = 'absolute';\n            this.textElement_m.ownerDocument!.body.appendChild(this._calibratorElement);\n\n            const canvas = this.textElement_m.ownerDocument!.createElement('canvas');\n            this._textIntrospecter = canvas.getContext('2d')!;\n        }\n    }\n\n    private _removeTextIntrospecter(): void {\n        this._textIntrospecter = undefined as any;\n        this._calibratorElement.remove();\n    }\n\n    private _emptyTextLines(textLines: IContentLine[]): void {\n        this._currentContentLine = {\n            spans: [{ type: SpanType.End, content: 'END', dir: TextDirection.Ltr, top: 0, left: 0, width: 0, height: 0, lineHeight: 0, attributes: {}, startJoint: JoinType.None, endJoint: JoinType.None }],\n            dir: TextDirection.InferFromContext,\n            lineHeight: 0,\n            maxFontSize: 1,\n            lineWidth: 0,\n            characterWidth: 0,\n            trailingSpaceWidth: 0,\n            endsWithNewline: false,\n            isLastLine: false,\n        };\n        textLines.splice(0, Infinity, this._currentContentLine);\n    }\n\n    private _truncateCurrentContentLine(textLines: IContentLine[]): void {\n        let lineWidth = 0;\n        const spans: OneOfRenderedSpans[] = [];\n        outer: for (let i = 0; i < this._currentContentLine!.spans.length; i++) {\n            const span = this._currentContentLine!.spans[i] as OneOfContentSpans | IEndSpan;\n            if (span.type === SpanType.End) {\n                break;\n            }\n            if (span.type === SpanType.Newline) {\n                spans.push({ type: SpanType.Ellipsis, content: '...', style: {}, top: 0, left: 0, width: 0, height: 0, lineHeight: 0, attributes: {}, startJoint: JoinType.None, endJoint: JoinType.None });\n                break;\n            }\n            const spanSize = this._introspectSpan({\n                type: SpanType.Word,\n                content: '...',\n                lineHeight: 0,\n                dir: TextDirection.Ltr,\n                style: span.style,\n                top: 0,\n                left: 0,\n                width: 0,\n                height: 0,\n                attributes: {},\n                styleIds: new Map<string, string>(),\n                __previousStyleIds: this.editorState_m ? [] : undefined,\n                __previousStyleIdToHistoryIndexMap: this.editorState_m ? new Map<string, number>() : undefined,\n            }, /* useDom */ true);\n            const relativeFontSize = this.resizedElementFontSize_m;\n            const characterSpacing = (this.style.characterSpacing || 0) * relativeFontSize;\n            const ellipsisWidth = spanSize.width - characterSpacing;\n\n\n            const copyOfSpan = copySpan(span);\n            for (let offset = 0; offset <= span.content.length; offset++) {\n                copyOfSpan.content = span.content.substring(0, offset);\n                const introspectSpanSize = this._introspectSpan(copyOfSpan, true);\n                const spanWidth = introspectSpanSize.width;\n                if (introspectSpanSize && lineWidth + spanWidth + ellipsisWidth > this.style.width! - (this.style.padding.top + this.style.padding.bottom)) {\n                    if (offset === 0) {\n\n                        // If ellipses is wider than the element width. Don't show anything.\n                        this._emptyTextLines(textLines);\n                        return;\n                    }\n                    const { preContentSpan } = this.splitSpan_m(span, offset - 1);\n                    preContentSpan.width = spanWidth;\n                    preContentSpan.lineHeight = introspectSpanSize.height;\n                    spans.push(preContentSpan, {\n                        type: SpanType.Ellipsis,\n                        content: '...',\n                        top: 0,\n                        style: span.style,\n                        left: 0,\n                        width: 0,\n                        height: 0,\n                        lineHeight: 0,\n                        attributes: {},\n                        startJoint: JoinType.None,\n                        endJoint: JoinType.None\n                    });\n                    break outer;\n                }\n            }\n            spans.push(span);\n            lineWidth += span.width;\n        }\n        this._currentContentLine!.spans = spans;\n        this._calculateCurrentContentLineDimensions();\n    }\n\n\n    /**\n     * Distribute one space accross text lines.\n     *\n     * @param editableSpan Span to be distributed.\n     * @param textLines Targeted text lines to recieve the span.\n     * @param abortSignal Abort signal that is used in distributeAllSpansAcrossTextLines to abort distribution when needed.\n     * @param useDomIntrospection Introspect spans using the DOM (expensive)\n     * @param restOfSpans Should only be provided to calculate the truncation of current line.\n     * @param forceAppendToCurrentContentLine Force append to current contentlLine. Should only be called when we already splitted words.\n     * @param forcedFontSize Force to apply a certain font size. The span font size is relative to this font size.\n     */\n    private _distributeOneSpanAcrossTextLines = (editableSpan: OneOfEditableSpans, textLines: IContentLine[], abortSignal: ISpanDistributionAbortSignal, useDomIntrospection: boolean = true, restOfSpans: OneOfEditableSpans[], forceAppendToCurrentContentLine: boolean = false, forcedFontSize?: number): void => {\n        const self = this;\n        if (!this._currentContentLine) {\n            this._currentContentLine = self._createContentLine();\n            textLines.push(this._currentContentLine);\n            this._currentLineWidth = 0;\n        }\n\n        if (isVariableSpan(editableSpan)) {\n            editableSpan.content = editableSpan.content.replace(/%20/gi, ' ');\n        }\n\n        const spanSize = this._introspectSpan(editableSpan, useDomIntrospection, forcedFontSize);\n        const fontSize = (editableSpan as OneOfContentSpans).style && (editableSpan as OneOfContentSpans).style.fontSize || this.resizedElementFontSize_m;\n        const lineHeight = (((editableSpan as OneOfContentSpans).style && (editableSpan as OneOfContentSpans).style.lineHeight) || this.style.lineHeight);\n\n        editableSpan.top = (lineHeight - 1) * fontSize / 2;\n        editableSpan.width = spanSize.width;\n        editableSpan.height = spanSize.height - (lineHeight - 1) * fontSize;\n        editableSpan.lineHeight = spanSize.height;\n\n        if (editableSpan.type === SpanType.End) {\n            appendEndSpan(editableSpan);\n            return;\n        }\n        if (editableSpan.type === SpanType.Newline) {\n            appendNewlineSpan(editableSpan);\n            return;\n        }\n\n        const relativeFontSize = editableSpan.style.fontSize ? this.resizedElementFontSize_m * editableSpan.style.fontSize : this.resizedElementFontSize_m;\n        const characterSpacing = (editableSpan.style.characterSpacing! || this.style.characterSpacing || 0) * relativeFontSize;\n        if (!forceAppendToCurrentContentLine &&\n            (this.style.textOverflow === 'truncate') &&\n            (editableSpan.type === SpanType.Word || editableSpan.type === SpanType.Variable) &&\n            this.wordWidth_m + editableSpan.width + (editableSpan.attributes.shouldRenderNumber ? STYLE_INDEX_MARGIN_RIGHT : 0) - characterSpacing > this.style.width! - this.style.padding.left - this.style.padding.right) {\n            handleWordsBiggerThanWidthOfElement(editableSpan);\n            return;\n        }\n        if ((editableSpan.type === SpanType.Word || editableSpan.type === SpanType.Variable) &&\n            this._previousSpanType === SpanType.Space) {\n            this._lastBreakIndex = this._currentContentLine.spans.length;\n        }\n        if (!forceAppendToCurrentContentLine &&\n            this._lastBreakIndex !== undefined &&\n            editableSpan.type !== SpanType.Space && editableSpan.type !== SpanType.Composition &&\n            this._currentLineWidth + editableSpan.width - characterSpacing /* ending char spacing should not be breakable */ >= this.style.width! - this.style.padding.left - this.style.padding.right &&\n            this._currentContentLine.spans.length !== 0) {\n            appendSpansThatExceedsCurrentContentLine(editableSpan);\n        }\n        else {\n            appendSpanToCurrentContentLine(editableSpan);\n        }\n\n        function appendSpanToCurrentContentLine(span: OneOfContentSpans): void {\n            self._currentContentLine!.lineWidth += span.width;\n            self._currentContentLine!.spans.push(span);\n            if (span.type === SpanType.Word || span.type === SpanType.Variable) {\n                self.wordWidth_m += span.width + (span.attributes.shouldRenderNumber ? STYLE_INDEX_MARGIN_RIGHT : 0);\n                if (self.wordWidth_m > self._widestWord) {\n                    self._widestWord = self.wordWidth_m;\n                }\n            }\n            else {\n                self.wordWidth_m = 0;\n            }\n            saveSpanPositionLeftAndSpanType();\n        }\n\n        function saveSpanPositionLeftAndSpanType(): void {\n            self._currentLineWidth += editableSpan.width;\n            if (editableSpan.attributes && editableSpan.attributes.shouldRenderNumber) {\n                self._currentLineWidth += STYLE_INDEX_MARGIN_RIGHT;\n            }\n            self._previousSpanType = editableSpan.type;\n        }\n\n        function appendSpansThatExceedsCurrentContentLine(span: OneOfContentSpans): void {\n            const belowMaxRows = !self.style.maxRows || self.rows_m < self.style.maxRows!;\n            if ((self.editor_m?.inEditMode && self.style.textOverflow === 'truncate') || belowMaxRows) {\n                const spinOffSpans = self._currentContentLine!.spans.splice(self._lastBreakIndex!, Infinity);\n                self._calculateCurrentContentLineDimensions();\n                const nextLineSpans = spinOffSpans.concat([span]);\n                self._addScrollHeight(textLines, abortSignal, (nextLineSpans as OneOfEditableSpans[]).concat(restOfSpans));\n                if (self.reachedTruncationLine_m) {\n                    return;\n                }\n                self._currentContentLine = self._createContentLine();\n                textLines.push(self._currentContentLine);\n                self.rows_m++;\n                if (!self.editor_m?.inEditMode && self.style.textOverflow === 'truncate') {\n                    self.wordWidth_m = 0; // All spans are redacted and redistributed. So word width should be zero.\n                    for (let i = 0; i < nextLineSpans.length; i++) {\n                        if (self.reachedTruncationLine_m) {\n                            return;\n                        }\n                        self._distributeOneSpanAcrossTextLines(nextLineSpans[i] as OneOfEditableSpans, textLines, abortSignal, useDomIntrospection, (nextLineSpans.slice(i + 1) as OneOfEditableSpans[]).concat(restOfSpans), undefined, forcedFontSize);\n                    }\n                }\n                else {\n                    self.wordWidth_m += span.width + (span.attributes.shouldRenderNumber ? STYLE_INDEX_MARGIN_RIGHT : 0); // The previous span widths are already added, so just add the last one.\n                    if (self.wordWidth_m > self._widestWord) {\n                        self._widestWord = self.wordWidth_m;\n                    }\n                    self._currentContentLine.spans.push(...nextLineSpans);\n                    let left = 0;\n                    for (const lineSpan of nextLineSpans) {\n                        left += lineSpan.width;\n                    }\n                    self._currentLineWidth = left;\n                }\n            }\n            else {\n                self._currentContentLine!.spans.push(span);\n                self._calculateCurrentContentLineDimensions();\n                if (!self.editor_m?.inEditMode && self.style.textOverflow === 'truncate') {\n                    self._addSpansAndTruncateCurrentContentLine(textLines, restOfSpans, abortSignal);\n                }\n                saveSpanPositionLeftAndSpanType();\n            }\n            if (span.attributes && span.attributes.shouldRenderNumber) {\n                self._currentLineWidth += STYLE_INDEX_MARGIN_RIGHT;\n            }\n            self._previousSpanType = span.type;\n            self._lastBreakIndex = undefined;\n        }\n\n        function handleWordsBiggerThanWidthOfElement(span: OneOfContentSpans): void {\n            const { preContentSpan, postContentSpan } = splitWordOverflowedSpan(span);\n            const newRestOfSpans = [postContentSpan as OneOfEditableSpans].concat(restOfSpans);\n            if (preContentSpan.content) {\n\n                // Split word overflow spans needs to be redistributed because they are being split by word width and not\n                // the current left span position. Also truncation can be reached!. Note, for arbic glyphs they can change\n                // when words are separated. For simplicity, we add one option to force append it to current line.\n                self._distributeOneSpanAcrossTextLines(preContentSpan, textLines, abortSignal, /* useDom */ true, newRestOfSpans, false, forcedFontSize);\n                if (self.reachedTruncationLine_m) {\n                    return;\n                }\n            }\n\n            // if empty pre-content and word width is zero, we cannot fit the first character of span. Thus, we\n            // should just show empty text element.\n            else if (self.wordWidth_m === 0) {\n                self.reachedTruncationLine_m = true;\n                abortSignal.shouldAbort = true;\n                return self._emptyTextLines(textLines);\n            }\n            self._calculateCurrentContentLineDimensions();\n            self._addScrollHeight(textLines, abortSignal, newRestOfSpans);\n            if (self.reachedTruncationLine_m) {\n                return;\n            }\n            const belowMaxRows = !self.style.maxRows || self.rows_m < self.style.maxRows!;\n            if (self.editor_m?.inEditMode || belowMaxRows) {\n                self._currentContentLine = self._createContentLine();\n                self.rows_m++;\n                self.wordWidth_m = 0;\n                self._currentLineWidth = 0;\n                textLines.push(self._currentContentLine);\n                self._distributeOneSpanAcrossTextLines(postContentSpan, textLines, abortSignal, /* useDom */ true, restOfSpans, false, forcedFontSize);\n            }\n            else {\n                self._addSpansAndTruncateCurrentContentLine(textLines, [postContentSpan as OneOfEditableSpans].concat(restOfSpans), abortSignal);\n            }\n        }\n\n\n        function splitWordOverflowedSpan(span: OneOfContentSpans): IContentSpanSplit {\n            if (!self._currentContentLine) {\n                throw new Error('Current content line is not set.');\n            }\n            const lastOffset = span.content.length;\n            const copyOfSpan = copySpan(span);\n            for (let offset = 1; offset <= lastOffset; offset++) {\n                copyOfSpan.content = span.content.substring(0, offset);\n                const introspectSpan = self._introspectSpan(copyOfSpan, true);\n                const marginRight = (offset === lastOffset && span.attributes.shouldRenderNumber)\n                    ? STYLE_INDEX_MARGIN_RIGHT\n                    : 0;\n\n                const widthWithoutMargins = self.style.width! - self.style.padding.left - self.style.padding.right;\n\n                if (self.wordWidth_m + introspectSpan.width + marginRight - characterSpacing > widthWithoutMargins) {\n                    return self.splitSpan_m(span, offset - 1);\n                }\n            }\n            throw new Error('Could not split span.');\n        }\n\n        function appendNewlineSpan(span: INewlineSpan): void {\n            self._previousSpanType = SpanType.Newline;\n            if (!self.style.maxRows || self.rows_m < self.style.maxRows!) {\n                self._currentContentLine!.spans.push(span);\n                self._calculateCurrentContentLineDimensions();\n                self._currentContentLine!.endsWithNewline = true;\n                self._addScrollHeight(textLines, abortSignal, restOfSpans);\n                if (self.reachedTruncationLine_m) {\n                    return;\n                }\n                if (!self.style.maxRows || self.rows_m < self.style.maxRows!) {\n                    self._currentContentLine = self._createContentLine();\n                    self.wordWidth_m = 0;\n                    textLines.push(self._currentContentLine);\n                    self.rows_m++;\n                }\n                self._lastBreakIndex = undefined;\n            }\n            else {\n                self._currentContentLine!.spans.push({\n                    type: SpanType.Space,\n                    attributes: {},\n                    dir: TextDirection.InferFromContext,\n                    top: 0,\n                    left: 0,\n                    width: span.width,\n                    height: 0,\n                    lineHeight: 0,\n                    content: ' ',\n                    style: cloneDeep(span.style),\n                    styleIds: new Map(),\n                    __previousStyleIds: [],\n                    __previousStyleIdToHistoryIndexMap: new Map<string, number>(),\n                } as ISpaceSpan);\n                self._calculateCurrentContentLineDimensions();\n            }\n        }\n\n        function appendEndSpan(span: IEndSpan): void {\n            self._currentContentLine!.spans.push(span);\n            self._calculateCurrentContentLineDimensions();\n            self._currentContentLine!.isLastLine = true;\n            self._addScrollHeight(textLines, abortSignal, restOfSpans);\n            if (self.reachedTruncationLine_m) {\n                return;\n            }\n            self._lastBreakIndex = undefined;\n        }\n    };\n\n    private _createContentLine(): IContentLine {\n        return {\n            spans: [],\n            dir: TextDirection.InferFromContext,\n            lineHeight: 0,\n            maxFontSize: 1,\n            lineWidth: 0,\n            trailingSpaceWidth: 0,\n            characterWidth: 0,\n            endsWithNewline: false,\n            isLastLine: false,\n        };\n    }\n\n    private _addSpansAndTruncateCurrentContentLine(textLines: IContentLine[], restOfSpans: OneOfEditableSpans[], metadata: ISpanDistributionAbortSignal): void {\n        this._currentContentLine!.spans.push(...restOfSpans);\n        this._calculateCurrentContentLineDimensions();\n        this._truncateCurrentContentLine(textLines);\n        this.reachedTruncationLine_m = true;\n        metadata.shouldAbort = true;\n    }\n\n    private _calculateCurrentContentLineDimensions(): void {\n        if (!this._currentContentLine) {\n            return;\n        }\n        let lineHeight = 0;\n        let maxFontSize = 0; // Use relative font size\n        let lineWidth = 0;\n        let characterWidth = 0;\n        let trailingSpaceWidth = 0;\n        let left = 0;\n        let isFirstSpanInLine = true;\n        let dir = TextDirection.InferFromContext;\n        for (const span of this._currentContentLine.spans) {\n            if (dir === TextDirection.InferFromContext && isContentSpan(span) && span.dir) {\n                dir = span.dir;\n            }\n            if (span.type === SpanType.End) {\n                if (this._currentContentLine.spans.length === 1) {\n                    let newLineHeight = this.style.lineHeight * this.resizedElementFontSize_m;\n\n                    if (this.editor_m?.currentStyle.lineHeight) {\n                        newLineHeight = this.editor_m?.currentStyle.lineHeight * this.resizedElementFontSize_m;\n                    }\n                    else if (this._previousContentLine?.lineHeight) {\n                        newLineHeight = this._previousContentLine?.lineHeight;\n                    }\n\n                    lineHeight = newLineHeight;\n                }\n                continue;\n            }\n\n            // Newline should not contribute to line height when it is not the first\n            if (span.type !== SpanType.Newline) {\n                if (span.lineHeight > lineHeight) {\n                    lineHeight = span.lineHeight;\n                }\n            }\n            else {\n\n                // Only contribute to line height when the newline is first(or only span in line, which is the same).\n                if (isFirstSpanInLine && span.lineHeight > lineHeight) {\n                    lineHeight = span.lineHeight;\n                }\n                lineWidth += span.width;\n                trailingSpaceWidth += span.width;\n                characterWidth += 1;\n                continue;\n            }\n            const characterSpacing = span.style.characterSpacing || this.style.characterSpacing || 0;\n            const fontSize = span.style.fontSize ? span.style.fontSize * this.resizedElementFontSize_m : this.resizedElementFontSize_m;\n            if (span.type === SpanType.Ellipsis) {\n                trailingSpaceWidth = characterSpacing * fontSize;\n                continue;\n            }\n            span.left = left;\n            if (span.type === SpanType.Word || span.type === SpanType.Variable) {\n                trailingSpaceWidth = characterSpacing * fontSize;\n            }\n            if (span.type === SpanType.Space) {\n                trailingSpaceWidth += span.width;\n            }\n            lineWidth += span.width;\n            if (span.style.fontSize && span.style.fontSize > maxFontSize) {\n                maxFontSize = span.style.fontSize; // Is relative to element font size\n            }\n            characterWidth += span.content.length;\n            left += span.width;\n            if (span.attributes.shouldRenderNumber) {\n                left += STYLE_INDEX_MARGIN_RIGHT;\n            }\n            isFirstSpanInLine = false;\n        }\n        this._currentContentLine.dir = dir;\n        this._currentContentLine.lineWidth = lineWidth;\n        this._currentContentLine.trailingSpaceWidth = trailingSpaceWidth;\n        this._currentContentLine.lineHeight = lineHeight;\n        this._currentContentLine.maxFontSize = maxFontSize || /* Happens only when there is only one newline */ 1;\n        this._currentContentLine.characterWidth = characterWidth;\n        if (lineWidth - trailingSpaceWidth > this._longestLine) {\n            this._longestLine = Math.round((lineWidth - trailingSpaceWidth) * 100) / 100;\n        }\n        this._currentLineWidth = 0;\n        this._previousContentLine = this._currentContentLine;\n    }\n\n    private _addScrollHeight(textLines: IContentLine[], abortSignal: ISpanDistributionAbortSignal, restOfSpans: OneOfEditableSpans[]): void {\n        this._scrollHeight += this._currentContentLine!.lineHeight;\n\n        // Add truncation margin for output, due to difference in browsers/OS:es\n        const truncationMargin = (process.env.ANIMATED_CREATIVE_JS ? 2 : 0);\n        if (this.style.textOverflow === 'truncate' &&\n            !this.editor_m?.inEditMode &&\n            this._scrollHeight > this.style.height! - (this.style.padding.top + this.style.padding.bottom) + truncationMargin) {\n            this.reachedTruncationLine_m = true;\n            const lastLine = textLines.pop()!;\n            this._currentContentLine = textLines.pop()!;\n            if (!this._currentContentLine) {\n                this._currentContentLine = {\n                    dir: TextDirection.InferFromContext,\n                    spans: [{ type: SpanType.End, content: 'END', dir: TextDirection.Ltr, top: 0, left: 0, width: 0, height: 0, lineHeight: 0, attributes: {}, startJoint: JoinType.None, endJoint: JoinType.None }],\n                    lineHeight: 0,\n                    maxFontSize: 0,\n                    trailingSpaceWidth: 0,\n                    lineWidth: 0,\n                    characterWidth: 0,\n                    endsWithNewline: false,\n                    isLastLine: false,\n                };\n                textLines.splice(0, Infinity, this._currentContentLine);\n                return;\n            }\n            this._currentContentLine.spans.push(...lastLine.spans, ...restOfSpans);\n            textLines.push(this._currentContentLine);\n            this._truncateCurrentContentLine(textLines);\n            abortSignal.shouldAbort = true;\n        }\n    }\n\n    private _introspectSpan(span: OneOfEditableSpans, useDom: boolean, fontSize?: number): ISize {\n        if (this._textIntrospecter && useDom) {\n            const fs = (isContentSpan(span) && span.style.fontSize && span.style.fontSize * (fontSize || this.style.fontSize!)) || fontSize || this.style.fontSize!;\n            const ff = (isVariableSpan(span) && this.editor_m?.inEditMode) ? '\"Open Sans\", ' + FALLBACK_FONT_FAMILY : this._resolveCssFontFamily((isContentSpan(span) && span.style.font) || this.style.font);\n            this._textIntrospecter.font = fs + 'px ' + ff;\n            const content = (span.startJoint || '') + span.content.replace(/\\u00A0/g, ' ') + (span.endJoint || '');\n            const isCapitalized = !!(isContentSpan(span) && span.style.uppercase || this.style.uppercase);\n            const metrics = this._textIntrospecter.measureText(isCapitalized ? content.toLocaleUpperCase() : content);\n            const length = span.content.length;\n            const characterSpacing = (isContentSpan(span) && span.style.characterSpacing) || this.style.characterSpacing;\n            const charSpacePixels = fs * characterSpacing * length;\n            const width = metrics.width + charSpacePixels;\n            const lineHeight = fs * ((isContentSpan(span) && span.style.lineHeight) || this.style.lineHeight);\n\n            // We just take content length for now, and don't filter out potential zero width space characters, like control characters etc.\n            // The user have to take this into consideration for now.\n            return {\n                width: width / this._scale,\n                height: lineHeight / this._scale,\n            };\n        }\n        else {\n            return {\n                width: span.width * this.fontSizeDiff_m,\n                height: span.lineHeight * this.fontSizeDiff_m,\n            };\n        }\n    }\n\n    renderTextWithDecorations_m(): void {\n        this.renderTextLines_m();\n        this.removeDecorationLayers_m();\n\n        /* webpack-strip-block:removed */\n\n        /* webpack-strip-block:removed */\n    }\n\n    normalizeTextLineSpans_m(): void {\n        const newTextLines: IContentLine[] = [];\n        const currentTextLine: IContentLine = {\n            spans: [],\n            dir: TextDirection.InferFromContext,\n            lineHeight: 0,\n            maxFontSize: 0,\n            lineWidth: 0,\n            trailingSpaceWidth: 0,\n            characterWidth: 0,\n            endsWithNewline: false,\n            isLastLine: false,\n        };\n        let lastSpan: OneOfRenderedSpans | undefined;\n        for (let line = 0; line < this.textLines_m.length; line++) {\n            const textLine = this.textLines_m[line];\n            for (const span of textLine.spans) {\n                if (span.type === SpanType.Ellipsis || span.type === SpanType.Composition) {\n                    lastSpan = span;\n                    currentTextLine.spans.push(span);\n                    continue;\n                }\n                if (span.content === '') {\n                    continue;\n                }\n                if (lastSpan && this.isMergeable_m(lastSpan, span)) {\n                    lastSpan.content += span.content;\n                    continue;\n                }\n                else {\n                    lastSpan = span;\n                    currentTextLine.spans.push(span);\n                    if (isContentSpan(span)) {\n                        for (const property of Object.keys(characterPropertyToUnitMap)) {\n                            if (hasSameStyleProperty(property, span.style, this.style)) {\n                                delete span.style[property];\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        // Set current shouldRenderNumber flag\n        if (typeof process !== 'undefined' && process.env.STUDIO_JS) {\n            if (this.renderUnderscoreLayer_m) {\n                let previousSpan: OneOfRenderedSpans | undefined;\n                const singlyIndexed = currentTextLine.spans.every(span => span.attributes.styleIndex === undefined || span.attributes.styleIndex === 1);\n\n                // If the only index is \"1\" don't show anything\n                if (singlyIndexed) {\n                    currentTextLine.spans.forEach(span => span.attributes.shouldRenderNumber = false);\n                }\n                // Make sure only last span with same index renders number\n                else {\n                    for (let spanIndex = 0; spanIndex < currentTextLine.spans.length; spanIndex++) {\n                        const span = currentTextLine.spans[spanIndex];\n                        const index = span.attributes.styleIndex;\n                        if (previousSpan) {\n                            const previousIndex = previousSpan.attributes.styleIndex;\n                            if (previousIndex === index) {\n                                previousSpan.attributes.shouldRenderNumber = false;\n                            }\n                            else if (previousIndex !== undefined) {\n                                previousSpan.attributes.shouldRenderNumber = true;\n                            }\n                        }\n                        previousSpan = span;\n                    }\n                    previousSpan = undefined;\n                }\n            }\n        }\n        newTextLines.push(currentTextLine);\n        this.textLines_m = newTextLines;\n        this.spans_m = this._getSpansFromTextLines();\n    }\n\n    isMergeable_m(source: OneOfRenderedSpans, target: OneOfEditableSpans): boolean {\n        if (source.type === SpanType.Newline || source.type === SpanType.End) {\n            return false;\n        }\n        if (source.type !== target.type) {\n            return false;\n        }\n        if (!hasSameStyleIds(source.styleIds, target.styleIds)) {\n            return false;\n        }\n        if (!deepEqual(source.__previousStyleIds, target.__previousStyleIds)) {\n            return false;\n        }\n        return this._hasSameStyleAndAttributes(source, target);\n    }\n\n    private _hasSameStyleAndAttributes(source: OneOfContentSpans, target: OneOfContentSpans): boolean {\n        const sourceStyle = omit(source.style, '__fontFamilyId');\n        const targetStyle = omit(target.style, '__fontFamilyId');\n        if (Object.keys(sourceStyle).length !== Object.keys(targetStyle).length) {\n            return false;\n        }\n        for (const property in sourceStyle) {\n            if (!hasSameStyleProperty(property as keyof ICharacterProperties, sourceStyle, targetStyle)) {\n                return false;\n            }\n        }\n        const sourceAttributes = omit(source.attributes, 'shouldRenderNumber');\n        const targetAttributes = omit(target.attributes, 'shouldRenderNumber');\n        if (Object.keys(sourceAttributes).length !== Object.keys(targetAttributes).length) {\n            return false;\n        }\n        for (const attribute in sourceAttributes) {\n            if (!deepEqual(source.attributes[attribute], target.attributes[attribute])) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    expandVariableSpans_m(spans: OneOfEditableSpans[]): OneOfEditableSpans[] {\n        const expandedSpans: OneOfEditableSpans[] = [];\n        for (let i = 0; i < spans.length; i++) {\n            if (spans[i].type === SpanType.Variable) {\n                const span = spans[i] as IVariableSpan;\n\n                /**\n                 * Store the span and give it a temporary ID.\n                 * We then resolve the variable to the correct feed data so that the\n                 * text resize the actual value rather than the variable.\n                 * The correct ID is then set in renderTextLines.\n                 */\n                if (!span.style.variable!.spanId || !this.variableSpanMap_m.get(span.style.variable!.spanId!)) {\n                    span.style.variable!.spanId = span.style.variable!.spanId || '' + Date.now();\n                    this.variableSpanMap_m.set(span.style.variable!.spanId!, {\n                        style: span.style!,\n                        span: span\n                    });\n                }\n\n                const variableSpan = this.variableSpanMap_m.get(span.style.variable!.spanId!)!;\n                if (!this.editor_m?.inEditMode && !this.renderUnderscoreLayer_m) {\n                    const feedSpans = createSpansFromString(this.feedStore_m.getFeedValue(\n                        variableSpan!.style.variable!,\n                        span.style.variable!.spanId!,\n                        this._option.element\n                    ).value as string, {}, span.style, copyStyle);\n                    expandedSpans.push(...feedSpans);\n                }\n                else {\n                    span.content = VARIABLE_PREFIX + decodeURIComponent(variableSpan.style.variable!.path);\n                    expandedSpans.push(span);\n                }\n                continue;\n            }\n            expandedSpans.push(spans[i]);\n        }\n        return expandedSpans;\n    }\n\n    private _getElementTextProperties(): Partial<ITextProperties> {\n        const resolvedText = this._option.inDesignView ? this.editor_m!.styleResolver.getResolvedText()!.style : {};\n        return Object.assign(pick(this.style,\n            'font',\n            'characterSpacing',\n            'lineHeight',\n            'textColor',\n            // 'uppercase',\n            // 'strikethrough',\n            // 'underline',\n            'textOverflow',\n            'textShadows',\n            'padding',\n            'maxRows',\n            'horizontalAlignment',\n            'verticalAlignment',\n        ), { fontSize: this.resizedElementFontSize_m }, resolvedText);\n    }\n\n    distributeAllSpansAcrossTextLines_m(spans: OneOfEditableSpans[], fontSize?: number): void {\n        this.resizedElementFontSize_m = fontSize || this.style.fontSize!;\n        const textLines: IContentLine[] = [];\n        this._resetTextMetadata();\n        const option: ISpanDistributionAbortSignal = {\n            shouldAbort: false,\n        };\n        for (let i = 0; i < spans.length; i++) {\n            if (option.shouldAbort) {\n                break;\n            }\n            this._distributeOneSpanAcrossTextLines(spans[i], textLines, option, /* useDom */ true, spans.slice(i + 1), false, fontSize);\n        }\n        this.textLines_m = textLines;\n    }\n\n    private _resetTextMetadata(): void {\n        this._scrollHeight = 0;\n        this._longestLine = 0;\n        this.wordWidth_m = 0;\n        this._widestWord = 0;\n        this.rows_m = 1;\n        this.reachedTruncationLine_m = false;\n        this._currentContentLine = undefined;\n        this._previousContentLine = undefined;\n    }\n\n    private _redistributeAllSpansAcrossLines(spans: OneOfEditableSpans[], useDom?: boolean): void {\n        const textLines: IContentLine[] = [];\n        this._resetTextMetadata();\n        const metadata: ISpanDistributionAbortSignal = {\n            shouldAbort: false,\n        };\n        for (let i = 0; i < spans.length; i++) {\n            if (metadata.shouldAbort) {\n                break;\n            }\n            this._distributeOneSpanAcrossTextLines(spans[i] as OneOfEditableSpans, textLines, metadata, useDom, spans.slice(i + 1), false);\n        }\n        this.textLines_m = textLines;\n    }\n\n    private _getNegativeLineHeightMargin(textLine: IContentLine): number {\n        if (textLine.maxFontSize < 1) {\n            textLine.maxFontSize = 1;\n        }\n        return -(textLine.lineHeight - textLine.maxFontSize * this.resizedElementFontSize_m) / 2;\n    }\n\n    renderTextLines_m(): void {\n        const textProperties = this._getElementTextProperties();\n        this.applyStyleOnElement_m(textProperties, this.rootElement_m, /* isRootElement */ false);\n\n        this.textElement_m!.innerHTML = '';\n        this.rootElement_m.style.fontSize = this.resizedElementFontSize_m + 'px';\n        this.textElement_m.classList.add('invisible-selection');\n        this.textLineElementToLineMap_m = new WeakMap<HTMLDivElement, number>();\n        this.lineToTextLineElementMap_m = new Map<number, HTMLDivElement>();\n        this.variableSpanMap_m = new Map<string, { span: OneOfContentSpans, style: Partial<ICharacterProperties> }>();\n        if (!this.editor_m?.inEditMode && this.style.textOverflow === 'scroll') {\n            this.rootElement_m.style.overflow = 'auto';\n        }\n        else {\n            this.rootElement_m.style.overflow = 'visible';\n        }\n        this.centerElement_m.style.alignItems = getVerticalFlexAlignment(this.style.verticalAlignment);\n        let horizontalAlignment = this.style.horizontalAlignment;\n\n        // For RTL text, we change to right align if it was left align.\n        if (horizontalAlignment === 'left') {\n            if (isContentSpan(this.textLines_m[0].spans[0]) && this.textLines_m[0].spans[0].dir === TextDirection.Rtl) {\n                horizontalAlignment = 'right';\n            }\n        }\n        if (this.renderUnderscoreLayer_m) {\n            if (isContentSpan(this.textLines_m[0].spans[0])) {\n                if (this.textLines_m[0].spans[0].dir === TextDirection.Rtl) {\n                    horizontalAlignment = 'right';\n                }\n                else {\n                    horizontalAlignment = 'left';\n                }\n            }\n            else {\n                horizontalAlignment = 'left';\n            }\n        }\n        this.centerElement_m.style.justifyContent = getHorizontalFlexAlignment(horizontalAlignment);\n        this.textElement_m.style.textAlign = horizontalAlignment;\n        this.textElement_m.style.lineHeight = this.style.lineHeight + '';\n\n        for (let line = 0; line < this.textLines_m.length; line++) {\n            const textLine = this.textLines_m[line];\n            const isLastLine = this.textLines_m.length - 1 === line;\n            const lineFragment = document.createDocumentFragment();\n            const lineElement = document.createElement('div');\n            lineElement.className = 'text-line';\n\n            // Use block and explicit height to prevent white space underneath it when children(spans)\n            // being wider than block width. This becomes apparant when font size becomes smaller and\n            // there is a lot of characters.\n            const currentDir = lineElement.dir = isContentSpan(textLine.spans[0]) ? textLine.spans[0].dir! : TextDirection.Ltr;\n            switch (horizontalAlignment) {\n                case 'left':\n                    if (currentDir === TextDirection.Ltr) {\n                        lineElement.style.justifyContent = 'flex-start';\n                    }\n                    else {\n                        lineElement.style.justifyContent = 'flex-end';\n                    }\n                    break;\n                case 'center':\n                    lineElement.style.justifyContent = 'center';\n                    break;\n                case 'right':\n                    if (currentDir === TextDirection.Ltr) {\n                        lineElement.style.justifyContent = 'flex-end';\n                    }\n                    else {\n                        lineElement.style.justifyContent = 'flex-start';\n                    }\n                    break;\n            }\n            lineElement.style.left = '0';\n            lineElement.style.width = '100%';\n            lineElement.style.height = '100%';\n            lineElement.style.display = 'flex';\n            lineElement.style.alignItems = 'baseline';\n            lineElement.style.height = Math.max(1, textLine.lineHeight) + 'px';\n            lineElement.style.whiteSpace = 'nowrap';\n            lineElement.style.fontSize = (textLine.maxFontSize * this.resizedElementFontSize_m!) + 'px';\n\n            if (this.style.characterSpacing) {\n                lineElement.style.letterSpacing = (this.style.characterSpacing) + 'em';\n            }\n            if (this.style.verticalAlignment === 'top' && line === 0) {\n                lineElement.style.marginTop = this._getNegativeLineHeightMargin(textLine) + 'px';\n            }\n            else if (this.style.verticalAlignment === 'bottom' && textLine.isLastLine) {\n                lineElement.style.marginBottom = this._getNegativeLineHeightMargin(textLine) + 'px';\n            }\n            this.textLineElementToLineMap_m.set(lineElement, line);\n            this.lineToTextLineElementMap_m.set(line, lineElement);\n            lineFragment.appendChild(lineElement);\n            const spanId = 't-' + line;\n            let column = 0;\n\n            let lastDir = isContentSpan(textLine.spans[0]) ? textLine.spans[0].dir : TextDirection.Ltr;\n            let bidiDirectionContainer = document.createElement('div');\n            bidiDirectionContainer.dir = lastDir!;\n            bidiDirectionContainer.style.unicodeBidi = 'bidi-override';\n            lineElement.appendChild(bidiDirectionContainer);\n            forEachSpan(textLine, (span, spanIndex) => {\n                if (textLine.spans.length !== 1 && span.type === SpanType.End) {\n                    return;\n                }\n                const isLastSpan = spanIndex === (isLastLine ? textLine.spans.length - 2 : textLine.spans.length - 1);\n                if (isContentSpan(span) && lastDir !== span.dir!) {\n                    bidiDirectionContainer = document.createElement('div');\n                    bidiDirectionContainer.dir = span.dir!;\n                    bidiDirectionContainer.style.unicodeBidi = 'bidi-override';\n                    lineElement.appendChild(bidiDirectionContainer);\n                    lastDir = span.dir!;\n                }\n                const spanElement = span.__viewElement = document.createElement('span');\n\n                if (this.renderUnderscoreLayer_m) {\n                    if (span.attributes.shouldRenderNumber) {\n                        spanElement.style.marginRight = STYLE_INDEX_MARGIN_RIGHT + 'px';\n                    }\n                }\n                let shouldSkipRenderDecoration = false;\n                if (span.type === SpanType.Space) {\n                    if (spanIndex === textLine.spans.length - 1 ||\n                        (spanIndex === textLine.spans.length - 2 && textLine.spans[textLine.spans.length - 1].type === SpanType.Newline)) {\n                        shouldSkipRenderDecoration = true;\n                    }\n                }\n                else if (span.type === SpanType.Newline) {\n                    shouldSkipRenderDecoration = true;\n                }\n\n                // We need 'inline-block' here, otherwise a parent's element's width is not the\n                // same as the sum of its children. Though there is a problem in Chrome for getting\n                // the caret position sometimes on inline-block. Right now we only experienced it on\n                // the translation panel. So we are just removing inline-block there.\n                // if (!this.renderUnderscoreLayer) {\n                spanElement.style.display = 'inline-block';\n                // }\n\n                // Prevents collapsing of spaces\n                spanElement.style.whiteSpace = 'pre-wrap';\n\n                spanElement.setAttribute('data-type', this._getStringSpanType(span.type));\n\n                const rootId = (this.rootElement_m.id || this.editor_m?.keyboardBindings.inputId);\n\n                spanElement.id = `${(this.viewElement_m?.id + '-' || '')}${rootId}-${spanId}-${spanIndex}`;\n\n                spanElement.setAttribute('data-cy', `${rootId}-${spanId}-${spanIndex}`);\n\n                if (isLastSpan) {\n                    if (textLine.trailingSpaceWidth) {\n                        switch (horizontalAlignment) {\n                            case 'left':\n                                if (currentDir === TextDirection.Rtl) {\n                                    bidiDirectionContainer.style.marginLeft = -textLine.trailingSpaceWidth + 'px';\n                                }\n                                break;\n                            case 'center':\n                                if (currentDir === TextDirection.Rtl) {\n                                    bidiDirectionContainer.style.marginLeft = -textLine.trailingSpaceWidth + 'px';\n                                }\n                                else {\n                                    bidiDirectionContainer.style.marginRight = -textLine.trailingSpaceWidth + 'px';\n                                }\n                                break;\n                            case 'right':\n                                if (currentDir === TextDirection.Rtl) {\n                                    bidiDirectionContainer.style.marginLeft = -textLine.trailingSpaceWidth + 'px';\n                                }\n                                else {\n                                    bidiDirectionContainer.style.marginRight = -textLine.trailingSpaceWidth + 'px';\n                                }\n                                break;\n                        }\n                    }\n                }\n\n                if (isContentSpan(span)) {\n                    spanElement.dir = span.dir!;\n                }\n                if (span.type === SpanType.Variable) {\n                    spanElement.setAttribute('data-variable', span.style.variable!.path);\n                    if (span.style.variable!.spanId !== spanElement.id) {\n                        this.variableSpanMap_m.delete(span.style.variable!.spanId!);\n                        span.style.variable!.spanId = spanElement.id;\n                        this.variableSpanMap_m.set(span.style.variable!.spanId!, {\n                            style: span.style!,\n                            span\n                        });\n                    }\n                    else if (!this.variableSpanMap_m.get(spanElement.id)) {\n                        span.style.variable!.spanId = spanElement.id;\n                        this.variableSpanMap_m.set(spanElement.id, {\n                            style: span.style!,\n                            span\n                        });\n                    }\n\n                    span.style.variable!.spanId = spanElement.id;\n\n                    if (!this.renderUnderscoreLayer_m) {\n                        this.feedStore_m.addFeedElement(spanElement.id, cloneDeep(span.style.variable!), this._option.viewElement?.__data);\n                    }\n                }\n\n                spanElement.addEventListener('click', this._onClick);\n                if (span.type === SpanType.End) {\n                    spanElement.style.height = this.editor_m?.currentStyle.lineHeight! * this.resizedElementFontSize_m + 'px';\n                    spanElement.innerHTML = '&#8203;'; // Zero-width-space\n                }\n                else {\n                    if (span.type === SpanType.Newline) {\n                        spanElement.innerHTML = ' ';\n                        spanElement.style.whiteSpace = 'pre';\n                        spanElement.style.width = span.width + 'px';\n                    }\n                    else if (span.type === SpanType.Ellipsis) {\n                        spanElement.innerHTML = '...';\n                    }\n                    else if (span.type === SpanType.Space) {\n                        spanElement.style.whiteSpace = 'pre';\n                        spanElement.innerHTML = span.content + '&zwnj;';\n                    }\n                    else if (span.type === SpanType.Composition) {\n                        spanElement.style.width = span.width + 'px';\n                        spanElement.innerHTML = '&#8203;';\n                        this.editor_m!.keyboardBindings.compositionSpanElement = spanElement;\n                    }\n                    else {\n                        const content = span.content.normalize('NFC');\n                        spanElement.innerHTML = encodeHtml((span.startJoint || '') + content.replace(/\\u00A0/g, ' ') + (span.endJoint || ''));\n                    }\n                    const textDecoration: string[] = [];\n                    if (this.style.underline) {\n                        textDecoration.push('underline');\n                    }\n                    if (this.style.strikethrough) {\n                        textDecoration.push('strikethrough');\n                    }\n\n                    const spanStyle = Object.assign({}, {\n                        underline: this.style.underline,\n                        strikethrough: this.style.strikethrough,\n                        uppercase: this.style.uppercase,\n                    }, span.style);\n                    if (span.type === SpanType.Newline) {\n                        // Using a big font size that exceeds max font size will pressure the rest of the text down a bit.\n                        // Using a small font size, will make the selection line and caret being small.\n                        // So we think using the max font size for the line makes most sense.\n                        spanStyle.fontSize = textLine.maxFontSize;\n                    }\n\n                    // Don't decorate spaces if it's in the end of the line\n                    if (shouldSkipRenderDecoration) {\n                        delete spanStyle.underline;\n                        delete spanStyle.strikethrough;\n                    }\n\n                    const textColor = spanStyle.textColor ?? this.style.textColor;\n                    this.applyStyleOnElement_m(Object.assign({ fontSize: 1, characterSpacing: this.style.characterSpacing, textColor }, spanStyle), spanElement);\n                }\n                if (isContentSpan(span)) {\n                    span.line = line;\n                    span.column = column;\n                    column += span.content.length;\n                }\n                bidiDirectionContainer.appendChild(spanElement);\n            });\n\n            this.textElement_m!.appendChild(lineFragment);\n        }\n    }\n\n    applyStyleOnElement_m(style: Partial<ICharacterProperties>, element: HTMLElement, useRelativeFontSize: boolean = true, animated: boolean = false): void {\n        const styleAttribute = element.style;\n        let handledTextDecorationProperty = false;\n        const characterStyleProperties = animated ? ['textColor'] : [...Object.keys(omit(characterPropertyToUnitMap, '__fontFamilyId')), 'padding'];\n\n        for (const property of characterStyleProperties) {\n            switch (property) {\n                case 'font':\n                    if (style.font) {\n                        styleAttribute.fontFamily = this._resolveCssFontFamily(style.font, element);\n                    }\n                    else {\n                        styleAttribute.fontFamily = '';\n                    }\n                    break;\n                case 'textColor':\n                    styleAttribute.color = style.textColor\n                        ? toRGBA(style[property]!)\n                        : '';\n                    break;\n                case 'fontSize':\n                    let fontSize = '';\n                    if (style.fontSize !== undefined) {\n                        fontSize = useRelativeFontSize\n                            ? (this.resizedElementFontSize_m * (style[property] as number)) + 'px'\n                            : this.resizedElementFontSize_m + 'px';\n                    }\n                    styleAttribute.fontSize = fontSize;\n                    break;\n                case 'underline':\n                case 'strikethrough':\n                    if (handledTextDecorationProperty) {\n                        break;\n                    }\n                    const cssTextDecoration: string[] = [];\n                    if (style.underline) {\n                        cssTextDecoration.push('underline');\n                    }\n                    if (style.strikethrough) {\n                        cssTextDecoration.push('line-through');\n                    }\n                    styleAttribute.textDecoration = cssTextDecoration.length > 0 ? cssTextDecoration.join(' ') : '';\n                    handledTextDecorationProperty = true;\n                    break;\n                case 'uppercase':\n                    if (style.uppercase) {\n                        styleAttribute.textTransform = 'uppercase';\n                    }\n                    else {\n                        styleAttribute.textTransform = '';\n                    }\n                    break;\n                case 'characterSpacing':\n                    styleAttribute.letterSpacing = style.characterSpacing !== undefined ? style.characterSpacing + 'em' : '';\n                    break;\n                case 'lineHeight':\n                    let lineHeight = 'none';\n                    if (style.lineHeight !== undefined) {\n                        lineHeight = useRelativeFontSize\n                            ? style[property] + 'em'\n                            : style[property] + '';\n                    }\n\n                    styleAttribute.lineHeight = lineHeight;\n                    break;\n                case 'textShadows':\n                    styleAttribute.textShadow = style.textShadows\n                        ? textShadowsCSSValue(style[property] as ITextShadow[])\n                        : '';\n                    break;\n                case 'variable':\n                    if (style.variable) {\n                        if (this.editor_m?.inEditMode || this.renderUnderscoreLayer_m) {\n                            styleAttribute.color = 'var(--variable-artifact-color)';\n                            styleAttribute.backgroundColor = this.renderUnderscoreLayer_m ? 'rgba(235, 235, 235, 0.7)' : '';\n                            styleAttribute.cursor = 'var(--variable-artifact-cursor)';\n                            styleAttribute.fontFamily = `'Open Sans', ${FALLBACK_FONT_FAMILY}`;\n                        }\n                        else {\n                            styleAttribute.color = styleAttribute.color || '';\n                            styleAttribute.cursor = '';\n                            styleAttribute.fontFamily = styleAttribute.fontFamily || '';\n                        }\n                    }\n                    break;\n                case 'padding':\n                    if (style['padding']) {\n                        styleAttribute.paddingTop = style[property].top + 'px';\n                        styleAttribute.paddingLeft = style[property].left + 'px';\n                        styleAttribute.paddingRight = style[property].right + 'px';\n                        styleAttribute.paddingBottom = style[property].bottom + 'px';\n                    }\n                    else {\n                        styleAttribute.paddingTop = '';\n                        styleAttribute.paddingLeft = '';\n                        styleAttribute.paddingRight = '';\n                        styleAttribute.paddingBottom = '';\n\n                    }\n                    break;\n                default:\n                    styleAttribute[property] = style[property];\n                    break;\n            }\n        }\n    }\n\n    /**\n     * Applies the only the styles that can be animated, does not recreate the span elements,\n     * only suitable for the styling that doesn't require text pipeline\n     *\n     * @param style Currently only supports `textColor`\n     */\n    applyOnlyAnimatedStyleOnElement_m(style: Pick<ICharacterProperties, 'textColor'>): void {\n        this.textLines_m.forEach(line => {\n            line.spans.forEach(span => {\n                if (isContentSpan(span) && span.__viewElement) {\n                    // if spans have additional styles, those override the text element styles\n                    const mergedStyle = {\n                        ...style,\n                        ...span.style\n                    };\n\n                    this.applyStyleOnElement_m(mergedStyle, span.__viewElement, true, true);\n                }\n            });\n        });\n    }\n\n    private _getStringSpanType(type: SpanType): string {\n        switch (type) {\n            case SpanType.Newline:\n                return 'newline';\n            case SpanType.Space:\n                return 'space';\n            case SpanType.Word:\n                return 'text';\n            case SpanType.Ellipsis:\n                return 'ellipsis';\n            case SpanType.End:\n                return 'end';\n            case SpanType.Variable:\n                return 'variable';\n            case SpanType.Composition:\n                return 'composition';\n        }\n    }\n\n    /* webpack-strip-block:removed */\n\n    private _onClick = (event: MouseEvent): void => {\n        if (!this.editor_m?.inEditMode && (!window.bfstudio || (window.bfstudio && window.bfstudio!.inShowcaseMode || (window.bfstudio!.inPreviewMode && window.bfstudio!.activePage === 'DV')))) {\n            const id = (event.currentTarget as HTMLElement)!.id;\n            if (!this.feedStore_m) {\n                return;\n            }\n            let feededElement = this.feedStore_m.elements.get(id);\n\n            if (!feededElement) {\n                const variableSpans: IVariableSpan[] = [];\n                for (const span of this.spans_m) {\n                    if (isContentSpan(span) && span.style?.variable) {\n                        variableSpans.push(span as IVariableSpan);\n                        if (variableSpans.length > 1) {\n                            break;\n                        }\n                    }\n                }\n\n                const isSingleVariable = variableSpans.length === 1 ? true : false;\n\n                if (isSingleVariable) {\n                    feededElement = this.feedStore_m.elements.get(variableSpans[0].style.variable!.spanId!);\n                }\n            }\n\n            if (feededElement) {\n                const element = feededElement.element;\n                if (hasActionPreventClickthrough(element) || hasActionTargetUrl(element)) {\n                    return;\n                }\n\n                const feedValue = this.feedStore_m.getFeedValue(feededElement.feed, id, feededElement.element!);\n                event.preventDefault();\n                event.stopPropagation();\n                this.emit('spanClicked', [event, feedValue.targetUrl]);\n            }\n        }\n    };\n\n    isOfNodeSpanType_m(node: Node | HTMLElement, type: SpanType): boolean {\n        if (node.nodeType === 3 && node.parentNode) {\n            node = node.parentNode as HTMLElement;\n        }\n        else {\n            return false;\n        }\n        if ((node as HTMLElement).dataset) {\n            return this.getSpanTypeString_m((node as HTMLElement).dataset.type!) === type;\n        }\n        else {\n            return false;\n        }\n    }\n\n    getSpanTypeString_m(type: string): SpanType {\n        switch (type) {\n            case 'newline':\n                return SpanType.Newline;\n            case 'space':\n                return SpanType.Space;\n            case 'text':\n                return SpanType.Word;\n            case 'end':\n                return SpanType.End;\n            case 'variable':\n                return SpanType.Variable;\n            case 'composition':\n                return SpanType.Composition;\n        }\n        throw new Error('Unknown span type.');\n    }\n\n    setStateOrElementStyle_m(stateStyle?: Partial<ITextProperties & ISize>): void {\n        if (stateStyle) {\n            this.style = { ...this._elementStyle, ...stateStyle };\n        }\n        else {\n            this.style = this._elementStyle;\n        }\n    }\n\n    private _resolveCssFontFamily(fontStyle?: IFontStyle, element?: HTMLElement): string {\n        let fontFamily = fontStyle && `\"f-${fontStyle.id}\"`;\n\n        // When no font family is set try to calculate which one to use\n        if (!fontFamily && element) {\n            const computedStyle = window.getComputedStyle(element).fontFamily;\n            if (computedStyle) {\n                fontFamily = computedStyle;\n            }\n        }\n\n        // Add fallback font if only one fontFamily is provided.\n        if (fontFamily && fontFamily.indexOf(',') === -1) {\n            fontFamily += ', ' + FALLBACK_FONT_FAMILY;\n        }\n\n        return fontFamily as string;\n    }\n\n    static isInCharacterRange_m(char: number, rangeMap: number[][]): boolean {\n        for (const range of rangeMap) {\n            if (range.length === 1) {\n                if (range[0] === char) {\n                    return true;\n                }\n            }\n            else {\n                if (char >= range[0] && char <= range[1]) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n\n    static getBidiDirection_m(char: number): TextDirection.InferFromContext | TextDirection.Rtl | TextDirection.Ltr | TextDirection.Previous {\n\n        if (char === CharacterCode.Space) {\n            return TextDirection.InferFromContext;\n        }\n\n        // These are strictly RTL characters\n        if (this.isInCharacterRange_m(char, R_AND_AL_BIDI_CHAR_RANGE_MAP)) {\n            return TextDirection.Rtl;\n        }\n\n        // These are strictly LTR characters\n        if (this.isInCharacterRange_m(char, L_BIDI_CHAR_RANGE_MAP)) {\n            return TextDirection.Ltr;\n        }\n\n        return TextDirection.Previous;\n    }\n}\n\n__inject(S.EDITOR_STATE, { optional: true }, RichText, 'editorState', 3);\n__inject(S.RICH_TEXT_EDITOR, { optional: true }, RichText, 'editor', 4);\n","\nimport { IBorder, IShadow, ITextShadow } from '@studio/domain/style';\n\n/**\n * Value of a CSS Property.  Could be a single value or a list of fallbacks\n * NOTE: array is for fallbacks\n */\nexport type CSSValue<T> = T | T[];\n\n/**\n * For general purpose CSS values\n **/\nexport type CSSValueGeneral = CSSValue<number | string>;\n\n/**\n * When you are sure that the value must be a string\n **/\nexport type CSSValueString = CSSValue<string>;\n\n/**\n * CSS properties that cascade also support these\n * @see https://drafts.csswg.org/css-cascade/#defaulting-keywords\n */\nexport type CSSGlobalValues\n  = 'initial'\n  | 'inherit'\n  | /** combination of `initial` and `inherit` */ 'unset'\n  | 'revert';\n\nexport interface IFontFace {\n  fontFamily?: string;\n\n  /**\n   * Location of a font-face.  Used with the @font-face at rule\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src\n   */\n  src?: CSSValueString;\n  unicodeRange?: any;\n  fontVariant?: 'common-ligatures' | 'small-caps' | CSSGlobalValues;\n  fontFeatureSettings?: string;\n  fontWeight?: CSSFontWeight;\n  fontStyle?: 'normal' | 'italic' | 'oblique' | CSSGlobalValues;\n}\n\n/**\n * Absolute size keywords\n * @see https://drafts.csswg.org/css-fonts-3/#absolute-size-value\n */\nexport type CSSAbsoluteSize = 'xx-small' | 'x-small' | 'small' | 'medium' | 'large'\n  | 'x-large' | 'xx-large';\n\n/**\n * an angle; 0' | '0deg' | '0grad' | '0rad' | '0turn' | 'etc.\n * @see https://drafts.csswg.org/css-values-3/#angles\n */\nexport type CSSAngle = CSSGlobalValues | string | 0;\n\n/**\n * initial state of an animation.\n * @see https://drafts.csswg.org/css-animations/#animation-play-state\n */\nexport type CSSAnimationPlayState = CSSGlobalValues | string | 'paused' | 'running';\n\n/**\n * blend mode\n * @see https://drafts.fxtf.org/compositing-1/#ltblendmodegt\n */\nexport type CSSBlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn'\n  | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';\n\n/**\n * border shorthand for style color and width\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-left\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-right\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-top\n */\nexport type CSSBorderShorthand = CSSGlobalValues | CSSColor | CSSLength | CSSLineStyleSet | string;\n\n/**\n * Determines the area within which the background is painted.\n * @see https://drafts.csswg.org/css-backgrounds/#box\n */\nexport type CSSBox = CSSGlobalValues | string | 'border-box' | 'padding-box' | 'content-box';\n\n/**\n * Color can be a named color, transparent, or a color function\n * @see https://drafts.csswg.org/css-color-3/#valuea-def-color\n */\nexport type CSSColor = CSSNamedColor | CSSGlobalValues | 'currentColor' | string;\n\nexport type CSSNamedColor =\n  'aliceblue' | 'antiquewhite' | 'aqua' | 'aquamarine' | 'azure' | 'beige' | 'bisque' | 'black' | 'blanchedalmond' | 'blue'\n  | 'blueviolet' | 'brown' | 'burlywood' | 'cadetblue' | 'chartreuse' | 'chocolate' | 'coral' | 'cornflowerblue' | 'cornsilk'\n  | 'crimson' | 'cyan' | 'darkblue' | 'darkcyan' | 'darkgoldenrod' | 'darkgray' | 'darkgreen' | 'darkgrey' | 'darkkhaki'\n  | 'darkmagenta' | 'darkolivegreen' | 'darkorange' | 'darkorchid' | 'darkred' | 'darksalmon' | 'darkseagreen'\n  | 'darkslateblue' | 'darkslategray' | 'darkslategrey' | 'darkturquoise' | 'darkviolet' | 'deeppink' | 'deepskyblue'\n  | 'dimgray' | 'dimgrey' | 'dodgerblue' | 'firebrick' | 'floralwhite' | 'forestgreen' | 'fuchsia' | 'gainsboro'\n  | 'ghostwhite' | 'gold' | 'goldenrod' | 'gray' | 'green' | 'greenyellow' | 'grey' | 'honeydew' | 'hotpink' | 'indianred'\n  | 'indigo' | 'ivory' | 'khaki' | 'lavender' | 'lavenderblush' | 'lawngreen' | 'lemonchiffon' | 'lightblue' | 'lightcoral'\n  | 'lightcyan' | 'lightgoldenrodyellow' | 'lightgray' | 'lightgreen' | 'lightgrey' | 'lightpink' | 'lightsalmon'\n  | 'lightseagreen' | 'lightskyblue' | 'lightslategray' | 'lightslategrey' | 'lightsteelblue' | 'lightyellow' | 'lime'\n  | 'limegreen' | 'linen' | 'maroon' | 'mediumaquamarine' | 'mediumblue' | 'mediumorchid' | 'mediumpurple' | 'mediumseagreen'\n  | 'mediumslateblue' | 'mediumspringgreen' | 'mediumturquoise' | 'mediumvioletred' | 'midnightblue' | 'mintcream'\n  | 'mistyrose' | 'moccasin' | 'navajowhite' | 'navy' | 'oldlace' | 'olive' | 'olivedrab' | 'orange' | 'purple'\n  | 'rebeccapurple' | 'red' | 'silver' | 'teal' | 'transparent' | 'white' | 'yellow';\n\n/**\n * Special type for border-color which can use 1 or 4 colors\n * @see https://drafts.csswg.org/css-backgrounds-3/#border-color\n */\nexport type CSSColorSet = string | CSSColor;\n\n/**\n  * This property specifies the type of rendering box used for an element. It is a shorthand property for many other display properties.\n  * @see https://developer.mozilla.org/en-US/docs/Web/CSS/display\n  */\nexport type CSSDisplay =\n  /* <display-outside> values */\n  'block' | 'inline' | 'run-in'\n  /* <display-inside> values */\n  | 'flow' | 'flow-root' | 'table' | 'flex' | 'grid' | 'ruby' | 'subgrid'\n  /* <display-outside> plus <display-inside> values */\n  | 'block flow' | 'inline table' | 'flex run-in'\n  /* <display-listitem> values */\n  | 'list-item' | 'list-item block' | 'list-item inline' | 'list-item flow' | 'list-item flow-root'\n  | 'list-item block flow' | 'list-item block flow-root' | 'flow list-item block'\n  /* <display-internal> values */\n  | 'table-row-group' | 'table-header-group' | 'table-footer-group' | 'table-row' | 'table-cell'\n  | 'table-column-group' | 'table-column' | 'table-caption' | 'ruby-base' | 'ruby-text'\n  | 'ruby-base-container' | 'ruby-text-container'\n  /* <display-box> values */\n  | 'contents' | 'none'\n  /* <display-legacy> values */\n  | 'inline-block' | 'inline-list-item' | 'inline-table' | 'inline-flex' | 'inline-grid';\n\n/**\n  * CSS Type <baseline-position> of Box Alignment\n  * @see https://www.w3.org/TR/css-align-3/#typedef-baseline-position\n  */\nexport type CSSBoxAlignmentBaselinePosition = 'baseline' | 'first baseline' | 'last baseline';\n\n/**\n  * CSS Type <content-distribution> of Box Alignment\n  * @see https://www.w3.org/TR/css-align-3/#typedef-content-distribution\n  */\nexport type CSSBoxAlignmentContentDistribution = 'space-between' | 'space-around' | 'space-evenly' | 'stretch';\n\nexport type CSSBoxAlignmentContentPositionWithOverflow =\n  | 'center' | 'start' | 'end' | 'flex-start' | 'flex-end'\n  | 'unsafe center' | 'unsafe start' | 'unsafe end' | 'unsafe flex-start' | 'unsafe flex-end'\n  | 'safe center' | 'safe start' | 'safe end' | 'safe flex-start' | 'safe flex-end';\n\nexport type CSSBoxAlignmentSelfPositionWithOverflow =\n  | 'center' | 'start' | 'end' | 'self-start' | 'self-end' | 'flex-start' | 'flex-end'\n  | 'unsafe center' | 'unsafe start' | 'unsafe end' | 'unsafe self-start' | 'unsafe self-end' | 'unsafe flex-start' | 'unsafe flex-end'\n  | 'safe center' | 'safe start' | 'safe end' | 'safe self-start' | 'safe self-end' | 'safe flex-start' | 'safe flex-end';\n\nexport type CSSBoxAlignmentLeftRightWithOverflow = 'left' | 'right' | 'unsafe left' | 'unsafe right' | 'safe left' | 'safe right';\n\n/**\n  * Type for justify-content in flex or grid\n  * @see https://www.w3.org/TR/css-align-3/#propdef-justify-content\n  */\nexport type JustifyContent =\n  | 'normal'\n  | CSSBoxAlignmentContentDistribution\n  | CSSBoxAlignmentContentPositionWithOverflow\n  | 'left'\n  | 'right';\n\n/**\n  * Type for align-content in flex or grid\n  * @see https://www.w3.org/TR/css-align-3/#propdef-align-content\n  */\nexport type AlignContent =\n  | 'normal'\n  | CSSBoxAlignmentBaselinePosition\n  | CSSBoxAlignmentContentDistribution\n  | CSSBoxAlignmentContentPositionWithOverflow;\n\n/**\n  * Type for justify-items in flex or grid\n  * @see https://www.w3.org/TR/css-align-3/#propdef-justify-items\n  */\nexport type JustifyItems =\n  | 'normal'\n  | 'stretch'\n  | CSSBoxAlignmentBaselinePosition\n  | CSSBoxAlignmentSelfPositionWithOverflow\n  | 'left'\n  | 'right'\n  | 'center'\n  | 'legacy left'\n  | 'legacy right'\n  | 'legacy center';\n\n/**\n  * Type for align-items in flex or grid\n  * @see https://www.w3.org/TR/css-align-3/#propdef-align-items\n  */\nexport type AlignItems =\n  | 'normal'\n  | 'stretch'\n  | CSSBoxAlignmentBaselinePosition\n  | CSSBoxAlignmentSelfPositionWithOverflow;\n\n/**\n  * Type for justify-self in flex or grid\n  * @see https://www.w3.org/TR/css-align-3/#propdef-justify-self\n  */\nexport type JustifySelf =\n  | 'auto'\n  | 'normal'\n  | 'stretch'\n  | CSSBoxAlignmentBaselinePosition\n  | CSSBoxAlignmentSelfPositionWithOverflow\n  | CSSBoxAlignmentLeftRightWithOverflow;\n\n/**\n  * Type for align-self in flex or grid\n  * @see https://www.w3.org/TR/css-align-3/#propdef-align-self\n  */\nexport type AlignSelf =\n  | 'auto'\n  | 'normal'\n  | 'stretch'\n  | CSSBoxAlignmentBaselinePosition\n  | CSSBoxAlignmentSelfPositionWithOverflow;\n\n/**\n * a gradient function like linear-gradient\n * @see https://drafts.csswg.org/css-images-3/#gradients\n */\nexport type CSSGradient = CSSGlobalValues | string;\n\n/**\n * complex type that describes the size of fonts\n * @see https://drafts.csswg.org/css-fonts-3/#propdef-font-size\n */\nexport type CSSFontSize = CSSGlobalValues | CSSLength | CSSPercentage | CSSAbsoluteSize | CSSRelativeSize;\n\n/**\n * a value that serves as an image\n * @see https://drafts.csswg.org/css-images-3/#typedef-image\n */\nexport type CSSImage = CSSGlobalValues | string | CSSGradient | CSSUrl;\n\n/**\n * an length; 0 | '0px' | '0em' etc.\n * @see https://drafts.csswg.org/css-values-3/#lengths\n */\nexport type CSSLength = CSSGlobalValues | string | number;\n\n/**\n * Style of a line (e.g. border-style)\n * @see https://drafts.csswg.org/css-backgrounds-3/#line-style\n */\nexport type CSSLineStyle = string | 'none' | 'hidden' | 'dotted'\n  | 'dashed' | 'solid' | 'double' | 'groove' | 'ridge' | 'inset'\n  | 'outset';\n\n/**\n * Special type for border-style which can use 1 or 4 line-style\n * @see https://drafts.csswg.org/css-backgrounds-3/#border-style\n */\nexport type CSSLineStyleSet = string | CSSLineStyle;\n\n/**\n * Specifies how the contents of a replaced element should be fitted to the box established by its used height and width.\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit\n */\nexport type CSSObjectFit = 'fill' | 'contain' | 'cover' | 'none' | 'scale-down' | CSSGlobalValues;\n\n/**\n * Overflow modes\n * @see https://drafts.csswg.org/css-overflow-3/#propdef-overflow\n */\nexport type CSSOverflow = 'visible' | 'hidden' | 'scroll' | 'clip' | 'auto';\n\n/**\n * a percentage; 0 | '0%' etc.\n * @see https://drafts.csswg.org/css-values-3/#percentage\n */\nexport type CSSPercentage = CSSGlobalValues | string | 0;\n\n/**\n * Defines a position (e.g. background-position)\n * @see https://drafts.csswg.org/css-backgrounds-3/#position\n */\nexport type CSSPosition = CSSAngle | string;\n\n/**\n * Relative size keywords\n * @see https://drafts.csswg.org/css-fonts-3/#relative-size-value\n */\nexport type CSSRelativeSize = 'larger' | 'smaller';\n\n/**\n * Specifies how background images are tiled after they have been sized and positioned\n * @see https://drafts.csswg.org/css-backgrounds/#repeat-style\n */\nexport type CSSRepeatStyle = 'repeat-x'\n  | 'repeat-y'\n  | 'repeat'\n  | 'space'\n  | 'round'\n  | 'no-repeat'\n  | 'repeat repeat'\n  | 'repeat space'\n  | 'repeat round'\n  | 'repeat no-repeat'\n  | 'space repeat'\n  | 'space space'\n  | 'space round'\n  | 'space no-repeat'\n  | 'round repeat'\n  | 'round space'\n  | 'round round'\n  | 'round no-repeat'\n  | 'no-repeat repeat'\n  | 'no-repeat space'\n  | 'no-repeat round'\n  | 'no-repeat no-repeat';\n\n/**\n * Tranform list for the element.\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function\n */\nexport type CSSTransformFunction = string | 'none';\n\n/**\n * Starting position for many gradients\n * @see https://drafts.csswg.org/css-images-3/#typedef-side-or-corner\n */\nexport type CSSSideOrCorner = CSSAngle\n  | 'left' | 'right' | 'top' | 'bottom'\n  | 'to left' | 'to right' | 'to top' | 'to bottom'\n  | 'left top' | 'right top' | 'left bottom' | 'right bottom'\n  | 'top left' | 'top right' | 'bottom left' | 'bottom right'\n  | 'to left top' | 'to right top' | 'to left bottom' | 'to right bottom'\n  | 'to top left' | 'to top right' | 'to bottom left' | 'to bottom right';\n\nexport type CSSRadialGradientEndingShape = 'circle' | 'ellipse';\n\n/**\n * Radial Gradient Size.\n * @see https://drafts.csswg.org/css-images-3/#ending-shape\n */\nexport type CSSRadialGradientSize = CSSLength | Array<CSSLength>\n  | 'closest-side' | 'farthest-side'\n  | 'closest-corner' | 'closest-side'\n  ;\n\n/** Supporting by `-timing-function` properties */\nexport type CSSTimingFunction\n  = /** e.g. steps(int,start|end)|cubic-bezier(n,n,n,n) */ string\n  | CSSGlobalValues\n  | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'linear' | 'step-start' | 'step-end';\n\n/**\n * Expressed as url('protocol://')\n * @see https://drafts.csswg.org/css-values-3/#urls\n */\nexport type CSSUrl = string;\n\n/**\n * Font weights\n */\nexport type CSSFontWeight = 'normal' | 'bold' | 'bolder' | 'lighter' | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | number | CSSGlobalValues;\n\n/**\n * This interface documents key CSS properties for autocomplete\n */\nexport interface ICSSProperties {\n\n  /**\n   * Smooth scrolling on an iPhone. Specifies whether to use native-style scrolling in an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-overflow-scrolling\n   */\n  '-webkit-overflow-scrolling'?: 'auto' | 'touch';\n\n  /**\n   * Aligns a flex container's lines within the flex container when there is extra space in the cross-axis, similar to how justify-content aligns individual items within the main-axis.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/align-content\n   */\n  alignContent?: AlignContent;\n\n  /**\n   * Sets the default alignment in the cross axis for all of the flex container's items, including anonymous flex items, similarly to how justify-content aligns items along the main axis.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/align-items\n   */\n  alignItems?: CSSValue<AlignItems>;\n  '-ms-align-items'?: CSSValue<AlignItems>;\n  '-webkit-align-items'?: CSSValue<AlignItems>;\n\n  /**\n   * Allows the default alignment to be overridden for individual flex items.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/align-self\n   */\n  alignSelf?: CSSValue<AlignSelf>;\n  '-webkit-align-self'?: CSSValue<AlignSelf>;\n  '-ms-flex-item-align'?: string;\n\n  /**\n   * This property allows precise alignment of elements, such as graphics, that do not have a baseline-table or lack the desired baseline in their baseline-table. With the alignment-adjust property, the position of the baseline identified by the alignment-baseline can be explicitly determined. It also determines precisely the alignment point for each glyph within a textual element.\n   */\n  alignmentAdjust?: any;\n\n  /**\n   * The alignment-baseline attribute specifies how an object is aligned with respect to its parent.\n   * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/alignment-baseline\n   */\n  alignmentBaseline?: 'auto' | 'baseline' | 'before-edge' | 'text-before-edge' | 'middle' | 'central' | 'after-edge' | 'text-after-edge' | 'ideographic' | 'alphabetic' | 'hanging' | 'mathematical' | 'inherit';\n\n  /**\n   * Shorthand property for animation-name, animation-duration, animation-timing-function, animation-delay,\n   * animation-iteration-count, animation-direction, animation-fill-mode, and animation-play-state.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation\n   */\n  animation?: CSSValueString;\n\n  /**\n   * Defines a length of time to elapse before an animation starts, allowing an animation to begin execution some time after it is applied.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-delay\n   */\n  animationDelay?: any;\n\n  /**\n   * Defines whether an animation should run in reverse on some or all cycles.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-direction\n   */\n  animationDirection?: CSSGlobalValues | 'normal' | 'alternate' | 'reverse' | 'alternate-reverse';\n\n  /**\n   * The animation-duration CSS property specifies the length of time that an animation should take to complete one cycle.\n   * A value of '0s', which is the default value, indicates that no animation should occur.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-duration\n   */\n  animationDuration?: CSSValue<string>;\n\n  /**\n   * Specifies how a CSS animation should apply styles to its target before and after it is executing.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-fill-mode\n   */\n  animationFillMode?: 'none' | 'forwards' | 'backwards' | 'both';\n\n  /**\n   * Specifies how many times an animation cycle should play.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-iteration-count\n   */\n  animationIterationCount?: CSSValue<number | 'infinite'>;\n\n  /**\n   * Defines the list of animations that apply to the element.\n   * Note: You probably want animationDuration as well\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-name\n   */\n  animationName?: CSSValue<string>;\n\n  /**\n   * Defines whether an animation is running or paused.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-play-state\n   */\n  animationPlayState?: CSSValue<CSSAnimationPlayState>;\n\n  /**\n   * Sets the pace of an animation\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-timing-function\n   */\n  animationTimingFunction?: CSSValue<CSSTimingFunction>;\n\n  /**\n   * Allows changing the style of any element to platform-based interface elements or vice versa.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/appearance\n   */\n  appearance?: CSSValue<'auto' | 'none'>;\n\n  /**\n   * Determines whether or not the “back” side of a transformed element is visible when facing the viewer.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/backface-visibility\n   */\n  backfaceVisibility?: CSSGlobalValues | 'visible' | 'hidden';\n\n  /**\n   * Shorthand property to set the values for one or more of:\n   * background-clip, background-color, background-image,\n   * background-origin, background-position, background-repeat,\n   * background-size, and background-attachment.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background\n   */\n  background?: any;\n\n  /**\n   * If a background-image is specified, this property determines\n   * whether that image's position is fixed within the viewport,\n   * or scrolls along with its containing block.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-attachment\n   */\n  backgroundAttachment?: 'scroll' | 'fixed' | 'local';\n\n  /**\n   * This property describes how the element's background images should blend with each other and the element's background color.\n   * The value is a list of blend modes that corresponds to each background image. Each element in the list will apply to the corresponding element of background-image. If a property doesn’t have enough comma-separated values to match the number of layers, the UA must calculate its used value by repeating the list of values until there are enough.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-blend-mode\n   */\n  backgroundBlendMode?: CSSValue<CSSBlendMode>;\n\n  /**\n   * Specifies whether an element's background, either the color or image, extends underneath its border.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-clip\n   */\n  backgroundClip?: CSSValue<CSSBox | 'text'>;\n\n  /**\n   * Sets the background color of an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-color\n   */\n  backgroundColor?: CSSValue<CSSColor>;\n\n  /**\n   * Sets a compositing style for background images and colors.\n   */\n  backgroundComposite?: any;\n\n  /**\n   * Applies one or more background images to an element. These can be any valid CSS image, including url() paths to image files or CSS gradients.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-image\n   */\n  backgroundImage?: CSSValue<CSSImage>;\n\n  /**\n   * Specifies what the background-position property is relative to.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-origin\n   */\n  backgroundOrigin?: CSSValue<CSSBox>;\n\n  /**\n   * Sets the position of a background image.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-position\n   */\n  backgroundPosition?: CSSValue<CSSPosition>;\n\n  /**\n   * Background-repeat defines if and how background images will be repeated after they have been sized and positioned\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-repeat\n   */\n  backgroundRepeat?: CSSValue<CSSRepeatStyle | string>;\n\n  /**\n   * Background-size specifies the size of a background image\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/background-size\n   */\n  backgroundSize?: 'auto' | 'cover' | 'contain' | CSSLength | CSSPercentage | CSSGlobalValues;\n\n  /**\n   * Obsolete - spec retired, not implemented.\n   * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/baseline-shift\n   */\n  baselineShift?: any;\n\n  /**\n   * Non standard. Sets or retrieves the location of the Dynamic HTML (DHTML) behavior.\n   * @see https://msdn.microsoft.com/en-us/library/ms530723(v=vs.85).aspx\n   */\n  behavior?: any;\n\n  /**\n   * Shorthand property that defines the different properties of all four sides of an element's border in a single declaration. It can be used to set border-width, border-style and border-color, or a subset of these.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border\n   */\n  border?: any;\n\n  /**\n   * Shorthand that sets the values of border-bottom-color,\n   * border-bottom-style, and border-bottom-width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom\n   */\n  borderBottom?: CSSBorderShorthand;\n\n  /**\n   * Sets the color of the bottom border of an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-color\n   */\n  borderBottomColor?: CSSValue<CSSColor>;\n\n  /**\n   * Defines the shape of the border of the bottom-left corner.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-left-radius\n   */\n  borderBottomLeftRadius?: any;\n\n  /**\n   * Defines the shape of the border of the bottom-right corner.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-right-radius\n   */\n  borderBottomRightRadius?: any;\n\n  /**\n   * Sets the line style of the bottom border of a box.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-style\n   */\n  borderBottomStyle?: CSSValue<CSSLineStyle>;\n\n  /**\n   * Sets the width of an element's bottom border. To set all four borders, use the border-width shorthand property which sets the values simultaneously for border-top-width, border-right-width, border-bottom-width, and border-left-width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-bottom-width\n   */\n  borderBottomWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Border-collapse can be used for collapsing the borders between table cells\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-collapse\n   */\n  borderCollapse?: any;\n\n  /**\n   * The CSS border-color property sets the color of an element's four borders. This property can have from one to four values, made up of the elementary properties:\n   *      •       border-top-color\n   *      •       border-right-color\n   *      •       border-bottom-color\n   *      •       border-left-color The default color is the currentColor of each of these values.\n   * If you provide one value, it sets the color for the element. Two values set the horizontal and vertical values, respectively. Providing three values sets the top, vertical, and bottom values, in that order. Four values set all for sides: top, right, bottom, and left, in that order.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-color\n   */\n  borderColor?: CSSValue<CSSColorSet>;\n\n  /**\n   * Specifies different corner clipping effects, such as scoop (inner curves), bevel (straight cuts) or notch (cut-off rectangles). Works along with border-radius to specify the size of each corner effect.\n   */\n  borderCornerShape?: any;\n\n  /**\n   * The property border-image-source is used to set the image to be used instead of the border style. If this is set to none the border-style is used instead.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-image-source\n   */\n  borderImageSource?: CSSValue<CSSImage>;\n\n  /**\n   * The border-image-width CSS property defines the offset to use for dividing the border image in nine parts, the top-left corner, central top edge, top-right-corner, central right edge, bottom-right corner, central bottom edge, bottom-left corner, and central right edge. They represent inward distance from the top, right, bottom, and left edges.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-image-width\n   */\n  borderImageWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Shorthand property that defines the border-width, border-style and border-color of an element's left border in a single declaration. Note that you can use the corresponding longhand properties to set specific individual properties of the left border — border-left-width, border-left-style and border-left-color.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-left\n   */\n  borderLeft?: CSSBorderShorthand;\n\n  /**\n   * The CSS border-left-color property sets the color of an element's left border. This page explains the border-left-color value, but often you will find it more convenient to fix the border's left color as part of a shorthand set, either border-left or border-color.\n   * Colors can be defined several ways. For more information, see Usage.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-left-color\n   */\n  borderLeftColor?: CSSValue<CSSColor>;\n\n  /**\n   * Sets the style of an element's left border. To set all four borders, use the shorthand property, border-style. Otherwise, you can set the borders individually with border-top-style, border-right-style, border-bottom-style, border-left-style.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-left-style\n   */\n  borderLeftStyle?: CSSValue<CSSLineStyle>;\n\n  /**\n   * Sets the width of an element's left border. To set all four borders, use the border-width shorthand property which sets the values simultaneously for border-top-width, border-right-width, border-bottom-width, and border-left-width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-left-width\n   */\n  borderLeftWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Allows Web authors to define how rounded border corners are\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-radius\n   */\n  borderRadius?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Shorthand property that defines the border-width, border-style and border-color of an element's right border in a single declaration. Note that you can use the corresponding longhand properties to set specific individual properties of the right border — border-right-width, border-right-style and border-right-color.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-right\n   */\n  borderRight?: CSSBorderShorthand;\n\n  /**\n   * Sets the color of an element's right border. This page explains the border-right-color value, but often you will find it more convenient to fix the border's right color as part of a shorthand set, either border-right or border-color.\n   * Colors can be defined several ways. For more information, see Usage.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-right-color\n   */\n  borderRightColor?: CSSValue<CSSColor>;\n\n  /**\n   * Sets the style of an element's right border. To set all four borders, use the shorthand property, border-style. Otherwise, you can set the borders individually with border-top-style, border-right-style, border-bottom-style, border-left-style.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-right-style\n   */\n  borderRightStyle?: CSSValue<CSSLineStyle>;\n\n  /**\n   * Sets the width of an element's right border. To set all four borders, use the border-width shorthand property which sets the values simultaneously for border-top-width, border-right-width, border-bottom-width, and border-left-width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-right-width\n   */\n  borderRightWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Specifies the distance between the borders of adjacent cells.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-spacing\n   */\n  borderSpacing?: CSSLength | string | 'inherit';\n\n  /**\n   * Sets the style of an element's four borders. This property can have from one to four values. With only one value, the value will be applied to all four borders; otherwise, this works as a shorthand property for each of border-top-style, border-right-style, border-bottom-style, border-left-style, where each border style may be assigned a separate value.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-style\n   */\n  borderStyle?: CSSValue<CSSLineStyleSet>;\n\n  /**\n   * Shorthand property that defines the border-width, border-style and border-color of an element's top border in a single declaration. Note that you can use the corresponding longhand properties to set specific individual properties of the top border — border-top-width, border-top-style and border-top-color.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-top\n   */\n  borderTop?: CSSBorderShorthand;\n\n  /**\n   * Sets the color of an element's top border. This page explains the border-top-color value, but often you will find it more convenient to fix the border's top color as part of a shorthand set, either border-top or border-color.\n   * Colors can be defined several ways. For more information, see Usage.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-color\n   */\n  borderTopColor?: CSSValue<CSSColor>;\n\n  /**\n   * Sets the rounding of the top-left corner of the element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-left-radius\n   */\n  borderTopLeftRadius?: any;\n\n  /**\n   * Sets the rounding of the top-right corner of the element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-right-radius\n   */\n  borderTopRightRadius?: any;\n\n  /**\n   * Sets the style of an element's top border. To set all four borders, use the shorthand property, border-style. Otherwise, you can set the borders individually with border-top-style, border-right-style, border-bottom-style, border-left-style.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-style\n   */\n  borderTopStyle?: CSSValue<CSSLineStyle>;\n\n  /**\n   * Sets the width of an element's top border. To set all four borders, use the border-width shorthand property which sets the values simultaneously for border-top-width, border-right-width, border-bottom-width, and border-left-width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-top-width\n   */\n  borderTopWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Sets the width of an element's four borders. This property can have from one to four values. This is a shorthand property for setting values simultaneously for border-top-width, border-right-width, border-bottom-width, and border-left-width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border-width\n   */\n  borderWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * This property specifies how far an absolutely positioned box's bottom margin edge is offset above the bottom edge of the box's containing block. For relatively positioned boxes, the offset is with respect to the bottom edges of the box itself (i.e., the box is given a position in the normal flow, then offset from that position according to these properties).\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/bottom\n   */\n  bottom?: CSSValue<'auto' | CSSLength | CSSPercentage | CSSGlobalValues>;\n\n  /**\n   * Obsolete.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-align\n   */\n  boxAlign?: any;\n\n  /**\n   * Breaks a box into fragments creating new borders, padding and repeating backgrounds or lets it stay as a continuous box on a page break, column break, or, for inline elements, at a line break.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-decoration-break\n   */\n  boxDecorationBreak?: any;\n\n  /**\n   * Deprecated\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-direction\n   */\n  boxDirection?: any;\n\n  /**\n   * Do not use. This property has been replaced by the flex-wrap property.\n   * Gets or sets a value that specifies the direction to add successive rows or columns when the value of box-lines is set to multiple.\n   */\n  boxLineProgression?: any;\n\n  /**\n   * Do not use. This property has been replaced by the flex-wrap property.\n   * Gets or sets a value that specifies whether child elements wrap onto multiple lines or columns based on the space available in the object.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-lines\n   */\n  boxLines?: any;\n\n  /**\n   * Do not use. This property has been replaced by flex-order.\n   * Specifies the ordinal group that a child element of the object belongs to. This ordinal value identifies the display order (along the axis defined by the box-orient property) for the group.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-ordinal-group\n   */\n  boxOrdinalGroup?: any;\n\n  /**\n   * Deprecated.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-flex\n   */\n  boxFlex?: number;\n\n  /**\n   * box sizing\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-sizing\n   */\n  boxSizing?: CSSGlobalValues | 'content-box' | 'border-box';\n  '-moz-box-sizing'?: CSSGlobalValues | 'content-box' | 'border-box';\n  '-webkit-box-sizing'?: CSSGlobalValues | 'content-box' | 'border-box';\n\n  /**\n   * Box shadow\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow\n   */\n  boxShadow?: CSSValueGeneral;\n\n  /**\n   * Deprecated.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-flex-group\n   */\n  boxFlexGroup?: number;\n\n  /**\n   * The CSS break-after property allows you to force a break on multi-column layouts. More specifically, it allows you to force a break after an element. It allows you to determine if a break should occur, and what type of break it should be. The break-after CSS property describes how the page, column or region break behaves after the generated box. If there is no generated box, the property is ignored.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/break-after\n   */\n  breakAfter?: 'auto' | 'avoid' | 'avoid-page' | 'page' | 'left' | 'right' | 'recto' | 'verso' | 'avoid-column' | 'column' | 'avoid-region' | 'region';\n\n  /**\n   * Control page/column/region breaks that fall above a block of content\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/break-before\n   */\n  breakBefore?: 'auto' | 'avoid' | 'avoid-page' | 'page' | 'left' | 'right' | 'recto' | 'verso' | 'avoid-column' | 'column' | 'avoid-region' | 'region';\n\n  /**\n   * Control page/column/region breaks that fall within a block of content\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/break-inside\n   */\n  breakInside?: 'auto' | 'avoid' | 'avoid-page' | 'avoid-column' | 'avoid-region';\n\n  /**\n   * The caption-side CSS property positions the content of a table's <caption> on the specified side.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/caption-side\n   */\n  captionSide?: CSSGlobalValues | 'top' | 'bottom' | 'block-start' | 'block-end' | 'inline-start' | 'inline-end';\n\n  /**\n   * The clear CSS property specifies if an element can be positioned next to or must be positioned below the floating elements that precede it in the markup.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/clear\n   */\n  clear?: CSSGlobalValues | 'none' | 'left' | 'right' | 'both';\n\n  /**\n   * Deprecated; see clip-path.\n   * Lets you specify the dimensions of an absolutely positioned element that should be visible, and the element is clipped into this shape, and displayed.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/clip\n   */\n  clip?: any;\n\n  /**\n   * Clipping crops an graphic, so that only a portion of the graphic is rendered, or filled. This clip-rule property, when used with the clip-path property, defines which clip rule, or algorithm, to use when filling the different parts of a graphics.\n   * @see https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/clip-rule\n   */\n  clipRule?: any;\n\n  /**\n   * The color property sets the color of an element's foreground content (usually text), accepting any standard CSS color from keywords and hex values to RGB(a) and HSL(a).\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/color\n   */\n  color?: CSSValue<CSSColor>;\n\n  /**\n   * Describes the number of columns of the element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/column-count\n   */\n  columnCount?: number;\n\n  /**\n   * Specifies how to fill columns (balanced or sequential).\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/column-fill\n   */\n  columnFill?: any;\n\n  /**\n   * The column-gap property controls the width of the gap between columns in multi-column elements.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/column-gap\n   */\n  columnGap?: any;\n\n  /**\n   * Sets the width, style, and color of the rule between columns.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/column-rule\n   */\n  columnRule?: any;\n\n  /**\n   * Specifies the color of the rule between columns.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/column-rule-color\n   */\n  columnRuleColor?: CSSValue<CSSColor>;\n\n  /**\n   * Specifies the width of the rule between columns.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/column-rule-width\n   */\n  columnRuleWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The column-span CSS property makes it possible for an element to span across all columns when its value is set to all. An element that spans more than one column is called a spanning element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/column-span\n   */\n  columnSpan?: any;\n\n  /**\n   * Specifies the width of columns in multi-column elements.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/column-width\n   */\n  columnWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * This property is a shorthand property for setting column-width and/or column-count.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/columns\n   */\n  columns?: any;\n\n  /**\n   * The content property is used with the :before and :after pseudo-elements, to insert generated content.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/content\n   */\n  content?: CSSValueString;\n\n  /**\n   * The counter-increment property accepts one or more names of counters (identifiers), each one optionally followed by an integer which specifies the value by which the counter should be incremented (e.g. if the value is 2, the counter increases by 2 each time it is invoked).\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/counter-increment\n   */\n  counterIncrement?: any;\n\n  /**\n   * The counter-reset property contains a list of one or more names of counters, each one optionally followed by an integer (otherwise, the integer defaults to 0.) Each time the given element is invoked, the counters specified by the property are set to the given integer.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/counter-reset\n   */\n  counterReset?: any;\n\n  /**\n   * The cue property specifies sound files (known as an \"auditory icon\") to be played by speech media agents before and after presenting an element's content; if only one file is specified, it is played both before and after. The volume at which the file(s) should be played, relative to the volume of the main element, may also be specified. The icon files may also be set separately with the cue-before and cue-after properties.\n   */\n  cue?: any;\n\n  /**\n   * The cue-after property specifies a sound file (known as an \"auditory icon\") to be played by speech media agents after presenting an element's content; the volume at which the file should be played may also be specified. The shorthand property cue sets cue sounds for both before and after the element is presented.\n   */\n  cueAfter?: any;\n\n  /**\n   * Specifies the mouse cursor displayed when the mouse pointer is over an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/cursor\n   */\n  cursor?: CSSValue<CSSGlobalValues | string | 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'grab' | 'grabbing'>;\n\n  /**\n   * The direction CSS property specifies the text direction/writing direction. The rtl is used for Hebrew or Arabic text, the ltr is for other languages.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/direction\n   */\n  direction?: CSSGlobalValues | 'ltr' | 'rtl';\n\n  /**\n   * This property specifies the type of rendering box used for an element. It is a shorthand property for many other display properties.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/display\n   */\n  display?: CSSValue<CSSGlobalValues | CSSDisplay>;\n\n  /**\n   * SVG: Used to determine or re-determine a scaled-baseline-table.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/dominant-baseline\n   */\n  dominantBaseline?: 'auto' | 'use-script' | 'no-change' | 'reset-size' | 'ideographic' | 'alphabetic' | 'hanging' | 'mathematical' | 'central' | 'middle' | 'text-after-edge' | 'text-before-edge' | 'inherit';\n\n  /**\n   * The ‘empty-cells’ CSS property specifies how the user agent should render borders and backgrounds around <table> cells that have no visible content.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/empty-cells\n   */\n  emptyCells?: CSSGlobalValues | 'show' | 'hide';\n\n  /**\n   * The ‘fill’ property paints the interior of the given graphical element. The area to be painted consists of any areas inside the outline of the shape. To determine the inside of the shape, all subpaths are considered, and the interior is determined according to the rules associated with the current value of the ‘fill-rule’ property. The zero-width geometric outline of a shape is included in the area to be painted.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/fill\n   */\n  fill?: CSSColor | 'context-stroke' | 'context-fill';\n\n  /**\n   * SVG: Specifies the opacity of the color or the content the current object is filled with.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/fill-opacity\n   */\n  fillOpacity?: number;\n\n  /**\n   * The ‘fill-rule’ property indicates the algorithm which is to be used to determine what parts of the canvas are included inside the shape. For a simple, non-intersecting path, it is intuitively clear what region lies \"inside\"; however, for a more complex path, such as a path that intersects itself or where one subpath encloses another, the interpretation of \"inside\" is not so obvious.\n   * The ‘fill-rule’ property provides two options for how the inside of a shape is determined:\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/fill-rule\n   */\n  fillRule?: 'nonzero' | 'evenodd';\n\n  /**\n   * Applies various image processing effects. This property is largely unsupported. See Compatibility section for more information.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/filter\n   */\n  filter?: string;\n\n  /**\n   * Shorthand for `flex-grow`, `flex-shrink`, and `flex-basis`.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex\n   */\n  flex?: number | string;\n  '-webkit-flex'?: number | string;\n  '-ms-flex'?: number | string;\n\n  /**\n   * Obsolete, do not use. This property has been renamed to align-items.\n   * Specifies the alignment (perpendicular to the layout axis defined by the flex-direction property) of child elements of the object.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-align\n   */\n  flexAlign?: any;\n  '-ms-flex-align'?: any;\n  '-webkit-flex-align'?: any;\n\n  /**\n   * The flex-basis CSS property describes the initial main size of the flex item before any free space is distributed according to the flex factors described in the flex property (flex-grow and flex-shrink).\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-basis\n   */\n  flexBasis?: any;\n\n  /**\n   * The flex-direction CSS property describes how flex items are placed in the flex container, by setting the direction of the flex container's main axis.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-direction\n   */\n  flexDirection?: any;\n  '-ms-flex-direction'?: any;\n  '-webkit-flex-direction'?: any;\n\n  /**\n   * The flex-flow CSS property defines the flex container's main and cross axis. It is a shorthand property for the flex-direction and flex-wrap properties.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-flow\n   */\n  flexFlow?: any;\n\n  /**\n   * Specifies the flex grow factor of a flex item.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-grow\n   */\n  flexGrow?: number;\n  '-ms-flex-grow'?: number;\n  '-webkit-flex-grow'?: number;\n\n  /**\n   * Do not use. This property has been renamed to align-self\n   * Specifies the alignment (perpendicular to the layout axis defined by flex-direction) of child elements of the object.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-item-align\n   */\n  flexItemAlign?: any;\n\n  /**\n   * Do not use. This property has been renamed to align-content.\n   * Specifies how a flexbox's lines align within the flexbox when there is extra space along the axis that is perpendicular to the axis defined by the flex-direction property.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-line-pack\n   */\n  flexLinePack?: any;\n\n  flexPositive?: any;\n  '-ms-flex-positive'?: any;\n  '-webkit-flex-positive'?: any;\n\n  flexNegative?: any;\n  '-ms-flex-negative'?: any;\n  '-webkit-flex-negative'?: any;\n\n  /**\n   * Gets or sets a value that specifies the ordinal group that a flexbox element belongs to. This ordinal value identifies the display order for the group.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-order\n   */\n  flexOrder?: any;\n\n  /**\n   * Specifies the flex shrink factor of a flex item.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-shrink\n   */\n  flexShrink?: number;\n  '-ms-flex-shrink'?: number;\n  '-webkit-flex-shrink'?: number;\n\n  /**\n   * Specifies whether flex items are forced into a single line or can be wrapped onto multiple lines.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/flex-wrap\n   */\n  flexWrap?: CSSGlobalValues | 'nowrap' | 'wrap' | 'wrap-reverse';\n  '-ms-flex-wrap'?: CSSGlobalValues | 'nowrap' | 'wrap' | 'wrap-reverse';\n  '-webkit-flex-wrap'?: CSSGlobalValues | 'nowrap' | 'wrap' | 'wrap-reverse';\n\n  /**\n   * Elements which have the style float are floated horizontally. These elements can move as far to the left or right of the containing element. All elements after the floating element will flow around it, but elements before the floating element are not impacted. If several floating elements are placed after each other, they will float next to each other as long as there is room.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/float\n   */\n  float?: CSSGlobalValues | 'left' | 'right' | 'none' | 'inline-start' | 'inline-end';\n\n  /**\n   * Flows content from a named flow (specified by a corresponding flow-into) through selected elements to form a dynamic chain of layout regions.\n   */\n  flowFrom?: any;\n\n  /**\n   * The font property is shorthand that allows you to do one of two things: you can either set up six of the most mature font properties in one line, or you can set one of a choice of keywords to adopt a system font setting.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font\n   */\n  font?: any;\n\n  /**\n   * The font-family property allows one or more font family names and/or generic family names to be specified for usage on the selected element(s)' text. The browser then goes through the list; for each character in the selection it applies the first font family that has an available glyph for that character.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-family\n   */\n  fontFamily?: any;\n\n  /**\n   * The font-kerning property allows contextual adjustment of inter-glyph spacing, i.e. the spaces between the characters in text. This property controls <bold>metric kerning</bold> - that utilizes adjustment data contained in the font. Optical Kerning is not supported as yet.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-kerning\n   */\n  fontKerning?: CSSGlobalValues | 'auto' | 'normal' | 'none';\n\n  /**\n   * Specifies the size of the font. Used to compute em and ex units.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-size\n   */\n  fontSize?: CSSValue<CSSFontSize>;\n\n  /**\n   * The font-size-adjust property adjusts the font-size of the fallback fonts defined with font-family, so that the x-height is the same no matter what font is used. This preserves the readability of the text when fallback happens.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-size-adjust\n   */\n  fontSizeAdjust?: any;\n\n  /**\n   * Allows you to expand or condense the widths for a normal, condensed, or expanded font face.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-stretch\n   */\n  fontStretch?: CSSGlobalValues | 'normal' | 'ultra-condensed' | 'extra-condensed' | 'condensed' | 'semi-condensed' | 'semi-expanded' | 'expanded' | 'extra-expanded' | 'ultra-expanded';\n\n  /**\n   * The font-style property allows normal, italic, or oblique faces to be selected. Italic forms are generally cursive in nature while oblique faces are typically sloped versions of the regular face. Oblique faces can be simulated by artificially sloping the glyphs of the regular face.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-style\n   */\n  fontStyle?: CSSGlobalValues | 'normal' | 'italic' | 'oblique';\n\n  /**\n   * This value specifies whether the user agent is allowed to synthesize bold or oblique font faces when a font family lacks bold or italic faces.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-synthesis\n   */\n  fontSynthesis?: any;\n\n  /**\n   * The font-variant property enables you to select the small-caps font within a font family.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-variant\n   */\n  fontVariant?: any;\n\n  /**\n   * Fonts can provide alternate glyphs in addition to default glyph for a character. This property provides control over the selection of these alternate glyphs.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-variant-alternates\n   */\n  fontVariantAlternates?: any;\n\n  /**\n   * Specifies the weight or boldness of the font.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight\n   */\n  fontWeight?: CSSFontWeight;\n\n  /**\n   * Lays out one or more grid items bound by 4 grid lines. Shorthand for setting grid-column-start, grid-column-end, grid-row-start, and grid-row-end in a single declaration.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-area\n   */\n  gridArea?: any;\n\n  /**\n   * Specifies the size of an implicitly-created grid column track.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-auto-columns\n   */\n  gridAutoColumns?: any;\n\n  /**\n   * Controls how the auto-placement algorithm works, specifying exactly how auto-placed items get flowed into the grid.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-auto-flow\n   */\n  gridAutoFlow?: any;\n\n  /**\n   * Specifies the size of an implicitly-created grid row track.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-auto-rows\n   */\n  gridAutoRows?: any;\n\n  /**\n   * Controls a grid item's placement in a grid area, particularly grid position and a grid span. Shorthand for setting grid-column-start and grid-column-end in a single declaration.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-column\n   */\n  gridColumn?: any;\n\n  /**\n   * Specifies the gutter between grid columns.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-column-gap\n   */\n  gridColumnGap?: any;\n\n  /**\n   * Controls a grid item's placement in a grid area as well as grid position and a grid span. The grid-column-end property (with grid-row-start, grid-row-end, and grid-column-start) determines a grid item's placement by specifying the grid lines of a grid item's grid area.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-column-end\n   */\n  gridColumnEnd?: any;\n\n  /**\n   * Determines a grid item's placement by specifying the starting grid lines of a grid item's grid area . A grid item's placement in a grid area consists of a grid position and a grid span. See also ( grid-row-start, grid-row-end, and grid-column-end)\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-column-start\n   */\n  gridColumnStart?: any;\n\n  /**\n   * Specifies the gutters between grid rows and columns, Shorthand for for grid-row-gap and grid-column-gap in a single declaration.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-gap\n   */\n  gridGap?: any;\n\n  /**\n   * Gets or sets a value that indicates which row an element within a Grid should appear in. Shorthand for setting grid-row-start and grid-row-end in a single declaration.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-row\n   */\n  gridRow?: any;\n\n  /**\n   * Determines a grid item’s placement by specifying the block-end. A grid item's placement in a grid area consists of a grid position and a grid span. The grid-row-end property (with grid-row-start, grid-column-start, and grid-column-end) determines a grid item's placement by specifying the grid lines of a grid item's grid area.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-row-end\n   */\n  gridRowEnd?: any;\n\n  /**\n   * Specifies the gutter between grid rows.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-row-gap\n   */\n  gridRowGap?: any;\n\n  /**\n   * Determines a grid item’s start position within the grid row by contributing a line, a span, or nothing (automatic) to its grid placement, thereby specifying the inline-start edge of its grid area.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-row-start\n   */\n  gridRowStart?: any;\n\n  /**\n   * Specifies a row position based upon an integer location, string value, or desired row size.\n   * css/properties-panel/grid-row is used as short-hand for grid-row-position and grid-row-position\n   */\n  gridRowPosition?: any;\n\n  gridRowSpan?: any;\n\n  /**\n   * Is a shorthand property for defining grid columns, rows, and areas.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-areas\n   */\n  gridTemplate?: any;\n\n  /**\n   * Specifies named grid areas which are not associated with any particular grid item, but can be referenced from the grid-placement properties. The syntax of the grid-template-areas property also provides a visualization of the structure of the grid, making the overall layout of the grid container easier to understand.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-areas\n   */\n  gridTemplateAreas?: any;\n\n  /**\n   * Specifies (with grid-template-rows) the line names and track sizing functions of the grid. Each sizing function can be specified as a length, a percentage of the grid container’s size, a measurement of the contents occupying the column or row, or a fraction of the free space in the grid.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-columns\n   */\n  gridTemplateColumns?: any;\n\n  /**\n   * Specifies (with grid-template-columns) the line names and track sizing functions of the grid. Each sizing function can be specified as a length, a percentage of the grid container’s size, a measurement of the contents occupying the column or row, or a fraction of the free space in the grid.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-rows\n   */\n  gridTemplateRows?: any;\n\n  /**\n   * Sets the height of an element. The content area of the element height does not include the padding, border, and margin of the element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/height\n   */\n  height?: CSSValue<'auto' | CSSLength | CSSPercentage | CSSGlobalValues>;\n\n  /**\n   * Specifies the minimum number of characters in a hyphenated word\n   * @see https://msdn.microsoft.com/en-us/library/hh771865(v=vs.85).aspx\n   */\n  hyphenateLimitChars?: any;\n\n  /**\n   * Indicates the maximum number of successive hyphenated lines in an element. The ‘no-limit’ value means that there is no limit.\n   * @see https://msdn.microsoft.com/en-us/library/hh771867(v=vs.85).aspx\n   */\n  hyphenateLimitLines?: any;\n\n  /**\n   * Specifies the maximum amount of trailing whitespace (before justification) that may be left in a line before hyphenation is triggered to pull part of a word from the next line back up into the current one.\n   * @see https://msdn.microsoft.com/en-us/library/hh771869(v=vs.85).aspx\n   */\n  hyphenateLimitZone?: any;\n\n  /**\n   * Specifies whether or not words in a sentence can be split by the use of a manual or automatic hyphenation mechanism.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/hyphens\n   */\n  hyphens?: CSSGlobalValues | string | 'none' | 'manual' | 'auto';\n\n  /**\n   * The image-rendering CSS property sets an image scaling algorithm. The property applies to an element itself, to any images set in its other properties, and to its descendants.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/image-rendering\n   */\n  imageRendering?: CSSGlobalValues | 'auto' | 'crisp-edges' | 'pixelated' | 'high-quality' | 'smooth';\n\n  /**\n   * Controls the state of the input method editor for text fields.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/ime-mode\n   */\n  imeMode?: CSSGlobalValues | 'auto' | 'normal' | 'active' | 'inactive' | 'disabled';\n\n  /**\n   * Defines how the browser distributes space between and around flex items\n   * along the main-axis of their container.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/justify-content\n   */\n  justifyContent?: JustifyContent;\n  '-webkit-justify-content'?: JustifyContent;\n  '-ms-flex-pack'?: string;\n\n  /**\n   * Defines the default justify-self for all items of the box, given them the\n   * default way of justifying each box along the appropriate axis\n   */\n  justifyItems?: JustifyItems;\n\n  /**\n   * Defines the way of justifying a box inside its container along the appropriate axis.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/justify-self\n   */\n  justifySelf?: JustifySelf;\n\n  layoutGrid?: any;\n\n  layoutGridChar?: any;\n\n  layoutGridLine?: any;\n\n  layoutGridMode?: any;\n\n  layoutGridType?: any;\n\n  /**\n   * Sets the left edge of an element\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/left\n   */\n  left?: CSSValue<'auto' | CSSLength | CSSPercentage | CSSGlobalValues>;\n\n  /**\n   * The letter-spacing CSS property specifies the spacing behavior between text characters.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/letter-spacing\n   */\n  letterSpacing?: any;\n\n  /**\n   * Deprecated. Gets or sets line-breaking rules for text in selected languages such as Japanese, Chinese, and Korean.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-break\n   */\n  lineBreak?: any;\n\n  lineClamp?: number;\n\n  /**\n   * Specifies the height of an inline block level element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-height\n   */\n  lineHeight?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Shorthand property that sets the list-style-type, list-style-position and list-style-image properties in one declaration.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/list-style\n   */\n  listStyle?: any;\n\n  /**\n   * This property sets the image that will be used as the list item marker. When the image is available, it will replace the marker set with the 'list-style-type' marker. That also means that if the image is not available, it will show the style specified by list-style-property\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-image\n   */\n  listStyleImage?: any;\n\n  /**\n   * Specifies if the list-item markers should appear inside or outside the content flow.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-position\n   */\n  listStylePosition?: CSSGlobalValues | 'inside' | 'outside';\n\n  /**\n   * Specifies the type of list-item marker in a list.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/list-style-type\n   */\n  listStyleType?: any;\n\n  /**\n   * The margin property is shorthand to allow you to set all four margins of an element at once. Its equivalent longhand properties are margin-top, margin-right, margin-bottom and margin-left. Negative values are also allowed.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/margin\n   */\n  margin?: any;\n\n  /**\n   * margin-bottom sets the bottom margin of an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/margin-bottom\n   */\n  marginBottom?: any;\n\n  /**\n   * margin-left sets the left margin of an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/margin-left\n   */\n  marginLeft?: any;\n\n  /**\n   * margin-right sets the right margin of an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/margin-right\n   */\n  marginRight?: any;\n\n  /**\n   * margin-top sets the top margin of an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/margin-top\n   */\n  marginTop?: CSSValueGeneral;\n\n  /**\n   * The marquee-direction determines the initial direction in which the marquee content moves.\n   */\n  marqueeDirection?: any;\n\n  /**\n   * The 'marquee-style' property determines a marquee's scrolling behavior.\n   */\n  marqueeStyle?: any;\n\n  /**\n   * This property is shorthand for setting mask-image, mask-mode, mask-repeat, mask-position, mask-clip, mask-origin, mask-composite and mask-size. Omitted values are set to their original properties' initial values.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/mask\n   */\n  mask?: any;\n\n  /**\n   * This property is shorthand for setting mask-border-source, mask-border-slice, mask-border-width, mask-border-outset, and mask-border-repeat. Omitted values are set to their original properties' initial values.\n   */\n  maskBorder?: any;\n\n  /**\n   * This property specifies how the images for the sides and the middle part of the mask image are scaled and tiled. The first keyword applies to the horizontal sides, the second one applies to the vertical ones. If the second keyword is absent, it is assumed to be the same as the first, similar to the CSS border-image-repeat property.\n   */\n  maskBorderRepeat?: any;\n\n  /**\n   * This property specifies inward offsets from the top, right, bottom, and left edges of the mask image, dividing it into nine regions: four corners, four edges, and a middle. The middle image part is discarded and treated as fully transparent black unless the fill keyword is present. The four values set the top, right, bottom and left offsets in that order, similar to the CSS border-image-slice property.\n   */\n  maskBorderSlice?: any;\n\n  /**\n   * Specifies an image to be used as a mask. An image that is empty, fails to download, is non-existent, or cannot be displayed is ignored and does not mask the element.\n   */\n  maskBorderSource?: any;\n\n  /**\n   * This property sets the width of the mask box image, similar to the CSS border-image-width property.\n   */\n  maskBorderWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Determines the mask painting area, which defines the area that is affected by the mask. The painted content of an element may be restricted to this area.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/mask-clip\n   */\n  maskClip?: any;\n\n  /**\n   * For elements rendered as a single box, specifies the mask positioning area. For elements rendered as multiple boxes (e.g., inline boxes on several lines, boxes on several pages) specifies which boxes box-decoration-break operates on to determine the mask positioning area(s).\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/mask-origin\n   */\n  maskOrigin?: any;\n\n  /**\n   * This property must not be used. It is no longer included in any standard or standard track specification, nor is it implemented in any browser. It is only used when the text-align-last property is set to size. It controls allowed adjustments of font-size to fit line content.\n   */\n  maxFontSize?: any;\n\n  /**\n   * Sets the maximum height for an element. It prevents the height of the element to exceed the specified value. If min-height is specified and is greater than max-height, max-height is overridden.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/max-height\n   */\n  maxHeight?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Sets the maximum width for an element. It limits the width property to be larger than the value specified in max-width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/max-width\n   */\n  maxWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Sets the minimum height for an element. It prevents the height of the element to be smaller than the specified value. The value of min-height overrides both max-height and height.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/min-height\n   */\n  minHeight?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Sets the minimum width of an element. It limits the width property to be not smaller than the value specified in min-width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/min-width\n   */\n  minWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The blend mode defines the formula that must be used to mix the colors with the backdrop\n   * @see https://drafts.fxtf.org/compositing-1/#mix-blend-mode\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode\n   */\n  mixBlendMode?: CSSValue<CSSBlendMode>;\n\n  /**\n   * Specifies how the contents of a replaced element should be fitted to the box established by its used height and width.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit\n   */\n  objectFit?: CSSObjectFit;\n\n  /**\n   * Determines the alignment of the element inside its box.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/object-position\n   */\n  objectPosition?: string | CSSGlobalValues;\n\n  /**\n   * Specifies the transparency of an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/opacity\n   */\n  opacity?: number | CSSGlobalValues;\n\n  /**\n   * Specifies the order used to lay out flex items in their flex container.\n   * Elements are laid out in the ascending order of the order value.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/order\n   */\n  order?: number;\n\n  /**\n   * In paged media, this property defines the minimum number of lines in\n   * a block container that must be left at the bottom of the page.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/orphans\n   */\n  orphans?: number;\n\n  /**\n   * The CSS outline property is a shorthand property for setting one or more of the individual outline properties outline-style, outline-width and outline-color in a single rule. In most cases the use of this shortcut is preferable and more convenient.\n   * Outlines differ from borders in the following ways:  •       Outlines do not take up space, they are drawn above the content.\n   *      •       Outlines may be non-rectangular. They are rectangular in Gecko/Firefox. Internet Explorer attempts to place the smallest contiguous outline around all elements or shapes that are indicated to have an outline. Opera draws a non-rectangular shape around a construct.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/outline\n   */\n  outline?: any;\n\n  /**\n   * The outline-color property sets the color of the outline of an element. An outline is a line that is drawn around elements, outside the border edge, to make the element stand out.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/outline-color\n   */\n  outlineColor?: CSSValue<CSSColor>;\n\n  /**\n   * The outline-style property sets the style of the outline of an element.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/outline-style\n   */\n  outlineStyle?: CSSGlobalValues | 'auto' | 'none' | 'dotted' | 'dashed' | 'solid' | 'double' | 'groove' | 'ridge' | 'inset' | 'outset';\n\n  /**\n   * The outline-offset property offsets the outline and draw it beyond the border edge.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/outline-offset\n   */\n  outlineOffset?: any;\n\n  /**\n   * The outline-width CSS property is used to set the width of the outline of an element. An outline is a line that is drawn around elements, outside the border edge, to make the element stand out\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/outline-width\n   */\n  outlineWidth?: CSSGlobalValues | 'thin' | 'medium' | 'thick' | CSSLength;\n\n  /**\n   * The overflow property controls how extra content exceeding the bounding box of an element is rendered. It can be used in conjunction with an element that has a fixed width and height, to eliminate text-induced page distortion.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/overflow\n   */\n  overflow?: CSSValue<CSSOverflow>;\n\n  /**\n   * Specifies the preferred scrolling methods for elements that overflow.\n   */\n  overflowStyle?: any;\n\n  /**\n    * The overflow-wrap CSS property specifies whether or not the browser should insert line breaks within words to prevent\n    * text from overflowing its content box. In contrast to word-break, overflow-wrap will only create a break if an entire\n    * word cannot be placed on its own line without overflowing.\n    * @see https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-wrap\n    */\n  overflowWrap?: CSSGlobalValues | 'normal' | 'break-word';\n\n  /**\n   * Controls how extra content exceeding the x-axis of the bounding box of an element is rendered.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-x\n   */\n  overflowX?: CSSValue<CSSOverflow>;\n\n  /**\n   * Controls how extra content exceeding the y-axis of the bounding box of an element is rendered.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-y\n   */\n  overflowY?: CSSValue<CSSOverflow>;\n\n  /**\n   * The padding optional CSS property sets the required padding space on one to four sides of an element. The padding area is the space between an element and its border. Negative values are not allowed but decimal values are permitted. The element size is treated as fixed, and the content of the element shifts toward the center as padding is increased.\n   * The padding property is a shorthand to avoid setting each side separately (padding-top, padding-right, padding-bottom, padding-left).\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/padding\n   */\n  padding?: any;\n\n  /**\n   * The padding-bottom CSS property of an element sets the padding space required on the bottom of an element. The padding area is the space between the content of the element and its border. Contrary to margin-bottom values, negative values of padding-bottom are invalid.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/padding-bottom\n   */\n  paddingBottom?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The padding-left CSS property of an element sets the padding space required on the left side of an element. The padding area is the space between the content of the element and its border. Contrary to margin-left values, negative values of padding-left are invalid.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/padding-left\n   */\n  paddingLeft?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The padding-right CSS property of an element sets the padding space required on the right side of an element. The padding area is the space between the content of the element and its border. Contrary to margin-right values, negative values of padding-right are invalid.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/padding-right\n   */\n  paddingRight?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The padding-top CSS property of an element sets the padding space required on the top of an element. The padding area is the space between the content of the element and its border. Contrary to margin-top values, negative values of padding-top are invalid.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/padding-top\n   */\n  paddingTop?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The page-break-after property is supported in all major browsers. With CSS3, page-break-* properties are only aliases of the break-* properties. The CSS3 Fragmentation spec defines breaks for all CSS box fragmentation.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/page-break-after\n   */\n  pageBreakAfter?: CSSGlobalValues | 'auto' | 'always' | 'avoid' | 'left' | 'right' | 'recto' | 'verso';\n\n  /**\n   * The page-break-before property sets the page-breaking behavior before an element. With CSS3, page-break-* properties are only aliases of the break-* properties. The CSS3 Fragmentation spec defines breaks for all CSS box fragmentation.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/page-break-before\n   */\n  pageBreakBefore?: CSSGlobalValues | 'auto' | 'always' | 'avoid' | 'left' | 'right' | 'recto' | 'verso';\n\n  /**\n   * Sets the page-breaking behavior inside an element. With CSS3, page-break-* properties are only aliases of the break-* properties. The CSS3 Fragmentation spec defines breaks for all CSS box fragmentation.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/page-break-inside\n   */\n  pageBreakInside?: CSSGlobalValues | 'auto' | 'avoid';\n\n  /**\n   * The pause property determines how long a speech media agent should pause before and after presenting an element. It is a shorthand for the pause-before and pause-after properties.\n   */\n  pause?: any;\n\n  /**\n   * The pause-after property determines how long a speech media agent should pause after presenting an element. It may be replaced by the shorthand property pause, which sets pause time before and after.\n   */\n  pauseAfter?: any;\n\n  /**\n   * The pause-before property determines how long a speech media agent should pause before presenting an element. It may be replaced by the shorthand property pause, which sets pause time before and after.\n   */\n  pauseBefore?: any;\n\n  /**\n   * The perspective property defines how far an element is placed from the view on the z-axis, from the screen to the viewer.\n   * Perspective defines how an object is viewed. In graphic arts, perspective is the representation on a flat surface of what the viewer's eye would see in a 3D space. (See Wikipedia for more information about graphical perspective and for related illustrations.)\n   * The illusion of perspective on a flat surface, such as a computer screen, is created by projecting points on the flat surface as they would appear if the flat surface were a window through which the viewer was looking at the object. In discussion of virtual environments, this flat surface is called a projection plane.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/perspective\n   */\n  perspective?: any;\n\n  /**\n   * The perspective-origin property establishes the origin for the perspective property. It effectively sets the X and Y position at which the viewer appears to be looking at the children of the element.\n   * When used with perspective, perspective-origin changes the appearance of an object, as if a viewer were looking at it from a different origin. An object appears differently if a viewer is looking directly at it versus looking at it from below, above, or from the side. Thus, the perspective-origin is like a vanishing point.\n   * The default value of perspective-origin is 50% 50%. This displays an object as if the viewer's eye were positioned directly at the center of the screen, both top-to-bottom and left-to-right. A value of 0% 0% changes the object as if the viewer was looking toward the top left angle. A value of 100% 100% changes the appearance as if viewed toward the bottom right angle.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/perspective-origin\n   */\n  perspectiveOrigin?: any;\n\n  /**\n   * The pointer-events property allows you to control whether an element can be the target for the pointing device (e.g, mouse, pen) events.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/pointer-events\n   */\n  pointerEvents?: CSSGlobalValues | 'auto' | 'none' | 'visiblePainted' | 'visibleFill' | 'visibleStroke' | 'visible' | 'painted' | 'fill' | 'stroke' | 'all';\n\n  /**\n   * The position property controls the type of positioning used by an element within its parent elements. The effect of the position property depends on a lot of factors, for example the position property of parent elements.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/position\n   */\n  position?: CSSValue<CSSGlobalValues | 'static' | 'relative' | 'absolute' | 'sticky' | '-webkit-sticky' | 'fixed'>;\n\n  /**\n   * Obsolete: unsupported.\n   * This property determines whether or not a full-width punctuation mark character should be trimmed if it appears at the beginning of a line, so that its \"ink\" lines up with the first glyph in the line above and below.\n   */\n  punctuationTrim?: any;\n\n  /**\n   * Sets the type of quotation marks for embedded quotations.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/quotes\n   */\n  quotes?: any;\n\n  /**\n   * Controls whether the last region in a chain displays additional 'overset' content according its default overflow property, or if it displays a fragment of content as if it were flowing into a subsequent region.\n   */\n  regionFragment?: any;\n\n  /**\n   * The resize CSS property lets you control the resizability of an element.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/resize\n   */\n  resize?: CSSGlobalValues | 'none' | 'both ' | 'horizontal' | 'vertical';\n\n  /**\n   * The rest-after property determines how long a speech media agent should pause after presenting an element's main content, before presenting that element's exit cue sound. It may be replaced by the shorthand property rest, which sets rest time before and after.\n   */\n  restAfter?: any;\n\n  /**\n   * The rest-before property determines how long a speech media agent should pause after presenting an intro cue sound for an element, before presenting that element's main content. It may be replaced by the shorthand property rest, which sets rest time before and after.\n   */\n  restBefore?: any;\n\n  /**\n   * Specifies the position an element in relation to the right side of the containing element.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/right\n   */\n  right?: CSSValue<'auto' | CSSLength | CSSPercentage | CSSGlobalValues>;\n\n  /**\n   * Specifies the distribution of the different ruby elements over the base.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/ruby-align\n   */\n  rubyAlign?: CSSGlobalValues | 'start' | 'center' | 'space-between' | 'space-around';\n\n  /**\n   * Specifies the position of a ruby element relatives to its base element. It can be position over the element (over), under it (under), or between the characters, on their right side (inter-character).\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/ruby-position\n   */\n  rubyPosition?: CSSGlobalValues | 'over' | 'under' | 'inter-character';\n\n  /**\n   * SVG: For the <ellipse> element, this attribute defines the x-radius of the element. A value of zero disables rendering of the element.\n   * https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/rx\n   */\n  rx?: number;\n\n  /**\n   * SVG: For the <ellipse> element, this attribute defines the y-radius of the element. A value of zero disables rendering of the element.\n   * https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/ry\n   */\n  ry?: number;\n\n  /**\n   * Defines the alpha channel threshold used to extract a shape from an image. Can be thought of as a \"minimum opacity\" threshold; that is, a value of 0.5 means that the shape will enclose all the pixels that are more than 50% opaque.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/shape-image-threshold\n   */\n  shapeImageThreshold?: any;\n\n  /**\n   * A future level of CSS Shapes will define a shape-inside property, which will define a shape to wrap content within the element. See Editor's Draft <http://dev.w3.org/csswg/css-shapes/> and CSSWG wiki page on next-level plans <http://wiki.csswg.org/spec/css-shapes>\n   */\n  shapeInside?: any;\n\n  /**\n   * Adds a margin to a shape-outside. In effect, defines a new shape that is the smallest contour around all the points that are the shape-margin distance outward perpendicular to each point on the underlying shape. For points where a perpendicular direction is not defined (e.g., a triangle corner), takes all points on a circle centered at the point and with a radius of the shape-margin distance. This property accepts only non-negative values.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/shape-margin\n   */\n  shapeMargin?: any;\n\n  /**\n   * Declares a shape around which text should be wrapped, with possible modifications from the shape-margin property. The shape defined by shape-outside and shape-margin changes the geometry of a float element's float area.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/shape-outside\n   */\n  shapeOutside?: any;\n\n  /**\n   * The speak property determines whether or not a speech synthesizer will read aloud the contents of an element.\n   */\n  speak?: any;\n\n  /**\n   * The speak-as property determines how the speech synthesizer interprets the content: words as whole words or as a sequence of letters, numbers as a numerical value or a sequence of digits, punctuation as pauses in speech or named punctuation characters.\n   */\n  speakAs?: any;\n\n  /**\n   * Location of a font-face.  Used with the @font-face at rule\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src\n   */\n  src?: CSSValueString;\n\n  /**\n   * SVG: Defines the color of the outline on a given graphical element.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/stroke\n   */\n  stroke?: string;\n\n  /**\n   * SVG: Controls the pattern of dashes and gaps used to stroke paths.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/stroke-dasharray\n   */\n  strokeDasharray?: number[];\n\n  /**\n   * SVG: Specifies the distance into the dash pattern to start the dash\n   * @see https://developer.mozilla.org/en/docs/Web/SVG/Attribute/stroke-dashoffset\n   */\n  strokeDashoffset?: CSSValue<CSSGlobalValues | CSSLength | CSSPercentage>;\n\n  /**\n   * SVG: Specifies the shape to be used at the end of open subpaths when they are stroked.\n   * @see https://developer.mozilla.org/en/docs/Web/SVG/Attribute/stroke-linecap\n   */\n  strokeLinecap?: CSSGlobalValues | 'butt' | 'round' | 'square';\n\n  /**\n   * SVG: Specifies the opacity of the outline on the current object.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/stroke-opacity\n   */\n  strokeOpacity?: number;\n\n  /**\n   * SVG: Specifies the width of the outline on the current object.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/stroke-width\n   */\n  strokeWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The tab-size CSS property is used to customise the width of a tab (U+0009) character.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/tab-size\n   */\n  tabSize?: any;\n\n  /**\n   * The 'table-layout' property controls the algorithm used to lay out the table cells, rows, and columns.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/table-layout\n   */\n  tableLayout?: any;\n\n  /**\n   * SVG: The text-anchor attribute is used to align (start-, middle- or end-alignment) a string of text relative to a given point.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/text-anchor\n   */\n  textAnchor?: 'start' | 'middle' | 'end' | 'inherit';\n\n  /**\n   * The text-align CSS property describes how inline content like text is aligned in its parent block element. text-align does not control the alignment of block elements itself, only their inline content.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-align\n   */\n  textAlign?: CSSGlobalValues | 'start' | 'end' | 'left' | 'right' | 'center' | 'justify' | 'justify-all' | 'match-parent';\n\n  /**\n   * The text-align-last CSS property describes how the last line of a block element or a line before line break is aligned in its parent block element.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-align-last\n   */\n  textAlignLast?: CSSGlobalValues | 'auto' | 'start' | 'end' | 'left' | 'right' | 'center' | 'justify';\n\n  /**\n   * The text-decoration CSS property is used to set the text formatting to underline, overline, line-through or blink.\n   * underline and overline decorations are positioned under the text, line-through over it.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-decoration\n   */\n  textDecoration?: any;\n\n  /**\n   * Sets the color of any text decoration, such as underlines, overlines, and strike throughs.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-decoration-color\n   */\n  textDecorationColor?: CSSValue<CSSColor>;\n\n  /**\n   * Sets what kind of line decorations are added to an element, such as underlines, overlines, etc.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-decoration-line\n   */\n  textDecorationLine?: any;\n\n  textDecorationLineThrough?: any;\n\n  textDecorationNone?: any;\n\n  textDecorationOverline?: any;\n\n  /**\n   * Specifies what parts of an element’s content are skipped over when applying any text decoration.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-decoration-skip\n   */\n  textDecorationSkip?: any;\n\n  /**\n   * This property specifies the style of the text decoration line drawn on the specified element. The intended meaning for the values are the same as those of the border-style-properties.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-decoration-style\n   */\n  textDecorationStyle?: CSSGlobalValues | 'solid' | 'double' | 'dotted' | 'dashed' | 'wavy';\n\n  textDecorationUnderline?: any;\n\n  /**\n   * The text-emphasis property will apply special emphasis marks to the elements text. Slightly similar to the text-decoration property only that this property can have affect on the line-height. It also is noted that this is shorthand for text-emphasis-style and for text-emphasis-color.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-emphasis\n   */\n  textEmphasis?: any;\n\n  /**\n   * The text-emphasis-color property specifies the foreground color of the emphasis marks.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-emphasis-color\n   */\n  textEmphasisColor?: CSSValue<CSSColor>;\n\n  /**\n   * The text-emphasis-style property applies special emphasis marks to an element's text.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-emphasis-style\n   */\n  textEmphasisStyle?: any;\n\n  /**\n   * This property helps determine an inline box's block-progression dimension, derived from the text-height and font-size properties for non-replaced elements, the height or the width for replaced elements, and the stacked block-progression dimension for inline-block elements. The block-progression dimension determines the position of the padding, border and margin for the element.\n   */\n  textHeight?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * Specifies the amount of space horizontally that should be left on the first line of the text of an element. This horizontal spacing is at the beginning of the first line and is in respect to the left edge of the containing block box.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-indent\n   */\n  textIndent?: any;\n\n  textJustifyTrim?: any;\n\n  textKashidaSpace?: any;\n\n  /**\n   * The text-line-through property is a shorthand property for text-line-through-style, text-line-through-color and text-line-through-mode. (Considered obsolete; use text-decoration instead.)\n   */\n  textLineThrough?: any;\n\n  /**\n   * Specifies the line colors for the line-through text decoration.\n   * (Considered obsolete; use text-decoration-color instead.)\n   */\n  textLineThroughColor?: CSSValue<CSSColor>;\n\n  /**\n   * Sets the mode for the line-through text decoration, determining whether the text decoration affects the space characters or not.\n   * (Considered obsolete; use text-decoration-skip instead.)\n   */\n  textLineThroughMode?: any;\n\n  /**\n   * Specifies the line style for line-through text decoration.\n   * (Considered obsolete; use text-decoration-style instead.)\n   */\n  textLineThroughStyle?: any;\n\n  /**\n   * Specifies the line width for the line-through text decoration.\n   */\n  textLineThroughWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The text-overflow shorthand CSS property determines how overflowed content that is not displayed is signaled to the users. It can be clipped, display an ellipsis ('…', U+2026 HORIZONTAL ELLIPSIS) or a Web author-defined string. It covers the two long-hand properties text-overflow-mode and text-overflow-ellipsis\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-overflow\n   */\n  textOverflow?: CSSGlobalValues | 'clip' | 'ellipsis' | string;\n\n  /**\n   * The text-overline property is the shorthand for the text-overline-style, text-overline-width, text-overline-color, and text-overline-mode properties.\n   */\n  textOverline?: any;\n\n  /**\n   * Specifies the line color for the overline text decoration.\n   */\n  textOverlineColor?: CSSValue<CSSColor>;\n\n  /**\n   * Sets the mode for the overline text decoration, determining whether the text decoration affects the space characters or not.\n   */\n  textOverlineMode?: any;\n\n  /**\n   * Specifies the line style for overline text decoration.\n   */\n  textOverlineStyle?: any;\n\n  /**\n   * Specifies the line width for the overline text decoration.\n   */\n  textOverlineWidth?: CSSValue<CSSLength | CSSPercentage>;\n\n  /**\n   * The text-rendering CSS property provides information to the browser about how to optimize when rendering text. Options are: legibility, speed or geometric precision.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-rendering\n   */\n  textRendering?: CSSGlobalValues | 'auto' | 'optimizeSpeed' | 'optimizeLegibility' | 'geometricPrecision';\n\n  /**\n   * Obsolete: unsupported.\n   */\n  textScript?: any;\n\n  /**\n   * The CSS text-shadow property applies one or more drop shadows to the text and <text-decorations> of an element. Each shadow is specified as an offset from the text, along with optional color and blur radius values.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-shadow\n   */\n  textShadow?: any;\n\n  /**\n   * This property transforms text for styling purposes. (It has no effect on the underlying content.)\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/text-transform\n   */\n  textTransform?: CSSGlobalValues | 'none' | 'capitalize' | 'uppercase' | 'lowercase' | 'full-width';\n\n  /**\n   * Unsupported.\n   * This property will add a underline position value to the element that has an underline defined.\n   */\n  textUnderlinePosition?: any;\n\n  /**\n   * After review this should be replaced by text-decoration should it not?\n   * This property will set the underline style for text with a line value for underline, overline, and line-through.\n   */\n  textUnderlineStyle?: any;\n\n  /**\n   * This property specifies how far an absolutely positioned box's top margin edge is offset below the top edge of the box's containing block. For relatively positioned boxes, the offset is with respect to the top edges of the box itself (i.e., the box is given a position in the normal flow, then offset from that position according to these properties).\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/top\n   */\n  top?: CSSValue<'auto' | CSSLength | CSSPercentage | CSSGlobalValues>;\n\n  /**\n   * Determines whether touch input may trigger default behavior supplied by the user agent, such as panning or zooming.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/touch-action\n   */\n  touchAction?: CSSGlobalValues | 'auto' | 'none' | 'pan-x' | 'pan-left' | 'pan-right' | 'pan-y' | 'pan-up' | 'pan-down' | 'manipulation';\n\n  /**\n   * CSS transforms allow elements styled with CSS to be transformed in two-dimensional or three-dimensional space. Using this property, elements can be translated, rotated, scaled, and skewed. The value list may consist of 2D and/or 3D transform values.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/transform\n   */\n  transform?: CSSTransformFunction;\n\n  /**\n   * This property defines the origin of the transformation axes relative to the element to which the transformation is applied.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/transform-origin\n   */\n  transformOrigin?: any;\n\n  /**\n   * This property allows you to define the relative position of the origin of the transformation grid along the z-axis.\n   */\n  transformOriginZ?: any;\n\n  /**\n   * This property specifies how nested elements are rendered in 3D space relative to their parent.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/transform-style\n   */\n  transformStyle?: CSSGlobalValues | 'flat' | 'preserve-3d';\n\n  /**\n   * The transition CSS property is a shorthand property for transition-property, transition-duration, transition-timing-function, and transition-delay. It allows to define the transition between two states of an element.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/transition\n   */\n  transition?: any;\n\n  /**\n   * Defines when the transition will start. A value of ‘0s’ means the transition will execute as soon as the property is changed. Otherwise, the value specifies an offset from the moment the property is changed, and the transition will delay execution by that offset.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/transition-delay\n   */\n  transitionDelay?: any;\n\n  /**\n   * The 'transition-duration' property specifies the length of time a transition animation takes to complete.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/transition-duration\n   */\n  transitionDuration?: any;\n\n  /**\n   * The 'transition-property' property specifies the name of the CSS property to which the transition is applied.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/transition-property\n   */\n  transitionProperty?: CSSValueString;\n\n  /**\n   * Sets the pace of action within a transition\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/transition-timing-function\n   */\n  transitionTimingFunction?: CSSTimingFunction;\n\n  /**\n   * The unicode-bidi CSS property specifies the level of embedding with respect to the bidirectional algorithm.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/unicode-bidi\n   */\n  unicodeBidi?: any;\n\n  /**\n   * unicode-range allows you to set a specific range of characters to be downloaded from a font (embedded using @font-face) and made available for use on the current page.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/unicode-range\n   */\n  unicodeRange?: any;\n\n  /**\n   * This is for all the high level UX stuff.\n   */\n  userFocus?: any;\n\n  /**\n   * For inputing user content\n   */\n  userInput?: any;\n\n  /**\n   * User select\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/user-select\n   */\n  userSelect?: 'auto' | 'text' | 'none' | 'contain' | 'all';\n  '-moz-user-select'?: 'auto' | 'text' | 'none' | 'contain' | 'all';\n  '-webkit-user-select'?: 'auto' | 'text' | 'none' | 'contain' | 'all';\n  '-ms-user-select'?: 'auto' | 'text' | 'none' | 'contain' | 'all';\n\n  /**\n   * The vertical-align property controls how inline elements or text are vertically aligned compared to the baseline. If this property is used on table-cells it controls the vertical alignment of content of the table cell.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/vertical-align\n   */\n  verticalAlign?: CSSGlobalValues | 'baseline' | 'sub' | 'super' | 'text-top' | 'text-bottom' | 'middle' | 'top' | 'bottom' | CSSLength | CSSPercentage;\n\n  /**\n   * The visibility property specifies whether the boxes generated by an element are rendered.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/visibility\n   */\n  visibility?: CSSGlobalValues | 'visible' | 'hidden' | 'collapse';\n\n  /**\n   * The voice-balance property sets the apparent position (in stereo sound) of the synthesized voice for spoken media.\n   */\n  voiceBalance?: any;\n\n  /**\n   * The voice-duration property allows the author to explicitly set the amount of time it should take a speech synthesizer to read an element's content, for example to allow the speech to be synchronized with other media. With a value of auto (the default) the length of time it takes to read the content is determined by the content itself and the voice-rate property.\n   */\n  voiceDuration?: any;\n\n  /**\n   * The voice-family property sets the speaker's voice used by a speech media agent to read an element. The speaker may be specified as a named character (to match a voice option in the speech reading software) or as a generic description of the age and gender of the voice. Similar to the font-family property for visual media, a comma-separated list of fallback options may be given in case the speech reader does not recognize the character name or cannot synthesize the requested combination of generic properties.\n   */\n  voiceFamily?: any;\n\n  /**\n   * The voice-pitch property sets pitch or tone (high or low) for the synthesized speech when reading an element; the pitch may be specified absolutely or relative to the normal pitch for the voice-family used to read the text.\n   */\n  voicePitch?: any;\n\n  /**\n   * The voice-range property determines how much variation in pitch or tone will be created by the speech synthesize when reading an element. Emphasized text, grammatical structures and punctuation may all be rendered as changes in pitch, this property determines how strong or obvious those changes are; large ranges are associated with enthusiastic or emotional speech, while small ranges are associated with flat or mechanical speech.\n   */\n  voiceRange?: any;\n\n  /**\n   * The voice-rate property sets the speed at which the voice synthesized by a speech media agent will read content.\n   */\n  voiceRate?: any;\n\n  /**\n   * The voice-stress property sets the level of vocal emphasis to be used for synthesized speech reading the element.\n   */\n  voiceStress?: any;\n\n  /**\n   * The voice-volume property sets the volume for spoken content in speech media. It replaces the deprecated volume property.\n   */\n  voiceVolume?: any;\n\n  /**\n   * The white-space property controls whether and how white space inside the element is collapsed, and whether lines may wrap at unforced \"soft wrap\" opportunities.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/white-space\n   */\n  whiteSpace?: CSSGlobalValues | 'normal' | 'nowrap' | 'pre' | 'pre-line' | 'pre-wrap';\n\n  /**\n   * Obsolete: unsupported.\n   */\n  whiteSpaceTreatment?: any;\n\n  /**\n   * In paged media, this property defines the mimimum number of lines\n   * that must be left at the top of the second page.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/widows\n   */\n  widows?: number;\n\n  /**\n   * Specifies the width of the content area of an element. The content area of the element width does not include the padding, border, and margin of the element.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/width\n   */\n  width?: CSSValue<'auto' | CSSLength | CSSPercentage | CSSGlobalValues>;\n\n  /**\n   * The ‘will-change’ CSS property provides a way for authors to hint browsers about the kind of changes to be expected on an element, so that the browser can set up appropriate optimizations ahead of time before the element is actually changed. These kind of optimizations can increase the responsiveness of a page by doing potentially expensive work ahead of time before they are actually required.\n   * @see https://developer.mozilla.org/en-US/docs/Web/CSS/will-change\n   */\n  willChange?: CSSValue<'auto' | 'scroll-position' | 'contents' | CSSValueString>;\n\n  /**\n   * The word-break property is often used when there is long generated content that is strung together without and spaces or hyphens to beak apart. A common case of this is when there is a long URL that does not have any hyphens. This case could potentially cause the breaking of the layout as it could extend past the parent element.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/word-break\n   */\n  wordBreak?: CSSGlobalValues | 'normal' | 'break-all' | 'keep-all';\n\n  /**\n   * The word-spacing CSS property specifies the spacing behavior between \"words\".\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/word-spacing\n   */\n  wordSpacing?: CSSGlobalValues | 'normal' | CSSLength | CSSPercentage;\n\n  /**\n   * An alias of css/properties-panel/overflow-wrap, word-wrap defines whether to break words when the content exceeds the boundaries of its container.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/word-wrap\n   */\n  wordWrap?: CSSGlobalValues | 'normal' | 'break-word';\n\n  /**\n   * Specifies how exclusions affect inline content within block-level elements. Elements lay out their inline content in their content area but wrap around exclusion areas.\n   */\n  wrapFlow?: any;\n\n  /**\n   * Set the value that is used to offset the inner wrap shape from other shapes. Inline content that intersects a shape with this property will be pushed by this shape's margin.\n   */\n  wrapMargin?: any;\n\n  /**\n   * Obsolete and unsupported. Do not use.\n   * This CSS property controls the text when it reaches the end of the block in which it is enclosed.\n   */\n  wrapOption?: any;\n\n  /**\n   * writing-mode specifies if lines of text are laid out horizontally or vertically, and the direction which lines of text and blocks progress.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/writing-mode\n   */\n  writingMode?: CSSGlobalValues | 'horizontal-tb' | 'vertical-rl' | 'vertical-lr' | 'sideways-rl' | 'sideways-lr';\n\n  /**\n   * The z-index property specifies the z-order of an element and its descendants.\n   * When elements overlap, z-order determines which one covers the other.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/z-index\n   */\n  zIndex?: CSSGlobalValues | 'auto' | number;\n\n  /**\n   * Sets the initial zoom factor of a document defined by @viewport.\n   * @see https://developer.mozilla.org/en/docs/Web/CSS/zoom\n   */\n  zoom?: 'auto' | number;\n\n  // VENDOR prefixes\n  // non-authoritative source: http://peter.sh/experiments/vendor-prefixed-css-property-overview/\n  '-apple-trailing-word'?: CSSValueGeneral;\n  '-epub-caption-side'?: CSSValueGeneral;\n  '-epub-hyphens'?: CSSValueGeneral;\n  '-epub-text-combine'?: CSSValueGeneral;\n  '-epub-text-emphasis'?: CSSValueGeneral;\n  '-epub-text-emphasis-color'?: CSSValueGeneral;\n  '-epub-text-emphasis-style'?: CSSValueGeneral;\n  '-epub-text-orientation'?: CSSValueGeneral;\n  '-epub-text-transform'?: CSSValueGeneral;\n  '-epub-word-break'?: CSSValueGeneral;\n  '-epub-writing-mode'?: CSSValueGeneral;\n  '-internal-marquee-direction'?: CSSValueGeneral;\n  '-internal-marquee-increment'?: CSSValueGeneral;\n  '-internal-marquee-repetition'?: CSSValueGeneral;\n  '-internal-marquee-speed'?: CSSValueGeneral;\n  '-internal-marquee-style'?: CSSValueGeneral;\n  '-moz-appearance'?: CSSValueGeneral;\n  '-moz-binding'?: CSSValueGeneral;\n  '-moz-border-bottom-colors'?: CSSValueGeneral;\n  '-moz-border-end'?: CSSValueGeneral;\n  '-moz-border-end-color'?: CSSValueGeneral;\n  '-moz-border-end-style'?: CSSValueGeneral;\n  '-moz-border-end-width'?: CSSValueGeneral;\n  '-moz-border-left-colors'?: CSSValueGeneral;\n  '-moz-border-right-colors'?: CSSValueGeneral;\n  '-moz-border-start'?: CSSValueGeneral;\n  '-moz-border-start-color'?: CSSValueGeneral;\n  '-moz-border-start-style'?: CSSValueGeneral;\n  '-moz-border-start-width'?: CSSValueGeneral;\n  '-moz-border-top-colors'?: CSSValueGeneral;\n  '-moz-box-align'?: CSSValueGeneral;\n  '-moz-box-direction'?: CSSValueGeneral;\n  '-moz-box-flex'?: CSSValueGeneral;\n  '-moz-box-ordinal-group'?: CSSValueGeneral;\n  '-moz-box-orient'?: CSSValueGeneral;\n  '-moz-box-pack'?: CSSValueGeneral;\n  '-moz-column-count'?: CSSValueGeneral;\n  '-moz-column-fill'?: CSSValueGeneral;\n  '-moz-column-gap'?: CSSValueGeneral;\n  '-moz-column-rule'?: CSSValueGeneral;\n  '-moz-column-rule-color'?: CSSValueGeneral;\n  '-moz-column-rule-style'?: CSSValueGeneral;\n  '-moz-column-rule-width'?: CSSValueGeneral;\n  '-moz-column-width'?: CSSValueGeneral;\n  '-moz-columns'?: CSSValueGeneral;\n  '-moz-control-character-visibility'?: CSSValueGeneral;\n  '-moz-float-edge'?: CSSValueGeneral;\n  '-moz-force-broken-image-icon'?: CSSValueGeneral;\n  '-moz-hyphens'?: CSSValueGeneral;\n  '-moz-image-region'?: CSSValueGeneral;\n  '-moz-margin-end'?: CSSValueGeneral;\n  '-moz-margin-start'?: CSSValueGeneral;\n  '-moz-math-display'?: CSSValueGeneral;\n  '-moz-math-variant'?: CSSValueGeneral;\n  '-moz-min-font-size-ratio'?: CSSValueGeneral;\n  '-moz-orient'?: CSSValueGeneral;\n  '-moz-osx-font-smoothing'?: CSSValueGeneral;\n  '-moz-outline-radius'?: CSSValueGeneral;\n  '-moz-outline-radius-bottomleft'?: CSSValueGeneral;\n  '-moz-outline-radius-bottomright'?: CSSValueGeneral;\n  '-moz-outline-radius-topleft'?: CSSValueGeneral;\n  '-moz-outline-radius-topright'?: CSSValueGeneral;\n  '-moz-padding-end'?: CSSValueGeneral;\n  '-moz-padding-start'?: CSSValueGeneral;\n  '-moz-script-level'?: CSSValueGeneral;\n  '-moz-script-min-size'?: CSSValueGeneral;\n  '-moz-script-size-multiplier'?: CSSValueGeneral;\n  '-moz-stack-sizing'?: CSSValueGeneral;\n  '-moz-tab-size'?: CSSValueGeneral;\n  '-moz-text-align-last'?: CSSValueGeneral;\n  '-moz-text-decoration-color'?: CSSValueGeneral;\n  '-moz-text-decoration-line'?: CSSValueGeneral;\n  '-moz-text-decoration-style'?: CSSValueGeneral;\n  '-moz-text-size-adjust'?: CSSValueGeneral;\n  '-moz-top-layer'?: CSSValueGeneral;\n  '-moz-transform'?: CSSValueGeneral;\n  '-moz-user-focus'?: CSSValueGeneral;\n  '-moz-user-input'?: CSSValueGeneral;\n  '-moz-user-modify'?: CSSValueGeneral;\n  '-moz-window-dragging'?: CSSValueGeneral;\n  '-moz-window-shadow'?: CSSValueGeneral;\n  '-ms-accelerator'?: CSSValueGeneral;\n  '-ms-animation'?: CSSValueGeneral;\n  '-ms-animation-delay'?: CSSValueGeneral;\n  '-ms-animation-direction'?: CSSValueGeneral;\n  '-ms-animation-duration'?: CSSValueGeneral;\n  '-ms-animation-fill-mode'?: CSSValueGeneral;\n  '-ms-animation-iteration-count'?: CSSValueGeneral;\n  '-ms-animation-name'?: CSSValueGeneral;\n  '-ms-animation-play-state'?: CSSValueGeneral;\n  '-ms-animation-timing-function'?: CSSValueGeneral;\n  '-ms-backface-visibility'?: CSSValueGeneral;\n  '-ms-background-position-x'?: CSSValueGeneral;\n  '-ms-background-position-y'?: CSSValueGeneral;\n  '-ms-behavior'?: CSSValueGeneral;\n  '-ms-block-progression'?: CSSValueGeneral;\n  '-ms-content-zoom-chaining'?: CSSValueGeneral;\n  '-ms-content-zoom-limit'?: CSSValueGeneral;\n  '-ms-content-zoom-limit-max'?: CSSValueGeneral;\n  '-ms-content-zoom-limit-min'?: CSSValueGeneral;\n  '-ms-content-zoom-snap'?: CSSValueGeneral;\n  '-ms-content-zoom-snap-points'?: CSSValueGeneral;\n  '-ms-content-zoom-snap-type'?: CSSValueGeneral;\n  '-ms-content-zooming'?: CSSValueGeneral;\n  '-ms-filter'?: CSSValueGeneral;\n  '-ms-flex-flow'?: CSSValueGeneral;\n  '-ms-flex-line-pack'?: CSSValueGeneral;\n  '-ms-flex-order'?: CSSValueGeneral;\n  '-ms-flex-preferred-size'?: CSSValueGeneral;\n  '-ms-flow-from'?: CSSValueGeneral;\n  '-ms-flow-into'?: CSSValueGeneral;\n  '-ms-font-feature-settings'?: CSSValueGeneral;\n  '-ms-grid-column'?: CSSValueGeneral;\n  '-ms-grid-column-align'?: CSSValueGeneral;\n  '-ms-grid-column-span'?: CSSValueGeneral;\n  '-ms-grid-columns'?: CSSValueGeneral;\n  '-ms-grid-row'?: CSSValueGeneral;\n  '-ms-grid-row-align'?: CSSValueGeneral;\n  '-ms-grid-row-span'?: CSSValueGeneral;\n  '-ms-grid-rows'?: CSSValueGeneral;\n  '-ms-high-contrast-adjust'?: CSSValueGeneral;\n  '-ms-hyphenate-limit-chars'?: CSSValueGeneral;\n  '-ms-hyphenate-limit-lines'?: CSSValueGeneral;\n  '-ms-hyphenate-limit-zone'?: CSSValueGeneral;\n  '-ms-hyphens'?: CSSValueGeneral;\n  '-ms-ime-align'?: CSSValueGeneral;\n  '-ms-ime-mode'?: CSSValueGeneral;\n  '-ms-interpolation-mode'?: CSSValueGeneral;\n  '-ms-layout-flow'?: CSSValueGeneral;\n  '-ms-layout-grid'?: CSSValueGeneral;\n  '-ms-layout-grid-char'?: CSSValueGeneral;\n  '-ms-layout-grid-line'?: CSSValueGeneral;\n  '-ms-layout-grid-mode'?: CSSValueGeneral;\n  '-ms-layout-grid-type'?: CSSValueGeneral;\n  '-ms-line-break'?: CSSValueGeneral;\n  '-ms-overflow-style'?: CSSValueGeneral;\n  '-ms-overflow-x'?: CSSValueGeneral;\n  '-ms-overflow-y'?: CSSValueGeneral;\n  '-ms-perspective'?: CSSValueGeneral;\n  '-ms-perspective-origin'?: CSSValueGeneral;\n  '-ms-perspective-origin-x'?: CSSValueGeneral;\n  '-ms-perspective-origin-y'?: CSSValueGeneral;\n  '-ms-scroll-chaining'?: CSSValueGeneral;\n  '-ms-scroll-limit'?: CSSValueGeneral;\n  '-ms-scroll-limit-x-max'?: CSSValueGeneral;\n  '-ms-scroll-limit-x-min'?: CSSValueGeneral;\n  '-ms-scroll-limit-y-max'?: CSSValueGeneral;\n  '-ms-scroll-limit-y-min'?: CSSValueGeneral;\n  '-ms-scroll-rails'?: CSSValueGeneral;\n  '-ms-scroll-snap-points-x'?: CSSValueGeneral;\n  '-ms-scroll-snap-points-y'?: CSSValueGeneral;\n  '-ms-scroll-snap-type'?: CSSValueGeneral;\n  '-ms-scroll-snap-x'?: CSSValueGeneral;\n  '-ms-scroll-snap-y'?: CSSValueGeneral;\n  '-ms-scroll-translation'?: CSSValueGeneral;\n  '-ms-scrollbar-3dlight-color'?: CSSValueGeneral;\n  '-ms-scrollbar-arrow-color'?: CSSValueGeneral;\n  '-ms-scrollbar-base-color'?: CSSValueGeneral;\n  '-ms-scrollbar-darkshadow-color'?: CSSValueGeneral;\n  '-ms-scrollbar-face-color'?: CSSValueGeneral;\n  '-ms-scrollbar-highlight-color'?: CSSValueGeneral;\n  '-ms-scrollbar-shadow-color'?: CSSValueGeneral;\n  '-ms-scrollbar-track-color'?: CSSValueGeneral;\n  '-ms-text-align-last'?: CSSValueGeneral;\n  '-ms-text-autospace'?: CSSValueGeneral;\n  '-ms-text-combine-horizontal'?: CSSValueGeneral;\n  '-ms-text-justify'?: CSSValueGeneral;\n  '-ms-text-kashida-space'?: CSSValueGeneral;\n  '-ms-text-overflow'?: CSSValueGeneral;\n  '-ms-text-size-adjust'?: CSSValueGeneral;\n  '-ms-text-underline-position'?: CSSValueGeneral;\n  '-ms-touch-action'?: CSSValueGeneral;\n  '-ms-touch-select'?: CSSValueGeneral;\n  '-ms-transform'?: CSSValueGeneral;\n  '-ms-transform-origin'?: CSSValueGeneral;\n  '-ms-transform-origin-x'?: CSSValueGeneral;\n  '-ms-transform-origin-y'?: CSSValueGeneral;\n  '-ms-transform-origin-z'?: CSSValueGeneral;\n  '-ms-transform-style'?: CSSValueGeneral;\n  '-ms-transition'?: CSSValueGeneral;\n  '-ms-transition-delay'?: CSSValueGeneral;\n  '-ms-transition-duration'?: CSSValueGeneral;\n  '-ms-transition-property'?: CSSValueGeneral;\n  '-ms-transition-timing-function'?: CSSValueGeneral;\n  '-ms-word-break'?: CSSValueGeneral;\n  '-ms-word-wrap'?: CSSValueGeneral;\n  '-ms-wrap-flow'?: CSSValueGeneral;\n  '-ms-wrap-margin'?: CSSValueGeneral;\n  '-ms-wrap-through'?: CSSValueGeneral;\n  '-ms-writing-mode'?: CSSValueGeneral;\n  '-ms-zoom'?: CSSValueGeneral;\n  '-webkit-align-content'?: CSSValueGeneral;\n  '-webkit-alt'?: CSSValueGeneral;\n  '-webkit-animation'?: CSSValueGeneral;\n  '-webkit-animation-delay'?: CSSValueGeneral;\n  '-webkit-animation-direction'?: CSSValueGeneral;\n  '-webkit-animation-duration'?: CSSValueGeneral;\n  '-webkit-animation-fill-mode'?: CSSValueGeneral;\n  '-webkit-animation-iteration-count'?: CSSValueGeneral;\n  '-webkit-animation-name'?: CSSValueGeneral;\n  '-webkit-animation-play-state'?: CSSValueGeneral;\n  '-webkit-animation-timing-function'?: CSSValueGeneral;\n  '-webkit-animation-trigger'?: CSSValueGeneral;\n  '-webkit-app-region'?: CSSValueGeneral;\n  '-webkit-appearance'?: CSSValueGeneral;\n  '-webkit-aspect-ratio'?: CSSValueGeneral;\n  '-webkit-backdrop-filter'?: CSSValueGeneral;\n  '-webkit-backface-visibility'?: CSSValueGeneral;\n  '-webkit-background-clip'?: CSSValueGeneral;\n  '-webkit-background-composite'?: CSSValueGeneral;\n  '-webkit-background-origin'?: CSSValueGeneral;\n  '-webkit-background-size'?: CSSValueGeneral;\n  '-webkit-border-after'?: CSSValueGeneral;\n  '-webkit-border-after-color'?: CSSValueGeneral;\n  '-webkit-border-after-style'?: CSSValueGeneral;\n  '-webkit-border-after-width'?: CSSValueGeneral;\n  '-webkit-border-before'?: CSSValueGeneral;\n  '-webkit-border-before-color'?: CSSValueGeneral;\n  '-webkit-border-before-style'?: CSSValueGeneral;\n  '-webkit-border-before-width'?: CSSValueGeneral;\n  '-webkit-border-bottom-left-radius'?: CSSValueGeneral;\n  '-webkit-border-bottom-right-radius'?: CSSValueGeneral;\n  '-webkit-border-end'?: CSSValueGeneral;\n  '-webkit-border-end-color'?: CSSValueGeneral;\n  '-webkit-border-end-style'?: CSSValueGeneral;\n  '-webkit-border-end-width'?: CSSValueGeneral;\n  '-webkit-border-fit'?: CSSValueGeneral;\n  '-webkit-border-horizontal-spacing'?: CSSValueGeneral;\n  '-webkit-border-image'?: CSSValueGeneral;\n  '-webkit-border-radius'?: CSSValueGeneral;\n  '-webkit-border-start'?: CSSValueGeneral;\n  '-webkit-border-start-color'?: CSSValueGeneral;\n  '-webkit-border-start-style'?: CSSValueGeneral;\n  '-webkit-border-start-width'?: CSSValueGeneral;\n  '-webkit-border-top-left-radius'?: CSSValueGeneral;\n  '-webkit-border-top-right-radius'?: CSSValueGeneral;\n  '-webkit-border-vertical-spacing'?: CSSValueGeneral;\n  '-webkit-box-align'?: CSSValueGeneral;\n  '-webkit-box-decoration-break'?: CSSValueGeneral;\n  '-webkit-box-direction'?: CSSValueGeneral;\n  '-webkit-box-flex'?: CSSValueGeneral;\n  '-webkit-box-flex-group'?: CSSValueGeneral;\n  '-webkit-box-lines'?: CSSValueGeneral;\n  '-webkit-box-ordinal-group'?: CSSValueGeneral;\n  '-webkit-box-orient'?: CSSValueGeneral;\n  '-webkit-box-pack'?: CSSValueGeneral;\n  '-webkit-box-reflect'?: CSSValueGeneral;\n  '-webkit-box-shadow'?: CSSValueGeneral;\n  '-webkit-clip-path'?: CSSValueGeneral;\n  '-webkit-color-correction'?: CSSValueGeneral;\n  '-webkit-column-axis'?: CSSValueGeneral;\n  '-webkit-column-break-after'?: CSSValueGeneral;\n  '-webkit-column-break-before'?: CSSValueGeneral;\n  '-webkit-column-break-inside'?: CSSValueGeneral;\n  '-webkit-column-count'?: CSSValueGeneral;\n  '-webkit-column-fill'?: CSSValueGeneral;\n  '-webkit-column-gap'?: CSSValueGeneral;\n  '-webkit-column-progression'?: CSSValueGeneral;\n  '-webkit-column-rule'?: CSSValueGeneral;\n  '-webkit-column-rule-color'?: CSSValueGeneral;\n  '-webkit-column-rule-style'?: CSSValueGeneral;\n  '-webkit-column-rule-width'?: CSSValueGeneral;\n  '-webkit-column-span'?: CSSValueGeneral;\n  '-webkit-column-width'?: CSSValueGeneral;\n  '-webkit-columns'?: CSSValueGeneral;\n  '-webkit-cursor-visibility'?: CSSValueGeneral;\n  '-webkit-dashboard-region'?: CSSValueGeneral;\n  '-webkit-filter'?: CSSValueGeneral;\n  '-webkit-flex-basis'?: CSSValueGeneral;\n  '-webkit-flex-flow'?: CSSValueGeneral;\n  '-webkit-flow-from'?: CSSValueGeneral;\n  '-webkit-flow-into'?: CSSValueGeneral;\n  '-webkit-font-feature-settings'?: CSSValueGeneral;\n  '-webkit-font-kerning'?: CSSValueGeneral;\n  '-webkit-font-size-delta'?: CSSValueGeneral;\n  '-webkit-font-smoothing'?: CSSValueGeneral;\n  '-webkit-font-variant-ligatures'?: CSSValueGeneral;\n  '-webkit-grid'?: CSSValueGeneral;\n  '-webkit-grid-area'?: CSSValueGeneral;\n  '-webkit-grid-auto-columns'?: CSSValueGeneral;\n  '-webkit-grid-auto-flow'?: CSSValueGeneral;\n  '-webkit-grid-auto-rows'?: CSSValueGeneral;\n  '-webkit-grid-column'?: CSSValueGeneral;\n  '-webkit-grid-column-end'?: CSSValueGeneral;\n  '-webkit-grid-column-gap'?: CSSValueGeneral;\n  '-webkit-grid-column-start'?: CSSValueGeneral;\n  '-webkit-grid-gap'?: CSSValueGeneral;\n  '-webkit-grid-row'?: CSSValueGeneral;\n  '-webkit-grid-row-end'?: CSSValueGeneral;\n  '-webkit-grid-row-gap'?: CSSValueGeneral;\n  '-webkit-grid-row-start'?: CSSValueGeneral;\n  '-webkit-grid-template'?: CSSValueGeneral;\n  '-webkit-grid-template-areas'?: CSSValueGeneral;\n  '-webkit-grid-template-columns'?: CSSValueGeneral;\n  '-webkit-grid-template-rows'?: CSSValueGeneral;\n  '-webkit-highlight'?: CSSValueGeneral;\n  '-webkit-hyphenate-character'?: CSSValueGeneral;\n  '-webkit-hyphenate-limit-after'?: CSSValueGeneral;\n  '-webkit-hyphenate-limit-before'?: CSSValueGeneral;\n  '-webkit-hyphenate-limit-lines'?: CSSValueGeneral;\n  '-webkit-hyphens'?: CSSValueGeneral;\n  '-webkit-initial-letter'?: CSSValueGeneral;\n  '-webkit-justify-items'?: CSSValueGeneral;\n  '-webkit-justify-self'?: CSSValueGeneral;\n  '-webkit-line-align'?: CSSValueGeneral;\n  '-webkit-line-box-contain'?: CSSValueGeneral;\n  '-webkit-line-break'?: CSSValueGeneral;\n  '-webkit-line-clamp'?: CSSValueGeneral;\n  '-webkit-line-grid'?: CSSValueGeneral;\n  '-webkit-line-snap'?: CSSValueGeneral;\n  '-webkit-locale'?: CSSValueGeneral;\n  '-webkit-logical-height'?: CSSValueGeneral;\n  '-webkit-logical-width'?: CSSValueGeneral;\n  '-webkit-margin-after'?: CSSValueGeneral;\n  '-webkit-margin-after-collapse'?: CSSValueGeneral;\n  '-webkit-margin-before'?: CSSValueGeneral;\n  '-webkit-margin-before-collapse'?: CSSValueGeneral;\n  '-webkit-margin-bottom-collapse'?: CSSValueGeneral;\n  '-webkit-margin-collapse'?: CSSValueGeneral;\n  '-webkit-margin-end'?: CSSValueGeneral;\n  '-webkit-margin-start'?: CSSValueGeneral;\n  '-webkit-margin-top-collapse'?: CSSValueGeneral;\n  '-webkit-marquee'?: CSSValueGeneral;\n  '-webkit-marquee-direction'?: CSSValueGeneral;\n  '-webkit-marquee-increment'?: CSSValueGeneral;\n  '-webkit-marquee-repetition'?: CSSValueGeneral;\n  '-webkit-marquee-speed'?: CSSValueGeneral;\n  '-webkit-marquee-style'?: CSSValueGeneral;\n  '-webkit-mask'?: CSSValueGeneral;\n  '-webkit-mask-box-image'?: CSSValueGeneral;\n  '-webkit-mask-box-image-outset'?: CSSValueGeneral;\n  '-webkit-mask-box-image-repeat'?: CSSValueGeneral;\n  '-webkit-mask-box-image-slice'?: CSSValueGeneral;\n  '-webkit-mask-box-image-source'?: CSSValueGeneral;\n  '-webkit-mask-box-image-width'?: CSSValueGeneral;\n  '-webkit-mask-clip'?: CSSValueGeneral;\n  '-webkit-mask-composite'?: CSSValueGeneral;\n  '-webkit-mask-image'?: CSSValueGeneral;\n  '-webkit-mask-origin'?: CSSValueGeneral;\n  '-webkit-mask-position'?: CSSValueGeneral;\n  '-webkit-mask-position-x'?: CSSValueGeneral;\n  '-webkit-mask-position-y'?: CSSValueGeneral;\n  '-webkit-mask-repeat'?: CSSValueGeneral;\n  '-webkit-mask-repeat-x'?: CSSValueGeneral;\n  '-webkit-mask-repeat-y'?: CSSValueGeneral;\n  '-webkit-mask-size'?: CSSValueGeneral;\n  '-webkit-mask-source-type'?: CSSValueGeneral;\n  '-webkit-max-logical-height'?: CSSValueGeneral;\n  '-webkit-max-logical-width'?: CSSValueGeneral;\n  '-webkit-min-logical-height'?: CSSValueGeneral;\n  '-webkit-min-logical-width'?: CSSValueGeneral;\n  '-webkit-nbsp-mode'?: CSSValueGeneral;\n  '-webkit-opacity'?: CSSValueGeneral;\n  '-webkit-order'?: CSSValueGeneral;\n  '-webkit-padding-after'?: CSSValueGeneral;\n  '-webkit-padding-before'?: CSSValueGeneral;\n  '-webkit-padding-end'?: CSSValueGeneral;\n  '-webkit-padding-start'?: CSSValueGeneral;\n  '-webkit-perspective'?: CSSValueGeneral;\n  '-webkit-perspective-origin'?: CSSValueGeneral;\n  '-webkit-perspective-origin-x'?: CSSValueGeneral;\n  '-webkit-perspective-origin-y'?: CSSValueGeneral;\n  '-webkit-print-color-adjust'?: CSSValueGeneral;\n  '-webkit-region-break-after'?: CSSValueGeneral;\n  '-webkit-region-break-before'?: CSSValueGeneral;\n  '-webkit-region-break-inside'?: CSSValueGeneral;\n  '-webkit-region-fragment'?: CSSValueGeneral;\n  '-webkit-rtl-ordering'?: CSSValueGeneral;\n  '-webkit-ruby-position'?: CSSValueGeneral;\n  '-webkit-scroll-snap-coordinate'?: CSSValueGeneral;\n  '-webkit-scroll-snap-destination'?: CSSValueGeneral;\n  '-webkit-scroll-snap-points-x'?: CSSValueGeneral;\n  '-webkit-scroll-snap-points-y'?: CSSValueGeneral;\n  '-webkit-scroll-snap-type'?: CSSValueGeneral;\n  '-webkit-shape-image-threshold'?: CSSValueGeneral;\n  '-webkit-shape-margin'?: CSSValueGeneral;\n  '-webkit-shape-outside'?: CSSValueGeneral;\n  '-webkit-svg-shadow'?: CSSValueGeneral;\n  '-webkit-tap-highlight-color'?: CSSValueGeneral;\n  '-webkit-text-align-last'?: CSSValueGeneral;\n  '-webkit-text-combine'?: CSSValueGeneral;\n  '-webkit-text-decoration'?: CSSValueGeneral;\n  '-webkit-text-decoration-color'?: CSSValueGeneral;\n  '-webkit-text-decoration-line'?: CSSValueGeneral;\n  '-webkit-text-decoration-skip'?: CSSValueGeneral;\n  '-webkit-text-decoration-style'?: CSSValueGeneral;\n  '-webkit-text-decorations-in-effect'?: CSSValueGeneral;\n  '-webkit-text-emphasis'?: CSSValueGeneral;\n  '-webkit-text-emphasis-color'?: CSSValueGeneral;\n  '-webkit-text-emphasis-position'?: CSSValueGeneral;\n  '-webkit-text-emphasis-style'?: CSSValueGeneral;\n  '-webkit-text-fill-color'?: CSSValueGeneral;\n  '-webkit-text-justify'?: CSSValueGeneral;\n  '-webkit-text-orientation'?: CSSValueGeneral;\n  '-webkit-text-security'?: CSSValueGeneral;\n  '-webkit-text-size-adjust'?: CSSValueGeneral;\n  '-webkit-text-stroke'?: CSSValueGeneral;\n  '-webkit-text-stroke-color'?: CSSValueGeneral;\n  '-webkit-text-stroke-width'?: CSSValueGeneral;\n  '-webkit-text-underline-position'?: CSSValueGeneral;\n  '-webkit-text-zoom'?: CSSValueGeneral;\n  '-webkit-touch-callout'?: CSSValueGeneral;\n  '-webkit-transform'?: CSSValueGeneral;\n  '-webkit-transform-origin'?: CSSValueGeneral;\n  '-webkit-transform-origin-x'?: CSSValueGeneral;\n  '-webkit-transform-origin-y'?: CSSValueGeneral;\n  '-webkit-transform-origin-z'?: CSSValueGeneral;\n  '-webkit-transform-style'?: CSSValueGeneral;\n  '-webkit-transition'?: CSSValueGeneral;\n  '-webkit-transition-delay'?: CSSValueGeneral;\n  '-webkit-transition-duration'?: CSSValueGeneral;\n  '-webkit-transition-property'?: CSSValueGeneral;\n  '-webkit-transition-timing-function'?: CSSValueGeneral;\n  '-webkit-user-drag'?: CSSValueGeneral;\n  '-webkit-user-modify'?: CSSValueGeneral;\n  '-webkit-writing-mode'?: CSSValueGeneral;\n}\n\nexport interface INestedCSSProperties extends ICSSProperties {\n  $nest?: NestedCSSSelectors;\n\n  /**\n   * A debug only (stripped in process.env.NODE_ENV !== 'production') name\n   * Helps you figure out where the class is coming from if you care\n   **/\n  $debugName?: string;\n}\n\nexport type MediaQuery = {\n  type?: 'screen' | 'print' | 'all';\n  orientation?: 'landscape' | 'portrait';\n  minWidth?: number | string;\n  maxWidth?: number | string;\n  minHeight?: number | string;\n  maxHeight?: number | string;\n};\n\nexport type NestedCSSSelectors = {\n  /** State selector */\n  '&:active'?: INestedCSSProperties;\n  '&:any'?: INestedCSSProperties;\n  '&:checked'?: INestedCSSProperties;\n  '&:default'?: INestedCSSProperties;\n  '&:disabled'?: INestedCSSProperties;\n  '&:empty'?: INestedCSSProperties;\n  '&:enabled'?: INestedCSSProperties;\n  '&:first'?: INestedCSSProperties;\n  '&:first-child'?: INestedCSSProperties;\n  '&:first-of-type'?: INestedCSSProperties;\n  '&:fullscreen'?: INestedCSSProperties;\n  '&:focus'?: INestedCSSProperties;\n  '&:hover'?: INestedCSSProperties;\n  '&:indeterminate'?: INestedCSSProperties;\n  '&:in-range'?: INestedCSSProperties;\n  '&:invalid'?: INestedCSSProperties;\n  '&:last-child'?: INestedCSSProperties;\n  '&:last-of-type'?: INestedCSSProperties;\n  '&:left'?: INestedCSSProperties;\n  '&:link'?: INestedCSSProperties;\n  '&:only-child'?: INestedCSSProperties;\n  '&:only-of-type'?: INestedCSSProperties;\n  '&:optional'?: INestedCSSProperties;\n  '&:out-of-range'?: INestedCSSProperties;\n  '&:read-only'?: INestedCSSProperties;\n  '&:read-write'?: INestedCSSProperties;\n  '&:required'?: INestedCSSProperties;\n  '&:right'?: INestedCSSProperties;\n  '&:root'?: INestedCSSProperties;\n  '&:scope'?: INestedCSSProperties;\n  '&:target'?: INestedCSSProperties;\n  '&:valid'?: INestedCSSProperties;\n  '&:visited'?: INestedCSSProperties;\n\n  /**\n   * Pseudo-elements\n   * https://developer.mozilla.org/en/docs/Web/CSS/Pseudo-elements\n   */\n  '&::after'?: INestedCSSProperties;\n  '&::before'?: INestedCSSProperties;\n  '&::first-letter'?: INestedCSSProperties;\n  '&::first-line'?: INestedCSSProperties;\n  '&::selection'?: INestedCSSProperties;\n  '&::backdrop'?: INestedCSSProperties;\n  '&::placeholder'?: INestedCSSProperties;\n  '&::marker'?: INestedCSSProperties;\n  '&::spelling-error'?: INestedCSSProperties;\n  '&::grammar-error'?: INestedCSSProperties;\n\n  /** Children */\n  '&>*'?: INestedCSSProperties;\n\n  /**\n   * Mobile first media query example\n   **/\n  '@media screen and (min-width: 700px)'?: INestedCSSProperties;\n  /**\n   * Desktop first media query example\n   **/\n  '@media screen and (max-width: 700px)'?: INestedCSSProperties;\n\n  /**\n   * Also cater for any other nested query you want\n   */\n  [selector: string]: INestedCSSProperties | undefined;\n};\n\n/**\n * For animation keyframe definition\n */\nexport interface IKeyFrames {\n  $debugName?: string;\n  [\n    /** stuff like `from`, `to` or `10%` etc */\n    key: string\n  ]: ICSSProperties | string | undefined;\n}\n\nexport function borderCSSValue(border: IBorder): string {\n    return `${border.thickness}px ${border.style} ${border.color}`;\n}\n\nexport function boxShadowsCSSValue(shadow: IShadow[]): string {\n    return shadow.map(s => `${s.offsetX}px ${s.offsetY}px ${s.blur}px ${s.spread}px ${s.color}`).join(',');\n}\n\nexport function dropShadowsFilterCSSValue(): string {\n    return '';\n    // return shadow.map(s => {\n    //     return `drop-shadow(${s.offsetX}px ${s.offsetY}px ${s.blur}px ${s.color})`;\n    // }).join(' ');\n}\n\nexport function textShadowsCSSValue(shadow: ITextShadow[]): string {\n    return shadow.map(s => `${s.offsetX}px ${s.offsetY}px ${s.blur}px ${s.color}`).join(',');\n}\n","import { TimingFunctionKey } from '@studio/domain';\nimport { getTimingFunctionByKey } from './timing-functions';\nimport { lerp } from '@studio/utils/utils';\n\ntype NumberObject = {[prop: string]: number};\ntype AnyObject = {[prop: string]: any};\n\nexport interface IAnimateToSettings {\n    duration?: number;\n    delay?: number;\n    callback?: (animator?: AnimatorLite) => void;\n    timingFunction?: TimingFunctionKey;\n}\n\n/** Used to animate elements if the creative is paused */\nexport class AnimatorLite {\n\n    private _speed = 1;\n\n    private _requestId?: number;\n    private _lastTimestamp;\n\n    private _fromValue: NumberObject;\n    private _toValue: NumberObject;\n\n    private _time = 0;\n    private _delay = 0;\n    private _duration = 0.5;\n    private _timingFunction = getTimingFunctionByKey('linear');\n    private _onTick?: (animator?: AnimatorLite) => void;\n\n    private _paused = true;\n    private _onCompletedCallbacks: (() => void)[] = [];\n    get isPlaying(): boolean {\n        return !this._paused;\n    }\n\n    constructor(public target: AnyObject) {}\n\n    static to(target: AnyObject, to: number | NumberObject, settings?: IAnimateToSettings): AnimatorLite {\n        return new AnimatorLite(target).to(to, settings);\n    }\n\n    to(to: number | NumberObject, settings?: IAnimateToSettings): AnimatorLite {\n        return this.fromTo(this.target, to, settings);\n    }\n\n    from(from: number | NumberObject, settings?: IAnimateToSettings): AnimatorLite {\n        return this.fromTo(from, this.target, settings);\n    }\n\n    fromTo(from: number | NumberObject, to: number | NumberObject, settings?: IAnimateToSettings): AnimatorLite {\n\n        this._applySettings(settings);\n\n        this._fromValue = this._filterAnimatableProperties(from);\n        this._toValue = this._filterAnimatableProperties(to);\n\n        return this.restart().play();\n    }\n\n    play(): AnimatorLite {\n        if (this._paused === true) {\n            this._paused = false;\n            this._requestId = requestAnimationFrame(this._tick);\n        }\n\n        return this;\n    }\n\n    pause(): void {\n        this._paused = true;\n        this._lastTimestamp = 0;\n        this._cancelAnimation();\n    }\n\n    restart(): AnimatorLite {\n        this._time = 0;\n        return this;\n    }\n\n    revert(): AnimatorLite {\n        this._speed *= -1;\n        return this.play();\n    }\n\n    private _applySettings(settings: IAnimateToSettings = {}): void {\n        if (settings.delay !== undefined) {\n            this._delay = settings.delay;\n        }\n        if (settings.duration !== undefined) {\n            this._duration = settings.duration;\n        }\n        if (settings.timingFunction !== undefined) {\n            this._timingFunction = getTimingFunctionByKey(settings.timingFunction);\n        }\n        this._onTick = settings.callback;\n    }\n\n\n    private _updateTarget(time: number): boolean {\n        const progress = this._getCompletionRate(time);\n        const timing = this._getTimingValue(progress);\n\n        if (typeof this._toValue === 'object') {\n            Object.keys(this._toValue).forEach(key => {\n                const from = this._fromValue[key];\n                const to = this._toValue[key];\n\n                if (typeof from !== 'number') {\n                    throw new Error(`Cannot animate property ${key}. Must be of type number`);\n                }\n                this.target[key] = lerp(from, to, timing);\n            });\n        }\n\n        if (this._onTick) {\n            this._onTick(this);\n        }\n\n        const isCompleted = this._speed < 0 ? progress <= 0 : progress >= 1;\n\n        if (isCompleted) {\n            for (const callback of this._onCompletedCallbacks) {\n                callback();\n            }\n        }\n\n        // Return true if animation is completed\n        return isCompleted;\n    }\n\n    onCompleted = (callback: () => void): void => {\n        this._onCompletedCallbacks.push(callback);\n    };\n\n    private _getTimingValue(progress: number): number {\n        return this._timingFunction(progress);\n    }\n\n    /**\n     * Get a value between 0 and 1 on how much progress on time have been\n     * @param time\n     */\n    private _getCompletionRate(time: number): number {\n        return Math.max(0, Math.min((time - this._delay) / this._duration, 1));\n    }\n\n    private _cancelAnimation(): void {\n        if (this._requestId) {\n            cancelAnimationFrame(this._requestId);\n            this._requestId = undefined;\n        }\n    }\n\n    private _tick = (t: number): void => {\n\n        if (this._paused) {\n            return;\n        }\n\n        if (!this._lastTimestamp) {\n            this._lastTimestamp = t;\n        }\n\n        const timestampDiff = (t - this._lastTimestamp) / 1000;\n        this._time += timestampDiff * this._speed;\n\n        this._lastTimestamp = t;\n\n        if (!this._updateTarget(this._time)) {\n            this._requestId = requestAnimationFrame(this._tick);\n        }\n        else {\n            this.pause();\n        }\n    };\n\n    private _filterAnimatableProperties(obj: number | any): NumberObject {\n\n        const result: NumberObject = {};\n        if (typeof obj === 'number') {\n            result.value = obj;\n        }\n        if (typeof obj === 'object') {\n            Object.keys(obj).forEach(key => {\n                const value = obj[key];\n                if (typeof value === 'number') {\n                    result[key] = value;\n                }\n            });\n        }\n        return result;\n    }\n}\n","export enum ErrorMessage {\n    ImageRemovedDuringLoad = 'Image was removed while loading',\n    ImageLoadingFailed = 'Could not load image',\n    ResizeObseravbleLoopLimit = 'ResizeObserver loop limit exceeded'\n}\n","import { IRadius } from '../domain';\n\nexport function makeRoundedShape (w: number, h: number, radius: IRadius): string {\n    const { topLeft: tl, topRight: tr, bottomRight: br, bottomLeft: bl} = radius;\n\n    return `M 0 ${tl} A ${tl} ${tl} 0 0 1 ${tl} 0`\n    + ` L ${w - tr} 0 A ${tr} ${tr} 0 0 1 ${w} ${tr}`\n    + `L ${w} ${h - br} A ${br} ${br} 0 0 1 ${w - br} ${h}`\n    + `L ${bl} ${h} A ${bl} ${bl} 0 0 1 0 ${h - bl} Z`;\n}\n","import { toHEX } from './color.utils';\nimport { isSafari, getBrowserVersion, isEdge, isFirefox } from '@ad/utils/browser';\nimport { aspectRatioScale, isSameSize } from '../utils/geom';\nimport { loadImagePromise, PromiseResolver } from '../utils/promises';\nimport {\n    AppearenceStyles,\n    IBorder,\n    IBoundingBox,\n    IColor,\n    IImageViewElement,\n    IImageElementDataNode,\n    ImageSizeMode,\n    IPosition,\n    IShadow,\n    ISize,\n    ISVGBackground,\n    ISVGBackgroundNode,\n    NodeKind,\n    OneOfElementDataNodes,\n    OneOfViewNodes, IImageAsset, IImageSettings, IRadius, RadiusType\n} from '../domain';\nimport { isViewElementNode, isImageNode, isVideoNode } from './nodes/helpers';\nimport { ICreativeEnvironment } from './environment';\nimport { ImageOptimizerUrlBuilder } from '../ad/utils/image-optimizer';\nimport { sanitizeUrl } from '../utils/sanitizer';\nimport { insertAfter } from '../ad/utils/dom';\nimport { ErrorMessage } from '../utils/errors/error-message.enum';\nimport { makeRoundedShape } from '../utils/svg-utils';\n\nconst SVG_IMAGE_OPTIONS = {\n    fit: 'xMidYMid meet',\n    crop: 'xMidYMid slice',\n    stretch: 'none'\n};\n\nconst SVG_NAMESPACE = 'http://www.w3.org/2000/svg';\nconst XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';\n\ntype Shapes = NodeKind.Ellipse | NodeKind.Image | NodeKind.Rectangle;\n\nenum IdSuffix {\n    Shape = '-shape',\n    Group = '-group',\n    LinearGradient = '-linear-gradient',\n    Border = '-border',\n    Clip = '-clip',\n    Shadow = '-shadow'\n}\n\ntype GradientPosition = {\n    from: { x: number, y: number },\n    to: { x: number, y: number },\n};\n\nexport class ImageError extends Error {\n    constructor(msg: string, public url: string) {\n        super(msg);\n        // Set the prototype explicitly.\n        Object.setPrototypeOf(this, ImageError.prototype);\n    }\n}\n\n/**\nElements need to be added in this order\n1. groupElement.appendChild(shapeElement);\n2. groupElement.appendChild(imageSvgElement);\n3. groupElement.appendChild(loadingElement);\n4. gradientElement.appendChild(stopElement);\n5. defsElement.appendChild(gradientElement);\n6. clipPathElement.appendChild(clipUseElement);\n7. defsElement.appendChild(borderElement);\n8. defsElement.appendChild(clipPathElement);\n9. groupElement.appendChild(borderUseElement);\n10. defsElement.appendChild(filterElement);\n11. svgElement!.appendChild(useElement);\n12. svgElement.appendChild(defsElement);\n13. svgElement.appendChild(groupElement);\n14. node.__rootElement!.appendChild(svgElement);\n */\n\n\nexport class SVGBackground implements ISVGBackground {\n\n    private _id: string;\n    private _document: Document;\n    private _shape: Shapes;\n    private _baseUrl: string;\n\n    /**\n     * DataElement, does not exist on creative\n     */\n    private _data?: OneOfElementDataNodes;\n\n    // Elements\n    private _groupElement: SVGGElement;\n    private _shapeElement: SVGEllipseElement | SVGPathElement;\n    private _defsElement: SVGDefsElement;\n    private _svgElement: SVGSVGElement;\n    private _shadowFilterElements: SVGFilterElement[] = [];\n    private _shadowUseElements: SVGUseElement[] = [];\n    private _gradientElement?: SVGGradientElement;\n    private _gradientElementStops: SVGStopElement[] = [];\n    private _loaderElement: SVGElement;\n    private _foreignObject: SVGElement;\n    /**\n     * Note that this only exists for images.\n     * Other shapes applies shadowns on shapeElement\n     */\n    private _borderElement?: SVGPathElement;\n    private _imageElement?: SVGImageElement;\n\n    // Current rendered properties used to know what to redraw\n    private _width: number;\n    private _height: number;\n    private _radius: IRadius;\n    private _color?: string;\n    private _url?: string;\n    private _image?: IBoundingBox & { fillOption: string };\n\n    private _gradientPosition?: GradientPosition;\n    private _clipPathElement: SVGClipPathElement;\n    private _borderUseElement: SVGUseElement;\n\n    private _border: IBorder<string>;\n    private _shadows: IShadow<string>[] = [];\n    private _shadowSize?: ISize;\n    private _shadowType: SvgShadowType = SvgShadowType.None;\n\n    private _styles: ISVGBackgroundNode & AppearenceStyles;\n    private _imageLoadPromise?: PromiseResolver<any>;\n\n    constructor(\n        private _window: Window,\n        private _element: ISVGBackgroundNode,\n        private _env: ICreativeEnvironment\n    ) {\n        this._document = this._window.document;\n        this._baseUrl = this._document.querySelector('head base') ? this._window.location.href.replace(this._window.location.hash, '') : '';\n        this._id = ((isViewElementNode(this._element) ? this._element.elementCid : 'creative') || 'unset') + '-' + Math.floor(Math.random() * 1000000);\n        this._shape = this._getShape();\n\n        // Note that data doesn't exist when this is used as creative background\n        this._data = (this._element as OneOfViewNodes).__data;\n        this._createSVG();\n    }\n\n    private setViewBox(x: number, y: number, width: number, height: number): void {\n        this._svgElement.setAttribute('viewBox', `${x} ${y} ${width} ${height}`);\n    }\n\n    public setResponsive(): void {\n        if(this._width > this._height) {\n            this._svgElement.style.height = 'auto';\n            this._svgElement.style.width = '100%';\n        } else {\n            this._svgElement.style.height = '100%';\n            this._svgElement.style.width = 'auto';\n        }\n\n        this.setViewBox(0, 0, this._width, this._height);\n    }\n\n    private _getShape(): Shapes {\n        switch (this._element?.kind) {\n            case NodeKind.Ellipse:\n            case NodeKind.Image:\n                return this._element.kind;\n            default:\n                return NodeKind.Rectangle;\n        }\n    }\n\n    private _createSVG(): SVGSVGElement {\n        if (this._svgElement) {\n            throw new Error('Background already added');\n        }\n        const document = this._document;\n        const groupElement = document.createElementNS(SVG_NAMESPACE, 'g');\n        const shapeElement = document.createElementNS(SVG_NAMESPACE, this._getShape() === 'ellipse' ? 'ellipse' : 'path');\n        const defsElement = document.createElementNS(SVG_NAMESPACE, 'defs');\n        const svgElement = document.createElementNS(SVG_NAMESPACE, 'svg');\n        const style = svgElement.style;\n\n        svgElement.setAttribute('xmlns', SVG_NAMESPACE); // Needed by serializer\n\n        style.position = 'absolute';\n        style.left = '0';\n        style.top = '0';\n        style.width = '100%';\n        style.height = '100%';\n        style.overflow = 'visible';\n        style.pointerEvents = 'none';\n        style.zIndex = '-1'; // Needs to be z-index -1 because otherwise selection dissappears from button\n\n        // Hack to avoid jagged edges on image export on rotated elements\n        if (this._shouldAddOutline()) {\n            style.outline = '1px solid transparent';\n        }\n\n        shapeElement.id = this._id + IdSuffix.Shape;\n        shapeElement.setAttribute('fill', 'transparent');\n\n        groupElement.id = this._id + IdSuffix.Group;\n        groupElement.appendChild(shapeElement);\n        svgElement.appendChild(defsElement);\n        svgElement.appendChild(groupElement);\n\n        this._shapeElement = shapeElement;\n        this._defsElement = defsElement;\n        this._groupElement = groupElement;\n        this._svgElement = svgElement;\n\n        if (isVideoNode(this._data)) {\n            this._foreignObject = this._createForeignObject();\n        }\n        // Add it as first child in the DOM to make it render behind all other items\n        this._element.__rootElement?.prepend(svgElement);\n\n        return svgElement;\n    }\n\n\n    private _createForeignObject(): SVGForeignObjectElement {\n        const foreignObject = document.createElementNS(SVG_NAMESPACE, 'foreignObject');\n        foreignObject.setAttribute('fill', 'transparent');\n        this._groupElement.appendChild(foreignObject);\n\n        return foreignObject;\n    }\n\n    private _showLoader(): void {\n        if (!this._loaderElement) {\n            this._loaderElement = createSVGLoaderImage(this._styles);\n        }\n        if (!this._loaderElement.parentNode) {\n            this._groupElement.appendChild(this._loaderElement);\n        }\n    }\n\n    private _hideLoader(): void {\n        if (this._loaderElement?.parentNode) {\n            this._groupElement.removeChild(this._loaderElement);\n        }\n    }\n\n    private _shouldAddOutline(): boolean {\n        if (this._env.IN_IMAGE_GENERATOR && this._element?.rotationZ) {\n            if (this._element.rotationZ !== 0) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    render_m(element: ISVGBackgroundNode, overrides?: AppearenceStyles): Promise<void> | undefined {\n        let promise: Promise<void> | undefined;\n\n        if (overrides) {\n            this._styles = { ...element, ...overrides }; // A bit expensive\n        }\n        else {\n            this._styles = element;\n        }\n\n        this._element = element;\n        if (this._shape === NodeKind.Image) {\n            promise = this._setImageUrl((this._styles as IImageViewElement).imageUrl);\n        }\n        this._setFill(this._styles.fill);\n        this._setBorder(this._styles.border);\n        this._setSizeAndRadius(this._styles);\n        this._setShadows(this._styles.shadows);\n        return promise;\n    }\n\n    private _setSizeAndRadius(styles: ISVGBackgroundNode & AppearenceStyles): void {\n        const { width, height, radius } = styles;\n\n        if (isNaN(width) || isNaN(height) || typeof width !== 'number' || typeof height !== 'number') {\n            throw new Error('width, height must be provided');\n        }\n\n        if (width !== this._width || height !== this._height) {\n            this._width = width;\n            this._height = height;\n            const overflow = this._getShadowOverflow();\n            this._svgElement.setAttribute('width', width + overflow * 2 + '');\n            this._svgElement.setAttribute('height', height + overflow * 2 + '');\n\n\n            if (this._shape === 'ellipse') {\n                // Center\n                this._shapeElement.setAttribute('cx', (overflow + width / 2) + '');\n                this._shapeElement.setAttribute('cy', (overflow + height / 2) + '');\n\n                // Radius\n                this._shapeElement.setAttribute('rx', width / 2 + '');\n                this._shapeElement.setAttribute('ry', height / 2 + '');\n            }\n            else {\n                if (this._foreignObject) {\n                    this._foreignObject.setAttribute('height', height + '');\n                    this._foreignObject.setAttribute('width', width + '');\n                }\n                if (this._imageElement) {\n                    this._imageElement.setAttribute('width', width + '');\n                    this._imageElement.setAttribute('height', height + '');\n                }\n            }\n            this._setBorderSize();\n            this._setGradientSize();\n            this._setShadowSize();\n        }\n        this._setRadius(radius);\n        this._setImageSize();\n    }\n\n    private _setGradientSize(): void {\n        if (this._gradientElement) {\n\n            if (!this._gradientPosition || typeof this._width !== 'number' || typeof this._height !== 'number') {\n                throw new Error('No gradient position provided');\n            }\n\n            const x1 = this._gradientPosition.from.x * this._width;\n            const y1 = this._gradientPosition.from.y * this._height;\n            const x2 = this._gradientPosition.to.x * this._width;\n            const y2 = this._gradientPosition.to.y * this._height;\n\n            this._gradientElement.setAttribute('x1', x1 + '');\n            this._gradientElement.setAttribute('y1', y1 + '');\n            this._gradientElement.setAttribute('x2', x2 + '');\n            this._gradientElement.setAttribute('y2', y2 + '');\n        }\n    }\n\n    private _fillToPosition(fill: IColor): GradientPosition | undefined {\n        if (fill?.stops?.length) {\n            const from = fill.start.position!;\n            const to = fill.end.position!;\n            return { from: { ...from }, to: { ...to } };\n        }\n    }\n\n    private _createLinearGradient(): SVGGradientElement {\n        if (!this._gradientElement) {\n            const gradientId = this._id + IdSuffix.LinearGradient;\n            const gradientElement = document.createElementNS(SVG_NAMESPACE, 'linearGradient');\n            gradientElement.id = gradientId;\n            gradientElement.setAttribute('gradientUnits', 'userSpaceOnUse');\n            const firstStop = document.createElementNS(SVG_NAMESPACE, 'stop');\n            gradientElement.appendChild(firstStop);\n            const secondStop = document.createElementNS(SVG_NAMESPACE, 'stop');\n            gradientElement.appendChild(secondStop);\n\n            this._gradientElementStops.push(firstStop, secondStop);\n            this._gradientElement = gradientElement;\n        }\n        return this._gradientElement;\n    }\n\n    private calculateRadius(radius: IRadius): IRadius {\n        const minValue = Math.min(this._element.width, this._element.height);\n            const maxRadiusValue = Math.ceil(minValue / 2);\n            const applyMaxCap = (currentRadius: number): number =>\n                currentRadius > maxRadiusValue\n                ? maxRadiusValue\n                : currentRadius;\n        return {\n            type: radius.type,\n            topLeft: applyMaxCap(radius.topLeft),\n            topRight: applyMaxCap(radius.topRight),\n            bottomRight: applyMaxCap(radius.bottomRight),\n            bottomLeft: applyMaxCap(radius.bottomLeft)\n        };\n    }\n\n    private _setRadius(radius: IRadius | undefined): void {\n        if (this._shape !== NodeKind.Ellipse) {\n            if (radius) {\n                this._radius = this.calculateRadius(radius);\n            }\n            else {\n                this._radius = {\n                    type: RadiusType.Joint,\n                    bottomLeft: 0,\n                    bottomRight: 0,\n                    topLeft: 0,\n                    topRight: 0\n                };\n            }\n\n            this._shapeElement.setAttribute('d', makeRoundedShape(this._element.width, this._element.height, this._radius));\n\n            if (this._borderElement) {\n                this._borderElement.setAttribute('d', makeRoundedShape(this._element.width, this._element.height, this._radius));\n            }\n        }\n    }\n\n    private _setFill(fill?: IColor): void {\n\n        const gradientId = this._id + IdSuffix.LinearGradient;\n        const colorString = fill?.toString();\n\n        if (colorString === this._color) {\n            return;\n        }\n\n        this._color = colorString;\n\n        if (fill) {\n            const stops = fill.stops || [];\n\n            // See more here: https://codepeD.o/NV/pen/jcnmK\n            if (fill.type === 'linear-gradient' && stops.length) {\n                const gradientElement = this._createLinearGradient();\n                this._gradientPosition = this._fillToPosition(fill);\n\n                if (this._width && this._height) {\n                    this._setGradientSize();\n                }\n\n                stops.forEach((stop, index) => {\n                    const color = stop.color;\n                    const stopElement = this._gradientElementStops[index]!;\n                    stopElement.setAttribute('offset', stop.offset + '%');\n                    stopElement.setAttribute('stop-color', toHEX(color));\n                    stopElement.setAttribute('stop-opacity', ((color.alpha / 100) * (fill!.alpha / 100)).toString());\n                });\n\n                // Add to DOM if not already added\n                if (!gradientElement.parentNode) {\n                    this._defsElement.appendChild(gradientElement);\n                }\n\n                // Hack for Safari\n                if (navigator.userAgent.includes('Safari') && navigator.vendor.includes('Apple')) {\n                    this._shapeElement.setAttribute('fill', `url('${this._baseUrl}#${gradientId}')`);\n                }\n                else {\n                    this._shapeElement.setAttribute('fill', `url(#${gradientId})`);\n                }\n            }\n            // Solid color\n            else {\n                this._shapeElement.setAttribute('fill', colorString!);\n            }\n        }\n        else {\n            this._shapeElement.setAttribute('fill', 'transparent');\n        }\n    }\n\n    private _setBorderSize(): void {\n        if (this._borderElement) {\n            this._borderElement.setAttribute('width', this._width + '');\n            this._borderElement.setAttribute('height', this._height + '');\n        }\n    }\n\n    /**\n     * Only for images and videos other elements have border applied on the shape itself\n     */\n     private _createBorderAndClipElement(): SVGPathElement {\n\n        if (!this._borderElement) {\n            const borderId = this._id + IdSuffix.Border;\n            const clipId = this._id + IdSuffix.Clip;\n            const borderElement = this._document.createElementNS(SVG_NAMESPACE, 'path');\n            borderElement.setAttribute('x', 0 + '');\n            borderElement.setAttribute('y', 0 + '');\n            borderElement.setAttribute('fill', 'transparent');\n\n            borderElement.id = borderId;\n\n            // Used to mask image to create a radius effect\n            this._clipPathElement = this._document.createElementNS(SVG_NAMESPACE, 'clipPath');\n            this._clipPathElement.id = clipId;\n\n            const clipUseElement = this._document.createElementNS(SVG_NAMESPACE, 'use');\n            clipUseElement.setAttributeNS(XLINK_NAMESPACE, 'xlink:href', `${this._baseUrl}#${borderId}`);\n            this._clipPathElement.appendChild(clipUseElement);\n\n            this._borderUseElement = this._document.createElementNS(SVG_NAMESPACE, 'use');\n            this._borderUseElement.setAttributeNS(XLINK_NAMESPACE, 'xlink:href', `${this._baseUrl}#${borderId}`);\n\n            const clipPathURL =  `url(${this._baseUrl}#${clipId})`;\n\n            if (this._imageElement) {\n                this._imageElement.setAttribute('clip-path', clipPathURL);\n            }\n            if (this._foreignObject) {\n                this._foreignObject.setAttribute('clip-path', clipPathURL);\n            }\n\n            this._defsElement.appendChild(borderElement);\n            this._defsElement.appendChild(this._clipPathElement);\n            this._groupElement.appendChild(this._borderUseElement);\n\n            this._borderElement = borderElement;\n        }\n        return this._borderElement;\n    }\n\n    private _setBorder(border?: IBorder): void {\n        let borderElement: SVGElement;\n\n        const { thickness, style, color } = border || { thickness: 0, style: 'solid' };\n        const colorString = color ? color.toString() : 'transparent';\n        const thicknessChange = this._border?.thickness !== thickness;\n\n        // Identical border, don't update\n        if (this._border && !thicknessChange && this._border.style === style && this._border.color === colorString) {\n            return;\n        }\n\n        this._border = {\n            thickness,\n            style,\n            color: colorString\n        };\n\n        // Odd width border fix. Anti-aliasing.\n        this._svgElement.style.boxShadow = thickness && this._shadowType !== SvgShadowType.BoxShadow ? `0 0 ${thickness}px transparent` : 'none';\n\n        // Image is handled differently (need to be clipped and border is on the outside)\n        if (this._shape === NodeKind.Image || isVideoNode(this._data)) {\n            borderElement = this._createBorderAndClipElement();\n        } else {\n            borderElement = this._shapeElement;\n        }\n\n        borderElement.setAttribute('stroke', this._border.color);\n        borderElement.setAttribute('stroke-width', this._border.thickness + '');\n        borderElement.setAttribute('stroke-linejoin', 'square');\n\n        if (this._border.style === 'solid') {\n            borderElement.setAttribute('stroke-linecap', 'butt');\n            borderElement.setAttribute('stroke-dasharray', '');\n        }\n        else if (this._border.style === 'dashed') {\n            borderElement.setAttribute('stroke-linecap', 'butt');\n            borderElement.setAttribute('stroke-dasharray', thickness * 3 + '');\n        }\n        else if (this._border.style === 'dotted') {\n            borderElement.setAttribute('stroke-linecap', 'round');\n            borderElement.setAttribute('stroke-dasharray', `1, ${thickness * 2}`);\n        }\n\n        // Update shadows when animating border size\n        if (thicknessChange) {\n            this._setCssShadows(this._shadows);\n        }\n    }\n\n    /**\n     * A more performant way to show shadows.\n     * Note that it doesn't support spread\n     * @param shadows\n     */\n    private _setCssShadows(shadows?: IShadow<string>[]): void {\n        const type = this._shadowType;\n        const style = this._svgElement.style;\n\n        const willChange = style.willChange\n            .split(',')\n            .filter(f => !!f)\n            .map(f => f.trim());\n\n        // Cleanup shadows\n        if (!shadows?.length || type === SvgShadowType.None) {\n            if (willChange.indexOf('filter') > -1) {\n                style.willChange = willChange\n                    .filter(f => f !== 'filter')\n                    .join(', ');\n                style.filter = '';\n            }\n            // this._resetBoxShadow();\n        }\n        else if (type === SvgShadowType.DropShadow) {\n\n            if (willChange.indexOf('filter') === -1) {\n                style.willChange = [...willChange, 'filter'].join(', ');\n            }\n\n            const dropShadows = shadows.map(s =>\n                `drop-shadow(${s.offsetX}px ${s.offsetY}px ${s.blur}px ${s.color})`\n            );\n            style.filter = dropShadows.join(' ');\n            // this._resetBoxShadow();\n        }\n        // Uncomment to start applying box shadows\n        // else if (type === SvgShadowType.BoxShadow) {\n\n        //     // Note that shadow ignores border so we need to add it to spread size\n        //     const border = this._border?.thickness || 0;\n\n        //     // The spread values of svg shadows is rendered half the size for SVGShadows (by a mistake)\n        //     const boxShadows = shadows.map(s =>\n        //         `${s.offsetX}px ${s.offsetY}px ${s.blur}px ${(s.spread + border) / 2}px ${s.color}`\n        //     );\n\n        //     style.boxShadow = boxShadows.join(',');\n        //     style.borderRadius = (this._styles.radius || 0) + 'px';\n        //     style.filter = 'unset';\n        // }\n    }\n\n    // private _resetBoxShadow(): void {\n    //     this._svgElement.style.boxShadow = 'unset';\n    //     this._svgElement.style.borderRadius = 'unset';\n    // }\n\n    /**\n     * This is the only way to use shadow spread and still handle transparent pngs etc.\n     * Beware that this approach is advanced and not even figma can handle spread well.\n     * @param shadows\n     * @returns\n     */\n    private _setShadows(shadows: IShadow[] = []): void {\n\n        if (shadows) {\n\n            const newShadows = shadows.map(s => ({ ...s, color: s.color.toString() }));\n            const shadowType = this._getShadowType();\n\n            let changed = this._shadows.length !== newShadows.length || shadowType !== this._shadowType;\n\n            if (!changed) {\n                changed = newShadows.some((s, i) => {\n                    const old = this._shadows && this._shadows[i];\n                    return !old\n                        || s.blur !== old.blur\n                        || s.spread !== old.spread\n                        || s.offsetX !== old.offsetX\n                        || s.offsetY !== old.offsetY\n                        || s.color !== old.color;\n                });\n            }\n\n            // Trigger new shadow size update if length of shadows have changed\n            if (newShadows.length !== this._shadows?.length) {\n                this._shadowSize = undefined;\n            }\n\n            this._shadows = newShadows;\n\n            if (!changed) {\n                return;\n            }\n\n            this._shadowType = shadowType;\n\n            // Make svg more performant by using overflow: clip when possible\n            this._setSvgOverflow();\n\n            const groupId = this._id + IdSuffix.Group;\n            const { width, height } = this._element;\n            const svgShadowLength = this._shadowType === SvgShadowType.SvgShadow ? shadows.length : 0;\n\n            // Remove additional shadow element if count have changed\n            while (this._shadowFilterElements.length > svgShadowLength) {\n                const filter = this._shadowFilterElements.pop()!;\n                const use = this._shadowUseElements.pop()!;\n                filter.parentNode?.removeChild(filter);\n                use.parentNode?.removeChild(use);\n            }\n\n            // Set css filter drop shadow instead (much more performant)\n            if (this._shadowType !== SvgShadowType.SvgShadow) {\n                this._setCssShadows(this._shadows);\n\n                // Might need to change back overflow size\n                this._setShadowSize();\n\n                return;\n            }\n\n            // reset css filter drop shadow\n            this._setCssShadows();\n\n\n            // Apply shadows backwards to get the correct z index...\n            shadows.forEach((shadow, index) => {\n\n                const color = shadow.color;\n                const filterId = this._id + IdSuffix.Shadow + index;\n                let filterElement = this._shadowFilterElements[index];\n                let useElement = this._shadowUseElements[index];\n\n                if (!filterElement) {\n\n                    // Note that the CSS drop-shadow filter doesn't support spread\n                    filterElement = document.createElementNS(SVG_NAMESPACE, 'filter');\n                    filterElement.id = filterId;\n                    filterElement.setAttribute('color-interpolation-filters', 'sRGB');\n                    filterElement.setAttribute('width', `300%`);\n                    filterElement.setAttribute('height', `300%`);\n                    setPosition(filterElement, -100, -100, '%');\n\n                    // Do a solid color with the same shape as the element (works for transparent pngs as well)\n                    const matrix = document.createElementNS(SVG_NAMESPACE, 'feColorMatrix');\n                    matrix.setAttribute('type', 'matrix');\n                    matrix.setAttribute('in', 'SourceGraphic');\n                    matrix.setAttribute('result', filterId + '_color');\n                    filterElement.appendChild(matrix);\n\n                    // Blur that shape\n                    const blur = document.createElementNS(SVG_NAMESPACE, 'feGaussianBlur');\n                    blur.setAttribute('type', 'matrix');\n                    blur.setAttribute('result', filterId + '_blur');\n                    blur.setAttribute('in', filterId + '_color');\n                    filterElement.appendChild(blur);\n\n                    this._shadowFilterElements.push(filterElement);\n                    this._defsElement.appendChild(filterElement);\n                }\n\n                if (!useElement) {\n                    useElement = document.createElementNS(SVG_NAMESPACE, 'use');\n                    useElement.setAttributeNS(XLINK_NAMESPACE, 'xlink:href', `${this._baseUrl}#${groupId}`); // Will not render <use> tag if this isn't set\n                    useElement.setAttribute('filter', `url(${this._baseUrl}#${filterId})`);\n                    useElement.setAttribute('width', '100%');\n                    useElement.setAttribute('height', '100%');\n                    setPosition(useElement, 0, 0);\n                    useElement.style.transformOrigin = '50% 50%';\n\n                    this._shadowUseElements.push(useElement);\n                    insertAfter(this._defsElement, useElement);\n                }\n\n                // Only way that works in Edge, example: https://codepen.io/mullany/pen/sJopz\n                const colorMatrix = `0 0 0 0 ${color.red / 255} 0 0 0 0 ${color.green / 255} 0 0 0 0 ${color.blue / 255} 0 0 0 ${color.alpha / 100} 0`;\n\n                filterElement.getElementsByTagName('feColorMatrix')[0].setAttribute('values', colorMatrix);\n                filterElement.getElementsByTagName('feGaussianBlur')[0].setAttribute('stdDeviation', shadow.blur + '');\n\n                setPosition(useElement, shadow.offsetX, shadow.offsetY);\n\n                // Use scale to set spread since it's not supported in SVG\n                useElement.style.transform = `scaleX(${1 + shadow.spread / width}) scaleY(${1 + shadow.spread / height})`;\n\n            });\n\n            this._setShadowSize();\n        }\n    }\n\n    private _getSvgFillOption = (data: IImageElementDataNode): string => {\n        const sizeMode = data.imageSettings.sizeMode;\n        if (!sizeMode) {\n            if (data.ratio) {\n                return 'xMidYMid slice';\n            }\n            else if (!data.ratio) {\n                return 'none';\n            }\n\n            return 'xMidYMid meet';\n        }\n        return SVG_IMAGE_OPTIONS[sizeMode];\n    };\n\n    private async _setImageUrl(url?: string): Promise<void> {\n        if (url === this._url) {\n            return;\n        }\n        this._url = url;\n\n        const clipId = this._id + IdSuffix.Clip;\n\n        if (!this._imageElement) {\n            const img = this._imageElement = document.createElementNS(SVG_NAMESPACE, 'image');\n            setPosition(img, 0, 0);\n            this._createBorderAndClipElement();\n            this._groupElement.insertBefore(img, this._borderUseElement);\n            img.setAttribute('clip-path', `url(${this._baseUrl}#${clipId})`);\n        }\n\n        if (url && isImageNode(this._data)) {\n\n            // Show loader when uploading images to canvas\n            if (this._data.imageAsset?.__loading) {\n                this._showLoader();\n            }\n            await this._loadImage(url);\n\n            // __loading is set to false after upload to canvas is completed\n            if (!this._data.imageAsset?.__loading) {\n                this._hideLoader();\n            }\n        }\n        else {\n            this._clearImageElement(true /** imageWasRemoved */);\n        }\n    }\n\n    private _loadImage(url: string): Promise<any> {\n        // Make sure to never set any js or other potential treat as src\n        url = sanitizeUrl(url);\n\n        if (!this._imageElement || !this._url) {\n            throw new Error('No image element added to svg');\n        }\n\n        const version = getBrowserVersion();\n\n        // Load events on SVGs doesn't work in certain browsers\n        if ((isSafari && version < 14) || (isEdge && version < 20)) {\n            this._imageLoadPromise = loadImagePromise(url);\n        }\n        else {\n            const promiseResolver = new PromiseResolver();\n            this._imageElement.addEventListener('load', () => promiseResolver.resolve());\n            this._imageElement.addEventListener('error', () => {\n                this._clearImageElement();\n                promiseResolver.reject(new ImageError(ErrorMessage.ImageLoadingFailed, url));\n            });\n            this._imageLoadPromise = promiseResolver;\n        }\n        this._imageElement.setAttributeNS(XLINK_NAMESPACE, 'xlink:href', url);\n        this._imageElement.setAttribute('src', url);\n        return this._imageLoadPromise.promise;\n    }\n\n    private _clearImageElement(imageWasRemoved: boolean = false): void {\n        if (!this._imageElement) {\n            return;\n        }\n        if (this._imageLoadPromise && imageWasRemoved) {\n            this._imageLoadPromise.reject(ErrorMessage.ImageRemovedDuringLoad);\n        }\n        this._imageElement.removeAttributeNS(XLINK_NAMESPACE, 'xlink:href');\n        this._imageElement.removeAttribute('xlink:href');\n        this._imageElement.removeAttribute('src');\n    }\n\n    // TODO: Maybe prevent from redrawing every time\n    private _setImageSize(): void {\n\n        if (this._shape === NodeKind.Image && this._imageElement) {\n\n            const element = this._styles as IImageViewElement;\n            const data = element.__data;\n            const imageElement = this._imageElement!;\n            const fillOption = this._getSvgFillOption(data);\n            const isCropped = ImageOptimizerUrlBuilder.isCropped_m(element);\n            const fitPosition = this._getSvgImagePosition(element, data.imageSettings, data.imageAsset, !!element.feed, isCropped);\n\n            let x = (fitPosition.x < 0 ? fitPosition.x : 0);\n            let y = (fitPosition.y < 0 ? fitPosition.y : 0);\n            let width = Math.max((this._width) + Math.abs(fitPosition.x), 0);\n            let height = Math.max((this._height) + Math.abs(fitPosition.y), 0);\n\n            if (data.imageSettings.sizeMode !== ImageSizeMode.Crop) {\n                x = 0;\n                y = 0;\n                width = this._width;\n                height = this._height;\n            }\n\n            // Setting an attribute makes chrome reload image when user have disabled cache\n            if (this._image &&\n                this._image.x === x &&\n                this._image.y === y &&\n                this._image.width === width &&\n                this._image.height === height &&\n                this._image.fillOption === fillOption) {\n                return;\n            }\n\n            this._shapeElement.style.overflow = data.imageSettings.sizeMode === ImageSizeMode.Crop ? 'hidden' : 'visible';\n\n            imageElement.setAttribute('width', width + '');\n            imageElement.setAttribute('height', height + '');\n            imageElement.setAttribute('preserveAspectRatio', fillOption);\n            imageElement.setAttribute('rx', this._radius + '');\n\n            const overflow = this._getShadowOverflow();\n            setPosition(imageElement, x + overflow, y + overflow);\n\n            if (this._borderElement) {\n                setPosition(this._borderElement, overflow, overflow);\n            }\n\n            this._image = { x, y, width, height, fillOption };\n        }\n    }\n\n    /**\n     * Make svg bigger than element to accommodate Chrome 87 and FF changes to svg filter clipping.\n     */\n    private _setShadowSize(): void {\n\n        const svgElement = this._svgElement;\n        const shadows = this._shadows || [];\n        const { width, height } = this._element;\n        const overflow = this._getShadowOverflow();\n        const shadowWidth = Math.ceil(width + overflow * 2);\n        const shadowHeight = Math.ceil(height + overflow * 2);\n        const shadowSize = { width: shadowWidth, height: shadowHeight };\n\n        if (!this._shadowSize || !isSameSize(this._shadowSize, shadowSize)) {\n\n            this._shadowSize = shadowSize;\n\n            svgElement.style.left = `-${overflow}px`;\n            svgElement.style.top = `-${overflow}px`;\n            svgElement.style.width = `${shadowWidth}px`;\n            svgElement.style.height = `${shadowHeight}px`;\n            svgElement.setAttribute('width', shadowWidth + '');\n            svgElement.setAttribute('height', shadowHeight + '');\n\n            if (this._shape === NodeKind.Ellipse) {\n                this._shapeElement.setAttribute('cx', (shadowWidth / 2) + 'px');\n                this._shapeElement.setAttribute('cy', (shadowHeight / 2) + 'px');\n            }\n            else {\n                setPosition(this._shapeElement, overflow, overflow);\n\n                if (this._shape === NodeKind.Image && this._image) {\n                    if (this._imageElement) {\n                        setPosition(this._imageElement, this._image.x + overflow, this._image.y + overflow);\n                    }\n                    if (this._borderElement) {\n                        setPosition(this._borderElement, overflow, overflow);\n                    }\n                }\n            }\n\n            if (this._getShadowType() !== SvgShadowType.SvgShadow) {\n                this._setCssShadows(shadows);\n            }\n            else {\n                shadows.forEach((shadow, index) => {\n                    const useElement = this._shadowUseElements[index];\n\n                    // Note: our spread values might be considered wrong 1px make the shadow 1px wider and taller (should be double)\n                    useElement.style.transform = `scaleX(${1 + shadow.spread / width}) scaleY(${1 + shadow.spread / height})`;\n                });\n            }\n\n        }\n    }\n\n    /**\n     * Make svg more performant by using overflow: clip when possible\n     */\n    private _setSvgOverflow(): void {\n\n        const type = this._shadowType;\n        const border = this._border?.thickness;\n\n        const clip = (type === SvgShadowType.None && !border) || type === SvgShadowType.SvgShadow;\n\n        // Clip is not supported in all browsers so fallback on visible\n        this._svgElement.style.overflow = clip? 'clip' : 'visible';\n    }\n\n    private _getSvgImagePosition(element: IImageViewElement, imageSettings: IImageSettings, imageAsset?: IImageAsset, isFeeded?: boolean, isCropped?: boolean): IPosition {\n\n        let x = 0;\n        let y = 0;\n\n        if (!isFeeded && !isCropped && imageAsset?.width && imageAsset?.height) {\n\n            // Image size on canvas including the hidden/overflow areas\n            const renderedImageSize = { ...aspectRatioScale(imageAsset as ISize, element, 'cover'), x: 0, y: 0 };\n\n            const overflowX = renderedImageSize.width - element.width;\n            const overflowY = renderedImageSize.height - element.height;\n\n            // Note: Note that these values are x2 larger than rendered in the svg due to hack needed\n            if (overflowX > 0) {\n                // fitPositionX = -1 meeans that we move the image 0.5px left\n                x = Math.round((1 - imageSettings.x * 2) * overflowX);\n\n            }\n            if (overflowY > 0) {\n                // fitPositionY = -1 meeans that we move the image 0.5px up\n                y = Math.round((1 - imageSettings.y * 2) * overflowY);\n            }\n        }\n\n        return { x, y };\n    }\n\n    private _getShadowOverflow(): number {\n\n        // Only svg shadows need overflow\n        if (this._getShadowType() !== SvgShadowType.SvgShadow) {\n            return 0;\n        }\n\n        const shadows = this._getAllShadowsFromDataElement();\n        const borderOverflow = this._element.border?.thickness || 0;\n        const shadowOverflow = shadows.reduce((max, s) => {\n            const offset = Math.max(Math.abs(s.offsetX), Math.abs(s.offsetY));\n            return Math.max(max, offset + s.blur * 2 + s.spread);\n        }, 0);\n        return borderOverflow + shadowOverflow;\n    }\n\n    private _getShadowType(): SvgShadowType {\n        const data = this._data;\n        const shadows = this._getAllShadowsFromDataElement();\n        if (shadows.length && data) {\n            const hasSpread = shadows.some(s => s.spread > 0);\n\n            // We can use css filter as long the shadow doesn't have spread\n            if (!hasSpread) {\n                return SvgShadowType.DropShadow;\n            }\n\n            // FF can't animate shadows without cropping them\n            if (isFirefox && shadows.length > 1) {\n                return SvgShadowType.DropShadow;\n            }\n\n            // Uncomment this to start using box shadows\n            // const { states, kind } = data;\n            // const fills = [ data.fill, ...states.map(s => s.fill) ].filter(f => typeof f !== 'undefined');\n            // const transparent = fills.length === 0 || fills.some(fill => fill?.isTransparent());\n\n            // // No or transparent background color\n            // if (transparent) {\n\n            //     // Solid images can have box-shadow\n            //     if (kind === NodeKind.Image && !this._isTransparentImage() && data.fitOption !== 'contain') {\n            //         return SvgShadowType.BoxShadow;\n            //     }\n            // }\n            // else {\n\n            //     // Ellipse doesn't use same border radius as dropshadow\n            //     if (kind !== NodeKind.Ellipse) {\n\n            //         return SvgShadowType.BoxShadow;\n            //     }\n            // }\n            return SvgShadowType.SvgShadow;\n        }\n\n        return SvgShadowType.None;\n    }\n\n    private _getAllShadowsFromDataElement(): IShadow<IColor>[] {\n        const data = this._data;\n        if (data) {\n            return [\n                ...data.states.map(s => s.shadows || []).reduce((acc, curr) => acc.concat(curr), []),\n                ...(data.shadows || [])\n            ];\n        }\n        return [];\n    }\n\n    // Uncomment if you want box shadow\n    // private _isTransparentImage(): boolean {\n    //     const url = ImageOptimizerUrlBuilder.getOriginalUrl(this._url);\n    //     const format = getImageExtension(url);\n\n    //     // Note: GIF might be transparent but it's highly unusual since it doesn't support alpha channels\n    //     if (!format || format === 'jpeg' || format === 'gif') {\n    //         return false;\n    //     }\n    //     return true;\n    // }\n}\n\nfunction setPosition(element: SVGElement, x: number, y: number, unit: '' | '%' | 'px' = 'px'): void {\n    const xString = x + unit;\n    const yString = y + unit;\n    if (element.getAttribute('x') !== xString) {\n        element.setAttribute('x', xString);\n    }\n    if (element.getAttribute('y') !== yString) {\n        element.setAttribute('y', yString);\n    }\n}\n\nexport function createSVGLoaderImage(size: ISize): SVGGElement {\n\n    const svgNamespace = 'http://www.w3.org/2000/svg';\n\n    const wrapperGroup = document.createElementNS(svgNamespace, 'g');\n\n    const circleGroup = document.createElementNS(svgNamespace, 'g');\n    circleGroup.setAttribute('transform', `translate(${(size.width / 2) - 12}, ${(size.height / 2) - 12})`);\n    circleGroup.setAttribute('stroke', '#ffffff');\n    circleGroup.setAttribute('stroke-width', '2');\n    circleGroup.setAttribute('fill', 'none');\n\n    const circleElement = document.createElementNS(svgNamespace, 'circle');\n    circleElement.setAttribute('stroke-opacity', '0.25');\n    circleElement.setAttribute('cx', '12');\n    circleElement.setAttribute('cy', '12');\n    circleElement.setAttribute('r', '12');\n\n    const pathElement = document.createElementNS(svgNamespace, 'path');\n    pathElement.setAttribute('d', 'M24 12c0-9.94-8.06-12-12-12');\n\n    const animateTransform = document.createElementNS(svgNamespace, 'animateTransform');\n    animateTransform.setAttribute('attributeName', 'transform');\n    animateTransform.setAttribute('type', 'rotate');\n    animateTransform.setAttribute('from', '0 12 12');\n    animateTransform.setAttribute('to', '360 12 12');\n    animateTransform.setAttribute('dur', '1s');\n    animateTransform.setAttribute('repeatCount', 'indefinite');\n\n    pathElement.appendChild(animateTransform);\n\n    circleGroup.appendChild(circleElement);\n    circleGroup.appendChild(pathElement);\n\n    const backgroundElement = document.createElementNS(svgNamespace, 'rect');\n    backgroundElement.setAttribute('width', `${size.width}`);\n    backgroundElement.setAttribute('height', `${size.height}`);\n    backgroundElement.setAttribute('fill', 'rgba(0,0,0,0.25)');\n\n    wrapperGroup.appendChild(backgroundElement);\n    wrapperGroup.appendChild(circleGroup);\n\n    return wrapperGroup;\n}\n\nenum SvgShadowType {\n    None,\n    DropShadow,\n    BoxShadow,\n    SvgShadow\n}\n","\n\n/**\n * Insert element after another element in DOM\n * @param afterNode\n * @param newNode\n */\nexport function insertAfter(afterNode: HTMLElement | SVGElement, newNode: HTMLElement | SVGElement): void {\n    if (afterNode.parentNode) {\n        afterNode.parentNode.insertBefore(newNode, afterNode.nextSibling);\n    }\n}\n\n/**\n * Get the topmost window we're allowed access to\n */\nexport function getTopSafeFrame(): Window {\n    let w = (window as Window);\n\n    // As long as a parent exists\n    while (w.parent && w !== w.parent) {\n        try {\n            w.parent.location.href;\n            if (!w.parent.document) {\n                break;\n            }\n            w = w.parent;\n        }\n        catch (e) {\n            break;\n        }\n    }\n    return w;\n}\n\n/**\n * If we have access to top window, return it.\n */\nexport function accessTopWindow(): Window | undefined {\n    let topWindow;\n\n    // Check if top window is accessible\n    try {\n        // Break if access to document is forbidden (throws an error)\n        const readyState = window.top?.document.readyState;\n        topWindow = readyState ? window.top : undefined;\n    // eslint-disable-next-line no-empty\n    } catch (e) { }\n\n    return topWindow;\n}\n\nexport function isIframe(w: Window = window): boolean {\n    try {\n        return w.self !== window.top;\n    } catch (e) {\n        return true;\n    }\n}\n","import { NodeKind, IWidgetElementDataNode, IButtonElementDataNode, ITextElementDataNode, OneOfElementDataNodes, IImageElementDataNode, IEllipseElementDataNode, IRectangleElementDataNode, IVideoElementDataNode, OneOfDataNodes } from '@studio/domain';\nimport { CreativeDataNode } from './nodes/creative-data-node';\nimport { isHidden, isTextNode, } from './nodes/helpers';\n\nexport interface INodeVisitor {\n    visitCreative_m(creative: CreativeDataNode): void;\n    visitRectangle_m(rect: IRectangleElementDataNode): void;\n    visitEllipse_m(ellipse: IEllipseElementDataNode): void;\n    visitImage_m(image: IImageElementDataNode): void;\n    visitButton_m(text: IButtonElementDataNode): void;\n    visitText_m(text: ITextElementDataNode): void;\n    visitWidget_m(text: IWidgetElementDataNode): void;\n    visitVideo_m(text: IVideoElementDataNode): void;\n}\n\nexport function visitOneNode(node: OneOfElementDataNodes | CreativeDataNode, visitor: INodeVisitor): void {\n    switch (node.kind) {\n        case NodeKind.Creative:\n            visitor.visitCreative_m(node);\n            break;\n        case NodeKind.Rectangle:\n            visitor.visitRectangle_m(node);\n            break;\n        case NodeKind.Ellipse:\n            visitor.visitEllipse_m(node);\n            break;\n        case NodeKind.Image:\n            visitor.visitImage_m(node);\n            break;\n        case NodeKind.Text:\n            visitor.visitText_m(node);\n            break;\n        case NodeKind.Button:\n            visitor.visitButton_m(node);\n            break;\n        case NodeKind.Widget:\n            visitor.visitWidget_m(node);\n            break;\n        case NodeKind.Video:\n            visitor.visitVideo_m(node);\n            break;\n    }\n}\n\nexport function visitAllNodes(node: OneOfDataNodes | CreativeDataNode, visitor: INodeVisitor, visitOnlyTextLikeNodes: boolean = false): void {\n    switch (node.kind) {\n        case NodeKind.Creative:\n            visitor.visitCreative_m(node);\n            visitAllChildren(node.nodes, visitor, visitOnlyTextLikeNodes);\n            break;\n        case NodeKind.Group:\n            visitAllChildren(node.nodes, visitor, visitOnlyTextLikeNodes);\n            break;\n        default:\n            if (!visitOnlyTextLikeNodes || isTextNode(node)) {\n                visitOneNode(node, visitor);\n            }\n    }\n}\n\nexport function visitAllChildren(children: OneOfDataNodes[], visitor: INodeVisitor, visitOnlyTextLikeNodes: boolean = false): void {\n    for (const child of children) {\n       if (!isHidden(child)) {\n            visitAllNodes(child, visitor, visitOnlyTextLikeNodes);\n      }\n    }\n}\n\n","/// <reference path=\"./global.d.ts\"/>\n\nimport { IAd } from '@ad/domain/ad';\nimport { isIpad, isSafari, preciseIOSVersion } from '@ad/utils/browser';\nimport { getOriginalUrl, ICroppingOptions, ImageOptimizerUrlBuilder } from '@ad/utils/image-optimizer';\nimport { isBase64, isUrl } from '@ad/utils/url';\nimport { NgZone } from '@angular/core';\nimport { ResizeObserverCallback } from '@juggle/resize-observer/lib/ResizeObserverCallback';\nimport { ResizeObserverOptions } from '@juggle/resize-observer/lib/ResizeObserverOptions';\nimport { ActionOperationMethod, ActionTrigger, AppearenceStyles, FILTER_MAP, IAction, IActionOperation, IButtonElementDataNode, IButtonViewElement, ICollection, ICreativeViewNode, IElement, IElementDataNode, IEllipseElementDataNode, IEllipseViewElement, IFontFamily, IFontStyle, IImageElementDataNode, IImageViewElement, INodeId, IPosition, IRectangleElementDataNode, IRectangleViewElement, ISize, IState, IText, ITextElementDataNode, ITextViewElement, IVersion, IVideoElementDataNode, IVideoViewElement, IWidgetElementDataNode, IWidgetViewElement, MouseOrTouchEvent, NodeKind, OneOfDataNodes, OneOfElementDataNodes, OneOfTextDataNodes, OneOfTextElementPropertyKeys, OneOfTextViewElements, OneOfViewNodes, SpanType, textProperties } from '@studio/domain';\nimport { Matrix } from '@studio/utils/matrix';\nimport { Container, DIContainer, inject } from '../utils/di';\nimport { injectFontFace, isElementDescendantOfElement } from '../utils/dom-utils';\nimport { handleError } from '../utils/errors';\nimport { EventEmitter } from '../utils/event-emitter';\nimport { sanitizeUrl } from '../utils/sanitizer';\nimport { deepEqual, getObjectDifference, pick } from '../utils/utils';\nimport { IActionHandler, isCancelTrigger, registerActionEventHandlers } from './actions/actions.utils';\nimport { isElementVisibleAtTime, isTimeAt } from './animation.utils';\nimport { AnimatorLite } from './animator-lite';\nimport { IRichTextFactory, IVideoRendererFactory, T } from './creative.container';\nimport { ICSSProperties } from './css-styles';\nimport { IFeedStore } from './elements/feed/feed-store.header';\nimport { IRichTextRenderOption } from './elements/rich-text/rich-text';\nimport { isContentSpan } from './elements/rich-text/text-nodes';\nimport { WidgetEvent } from './elements/widget/events';\nimport { IWidgetRenderer } from './elements/widget/widget-renderer.header';\nimport { ICreativeEnvironment } from './environment';\nimport { CreativeDataNode } from './nodes/creative-data-node';\nimport { createViewElement, forEachDataElement, forEachElement, isGroupDataNode, isHidden, isImageNode, isTextNode, isVideoNode, isWidgetNode, resetNodeCid } from './nodes/helpers';\nimport { IAdditionalState, ICachedCssStyles, IPositionStyle, IRenderer, ISizeStyle } from './renderer.header';\nimport { animationsToState, getShadowPropertyValue, getViewElementProperty } from './rendering/states.utils';\nimport { SVGBackground } from './svg-background';\nimport { INodeVisitor, visitAllChildren, visitAllNodes, visitOneNode } from './visitor';\n\nlet instanceCounter = 0;\n\ndeclare class ResizeObserver {\n    constructor(callback: ResizeObserverCallback);\n    observe(target: Element, options?: ResizeObserverOptions): void;\n    unobserve(target: Element): void;\n    disconnect(): void;\n}\n\ntype RendererEvents =\n    'textElementInteractionsStarted'\n    | 'textElementInteractionsEnded'\n    | 'click'\n    | 'destroy';\n\nexport interface IRendererOption {\n    ngZone?: NgZone;\n    contentWindow?: Window;\n    canvasSize?: ISize;\n    elements?: ICollection<IElement>;\n    versions?: ICollection<IVersion>;\n    currentVersionId?: string;\n    inDesignView?: boolean;\n    fontFamilies?: ICollection<IFontFamily>;\n    zoom?: number;\n    brandId?: string;\n}\n\nexport class Renderer extends EventEmitter<RendererEvents> implements IRenderer, INodeVisitor {\n    private viewTree: ICreativeViewNode;\n\n    get canvasSize_m(): ISize {\n        return { width: this.viewTree.width, height: this.viewTree.height };\n    }\n\n    private get creativeSize(): ISize {\n        return { width: this.creativeDocument.width, height: this.creativeDocument.height };\n    }\n\n    get isEditorMode(): boolean {\n        return !window.bfstudio?.inPreviewMode && this.env_m.STUDIO_JS;\n    }\n\n    styleRules_m = new Map<string, {\n        /**\n         * Keep track of previous and current values both\n         * the raw and actual CSSStyleRule as css values get trimmed when\n         * applied in some cases (e.g transform matrices)\n         */\n        previous: ICachedCssStyles,\n        current: ICachedCssStyles\n    }>();\n    rootElement: HTMLDivElement;\n    time_m = 0;\n    loop = 1;\n    storedViewElements = new Map<string, OneOfViewNodes>();\n    destroyed_m = false;\n    shouldRerender_m: boolean;\n    private _isPlaying: boolean;\n\n    private _window: Window;\n    private static _scopeIndex = 0;\n    private _scopeId: string;\n    private _styleSheet: CSSStyleSheet;\n    private _browserDocument: Document;\n    private _htmlElements = new Map<string, HTMLElement>();\n    private _fragment: DocumentFragment;\n    private _styleElement?: HTMLStyleElement;\n    private _mountPoint: HTMLElement;\n    private _inDesignView: boolean;\n    private _onlyRenderTextWithoutFontLoad: boolean;\n    private _toggledStatesMap = new Map<string, IAdditionalState[]>();\n    private _isTouchEvent_m?: boolean;\n    private _preventNextClickThrough_m = false;\n    private _imageDebounceTimeouts = this.env_m.STUDIO_JS ? new Map<string, number>() : undefined;\n    preloadingElements = new Map<string, Promise<any>>();\n    elements_m?: ICollection<IElement>;\n    versions_m?: ICollection<IVersion>;\n    get creativeDocument(): CreativeDataNode {\n        return this._creativeDocument;\n    }\n    private _creativeDocument: CreativeDataNode;\n\n    private logger?: { [key: string]: any } = window['logger'] && window.app === 'bannerflow'\n        ? new window['logger']('Renderer' + instanceCounter++)\n        : undefined;\n\n    private _scale = 1;\n    private _resizeObserver?: ResizeObserver;\n\n    constructor(\n        @DIContainer() private container: Container<T>,\n        @inject(T.CREATIVE_DATA) creativeDocument: CreativeDataNode,\n        option: IRendererOption = {},\n        @inject(T.ENVIRONMENT) public env_m: ICreativeEnvironment,\n        @inject(T.FEED_STORE) public feedStore?: IFeedStore,\n        @inject(T.WIDGET_RENDERER) public WidgetRenderer?: IWidgetRenderer,\n        @inject(T.AD) public ad?: IAd) {\n        super();\n        this.setCreativeDocument(creativeDocument);\n        this.elements_m = option.elements;\n        this.versions_m = option.versions;\n        this._inDesignView = option.inDesignView || false;\n        this._window = option.contentWindow || window;\n        this._browserDocument = this._window.document;\n        this._styleElement = this._browserDocument.createElement('style');\n        this._browserDocument.head!.appendChild(this._styleElement);\n        this._styleSheet = this._styleElement.sheet as CSSStyleSheet;\n        this._fragment = this._browserDocument.createDocumentFragment();\n\n        this._resetViewTree();\n\n        if (this.env_m.STUDIO_JS && this.feedStore) {\n            this.feedStore.on('dataChanged', this.updateViewElementValues);\n        }\n    }\n\n    getNodeIndex_m(node: INodeId): number {\n        return this.creativeDocument.elements.findIndex(e => e.id === node.id);\n    }\n\n    setCreativeDocument(creativeDocument: CreativeDataNode): void {\n        this._creativeDocument = creativeDocument;\n    }\n\n    setPlaying_m(isPlaying: boolean): void {\n        this._isPlaying = isPlaying;\n    }\n\n    getViewElementById<T extends OneOfViewNodes>(id: string): Readonly<T | undefined> {\n        return this.viewTree.nodes.find(element => element.id === id) as T | undefined;\n    }\n\n    visitCreative_m(creative: CreativeDataNode): void {\n        const inDV = this.env_m.STUDIO_JS === true;\n        this._scopeId = `b${Renderer._scopeIndex}`;\n        this.rootElement = this._browserDocument.createElement('div');\n        this.rootElement.setAttribute('data-banner', ''); // TODO: Remove this after image renderer is updated\n        this.rootElement.setAttribute('data-creative', '');\n        this._htmlElements.set(this._scopeId, this.rootElement);\n        this._scaleViewTree(creative);\n        this.viewTree.fill = creative.fill;\n        this.viewTree.border = creative.border;\n        this.viewTree.__rootElement = this.rootElement;\n\n        this.insertStyle_m(this._scopeId, {\n            width: '100%',\n            height: '100%',\n            boxSizing: 'border-box',\n            position: 'relative',\n            overflow: !inDV ? 'clip' : 'visible',\n            fontFamily: 'Helvetica, Arial, Tahoma, \"Microsoft Yahei\", 微软雅黑, STXihei, 华文细黑, sans-serif',\n            '-webkit-font-smoothing': 'antialiased',\n            '-moz-osx-font-smoothing': 'grayscale'\n        });\n\n        this.setBackgroundElement_m(this.viewTree);\n        this._fragment.appendChild(this.rootElement);\n        Renderer._scopeIndex++;\n        this.rootElement.addEventListener('mousemove', this._onCreativeMouseMove);\n    }\n\n    /**\n     * Ugly workaround for mouseenter/mouseleave on text elements for actions.\n     * Events propagate in nasty ways causing mousenter to get\n     * stuck on random occasions so we have to \"manually\" trigger\n     * mouseleave event if the element no longer is being hovered\n     */\n    private _onCreativeMouseMove = (e: MouseEvent): void => {\n        if (this.isEditorMode) {\n            return;\n        }\n\n        forEachElement(this.viewTree, element => {\n            if (!element.__actionListeners) {\n                return;\n            }\n\n            for (const actionListener of element.__actionListeners) {\n                if (actionListener.trigger !== ActionTrigger.MouseLeave) {\n                    continue;\n                }\n\n                const actionStateEnabled = this.getAdditionalStates_m(element.__data)\n                    .find(additionalState =>\n                        actionListener.action.operations\n                            .find(op => op.value === additionalState.state.id));\n\n                if (actionStateEnabled && !actionStateEnabled?.animation?.isPlaying && !isElementDescendantOfElement(element.__rootElement!, e.target)) {\n                    actionListener.event(e, true);\n                }\n            }\n        });\n    };\n\n    visitRectangle_m(rectangle: IRectangleElementDataNode): IRectangleViewElement {\n        const viewElement = this._createViewElementFromDataElement<IRectangleViewElement>(rectangle);\n\n        this._createClickListener(viewElement);\n\n        return viewElement;\n    }\n\n    visitEllipse_m(ellipse: IEllipseElementDataNode): IEllipseViewElement {\n        const viewElement = this._createViewElementFromDataElement<IEllipseViewElement>(ellipse);\n\n        this._createClickListener(viewElement);\n\n        return viewElement;\n    }\n\n    visitText_m(text: ITextElementDataNode): ITextViewElement {\n        return this.visitTextNode_m(text) as ITextViewElement;\n    }\n\n    visitButton_m(button: IButtonElementDataNode): IButtonViewElement {\n        return this.visitTextNode_m(button) as IButtonViewElement;\n    }\n\n    visitTextNode_m(text: OneOfTextDataNodes): OneOfTextViewElements {\n        const viewElement = this._createViewElementFromDataElement<OneOfTextViewElements>(text);\n        viewElement.__rootElement!.classList.add('text');\n\n        this.insertStyle_m(viewElement.elementCid!, this.getDefaultStyle_m(viewElement));\n\n        if (this.env_m.STUDIO_JS) {\n            if (text.font) {\n                for (const [_, style] of text.characterStyles.entries()) {\n                    if (style.font) {\n                        this.injectFontFace(style.font);\n                    }\n                }\n                this.injectFontFace(text.font);\n            }\n        }\n\n        if (!(self as any).inServer) {\n            this._renderText(viewElement);\n        }\n\n        return viewElement;\n    }\n\n    visitImage_m(image: IImageElementDataNode): IImageViewElement {\n        const viewElement = this._createViewElementFromDataElement<IImageViewElement>(image);\n        this._createClickListenerWithFeed(image, viewElement);\n\n        return viewElement;\n    }\n\n    visitWidget_m(widgetDataElement: IWidgetElementDataNode): IWidgetViewElement {\n        const viewElement = this._createViewElementFromDataElement<IWidgetViewElement>(widgetDataElement);\n\n        const creativeElement = viewElement.__rootElement!.parentNode;\n\n        if (creativeElement) {\n            if (!creativeElement.querySelector(`#widget-${widgetDataElement.id}`)) {\n                this.WidgetRenderer!.createWidget(viewElement, widgetDataElement);\n            }\n        }\n\n        return viewElement;\n    }\n\n    visitVideo_m(videoDataElement: IVideoElementDataNode, skipVideoRenderer?: boolean): IVideoViewElement {\n        const viewElement = this._createViewElementFromDataElement<IVideoViewElement>(videoDataElement);\n\n        if (skipVideoRenderer) {\n            return viewElement;\n        }\n\n        this._createClickListenerWithFeed(videoDataElement, viewElement);\n\n        const createVideoRenderer = this.container.resolve<IVideoRendererFactory>(T.VIDEO_RENDERER_FACTORY);\n        viewElement.__videoRenderer = createVideoRenderer(viewElement);\n\n        return viewElement;\n    }\n\n    private _createClickListenerWithFeed(element: OneOfElementDataNodes, viewElement: OneOfViewNodes): void {\n        const onClick = (event: MouseEvent): void => {\n            let deepLinkUrl: string | undefined = '';\n            if (element.feed && this.feedStore) {\n                deepLinkUrl = this.feedStore.getFeedValue(element.feed, element.id).targetUrl;\n            }\n            this._onClick(event, deepLinkUrl, viewElement);\n        };\n\n        this.on('destroy', () => {\n            if (viewElement.__rootElement) {\n                viewElement.__rootElement.removeEventListener('click', onClick);\n            }\n        });\n\n        viewElement.__rootElement!.addEventListener('click', onClick);\n    }\n\n    private _createClickListener(viewElement: OneOfViewNodes): void {\n        const onElementClick = (event: MouseEvent): void => {\n            if (this.isEditorMode) {\n                return;\n            }\n            this._onClick(event, undefined, viewElement);\n        };\n        viewElement.__rootElement!.addEventListener('click', onElementClick);\n        this.on('destroy', () => viewElement.__rootElement!.removeEventListener('click', onElementClick));\n    }\n\n    private _triggerClickActions(event: MouseOrTouchEvent, viewElement: OneOfViewNodes): boolean {\n        const actionListeners = viewElement.__actionListeners\n            ?.filter(al =>\n                al.trigger === ActionTrigger.Click\n                && !al.action.disabled\n            ) || [];\n\n        if (actionListeners.length) {\n            for (const listener of actionListeners) {\n                if (listener.action.operations.some(op => op.method === ActionOperationMethod.OpenUrl)) {\n                    listener.event(event);\n                    break;\n                }\n                listener.event(event);\n            }\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n\n    private _onClick = (event: MouseOrTouchEvent, deepLinkUrl?: string, viewElement?: OneOfViewNodes): void => {\n        if (this.isEditorMode) {\n            return;\n        }\n        if (this._preventNextClickThrough_m) {\n            event.stopPropagation();\n            this._preventNextClickThrough_m = false;\n            return;\n        }\n\n        /**\n         * Check if the element clicked on has any click actions and trigger those.\n         * The triggered action will loop back here without a viewElement to\n         * continue with the clickthrough\n         */\n        if (viewElement) {\n            const isClickAction = this._triggerClickActions(event, viewElement);\n            if (isClickAction) {\n                return;\n            }\n        }\n\n        if (!this.env_m.STUDIO_JS) {\n            event.stopPropagation();\n        }\n        this.emit('click', [event, deepLinkUrl]);\n    };\n\n    setBackgroundElement_m(node: OneOfViewNodes | ICreativeViewNode, overrides?: AppearenceStyles): void {\n        if (!node.__svgBackground) {\n            node.__svgBackground = new SVGBackground(this._window, node, this.env_m);\n        }\n\n        const svg = node.__svgBackground;\n\n        const promise = svg.render_m(node, overrides);\n\n        if (promise && (isImageNode(node) || isVideoNode(node))) {\n            const id = node.id;\n\n            if (!this.preloadingElements.has(id)) {\n                this.logger?.verbose('[SvgBackground] adding image to preload:', id);\n                this.preloadingElements.set(id, promise);\n            }\n        }\n    }\n\n    setCreativeStyle<Key extends keyof CreativeDataNode, Property = CreativeDataNode[Key]>(styleKey: Key, styleProperty: Property): void {\n        Object.assign(this.creativeDocument, { [styleKey]: styleProperty });\n        Object.assign(this.viewTree, { [styleKey]: styleProperty });\n\n        this.setBackgroundElement_m(this.viewTree);\n    }\n\n    private _getImageUrl(element: IImageElementDataNode): string | undefined {\n        const feed = element.feed;\n        const viewElement = this.storedViewElements.get(element.id) as IImageViewElement;\n        const feedValue = feed && this.feedStore!.getFeedValue(feed, element.id, element)?.value;\n        const imageAsset = element.imageAsset;\n        const feedUrl = typeof feedValue === 'string' ? sanitizeUrl(feedValue) : undefined;\n        const inDV = this.env_m.DESIGN_VIEW && this.isEditorMode;\n        const inMV = !this.env_m.DESIGN_VIEW && this.env_m.STUDIO_JS; // is there a better MV detection?\n        const id = element.id;\n        const url = feedUrl || imageAsset?.url;\n\n        // DV contains base64 images while upload is ongoing, can't be optimized\n        if (isBase64(url)) {\n            return url;\n        }\n\n        // Note that the base64 check must be BEFORE this to not cause performance issues with regex\n        if (!isUrl(url)) {\n            return '';\n        }\n\n        // This is a feeded image but no feed value is available this \"loop\"\n        if (feed && !feedUrl) {\n            return '';\n        }\n\n        // Debounce optimization in DV if a URL already is set\n        if ((inDV || inMV) && id && this._imageDebounceTimeouts) {\n            const timeout = this._imageDebounceTimeouts.get(id);\n\n            // Clear old timeout to achieve \"debounce\"\n            if (timeout) {\n                window.clearTimeout(timeout);\n            }\n\n\n            // Only debounce if URL haven't changed (hence size change)\n            if (getOriginalUrl(viewElement.imageUrl) === url) {\n                this._imageDebounceTimeouts.set(id, window.setTimeout(() => {\n                    this._debouncedGetImageUrl(element);\n                }, 1000));\n\n                // Use current url meanwhile\n                return viewElement.imageUrl;\n            }\n        }\n        // Don't calculate new image sizes every tick if not needed since it's expensive\n        else if (getOriginalUrl(viewElement.imageUrl) === url) {\n            return viewElement.imageUrl;\n        }\n\n        const sizeLimit = {\n            width: this.creativeDocument.width * this._scale * 2,\n            height: this.creativeDocument.height * this._scale * 2,\n        };\n\n\n        let cropping: ICroppingOptions | undefined;\n        // in DV we do load the image uncropped, as is\n        if (!inDV) {\n            cropping = ImageOptimizerUrlBuilder.getCroppingOptions(element);\n        }\n\n        return ImageOptimizerUrlBuilder.getUrlByElement_m(element, { feedUrl, force: inDV, sizeLimit, cropping });\n    }\n\n    /**\n     * Update url when this function has not been called in X ms\n     */\n    private _debouncedGetImageUrl(element: IImageElementDataNode): void {\n        if (!this.destroyed_m) {\n            const viewElement = this.storedViewElements.get(element.id) as IImageViewElement;\n            // Remove url to trigger prevent debounce in this._getImageUrl\n            viewElement.imageUrl = undefined;\n            viewElement.imageUrl = this._getImageUrl(element);\n\n            // Update in DOM\n            this.setBackgroundElement_m(viewElement);\n        }\n    }\n\n    /**\n     * Show a state fully without animating it. Used mainly for preview on canvas\n     * @param element\n     * @param state\n     * @param rate value between 0 and 1\n     */\n    addAdditionalState_m(element: OneOfElementDataNodes, state: IState, rate: number): IAdditionalState {\n        const timeStates = this.getAdditionalStates_m(element);\n        let timeState = this._getAdditionalState(element, state);\n\n        if (!timeState) {\n            timeState = { state, rate };\n            timeStates.push(timeState);\n        }\n        else {\n            timeState.rate = rate;\n        }\n\n        this._toggledStatesMap.set(element.id, timeStates);\n\n        return timeState;\n    }\n\n    private _getAdditionalState(element: OneOfElementDataNodes, state: IState): IAdditionalState | undefined {\n        const timeStates = this.getAdditionalStates_m(element);\n        return timeStates.find(s => state === s.state);\n    }\n\n    getAdditionalStates_m(element: OneOfElementDataNodes): IAdditionalState[] {\n        return this._toggledStatesMap.get(element.id) || [];\n    }\n\n    clearAdditionalStates_m(): void {\n        this._toggledStatesMap.forEach((_, elementId) => {\n            const element = this._getDataElementById(elementId);\n            if (element) {\n                this.removeAdditionalStates_m(element);\n            }\n        });\n    }\n\n    removeAdditionalState_m(element: OneOfElementDataNodes, state: IState): void {\n        const stateMap = this._toggledStatesMap.get(element.id);\n        const activeStates = stateMap?.filter(s => s.state.id !== state.id) || [];\n        this._toggledStatesMap.delete(element.id);\n        this._toggledStatesMap.set(element.id, activeStates);\n    }\n\n    removeAdditionalStates_m(element: OneOfElementDataNodes, renderElement: boolean = true): void {\n        const states = this.getAdditionalStates_m(element);\n        this._toggledStatesMap.delete(element.id);\n        if (states.length) {\n            states.forEach(state => state.animation?.pause());\n            if (renderElement) {\n                this.renderElement_m(element);\n            }\n        }\n    }\n\n    private _renderText(textElement: OneOfTextViewElements): void {\n        let richTextRenderer = textElement.__richTextRenderer;\n        const textDataElement = textElement.__data;\n\n        if (richTextRenderer) {\n            richTextRenderer.rerender();\n            return;\n        }\n\n        const options: IRichTextRenderOption = {\n            feedStore: this.feedStore!,\n            element: textDataElement,\n            viewElement: textElement,\n            skipFontLoad: this._onlyRenderTextWithoutFontLoad,\n            document: this.creativeDocument,\n            inDesignView: this._inDesignView,\n        };\n        const text: IText = {\n            spans: textDataElement.__dirtyContent?.spans || textDataElement.content.spans, style: pick(Object.assign(textElement, textDataElement.__dirtyContent?.style || {}),\n                'width',\n                'height',\n                ...textProperties\n            )\n        };\n        const createRichText = this.container.resolve<IRichTextFactory>(T.RICH_TEXT_FACTORY);\n        richTextRenderer = textElement.__richTextRenderer = createRichText(text, textElement.__rootElement!, options);\n        richTextRenderer.init_m();\n\n        const onElementInteractionsStarted = (): void => {\n            this.emit('textElementInteractionsStarted', [richTextRenderer]);\n        };\n        const onElementInteractionsEnded = (): void => {\n            this.emit('textElementInteractionsEnded', [richTextRenderer]);\n        };\n        const onElementDestroyed = (): void => {\n            richTextRenderer.off('interactionsStarted', onElementInteractionsStarted);\n            richTextRenderer.off('interactionsEnded', onElementInteractionsEnded);\n            richTextRenderer.off('destroyed', onElementDestroyed);\n        };\n\n        const onSpanClicked = (event: MouseEvent, deepLinkUrl?: string): void => {\n            this._onClick(event, deepLinkUrl);\n        };\n\n        const onTextClick = (event: MouseEvent): void => {\n            let deepLinkUrl: string | undefined = '';\n            try {\n                if (this.feedStore) {\n                    for (const span of textElement.__richTextRenderer.text_m.spans) {\n                        if (isContentSpan(span) && span.style.variable) {\n                            const feedValue = this.feedStore.getFeedValue(span.style.variable, span.style.variable.spanId!);\n                            deepLinkUrl = feedValue.targetUrl;\n                            break;\n                        }\n                    }\n                }\n                // eslint-disable-next-line no-empty\n            } catch (e) { }\n            this._onClick(event, deepLinkUrl, textElement);\n        };\n\n        textElement.__rootElement!.addEventListener('click', onTextClick);\n\n        this.on('destroy', () => {\n            if (textElement.__rootElement) {\n                textElement.__rootElement!.removeEventListener('click', onTextClick);\n            }\n        });\n\n        // Try to remove listeners, renderText is triggered by undo/redo\n        richTextRenderer.off('interactionsStarted', onElementInteractionsStarted);\n        richTextRenderer.off('interactionsEnded', onElementInteractionsEnded);\n        richTextRenderer.off('destroyed', onElementDestroyed);\n        richTextRenderer.off('spanClicked', onSpanClicked);\n\n        richTextRenderer.on('interactionsStarted', onElementInteractionsStarted);\n        richTextRenderer.on('interactionsEnded', onElementInteractionsEnded);\n        richTextRenderer.on('spanClicked', onSpanClicked);\n        richTextRenderer.on('destroyed', onElementDestroyed);\n    }\n\n    /**\n     * Set view element value without updating DOM\n     * @param element\n     * @param time\n     */\n    setViewElementValues_m(element: OneOfElementDataNodes, time: number, setStyle: boolean = true): void {\n        this.time_m = time;\n        const viewElement = this.storedViewElements.get(element.id)!;\n\n        if (!viewElement) {\n            throw new Error(`Could not find view node`);\n        }\n\n        viewElement.duration = element.duration;\n        viewElement.time = element.time;\n\n        // Always rerender on loop to make sure images/feeded elements doesn't blink\n        const isLoop = time === 0;\n        const additionalAnimationStates = this._toggledStatesMap.get(element.id)?.map(state => state);\n        const isVisible = isElementVisibleAtTime(element, this.time_m) && !this._shouldHideOverlapElement(viewElement);\n\n        // If not in view don't do any calculation and just hide the element.\n        // We can't run this if setStyle === false since that will mess up initialization\n        if (setStyle && !isVisible && !isLoop) {\n            viewElement.opacity = 0;\n            this._renderStyleOnViewElement(viewElement);\n        }\n        else {\n            const animationState = animationsToState(element, this.creativeSize, time, additionalAnimationStates);\n            this._setViewElementValuesWithState(viewElement, element, animationState, setStyle);\n        }\n    }\n\n    private _setViewElementValuesWithState(viewElement: OneOfViewNodes, element: OneOfElementDataNodes, state: IState, setStyle: boolean = true): void {\n        this.logger?.debug(`_setViewElementValuesWithState[${element.name}]`);\n\n        const isWidget = isWidgetNode(element);\n\n        viewElement.x = getViewElementProperty('x', element, state, this._scale);\n        viewElement.y = getViewElementProperty('y', element, state, this._scale);\n        viewElement.width = getViewElementProperty('width', element, state, isWidget ? undefined : this._scale);\n        viewElement.height = getViewElementProperty('height', element, state, isWidget ? undefined : this._scale);\n        viewElement.originX = getViewElementProperty('originX', element, state);\n        viewElement.originY = getViewElementProperty('originY', element, state);\n        viewElement.scaleX = getViewElementProperty('scaleX', element, state, isWidget ? this._scale : undefined);\n        viewElement.scaleY = getViewElementProperty('scaleY', element, state, isWidget ? this._scale : undefined);\n        viewElement.rotationX = getViewElementProperty('rotationX', element, state);\n        viewElement.rotationY = getViewElementProperty('rotationY', element, state);\n        viewElement.rotationZ = getViewElementProperty('rotationZ', element, state);\n        viewElement.mirrorX = getViewElementProperty('mirrorX', element, state);\n        viewElement.mirrorY = getViewElementProperty('mirrorY', element, state);\n        viewElement.opacity = getViewElementProperty('opacity', element, state);\n        viewElement.border = getViewElementProperty('border', element, state, this._scale);\n        viewElement.fill = getViewElementProperty('fill', element, state);\n        viewElement.shadows = getViewElementProperty('shadows', element, state, this._scale);\n        viewElement.radius = getViewElementProperty('radius', element, state, this._scale);\n        viewElement.filters = getViewElementProperty('filters', element, state);\n        viewElement.perspective = this._getPerspective(element);\n\n        // Need to adjust x & y to compensate for not scaling width and height\n        if (isWidget && this._scale !== 1) {\n            viewElement.x -= (viewElement.width * (1 - this._scale)) / 2;\n            viewElement.y -= (viewElement.height * (1 - this._scale)) / 2;\n        }\n\n        if (isImageNode(viewElement)) {\n            const imgElement = element as IImageElementDataNode;\n            if (imgElement.feed) {\n                viewElement.feed = getViewElementProperty('feed', imgElement, state);\n                imgElement.imageAsset = undefined;\n            }\n            else if (imgElement.imageAsset) {\n                viewElement.feed = imgElement.feed = undefined;\n            }\n\n            // Use this only\n            viewElement.imageUrl = this._getImageUrl(viewElement.__data);\n        }\n\n        // maps to text prop changes, true if property changed, undefined if not changed\n        const textPropertyChangedMap: { [key in OneOfTextElementPropertyKeys]?: boolean } = {};\n        if ((isTextNode(viewElement))) {\n            const previousProps = {};\n            const dynamicProperties: OneOfTextElementPropertyKeys[] = [\n                'textColor'\n            ];\n            for (const prop of dynamicProperties) {\n                previousProps[prop] = viewElement[prop];\n            }\n\n            // scale all text spans shadows as well - STUDIO-8284\n            viewElement.content.spans.forEach(span => {\n                if (span.type === SpanType.Word\n                    || span.type === SpanType.Composition\n                    || span.type === SpanType.Space\n                    || span.type === SpanType.Variable\n                    || span.type === SpanType.Newline) {\n                    if (span.style.textShadows) {\n                        span.style.textShadows = span.style.textShadows.map(shadow => getShadowPropertyValue('TextShadow[]', shadow, this._scale));\n                    }\n                }\n            });\n\n            viewElement.textColor = getViewElementProperty('textColor', element, state);\n            viewElement.textShadows = getViewElementProperty('textShadows', element, state, this._scale);\n            viewElement.underline = getViewElementProperty('underline', element, state);\n            viewElement.strikethrough = getViewElementProperty('strikethrough', element, state);\n            viewElement.uppercase = getViewElementProperty('uppercase', element, state);\n            viewElement.textOverflow = getViewElementProperty('textOverflow', element, state);\n            viewElement.lineHeight = getViewElementProperty('lineHeight', element, state);\n            viewElement.fontSize = getViewElementProperty('fontSize', element, state, this._scale);\n            viewElement.maxRows = getViewElementProperty('maxRows', element, state);\n            viewElement.padding = getViewElementProperty('padding', element, state, this._scale);\n            viewElement.characterSpacing = getViewElementProperty('characterSpacing', element, state);\n            viewElement.horizontalAlignment = getViewElementProperty('horizontalAlignment', element, state);\n            viewElement.verticalAlignment = getViewElementProperty('verticalAlignment', element, state);\n\n            const dirty = (element as OneOfTextDataNodes).__dirtyContent;\n            const fontSize = dirty?.style.fontSize ?? viewElement.fontSize;\n            const textShadows = dirty?.style.textShadows ?? viewElement.textShadows;\n            const padding = dirty?.style.padding ?? viewElement.padding;\n            viewElement.__richTextRenderer?.setStyle_m('textShadows', textShadows, viewElement.__richTextRenderer.style);\n            viewElement.__richTextRenderer?.setStyle_m('fontSize', fontSize, viewElement.__richTextRenderer.style);\n            viewElement.__richTextRenderer?.setStyle_m('padding', padding, viewElement.__richTextRenderer.style);\n\n            for (const prop of dynamicProperties) {\n                textPropertyChangedMap[prop] = !deepEqual(viewElement[prop], previousProps[prop]);\n            }\n        }\n\n        if (isVideoNode(viewElement) && viewElement.__videoRenderer) {\n            viewElement.__videoRenderer.updateVideo();\n        }\n\n        if (isWidget) {\n            element.__widget?.emit(WidgetEvent.ViewNodeChanged, [viewElement]);\n        }\n\n        if (setStyle) {\n            this.setBackgroundElement_m(viewElement);\n            this._renderStyleOnViewElement(viewElement, textPropertyChangedMap);\n        }\n    }\n\n    private _shouldHideOverlapElement(viewElement: OneOfViewNodes): boolean {\n        const rounding = 0.001;\n        const viewEndTime = viewElement.time + viewElement.duration;\n\n        // Only do this if current time is at end of element\n        if (isTimeAt(viewEndTime, this.time_m, rounding)) {\n            return this.creativeDocument.elements.some(({ time }) => isTimeAt(viewEndTime, time, rounding));\n        }\n        return false;\n    }\n    /**\n     * Update style on DOM with current viewElement values\n     */\n    private _renderStyleOnViewElement(viewElement: OneOfViewNodes, textPropertyChangedMap?: { [key in OneOfTextElementPropertyKeys]?: boolean }): void {\n        const styleRule = this.styleRules_m.get(viewElement.elementCid!);\n\n        if (!styleRule) {\n            throw new Error(`Could not get stylerule for element. ${this.env_m.STUDIO_JS ? 'This is most likely caused by the element no longer existing from an undo/redo.' : ''}`);\n        }\n\n        const {\n            current: currentStyle,\n            previous: previousStyle\n        } = styleRule;\n\n        currentStyle.rawStyleValue = this.getDefaultStyle_m(viewElement);\n\n        const changedStyles = getObjectDifference(previousStyle.rawStyleValue, currentStyle.rawStyleValue);\n\n        const styleProperties = [\n            'pointerEvents',\n            'transform',\n            'width',\n            'height',\n            'opacity',\n            'filter',\n            'visibility'\n        ];\n\n        for (const property of styleProperties) {\n            if (property in changedStyles) {\n                viewElement.__rootElement!.style[property] = changedStyles[property];\n            }\n        }\n\n        // We only want to change backface visibility if it's not undefined\n        if (changedStyles.backfaceVisibility) {\n            previousStyle.styleRule.style.backfaceVisibility = changedStyles.backfaceVisibility;\n        }\n\n        if (isTextNode(viewElement)) {\n            const sizeChanged = typeof changedStyles.width !== 'undefined'\n                || typeof changedStyles.height !== 'undefined';\n\n            let elementIsFeeded = false;\n            const feedStore = viewElement.__richTextRenderer?.feedStore_m;\n\n            if (sizeChanged || (this.shouldRerender_m && feedStore)) {\n                elementIsFeeded = !!feedStore?.elements.get(viewElement.id) ||\n                    !!viewElement.__richTextRenderer.text_m.spans\n                        .find(span => span.type === SpanType.Variable) ||\n                    !!viewElement.__dirtyContent?.spans\n                        .find(span => span.type === SpanType.Variable);\n            }\n\n            if (textPropertyChangedMap?.textColor) {\n                const textColor = viewElement.textColor;\n                viewElement.__richTextRenderer.applyOnlyAnimatedStyleOnElement_m({ textColor });\n            }\n\n            if (elementIsFeeded || sizeChanged) {\n                viewElement.__richTextRenderer.rerender(false, viewElement);\n            }\n        }\n\n        previousStyle.rawStyleValue = currentStyle.rawStyleValue;\n        previousStyle.styleRule = currentStyle.styleRule;\n    }\n\n    setAllViewElementsValues_m(time: number, shouldRerender?: boolean): void {\n        if (this.destroyed_m) {\n            return;\n        }\n\n        if (shouldRerender) {\n            this.shouldRerender_m = shouldRerender;\n        }\n\n        forEachDataElement(this.creativeDocument, element => {\n            if (!isHidden(element)) {\n                this.setViewElementValues_m(element, time);\n            }\n        });\n        this.shouldRerender_m = false;\n    }\n\n    updateCreativeValues(): void {\n        // rescale creative background\n        this.setBackgroundElement_m(this.viewTree);\n    }\n\n    updateViewElementValues = (): void => {\n        this.setAllViewElementsValues_m(this.time_m);\n    };\n\n    renderElement_m(element: OneOfElementDataNodes): void {\n        this.setViewElementValues_m(element, this.time_m);\n    }\n\n    renderElementById_m(id: string): void {\n        const element = this._getDataElementById(id);\n        if (element) {\n            this.renderElement_m(element);\n        }\n    }\n\n    setActions_m(dataElement: OneOfElementDataNodes): void {\n        const viewElement = this.viewTree.nodes.find(el => el.id === dataElement.id)!;\n\n        if (isGroupDataNode(viewElement)) {\n            return;\n        }\n\n        let ActionHandler: IActionHandler = {\n            callback: (event: MouseOrTouchEvent, trigger: ActionTrigger, forceClearStates?: boolean) => {\n\n                if (this.isEditorMode) {\n                    return;\n                }\n\n                /**\n                 * Treat all following events explicitly for touch\n                 * to avoid actions potentially triggering more than once\n                 */\n                if (trigger === ActionTrigger.TouchStart) {\n                    this._isTouchEvent_m = true;\n                }\n\n                /**\n                 * Special check to properly trigger mouseleave\n                 * events for text elements\n                 */\n                if (trigger === ActionTrigger.MouseLeave && !forceClearStates && event.target !== viewElement.__rootElement) {\n                    return;\n                }\n\n                if (this._isTouchEvent_m && trigger.startsWith('mouse')) {\n                    return;\n                }\n\n                const target = event instanceof MouseEvent\n                    ? event.relatedTarget\n                    : event.target;\n\n                if (trigger !== ActionTrigger.MouseLeave && target && !this._browserDocument.body.contains(target as HTMLElement)) {\n                    return;\n                }\n\n                dataElement.actions\n                    .filter(action => action.triggers.find(tr => tr === trigger))\n                    .forEach(action => {\n\n                        if (action.disabled) {\n                            return;\n                        }\n\n                        action.operations.forEach(operation => {\n                            switch (operation.method) {\n                                case ActionOperationMethod.OpenUrl:\n                                    this._onClick(event, operation.value as string);\n                                    break;\n\n                                case ActionOperationMethod.SetState:\n                                case ActionOperationMethod.RemoveState:\n                                case ActionOperationMethod.ClearStates:\n                                    if (action.preventClickThrough) {\n                                        this._preventNextClickThrough_m = true;\n                                    }\n                                    this._setActionState(operation, action, trigger);\n                                    break;\n                            }\n                        });\n\n                    });\n            }\n        };\n\n        ActionHandler = {\n            ...ActionHandler,\n            ...registerActionEventHandlers(ActionHandler)\n        };\n\n        viewElement.__actionListeners = viewElement.__actionListeners || [];\n\n        for (const listener of viewElement.__actionListeners) {\n            // useCapture should be true, since the addEventListener set it to true\n            viewElement.__rootElement!.removeEventListener(listener.trigger, listener.event, true);\n        }\n\n        viewElement.__actionListeners = [];\n\n        for (const action of dataElement.actions) {\n            if (action.disabled) {\n                continue;\n            }\n\n            for (const trigger of action.triggers) {\n                /**\n                 * Clicks has to be handled from onClick\n                 * to avoid event emission race-conditions\n                */\n                if (trigger !== ActionTrigger.Click) {\n                    if (trigger === ActionTrigger.TouchStart) {\n                        viewElement.__rootElement!.addEventListener(trigger, ActionHandler[trigger], { passive: true });\n                    }\n                    else {\n                        viewElement.__rootElement!.addEventListener(trigger, ActionHandler[trigger], true);\n                    }\n                }\n\n                viewElement.__actionListeners.push({\n                    trigger,\n                    event: ActionHandler[trigger],\n                    action\n                });\n            }\n        }\n    }\n\n    private _setActionState(operation: IActionOperation, action: IAction, trigger: ActionTrigger): void {\n        const stateTargetViewElement = this.viewTree.nodes.find(el => el.id === operation.target);\n\n        if (!stateTargetViewElement) {\n            return;\n        }\n\n        const stateTargetDataElement = stateTargetViewElement.__data;\n        const stateId = operation.value;\n\n        if (!stateId && (operation.method === ActionOperationMethod.SetState || operation.method === ActionOperationMethod.RemoveState)) {\n            return;\n        }\n\n        /**\n         * Only trigger the backup MouseLeave if the MouseDown\n         * has happened for pressed states\n         **/\n\n        if (action.templateId === 'reserved-pressed' && isCancelTrigger(trigger)) {\n            const pressedAction = stateTargetDataElement.actions\n                .find(targetAction => targetAction.templateId === 'reserved-pressed' && targetAction.operations.find(ops => ops.value))!;\n\n            const currentTimeState = this.getAdditionalStates_m(stateTargetDataElement).find(timeState => timeState.state.id === pressedAction.operations[0].value);\n\n            if (!currentTimeState || currentTimeState.rate === 0) {\n                return;\n            }\n        }\n\n        const targetState = stateTargetDataElement.states\n            .find(state => state.id === stateId);\n\n        const duration = operation.animation!.duration ?? 0.2;\n        const timingFunction = operation.animation!.timingFunction;\n\n        /**\n         * When the default animator is paused we'll have to rely\n         * on animatorlite's own tick to trigger the\n         * rerenderering of the element\n         */\n        const animatorLiteCallback = (): void => {\n            if (this._isPlaying) {\n                return;\n            }\n            this.setViewElementValues_m(stateTargetDataElement, this.time_m);\n        };\n        const settings = { duration, timingFunction, callback: animatorLiteCallback };\n\n        // Animate in a state\n        if (targetState) {\n            const currentTimeState = this.getAdditionalStates_m(stateTargetDataElement)\n                .find(additionalState =>\n                    additionalState.animation && additionalState.state.id === targetState.id\n                );\n\n            // State is already visible (with rate 0-1)\n            if (currentTimeState) {\n                if (operation.method === ActionOperationMethod.RemoveState) {\n                    this.getAdditionalStates_m(stateTargetDataElement)\n                        .filter(additionalState => targetState === additionalState.state && additionalState.animation)\n                        .forEach(timeState => {\n                            if (timeState?.animation) {\n                                timeState.animation.to({ rate: 0 }, settings);\n                            }\n                        });\n                }\n                else {\n                    currentTimeState.animation!.to({ rate: 1 }, settings);\n                }\n            }\n            // Add and animate in the new state from rate 0\n            else {\n                if (operation.method === ActionOperationMethod.SetState) {\n                    const timeState = this.addAdditionalState_m(stateTargetDataElement, targetState, 0);\n                    timeState.animation = AnimatorLite.to(timeState, { rate: 1 }, settings);\n                    timeState.animation.onCompleted(() => {\n                        if (timeState.rate === 0) {\n                            this.removeAdditionalState_m(stateTargetDataElement, targetState);\n                        }\n                    });\n                }\n            }\n        }\n        // Remove state\n        else if (!targetState || operation.method === ActionOperationMethod.ClearStates) {\n            this.getAdditionalStates_m(stateTargetDataElement)\n                .filter(state => state.animation)\n                .forEach(timeState => {\n                    if (timeState?.animation) {\n                        timeState.animation.to({ rate: 0 }, settings);\n                    }\n                });\n        }\n    }\n\n    rerender_m(creative: CreativeDataNode): void {\n        this.logger?.debug(`rerender_m`);\n\n        this._onlyRenderTextWithoutFontLoad = false;\n        this.setCreativeDocument(creative);\n        this._clearElementHandlers();\n\n        this._resetViewTree();\n\n        this._fragment = this._browserDocument.createDocumentFragment();\n\n        resetNodeCid();\n        this._mountPoint.innerHTML = '';\n\n        this._removeStyles();\n        visitAllNodes(this.creativeDocument, this);\n        this.rootElement.addEventListener('click', this._onClick);\n\n        this._setBaseStyles(this._onlyRenderTextWithoutFontLoad);\n\n        this.updateElementOrder_m();\n\n        this._mountPoint.appendChild(this._fragment);\n        this.WidgetRenderer?.creativeApi.bind();\n    }\n\n    private _resetInitialState(time: number, onlyRenderTextWithoutFontLoad: boolean, resetNodeId: boolean = true): void {\n        // clear host element\n        this._mountPoint.innerHTML = '';\n\n        this.time_m = time;\n        this._onlyRenderTextWithoutFontLoad = onlyRenderTextWithoutFontLoad;\n\n        if (resetNodeId) {\n            resetNodeCid();\n        }\n\n        this._resetViewTree();\n        this._removeStyles();\n    }\n\n    private _setBaseStyles(onlyRenderTextWithoutFontLoad: boolean): void {\n        this._insertStyles();\n        for (const element of this.creativeDocument.elements) {\n            if (isHidden(element)) {\n                continue;\n            }\n            if (onlyRenderTextWithoutFontLoad) {\n                if (!isTextNode(element)) {\n                    continue;\n                }\n            }\n            const viewElement = this.storedViewElements.get(element.id)!;\n            const styleRule = this.styleRules_m.get(viewElement.elementCid!)!.current.styleRule;\n            const willChange: string[] = [];\n            for (let i = 0; i < styleRule.style.length; i++) {\n                if (styleRule.style[i] === 'transform') {\n                    if ((this._scale !== 1 && isTextNode(element)) || this._scale === 1) {\n                        willChange.push(styleRule.style[i]);\n                    }\n                }\n\n                if (!!styleRule.style[i].match(/(opacity|perspectiveOrigin)/)) {\n                    willChange.push(styleRule.style[i]);\n                }\n            }\n            styleRule.style.willChange = willChange.join(', ');\n        }\n\n        this.updateElementOrder_m();\n    }\n\n    initialize(mountPoint: HTMLElement, time: number = 0, onlyRenderTextWithoutFontLoad: boolean = false): void {\n        this.logger?.verbose('initialize');\n\n        if (this.destroyed_m) {\n            return;\n        }\n\n        // 1. set host element\n        this._mountPoint = mountPoint;\n\n        // 2. reset to initial state\n        this._resetInitialState(time, onlyRenderTextWithoutFontLoad, false);\n\n        // 3. determine & set scale\n        const { width } = mountPoint.getBoundingClientRect();\n        const originalWidth = this.creativeDocument.width;\n        const scale = this._calculateScale(width, originalWidth);\n        this._setScale(scale);\n\n        // 4. visit creative and all elements\n        visitAllNodes(this.creativeDocument, this, onlyRenderTextWithoutFontLoad);\n\n        // 5. insert base styles\n        this._setBaseStyles(onlyRenderTextWithoutFontLoad);\n\n        // 6. append creative container to host\n        this._mountPoint.appendChild(this._fragment);\n\n        // 7. add observers\n        this.rootElement.addEventListener('click', this._onClick);\n        // should be done once the render is fully done, unfortunately the animated creative does magic with feeds and not fully inits all elements\n        this._initResizeObserver(mountPoint);\n    }\n\n    /**\n     * @deprecated - use the correct initialize flow - initialize()\n     */\n    render(mountPoint: HTMLElement, time: number = 0, onlyRenderTextWithoutFontLoad: boolean = false): void {\n        this.logger?.verbose('render');\n\n        this.time_m = time;\n        this._onlyRenderTextWithoutFontLoad = onlyRenderTextWithoutFontLoad;\n\n        const { width } = mountPoint.getBoundingClientRect();\n        const originalWidth = this.creativeDocument.width;\n\n        const scale = this._calculateScale(width, originalWidth);\n        this._setScale(scale);\n\n        mountPoint.innerHTML = '';\n\n        this._resetViewTree();\n        this._removeStyles();\n\n        if (this.destroyed_m) {\n            return;\n        }\n        // Work around to get the cycle of WidgetRenderer's initialization correct\n        this.visitCreative_m(this.creativeDocument);\n\n        visitAllChildren(this.creativeDocument.elements, this, onlyRenderTextWithoutFontLoad);\n        this.rootElement.addEventListener('click', this._onClick);\n\n        this._setBaseStyles(onlyRenderTextWithoutFontLoad);\n\n        this.updateElementOrder_m();\n        mountPoint.appendChild(this._fragment);\n        this._mountPoint = mountPoint;\n\n        // should be done once the render is fully done, unfortunately the animated creative does magic with feeds and not fully inits all elements\n        this._initResizeObserver(mountPoint);\n    }\n\n    private _clearElementHandlers(): void {\n        forEachElement(this.viewTree, element => {\n            if (isTextNode(element)) {\n                element.__richTextRenderer.destroy_m();\n            }\n            if (isVideoNode(element)) {\n                element.__videoRenderer.destroy();\n            }\n            const styleRule = this.styleRules_m.get(element.elementCid!)!;\n            styleRule.current.styleRule.style.willChange = '';\n            styleRule.previous.styleRule.style.willChange = '';\n            if (element.__rootElement) {\n                element.__rootElement.removeEventListener('click', this._onClick);\n            }\n        });\n\n        this.rootElement?.removeEventListener('click', this._onClick);\n        this.rootElement?.removeEventListener('mousemove', this._onCreativeMouseMove);\n    }\n\n    destroyElement_m(node: OneOfDataNodes, isDefinitivelyDestroyed: boolean = true): void {\n        const documentNode = this.creativeDocument.findNodeById_m(node.id, true);\n\n        if (!documentNode) {\n            throw new Error(`Could not find ${node.kind}`);\n        }\n\n        if (isDefinitivelyDestroyed) {\n            (documentNode.__parentNode || this.creativeDocument).removeNodeById_m(documentNode.id);\n            if (isHidden(node)) {\n                return;\n            }\n        }\n\n        if (isGroupDataNode(documentNode)) {\n            return;\n        }\n\n        this.removeAdditionalStates_m(documentNode, false);\n        const viewElement = this.storedViewElements.get(node.id)!;\n        this.viewTree.nodes = this.viewTree.nodes.filter(n => n.id !== viewElement.id);\n\n        const cid = viewElement.elementCid!;\n        const styleRule = this.styleRules_m.get(cid)!;\n        this._removeStyle(styleRule.current.styleRule);\n        const imageTimeout = this._imageDebounceTimeouts?.get(cid);\n\n        if (imageTimeout) {\n            window.clearTimeout(imageTimeout);\n        }\n\n        if (isTextNode(viewElement) && viewElement.__richTextRenderer) {\n            viewElement.__richTextRenderer.destroy_m();\n            viewElement.__richTextRenderer = undefined as any;\n        }\n\n        if (isWidgetNode(viewElement)) {\n            viewElement.__data.__widget?.destroy();\n        }\n\n        if (isVideoNode(viewElement)) {\n            viewElement.__videoRenderer.destroy();\n        }\n\n        const nodeElement = viewElement.__safari3dElement || viewElement.__rootElement;\n\n        if (!nodeElement) {\n            throw new Error(`HTML element does not exist on canvas.`);\n        }\n\n        this.rootElement.removeChild(nodeElement);\n    }\n\n    destroy(): void {\n        this.emit('destroy');\n        if (this._styleElement && this._styleElement.parentNode) {\n            (this._styleElement.parentNode as HTMLElement).removeChild(this._styleElement);\n        }\n\n        this._clearElementHandlers();\n\n        this.clearAdditionalStates_m();\n\n        if (this.feedStore) {\n            this.feedStore.destroy();\n            this.feedStore.off('dataChanged', this.updateViewElementValues);\n        }\n\n        while (this.viewTree.nodes.length) {\n            this.destroyElement_m(this.viewTree.nodes[0].__data);\n        }\n\n        this._styleSheet = undefined as any;\n        this.styleRules_m.clear();\n\n        if (this.WidgetRenderer) {\n            this.WidgetRenderer.destroy();\n        }\n        this.storedViewElements.clear();\n\n        this._resizeObserver?.disconnect();\n        this.destroyed_m = true;\n        this.clearEvents();\n    }\n\n    private _createViewElementFromDataElement<T extends OneOfViewNodes>(dataElement: OneOfElementDataNodes): T {\n        const viewElement = createViewElement(dataElement);\n        this.storedViewElements.set(dataElement.id, viewElement);\n        this.setViewElementValues_m(dataElement, this.time_m, false);\n\n        viewElement.__rootElement = this._createElement(viewElement);\n        this.insertStyle_m(viewElement.elementCid!, {\n            ...this.getDefaultStyle_m(viewElement)\n        });\n        this.setBackgroundElement_m(viewElement);\n\n        this.viewTree.nodes.push(viewElement);\n\n        this.updateElementOrder_m();\n\n        this.setActions_m(dataElement);\n\n        return viewElement as T;\n    }\n\n    /**\n     * Update order of view elements and DOM based on the order of the dataElements\n     */\n    updateElementOrder_m(): void {\n        const elements = this.creativeDocument.elements;\n        const viewElements = this.viewTree.nodes;\n\n        // Sort view elements in the same order as the data elements.\n        viewElements.sort((a, b) => elements.indexOf(a.__data) - elements.indexOf(b.__data));\n\n        // Update indexes on DOM by changing order of elements\n        forEachElement(this.viewTree, (element, _group, index) => this._moveViewElementInDom(element, index));\n    }\n\n    /**\n     * Used to bring a text to top while editing text.\n     */\n    bringElementToTop_m(element: OneOfViewNodes): void {\n        this._moveViewElementInDom(element, Number.MAX_VALUE);\n    }\n\n    /**\n     * Move viewElement in DOM to a certain index.\n     */\n    private _moveViewElementInDom(element: OneOfViewNodes, newIndex: number): void {\n        const domElement = element.__safari3dElement || element.__rootElement;\n        const parent = domElement?.parentNode;\n\n        if (domElement && parent) {\n\n            // Exclude SVG background from list of child elements\n            const children = Array.from(parent.children).filter(e => e.tagName === 'DIV');\n            const currentIndex = children?.length ? children.indexOf(domElement) : -1;\n\n            if (currentIndex > -1 && currentIndex !== newIndex) {\n                // null puts the element in the end\n                parent.insertBefore(domElement, children[newIndex] || null);\n            }\n        }\n    }\n\n    getDefaultStyle_m(element: OneOfViewNodes): any {\n        const elementIsVisibleAtTime = isElementVisibleAtTime(element.__data, this.time_m);\n\n        /**\n         * Show and hide elements with opacity and pointer-events instead of\n         * relying in visiblity due to a bug in widgets on iOS 14\n         */\n        const opacity = (typeof element.opacity === 'number'\n            ? ({ opacity: `${elementIsVisibleAtTime ? element.opacity : 0}` })\n            : undefined);\n\n        const filters = element.filters || {};\n        const filterString = (Object.entries(filters) as Array<[keyof typeof filters, (typeof filters)[keyof typeof filters]]>)\n            .filter(([_, filter]) => filter?.value !== undefined)\n            // We can assert that filter exists as we filtered it (heh)\n            .map(([key, filter]) => {\n                const filterUnit = FILTER_MAP[key]?.unit;\n                return `${key}(${filter!.value!.toFixed(0)}${filterUnit})`;\n            })\n            .join(' ');\n\n        // See comment about opacity above\n        let isIOS = false;\n        if (!isIpad && preciseIOSVersion.simple <= 0) {\n            isIOS = true;\n        }\n\n        const defaultStyles = {\n            pointerEvents: elementIsVisibleAtTime ? 'auto' : 'none',\n            ...this.getPositionAndSizeStyle_m(element),\n            ...(typeof element.radius === 'number' ? { borderRadius: `${element.radius}px` } : undefined),\n            ...opacity,\n            visibility: isIOS || elementIsVisibleAtTime ? 'visible' : 'hidden',\n            filter: filterString || 'unset'\n        } as any;\n\n        return defaultStyles;\n    }\n\n    rerenderText_m(): void {\n        for (const element of this.viewTree.nodes) {\n            if (isTextNode(element)) {\n                element.__richTextRenderer.rerender();\n            }\n        }\n    }\n\n    private _getPerspective(element: IElementDataNode): number {\n        return Math.max(element.width, element.height) * 2;\n    }\n\n    getPositionAndSizeStyle_m(element: OneOfViewNodes): IPositionStyle & ISizeStyle {\n        return {\n            width: element.width + 'px',\n            height: element.height + 'px',\n            transform: this.getTransformMatrix_m(element),\n        };\n    }\n\n    getTransformString_m(element: OneOfViewNodes, excludeTranslate: boolean = false): string {\n\n        const scale = this._getScaleOfElement(element);\n        let transformString = excludeTranslate ? '' : `translate(${element.x}px, ${element.y}px)`;\n\n        if (element.rotationZ) {\n            transformString += ` rotateZ(${element.rotationZ}rad)`;\n        }\n        if (element.rotationY) {\n            transformString += ` rotateY(${element.rotationY}rad)`;\n        }\n        if (element.rotationX) {\n            transformString += ` rotateX(${element.rotationX}rad)`;\n        }\n\n        transformString += ` scaleX(${scale.x})`;\n        transformString += ` scaleY(${scale.y})`;\n\n        return transformString;\n    }\n\n    /**\n     * Get a css transform matrix3d from view element.\n     * @param element\n     * @returns\n     */\n    getTransformMatrix_m(element: OneOfViewNodes): string {\n\n        const scale = this._getScaleOfElement(element);\n        const matrix = new Matrix();\n\n        matrix.translate_m(element.x, element.y);\n\n        // Set perspective AFTER moving but BEFORE rotating element\n        // to always keep perspective-origin in the center of the element\n        matrix.perspective_m(element.perspective || 800);\n\n        // Order of these is crucial to 3D-rotate in an expected way\n        if (element.rotationZ) {\n            matrix.rotateZ_m(element.rotationZ);\n        }\n        if (element.rotationY) {\n            matrix.rotateY_m(element.rotationY);\n        }\n        if (element.rotationX) {\n            matrix.rotateX_m(element.rotationX);\n        }\n\n        matrix.scale_m(scale.x, scale.y);\n\n        // Hack for blurry images when not \"3D\" in responsive ads and zoomed canvas.\n        // Safari messes up z-index for non 3d rotated elements\n        if (!element.rotationY && !element.rotationX && element.kind === NodeKind.Image) {\n            matrix.rotateY_m(Math.PI * 2);\n        }\n\n        return matrix.toCSS_m();\n    }\n\n    private _getScaleOfElement(styles: OneOfViewNodes): IPosition {\n        return {\n            x: (typeof styles.scaleX === 'number' ? styles.scaleX : 1) * (styles.mirrorX ? -1 : 1),\n            y: (typeof styles.scaleY === 'number' ? styles.scaleY : 1) * (styles.mirrorY ? -1 : 1)\n        };\n    }\n\n    private _removeStyle(rule: CSSStyleRule): void {\n        for (let i = this._styleSheet.cssRules.length - 1; i >= 0; i--) {\n            if ((this._styleSheet.cssRules[i] as any).selectorText === rule.selectorText) {\n                this._styleSheet.deleteRule(i);\n                break;\n            }\n        }\n    }\n\n    private _removeStyles(): void {\n        this.styleRules_m.clear();\n        const count = this._styleSheet && this._styleSheet.cssRules ? this._styleSheet.cssRules.length : 0;\n        for (let i = count - 1; i > 2; i--) {\n            this._styleSheet.deleteRule(i);\n        }\n    }\n\n    private _insertStyles(): void {\n        const styleSheet = this._styleSheet;\n\n        // Safari hack to not overlap element\n        if (isSafari) {\n            styleSheet.insertRule(`#${this._scopeId} .safari-3d {position:absolute;left:0;top:0;bottom:0;right:0,pointer-events:none; transform: translateZ(0); }`,\n                styleSheet.cssRules.length);\n        }\n\n        // Element divs\n        styleSheet.insertRule(`#${this._scopeId} .element{position:absolute;left:0;top:0;}`,\n            styleSheet.cssRules.length);\n\n        // Text div inside element divs\n        styleSheet.insertRule(`#${this._scopeId} .text>div{position:relative;}`,\n            styleSheet.cssRules.length);\n    }\n\n    insertStyle_m(cid: string, style: ICSSProperties): void {\n        let selector: string;\n        if (cid !== this._scopeId) {\n            selector = `#${this._scopeId} #${cid}`;\n        }\n        else {\n            selector = '#' + cid;\n        }\n        let rules = '';\n        for (const rule in style) {\n            if (style[rule]) {\n                rules += rule.replace(/([A-Z])/g, (m) => '-' + m.toLowerCase()) + ':' + style[rule] + ';';\n            }\n        }\n\n        // Insert rules for element div\n        this._styleSheet.insertRule(`${selector}{${rules}}`, this._styleSheet.cssRules.length);\n        const styleRule = this._styleSheet.cssRules[this._styleSheet.cssRules.length - 1] as CSSStyleRule;\n        const styles = this._getStyleValues(styleRule);\n        this.styleRules_m.set(cid, {\n            previous: {\n                styleRule: styleRule,\n                rawStyleValue: styles\n            },\n            current: {\n                styleRule: styleRule,\n                rawStyleValue: styles\n            }\n        });\n        const element = this._htmlElements.get(cid)!;\n        element.setAttribute('id', cid);\n    }\n\n    private _getStyleValues(styleRule: CSSStyleRule): CSSStyleDeclaration {\n        const styles = {} as CSSStyleDeclaration;\n        for (let i = 0; i < styleRule.style.length; i++) {\n            const style = styleRule.style[i];\n            styles[style] = styleRule.style[styleRule.style[i]];\n        }\n        return styles;\n    }\n\n    private _createElement(element: OneOfViewNodes): HTMLDivElement {\n        const htmlElement = this._browserDocument.createElement('div');\n        this._htmlElements.set(element.elementCid!, htmlElement);\n\n        if (this.env_m.STUDIO_JS && this.env_m.IN_TEST && element.name) {\n            htmlElement.setAttribute('data-test-name', element.name);\n        }\n\n        htmlElement.classList.add('element', 'kind-' + element.kind);\n\n        if (isSafari) {\n            const wrapper3d = this._browserDocument.createElement('div');\n            wrapper3d.classList.add('safari-3d');\n            wrapper3d.appendChild(htmlElement);\n            element.__safari3dElement = wrapper3d;\n            this.rootElement.appendChild(wrapper3d);\n        }\n        else {\n            this.rootElement.appendChild(htmlElement);\n        }\n        return htmlElement;\n    }\n\n    async injectFontFace(fontStyle: IFontStyle): Promise<void> {\n        try {\n            const fontFace = await injectFontFace(fontStyle);\n            if (!this._browserDocument.fonts.has(fontFace)) {\n                this._browserDocument.fonts.add(fontFace);\n            }\n        }\n        catch (err) {\n            // Do nothing.\n            handleError('Could not load font', {\n                enabled: this.env_m.STUDIO_JS,\n                contexts: {\n                    font: fontStyle,\n                    originalError: err\n                }\n            });\n        }\n    }\n\n    private _getDataElementById(id: string): OneOfElementDataNodes | undefined {\n        return this.storedViewElements.get(id)?.__data;\n    }\n\n    getScale_m(): number {\n        return this._scale;\n    }\n\n    private _setScale(scale: number): void {\n        if (scale === this._scale) {\n            return;\n        }\n\n        if (scale === 0) {\n            this.logger?.verbose('Trying to set scale to 0. Aborting.');\n            return;\n        }\n\n        this.logger?.debug('setting scale: ' + scale);\n\n        this._scale = scale;\n        this._scaleViewTree(this.creativeDocument);\n    }\n\n    private _setScaleAndUpdate(scale: number): void {\n        this._setScale(scale);\n\n        // workaround because resize observer will trigger updates too early and we dont have a safer way to check everything was inited yet\n        if (this.creativeDocument.elements.every(element => this.storedViewElements.has(element.id) || isHidden(element))) {\n            this.updateCreativeValues();\n            this.updateViewElementValues();\n        }\n    }\n\n    private _scaleViewTree(size: any): void {\n        this.viewTree.width = size.width * this._scale;\n        this.viewTree.height = size.height * this._scale;\n    }\n\n    private _calculateScale(width: number, originalWidth: number): number {\n        return width / originalWidth;\n    }\n\n    private _initResizeObserver(host: Element): void {\n        if (this.ad?.responsive && typeof ResizeObserver !== 'undefined') {\n            this.logger?.verbose('initializing ResizeObserver');\n            this._resizeObserver = new ResizeObserver((observerEntries) => {\n                this.logger?.debug('ResizeObserver: resize observed');\n                const entry = observerEntries[0];\n                const box = entry.borderBoxSize && entry.borderBoxSize[0];\n                let width = box?.inlineSize; // Safari returns inlineSize undefined\n\n                if (typeof width !== 'number') {\n                    const boundingRect = entry.target.getBoundingClientRect();\n                    width = boundingRect.width;\n                }\n\n                const newScale = this._calculateScale(width, this.creativeDocument.width);\n                this._setScaleAndUpdate(newScale);\n            });\n\n            this._resizeObserver.observe(host);\n        }\n    }\n\n    private _resetViewTree(): void {\n        this.viewTree = {\n            kind: NodeKind.Creative,\n            nodes: [],\n            width: this.creativeDocument.width,\n            height: this.creativeDocument.height\n        };\n    }\n\n    hideElement_m(element: OneOfDataNodes): void {\n        this.destroyElement_m(element, false);\n    }\n\n    showElement_m(element: OneOfElementDataNodes): void {\n        visitOneNode(element, this);\n    }\n}\n","import { IRendererFactory, T } from './creative.container';\nimport { IRenderer } from './renderer.header';\nimport { IRendererOption } from './renderer';\nimport { Container } from '@studio/utils/di';\nimport { IAnimator } from './animator.header';\nimport { IFeedStore } from './elements/feed/feed-store.header';\nimport { ICreative } from './creative.header';\nimport { CreativeDataNode } from './nodes/creative-data-node';\n\nexport class Creative implements ICreative {\n    renderer_m: IRenderer;\n    animator_m: IAnimator;\n    feedStore_m: IFeedStore;\n\n    constructor(\n        data: CreativeDataNode,\n        option: IRendererOption,\n        container: Container<T>)\n    {\n        const createRenderer = container.resolve<IRendererFactory>(T.RENDERER_FACTORY);\n        this.renderer_m = createRenderer(option);\n        this.animator_m = container.resolve(T.ANIMATOR);\n        this.feedStore_m = this.renderer_m.feedStore!;\n    }\n}\n","import { Container } from '@studio/utils/di';\nimport { ICreativeEnvironment } from './environment';\nimport { concatUrl } from '@ad/utils/url';\nimport { IJsonpFile } from '@ad/domain/ad-data-creative';\nimport { IFontFamily, IText, IVideoViewElement } from '@studio/domain';\nimport { RichText, IRichTextRenderOption } from './elements/rich-text/rich-text';\nimport { IEditorState } from './elements/rich-text/rich-text.types';\nimport { RichTextSelectionService } from './elements/rich-text/rich-text.selection';\nimport { RichTextEditorService } from './elements/rich-text/rich-text.editor';\nimport { RichTextEditorKeyboardBindings } from './elements/rich-text/rich-text.editor.keyboard-bindings';\nimport { RichTextEditorMouseBindings } from './elements/rich-text/rich-text.editor.mouse-bindings';\nimport { RichTextEditorStyleResolver } from './elements/rich-text/rich-text.editor.style-resolver';\nimport { IRichTextEditorService } from './elements/rich-text/rich-text.editor.header';\nimport { RichTextHtmlResolver } from './elements/rich-text/rich-text.html-resolver';\nimport { IRendererOption, Renderer } from './renderer';\nimport { Animator } from './animator';\nimport { Creative } from './creative';\nimport { IRenderer } from './renderer.header';\nimport { IFeedStore } from './elements/feed/feed-store.header';\nimport { ICreative } from './creative.header';\nimport { IAd } from '@ad/domain/ad';\nimport { IWidgetRenderer } from './elements/widget/widget-renderer.header';\nimport { IVideoRenderer } from './elements/video/video-renderer.header';\nimport { CreativeDataNode } from './nodes/creative-data-node';\n\n/* webpack-strip-block:removed */\n\n\nexport const enum T {\n    AD,\n    CREATIVE_DATA,\n    ENVIRONMENT,\n\n    RENDERER,\n    WIDGET_RENDERER,\n    ANIMATOR,\n    FEED_STORE,\n    VIDEO_RENDERER,\n\n    AD_API,\n    CREATIVE_API,\n    TIMELINE_API,\n\n    RENDERER_FACTORY,\n    CREATIVE_FACTORY,\n    FEED_STORE_FACTORY,\n    VIDEO_RENDERER_FACTORY,\n\n    RICH_TEXT,\n    RICH_TEXT_EDITOR,\n    RICH_TEXT_EDITOR_KEYBOARD_BINDINGS,\n    RICH_TEXT_EDITOR_MOUSE_BINDINGS,\n    RICH_TEXT_EDITOR_STYLE_RESOLVER,\n    RICH_TEXT_EDITOR_HTML_RESOLVER,\n    RICH_TEXT_EDITOR_SELECTION,\n    RICH_TEXT_FACTORY,\n\n    NG_ZONE,\n    HOTKEY_SERVICE,\n    ACTIVITY_LOGGER_SERVICE,\n    TEST_LOCKER_SERVICE,\n    EDITOR_HISTORY_SERVICE,\n    EDITOR_STATE,\n    TEXT_SELECTION_CHANGE_SUBJECT,\n    TEXT_CHANGE_SUBJECT,\n    FONT_FAMILIES,\n    EDITOR_EVENT\n}\n\nexport type IRichTextFactory = (text: IText, rootElement: HTMLDivElement, options: IRichTextRenderOption) => RichText;\nexport type IRendererFactory = (option: IRendererOption) => IRenderer;\nexport type ICreativeFactory = (creative: CreativeDataNode, option: IRendererOption, ad: IAd) => ICreative;\nexport type IFeedStoreFactory = (brandId: string) => IFeedStore;\nexport type IVideoRendererFactory = (viewElement: IVideoViewElement) => IVideoRenderer;\n\ndeclare let __webpack_public_path__: string;\nexport async function registerFeaturesByFiles(files: IJsonpFile[], origin: string, container: Container<T>): Promise<void> {\n    const registerTasks: Promise<void>[] = [];\n    __webpack_public_path__ = origin && concatUrl(origin, '/scripts/');\n    for (const file of files) {\n        if (!file.id.startsWith('preload')) {\n            continue;\n        }\n        const matches = /^([\\w-]+)/.exec(file.url)!;\n        switch (matches[1]) {\n            case 'widget':\n                registerTasks.push(registerWidgetFeature(container));\n                break;\n            case 'feed':\n                registerTasks.push(registerFeedStoreFeature(container));\n                break;\n            case 'video':\n                registerTasks.push(registerVideoFeature(container));\n                break;\n        }\n    }\n    await Promise.all(registerTasks);\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    __webpack_public_path__ = '';\n}\n\nasync function registerFeedStoreFeature(container: Container<T>): Promise<void> {\n    const { FeedStore: FeedStoreC } = await import(/* webpackChunkName: \"feed\" */'./elements/feed/feed-store');\n    container.registerFactory_m<IFeedStoreFactory>(T.FEED_STORE_FACTORY, (factoryContainer) => (brandId: string): IFeedStore => {\n            const renderer = factoryContainer.resolve<IRenderer>(T.RENDERER);\n            const env = factoryContainer.resolve<ICreativeEnvironment>(T.ENVIRONMENT);\n            return new FeedStoreC(renderer, env, brandId);\n        });\n    container.resolve<IFeedStoreFactory>(T.FEED_STORE_FACTORY);\n}\n\nasync function registerWidgetFeature(container: Container<T>): Promise<void> {\n    const {\n        WidgetRenderer: WidgetRendererC,\n        AdApi: AdApiC,\n        CreativeApi: CreativeApiC,\n        TimelineApi: TimelineApiC\n    } = await import(/* webpackChunkName: \"widget\" */'./elements/widget/widget.module');\n    container.register_m(T.WIDGET_RENDERER, WidgetRendererC);\n    container.register_m(T.AD_API, AdApiC);\n    container.register_m(T.CREATIVE_API, CreativeApiC);\n    container.register_m(T.TIMELINE_API, TimelineApiC);\n}\n\nasync function registerVideoFeature(container: Container<T>): Promise<void> {\n    const {\n        VideoRenderer: VideoRendererC,\n    } = await import(/* webpackChunkName: \"video\" */'./elements/video/video.module');\n    container.registerFactory_m<IVideoRendererFactory>(T.VIDEO_RENDERER_FACTORY, (factoryContainer) => (viewElement: IVideoViewElement): IVideoRenderer => {\n        const animator = factoryContainer.resolve<Animator>(T.ANIMATOR);\n        const renderer = factoryContainer.resolve<IRenderer>(T.RENDERER);\n        const ad = factoryContainer.resolve<IAd>(T.AD);\n        return new VideoRendererC(ad, renderer, animator, viewElement);\n    });\n    container.register_m(T.VIDEO_RENDERER, VideoRendererC);\n}\n\nexport function createCreativeContainer(): Container<T> {\n    const creativeContainer = new Container<T>();\n\n    creativeContainer.register_m(T.RICH_TEXT, RichText);\n    creativeContainer.register_m(T.ANIMATOR, Animator);\n\n    /* webpack-strip-block:removed */\n\n    creativeContainer.registerFactory_m<IRichTextFactory>(T.RICH_TEXT_FACTORY, (container) => (text: IText, rootElement: HTMLDivElement, options: IRichTextRenderOption): RichText => {\n            let richText: RichText;\n            if (process.env.STUDIO_JS) {\n                const richTextContainer = new Container();\n                richTextContainer.parent = container;\n                /* webpack-strip-block:removed */\n                const richTextEditorService = richTextContainer.resolve<IRichTextEditorService>(T.RICH_TEXT_EDITOR);\n                const editorState = container.maybeResolve<IEditorState>(T.EDITOR_STATE);\n                const fontFamilies = container.resolve<IFontFamily[]>(T.FONT_FAMILIES);\n                richText = new RichText(text, rootElement, options, editorState, richTextEditorService, fontFamilies);\n                (richTextEditorService as any).text = richText;\n            }\n            else {\n                richText = new RichText(text, rootElement, options);\n            }\n            return richText;\n        });\n\n    creativeContainer.registerFactory_m<IRendererFactory>(T.RENDERER_FACTORY, (container) => (option: IRendererOption): Renderer => {\n        const document = container.resolve<CreativeDataNode>(T.CREATIVE_DATA);\n            const env = container.resolve<ICreativeEnvironment>(T.ENVIRONMENT);\n            const renderer = new Renderer(container, document, option, env);\n            const createFeedStore = container.maybeResolve<IFeedStoreFactory>(T.FEED_STORE_FACTORY);\n            container.register_m(T.RENDERER, renderer);\n            if (createFeedStore) {\n                renderer.feedStore = createFeedStore(option.brandId!);\n            }\n            const widgetRenderer = container.maybeResolve<IWidgetRenderer>(T.WIDGET_RENDERER);\n            renderer.WidgetRenderer = widgetRenderer;\n            const ad = container.maybeResolve<IAd>(T.AD);\n            renderer.ad = ad;\n            return renderer;\n        });\n\n    creativeContainer.registerFactory_m<ICreativeFactory>(T.CREATIVE_FACTORY, (container) => (creativeData: CreativeDataNode, option: IRendererOption, ad: IAd): Creative => {\n            container.register_m(T.CREATIVE_DATA, creativeData);\n            container.register_m(T.AD, ad);\n            return new Creative(creativeData, option, container);\n        });\n\n    /** Remove modules that are autoresolved inside of studio for the output */\n    /* webpack-strip-block:removed */\n\n    return creativeContainer;\n}\n","import { ICreativeEnvironment } from '@creative/environment';\nimport { IFontStyle, IFeed, SpanType, ICreativeDataNode } from '@studio/domain';\nimport { Container } from '@studio/utils/di';\nimport { injectFontFace, injectFontStyle } from '@studio/utils/dom-utils';\nimport { _performanceMark } from '@studio/utils/performance';\nimport { SafeEval } from '@studio/utils/safe-eval';\nimport { Ad } from '@ad/ad';\nimport { AdEvents, IAdEventData } from '@ad/domain/ad-events';\nimport { imageOptimizerDefaults, ImageOptimizerUrlBuilder } from '@ad/utils/image-optimizer';\nimport { replaceOrigin, isUrl, isRelativeUrl, concatUrl, isBannerflow, getDomain } from '@ad/utils/url';\nimport { IAnimatedCreative } from './animated-creative.interface';\nimport { Animator } from './animator';\nimport { IAnimator } from './animator.header';\nimport { createCreativeContainer, ICreativeFactory, registerFeaturesByFiles, T } from './creative.container';\nimport { IFeedStore } from './elements/feed/feed-store.header';\nimport { FONT_SERVICE_TEXT_PARAMETER, IFontServiceParams, getFontServiceParamsFromString } from './font-service.utils';\nimport { isImageNode, isTextNode, isVideoNode, isWidgetNode } from './nodes/helpers';\nimport { CreativeDataNode } from './nodes/creative-data-node';\nimport { IRenderer } from './renderer.header';\n\n\nexport interface IFontPreloadAsset {\n    type: 'font';\n    style: IFontStyle;\n}\n\nexport interface IFeedPreloadAsset {\n    type: 'feed';\n    id: string;\n}\n\nexport type PreloadAsset = IFontPreloadAsset | IFeedPreloadAsset;\n\ninterface IPreloadAssets {\n    fonts: IFontStyle[];\n    feeds: string[];\n}\n\nexport interface IDeeplinkEvent {\n    event: MouseEvent;\n    deepLinkUrl?: string;\n}\n\nexport class AnimatedCreative implements IAnimatedCreative {\n\n    env: ICreativeEnvironment;\n    hasWidgetElements: boolean;\n    animator?: IAnimator;\n    feedStore: IFeedStore;\n    private _iframe?: HTMLIFrameElement;\n    private _rootElement?: HTMLElement;\n    private _preloadedFeeds: string[] = [];\n    private _preloadAssets: IPreloadAssets = { fonts: [], feeds: [] };\n    private _stoppedOmniRenderRecording = false;\n    private _inSandboxedIframe = false;\n\n    private get _window(): Window | undefined {\n        return (this._inSandboxedIframe ? window : this._iframe?.contentWindow) || undefined;\n    }\n\n    private get _document(): Document {\n        const document = this._window?.document;\n        if (!document) {\n            throw new Error('No document found');\n        }\n        return document;\n    }\n\n    /**\n     * The creative renderer. Note that this is shared between canvas and creatives.\n     */\n    renderer?: IRenderer;\n    private _pixelVisibleInterval?: number;\n    private destroyed = false;\n    private creativeStylesRef?: HTMLStyleElement;\n    private creativeDataNode: CreativeDataNode;\n\n    constructor(\n        public ad: Ad,\n        creativeData: ICreativeDataNode,\n        preloadAssets: PreloadAsset[],\n        private _onLoadCallback?: (creative?: IAnimatedCreative) => any,\n        env?: ICreativeEnvironment\n    ) {\n        console.debug('[AnimatedCreative] construct');\n\n        if (typeof creativeData.nodes === 'undefined' && creativeData.elements.length > 0) {\n            creativeData.nodes = creativeData.elements;\n        }\n        this.creativeDataNode = new CreativeDataNode(creativeData);\n\n        try {\n            this._setEnvironments(env);\n            for (const preloadAsset of preloadAssets) {\n                switch (preloadAsset.type) {\n                    case 'font':\n                        this._preloadAssets.fonts.push(preloadAsset.style);\n                        break;\n                    case 'feed':\n                        this._preloadAssets.feeds.push(preloadAsset.id);\n                        break;\n                }\n            }\n\n            const iframe = this._createIframe();\n            console.debug('[AnimatedCreative] created iframe');\n\n            const contentWindow = iframe.contentWindow;\n\n            this._inSandboxedIframe = !iframe.contentDocument;\n\n            if (this._inSandboxedIframe) {\n                console.debug('[AnimatedCreative] is sandboxed. Removing iframe');\n\n                iframe.remove();\n                this.init();\n            }\n            else if (contentWindow) {\n                this._iframe = iframe;\n                // Wait for iframeWindow to be available\n                this._onIframeWindowLoad(contentWindow, this.init);\n            }\n            else {\n                console.warn('Did not initialize the creative, due to container element is not visible:\\n', this.ad.container);\n                return;\n            }\n        }\n        catch (e) {\n            throw new Error('Could not initialize creative: ' + (e as any)?.message);\n        }\n    }\n\n    /**\n     * When iframe window is ready to use, init creative\n     */\n    private init = async (): Promise<void> => {\n        console.debug('[AnimatedCreative] init');\n        _performanceMark('ac:init:start');\n\n        const contentWindow = this._window;\n\n        if (!contentWindow) {\n            throw new Error('Ad container is not visible');\n        }\n\n        if (this.destroyed) {\n            return;\n        }\n\n        this._insertCreativeStyles();\n        this._rootElement = this._getRootElement();\n\n        const adContainer = new Container<T>();\n        adContainer.register_m(T.AD, this.ad);\n        adContainer.register_m(T.CREATIVE_DATA, this.creativeDataNode);\n        adContainer.register_m(T.ENVIRONMENT, this.env);\n        const creativeContainer = createCreativeContainer();\n        creativeContainer.parent = adContainer;\n        const createCreative = creativeContainer.resolve<ICreativeFactory>(T.CREATIVE_FACTORY);\n\n        console.debug('[AnimatedCreative] loading feature files / init IO / SafeEval');\n        _performanceMark('ac:init:load:features:start');\n\n        await Promise.all([\n            registerFeaturesByFiles(this.ad.selectedCreative.animated.files, this.ad.getOrigin()!, creativeContainer),\n            ImageOptimizerUrlBuilder.init_m(\n                this.env?.IMAGE_OPTIMIZER_ORIGIN || '',\n                this.ad.selectedCreative.animated.defaultOrigin,\n                this._getDpr()\n            ),\n            SafeEval.init(this._inSandboxedIframe)\n        ]);\n\n        console.debug('[AnimatedCreative] loaded feature files / init IO / SafeEval');\n        _performanceMark('ac:init:load:features:end');\n\n        const creative = createCreative(this.creativeDataNode, {\n            contentWindow,\n            brandId: this.ad.data.brand.id,\n        }, this.ad);\n\n        this.renderer = creative.renderer_m;\n        this.renderer.on('click', this._onClick);\n\n        if (creative.feedStore_m) {\n            _performanceMark('ac:init:load:feeds:start');\n\n            this.feedStore = creative.feedStore_m;\n            this.renderer.feedStore = this.feedStore;\n\n            // Override the first feed, used for example with DCO\n            if (this.ad.overriddenFeedData && this._preloadAssets.feeds.length > 0) {\n                this.renderer.feedStore.feeds.set(this._preloadAssets.feeds[0], {\n                    feed: {\n                        data: this.ad.overriddenFeedData,\n                        intervalInSeconds: 0,\n                    },\n                    interval: undefined,\n                    overridden: true\n                });\n            }\n\n            await this._preloadFeeds();\n            _performanceMark('ac:init:load:feeds:end');\n        }\n\n        this.animator = creative.animator_m;\n\n        this._initEventBubbling();\n\n        _performanceMark('ac:init:render:start');\n        // Viewtree has to be initialized before preloading fonts, images and videos\n        this.renderer.render(this._rootElement, 0, true);\n        _performanceMark('ac:init:render:end');\n\n        try {\n            console.debug('[AnimatedCreative] preloading fonts');\n            await this._preloadFonts();\n            console.debug('[AnimatedCreative] loaded fonts');\n        } catch (e) {\n            console.error('Failed to preload fonts', e);\n        } finally {\n            // Note: We have to rerender to include the fonts\n            // TODO: Remove this hack in the future. when we rewrite renderer to have loadAssets method.\n\n            _performanceMark('ac:init:rerender:start');\n            this.renderer.rerender_m(this.creativeDataNode);\n            _performanceMark('ac:init:rerender:end');\n        }\n\n        try {\n            console.debug('[AnimatedCreative] preloading elements');\n            _performanceMark('ac:init:load:elements:start');\n            const preloadElements = [...this.renderer.preloadingElements.values()];\n            // not supported in all browsers\n            if (Promise.allSettled) {\n                const results = await Promise.allSettled(preloadElements);\n                console.debug('[AnimatedCreative] loaded elements');\n\n                results.forEach(result => {\n                    if (result.status === 'rejected') {\n                        throw result.reason;\n                    }\n                });\n            } else {\n                await Promise.all(preloadElements);\n            }\n            _performanceMark('ac:init:load:elements:end');\n        } catch (err) {\n            const error = err as {\n                message?: string,\n                url?: string\n            };\n            if (error.message) {\n                this._handleError(error.message, {\n                    level: 'error',\n                    contexts: {\n                        image: error.url ? { url: error.url } : undefined,\n                        originalError: err\n                    }\n                });\n            } else {\n                console.error(err);\n            }\n        }\n\n        this._checkForWidgetElementNodes();\n\n        if (this.renderer.WidgetRenderer) {\n            try {\n                console.debug('[AnimatedCreative] loading widgets');\n                _performanceMark('ac:init:load:widgets:start');\n\n                // Ugly workaround to ensure that all widgets has completely loaded to ensure that they are in sync with the creative\n                await Promise.all(this.renderer.WidgetRenderer.widgetInitializingPromises);\n                await Promise.all(this.renderer.WidgetRenderer.widgetLoadingPromises);\n\n                console.debug('[AnimatedCreative] loaded widgets');\n                _performanceMark('ac:init:load:widgets:end');\n            } catch (err: any) {\n                this._handleError(err.message, {\n                    level: 'error',\n                    contexts: err.contexts ?? undefined\n                });\n            }\n        }\n\n        // Sometimes iframe is hidden (display: none), for on-site banners. Where the publisher have\n        // implemented media queries to show and hide multiple banners to simulate responsiveness.\n        // Hidden loaded banners have the fallback, that they have zero height when inspected, which\n        // currently affects text rendering. So, we have to wait until it is shown to rerender.\n        _performanceMark('ac:init:visibility:check');\n\n        if (!this._isPixelVisible()) {\n            console.debug('[AnimatedCreative] not visible. Adding visibility listener');\n\n            this._pixelVisibleInterval = contentWindow.setInterval(() => {\n                if (this._isPixelVisible()) {\n                    console.debug('[AnimatedCreative] became visible');\n\n                    this.renderer?.rerender_m(this.creativeDataNode);\n                    this._showIframe();\n                    if (Animator) {\n                        this._initPlayback();\n                    }\n                    contentWindow.clearInterval(this._pixelVisibleInterval);\n                }\n            }, 10);\n        }\n        else {\n            this._showIframe();\n\n            if (Animator) {\n                this._initPlayback();\n            }\n        }\n\n        if (typeof this._onLoadCallback === 'function') {\n            this._onLoadCallback(this);\n        }\n\n        _performanceMark('ac:init:end');\n    };\n\n    private _getRootElement(): HTMLElement {\n        if (this._inSandboxedIframe) {\n            return this.ad.container;\n        }\n        else {\n            return this._document.body;\n        }\n    }\n\n    /**\n     * @summary\n     * Check pixel visibilty.\n     *\n     * @description\n     * The ability to render visible pixels on the banner. Notice, this API is different from\n     * DOM visibility, where display none is still counted as visibly. We have manually confirmed\n     * that display none:ed DOM subtree's are cheap to check bounding rect.\n     */\n    private _isPixelVisible(): boolean {\n        const testElement = this._document.createElement('div');\n        const style = testElement.style;\n        style.height = '1px';\n        style.width = '1px';\n        style.position = 'absolute';\n        style.top = '-100000px';\n        this.ad.container.appendChild(testElement);\n        const result = testElement.getBoundingClientRect().height > 0;\n        this.ad.container.removeChild(testElement);\n        return result;\n    }\n\n    private _checkForWidgetElementNodes(): void {\n        if (!this.renderer) {\n            return;\n        }\n\n        for (const element of this.renderer.creativeDocument.elements) {\n            if (isWidgetNode(element)) {\n                this.hasWidgetElements = true;\n                break;\n            }\n        }\n    }\n\n    private _initPlayback(): void {\n        _performanceMark('ac:animator:start');\n\n        if (!this.animator) {\n            return;\n        }\n\n        const autoplay = this.ad.shouldAutoplay();\n        this.animator.seek(this._getStartTime());\n\n        if (this.ad.isOmniRender()) {\n            // Map stop and pause for omniRender record logic\n            // OmniRender stops recording when loop is emitted\n            // and set loops to 1\n            this.creativeDataNode.loops = 1;\n            this.animator.on('pause', () => {\n                if (!this._stoppedOmniRenderRecording) {\n                    this._stoppedOmniRenderRecording = true;\n                    setTimeout(() => this.animator?.emit('loop'), 0);\n                }\n            });\n        }\n        // Play/pause creative when it leaves or enter view\n        if (this.ad.viewability.pauseOutsideView()) {\n            this.ad.on(AdEvents.ViewEnter, () => {\n                this.animator?.play();\n            });\n            this.ad.on(AdEvents.ViewLeave, () => {\n                this.animator?.pause();\n            });\n            if (this.ad.viewability.visible && autoplay) {\n                this.animator.play();\n            }\n        }\n        else if (autoplay) {\n            console.debug('[AnimatedCreative] autoplaying');\n            this.animator.play();\n        }\n\n        this.ad.on(AdEvents.Stop, () => {\n            this.animator?.pause();\n        });\n\n        _performanceMark('ac:animator:end');\n    }\n\n    /**\n     * When user clicks the creative\n     */\n    private _onClick = (e: MouseEvent, deepLinkUrl?: string): void => {\n        const url = this._getClickUrl();\n        if (!url) {\n            return;\n        }\n\n        if (deepLinkUrl) {\n            this.ad.tracking.click({ x: e.x, y: e.y, deepLinkUrl });\n        }\n        else {\n            this.ad.tracking.click(e);\n        }\n    };\n\n    private _getStartTime(): number {\n        const seek = parseFloat(this.ad.parameters?.seek || '');\n\n        // Seek parameter is added to the tag\n        if (!isNaN(seek)) {\n            return seek;\n        }\n        // Used by image generator to capture preload image at the right place in timeline\n        if (this._shouldStartFromPreloadFrame()) {\n            const preloadFrame = this.creativeDataNode.preloadImage?.frames && this.creativeDataNode.preloadImage.frames[0];\n\n            // Defaults to 1 if not set\n            return typeof preloadFrame === 'number' ? preloadFrame : 1;\n        }\n        else {\n            return this.creativeDataNode.startTime || 0;\n        }\n    }\n\n    private _shouldStartFromPreloadFrame(): boolean {\n        return this.ad.parameters?.seek === 'preload-frame';\n    }\n\n    private _setEnvironments(env?: ICreativeEnvironment): void {\n        if (env) {\n            this.env = env;\n            this.env.ANIMATED_CREATIVE_JS = true;\n            this.env.IN_IMAGE_GENERATOR = this.ad.parameters.env === 'image-generator' || this._shouldStartFromPreloadFrame();\n            if (!isBannerflow(window.location.href)) {\n                const origin = this.ad.getOrigin();\n                if (!isBannerflow(origin!)) {\n                    this.env.CUSTOM_AD_DOMAIN = getDomain(origin, false);\n                }\n\n                if (origin) {\n                    for (const e in this.env) {\n                        const value = this.env[e];\n                        if (!isUrl(value)) {\n                            continue;\n                        }\n                        if (isRelativeUrl(value)) {\n                            this.env[e] = concatUrl(origin, value);\n                        } else if (!origin.includes('bannerflow.com/creatives')) {\n                            // don't replace origin for ACG hosted ads in production\n                            this.env[e] = replaceOrigin(value, origin);\n                        }\n                    }\n                }\n            }\n            imageOptimizerDefaults.imageOptimizerOrigin = this.env.IMAGE_OPTIMIZER_ORIGIN;\n        }\n    }\n\n    /**\n     * Create wrapping iframe.\n     * Note that in this stage we cannot insert content into the iframe in all browers (FF)\n     */\n    private _createIframe(): HTMLIFrameElement {\n        const iframe = document.createElement('iframe');\n        // Dimension hacks to fix iframe issues in iOS:\n        // https://stackoverflow.com/a/20142280\n        const style = iframe.style;\n        style.width = style.height = '1px';\n        style.minWidth = style.maxWidth = style.minHeight = '100%';\n        style.outline = style.border = style.transform = style.filter = 'none';\n        style.display = 'block';\n        style.position = 'absolute';\n        style.left = style.top = style.opacity = '0';\n        style.transformOrigin = '0 0';\n        iframe.src = 'about:blank';\n        iframe.scrolling = 'no';\n\n        if (this.ad.shouldFadeIn()) {\n            style.transition = 'opacity 0.2s ease';\n        }\n        this.ad.container.appendChild(iframe);\n\n        return iframe;\n    }\n\n    private _showIframe(): void {\n        console.debug('[AnimatedCreative] showing iframe');\n        _performanceMark('ac:iframe:show');\n\n        if (this._iframe) {\n            this._iframe.style.opacity = '1';\n        }\n    }\n    /**\n     * Needs to be executed AFTER the document is ready\n     */\n    private _insertCreativeStyles(): void {\n\n        const url = this._getClickUrl();\n        const cursor = url ? 'pointer;' : 'default;';\n        const doc = this._document;\n        const style = doc.createElement('style');\n\n        style.innerHTML = `*{box-sizing: border-box;}html,body{margin:0;padding:0;overflow:hidden;width:100%;height:100%;-ms-user-select:none;-moz-user-select:none;-webkit-user-select:none;user-select:none;cursor:${cursor};}`;\n\n        this.creativeStylesRef = style;\n\n        doc.head.appendChild(style);\n    }\n\n    private _getClickUrl(): string | undefined {\n\n        const redirectUrl = this.ad.tracking.getRedirectUrl();\n\n        if (redirectUrl === false) {\n            return;\n        }\n\n        return redirectUrl || this.ad.tracking.getTargetUrl();\n    }\n\n    /**\n     * When iframe window is ready\n     * @param callback\n     */\n    private _onIframeWindowLoad(iframeWindow: Window, callback: () => any): void {\n        console.debug('[AnimatedCreative] waiting for iframe');\n\n        if (iframeWindow.document.readyState === 'complete') {\n            setTimeout(() => {\n                callback();\n            }, 100);\n        } else {\n            const onLoad = (): void => {\n                if (callback) {\n                    callback();\n                }\n                if (iframeWindow) {\n                    iframeWindow.removeEventListener('load', onLoad);\n                }\n            };\n            iframeWindow.addEventListener('load', onLoad);\n        }\n    }\n\n    private _initEventBubbling(): void {\n        const { animator, ad } = this;\n\n        if (animator && ad) {\n            console.debug('[AnimatedCreative] subscribing to animator events');\n\n            animator.on('loop', () => ad.emit(AdEvents.Loop, [this._getAnimatorEventData()]));\n            animator.on('pause', () => ad.emit(AdEvents.Pause, [this._getAnimatorEventData()]));\n            animator.on('play', () => ad.emit(AdEvents.Play, [this._getAnimatorEventData()]));\n            animator.on('stop', () => ad.emit(AdEvents.Stop, [this._getAnimatorEventData()]));\n            animator.on('seek', () => ad.emit(AdEvents.Seek, [this._getAnimatorEventData()]));\n            _performanceMark('ac:animated-events:added');\n        }\n    }\n\n    private _getAnimatorEventData(): IAdEventData {\n        const animator = this.animator;\n\n        return {\n            ad: this.ad,\n            time: animator?.time || 0,\n            loop: animator?.loop || 0\n        };\n    }\n\n    destroy(): void {\n        clearInterval(this._pixelVisibleInterval);\n        this._rootElement?.removeEventListener('click', this._onClick);\n        this.destroyed = true;\n\n        try {\n            if (this.creativeStylesRef) {\n                this._document.head.removeChild(this.creativeStylesRef);\n                this.creativeStylesRef = undefined;\n            }\n            // eslint-disable-next-line no-empty\n        } catch { }\n\n        this.renderer?.destroy();\n        this.animator?.destroy();\n    }\n\n    /**\n     * Preloads all feeds as well as fonts that are used in conjunction as character styling\n     */\n    private async _preloadFeeds(): Promise<void> {\n        _performanceMark('ac:preload:feeds:start');\n\n        this.creativeDataNode.elements.forEach(child => {\n            if (isTextNode(child)) {\n                for (const span of child.content.spans) {\n                    if (span.type === SpanType.Variable) {\n                        if (this._preloadedFeeds.indexOf(span.style.variable!.id) === -1) {\n                            this._preloadedFeeds.push(span.style.variable!.id);\n                        }\n                    }\n                }\n            }\n            else if (child.feed && (isImageNode(child) || isVideoNode(child))) {\n                    if (this._preloadedFeeds.indexOf(child.feed.id) === -1) {\n                        this._preloadedFeeds.push(child.feed.id);\n                    }\n            }\n        });\n\n        await this.feedStore.preloadFeeds(this._preloadedFeeds);\n        _performanceMark('ac:preload:feeds:end');\n    }\n\n    private _getDpr(): number {\n        // STUDIO-6228 - use better quality images in exported creatives\n        // explicitly left out for fitOption=cover above, because it needs the exact size\n        if (this.env.IN_IMAGE_GENERATOR || this.ad.isOmniRender()) {\n            return 2;\n        }\n        return 1;\n    }\n\n    private async _preloadFonts(): Promise<void> {\n        _performanceMark('ac:preload:fonts:start');\n\n        if (this.feedStore) {\n            this.renderer?.creativeDocument.elements.forEach(child => {\n                if (isTextNode(child)) {\n                    for (const span of child.content.spans) {\n                        if (span.type === SpanType.Variable) {\n                            this.feedStore.addFeedElement(child.id, span.style.variable as IFeed, child);\n                        }\n                    }\n                }\n            });\n\n            for (const id of this._preloadedFeeds) {\n                // Adds to fontCharacterCache and uses preload below if in output\n                this.feedStore.loadFontsBasedOnFeedData(id, true);\n            }\n        }\n\n        for (const font of this._preloadAssets.fonts) {\n            if (font) {\n                if (!font.src.startsWith('data')) {\n                    const [url, encodedChars] = font.src.split(FONT_SERVICE_TEXT_PARAMETER);\n                    const feedCharacters = (this.feedStore && this.feedStore.fontCharacterCache.get(font.id)) || '';\n                    const textCharacters = decodeURIComponent(encodedChars);\n                    const { textParams, distinctText }: IFontServiceParams = getFontServiceParamsFromString(feedCharacters + textCharacters);\n                    if (feedCharacters) {\n                        this.feedStore.fontCharacterCache.set(font.id, distinctText);\n                        font.src = url + textParams;\n                    }\n                    // Don't load the font if no characters are included\n                    if (!distinctText) {\n                        continue;\n                    }\n                }\n\n                try {\n                    const fallbackFontInjection = window.app === 'bannerflow' && this.ad.parameters['font-loading'];\n                    if (!fallbackFontInjection) {\n                        const fontFace = await injectFontFace(font, this.env.FONTSERVICE_API_ORIGIN);\n                        this._document.fonts.add(fontFace);\n                    } else {\n                        injectFontStyle(this._document, font, this.env.FONTSERVICE_API_ORIGIN);\n                        await this._document.fonts.load(`1em f-${font.id}`); // resolves once the passed font family is loaded\n                    }\n                } catch (err) {\n                    /* Do nothing */\n                    this._handleError('Could not load font', {\n                        level: 'error',\n                        contexts: {\n                            font,\n                            originalError: err\n                        }\n                    });\n                }\n            }\n        }\n        _performanceMark('ac:preload:fonts:end');\n    }\n\n    private _handleError(message: string, sentry?: SentryError): void {\n        if (sentry && window.app === 'bannerflow' && !!Sentry) {\n            Sentry.captureMessage(message, {\n                level: sentry.level,\n                contexts: sentry.contexts\n            });\n        }\n        console.error(message);\n    }\n}\n\ninterface SentryError {\n    level: string;\n    contexts?: { [key: string]: any; };\n}\n\nexport { Color } from '../creative/color';\n"],"names":["inProgress","dataWebpackPrefix","userAgent","window","navigator","toLowerCase","isOpera","opr","addons","opera","indexOf","isFirefox","InstallTrigger","isSafari","vendor","isEdge","document","documentMode","StyleMedia","isChrome","test","isEdgeChromium","isIpad","CSS","match","platform","maxTouchPoints","preciseIOSVersion","agent","start","simple","Number","substr","replace","full","split","map","v","major","minor","patch","e","console","warn","getBrowserVersion","ua","tem","M","exec","parseFloat","appName","appVersion","splice","fitOptionToSizeMode","fitOption","ImageOptimizerUrlBuilder","origin","_options","static","defaultOrigin","dpr","webP","minorIOSVersion","webPPromise","Promise","res","Image","onload","onerror","height","src","testWebP","element","imageSettings","sizeMode","size","originalSize","alignH","alignV","width","renderedImageSize","x","y","croppingArea","scale","crop","points","x2","Math","min","y2","getCroppingOptions","imageAsset","settings","sizeLimit","states","reduce","accumulator","state","scaleX","scaleY","max","coverSize","assetWidth","assetHeight","getMaxScaledSize","url","feedUrl","defaultQuality","force","undefined","quality","cropping","format","getFormat","urlWithOrigin","getDevicePixelRatio","highDpi","getUrl","options","baseOptions","Error","imageOptimizerOrigin","imageOptimizerDefaults","webpSupport","param","decodeURIComponent","position","positionX","positionY","w","round","h","q","imageOptimizerParameters","u","encodeURIComponent","f","rt","getOptimizerRatioParameter","query","method","getImageOptimizerUrl","urlOrElement","imageUrl","this","getImageExtension","isNotSvgOrGif","isSizeModeCrop","__data","_isOptimized","getOriginalUrl","isOptimizedUrl","devicePixelRatio","webPSupport","originalFormat","iOSVersion","domainRegex","urlRegex","getUrlParameters","urlParams","cache","URL","searchParams","forEach","value","key","search","decode","s","substring","location","isRelativeUrl","isUrl","isBase64","str","startsWith","concatUrl","domain","path","length","charAt","getDomain","stripProtocol","removeProtocol","replaceOrigin","newOrigin","isBannerflow","hostname","isSameDomain","a","b","objectToQueryString","params","removeEmpty","queries","toString","push","join","getFileExtension","matches","isVideoFile","ext","isInLocalEnvironment","protocol","registerActionEventHandlers","ActionHandler","triggers","trigger","event","forceClearStates","callback","hasActionPreventClickthrough","dataElement","actions","some","action","disabled","preventClickThrough","hasActionTargetUrl","operations","op","isCancelTrigger","getInAnimationDuration","animations","getAnimationDurationOfType","getOutAnimationDuration","type","getDurationOfAnimations","filter","animation","getDuration","getAllKeyframes","isElementVisibleAtTime","time","isTimeAt","elementOrAnimations","Array","isArray","keyframes","getPreviousTime","times","tolerance","t","numberToTime","slice","sort","sortByTimeReversed","find","k","getNextTime","sortByTime","duration","toRelativeTime","absoluteTime","getTime","from","target","isTimeBetween","t1","t2","toTimeAndDuration","to","getTimeBetween","k1","k2","Animator","constructor","creative","_renderer","super","isPlaying","loop","_destroyed","_preview","_startTimestamp","_lastTime","_speed","_elementsAnimationState","Map","_eventQueue","_isOmniRender","href","_tick","_cancelAnimation","stopTime","_getStopTime","loops","timeDiff","timeInSeconds","_infinite","stop","setTime_m","pause","next","pop","fn","emit","_requestId","requestAnimationFrame","latestAnimationEnd","elements","getCreativeAnimationDuration","play","preview","_getStartTime","setPlaying_m","toggle","seek","replay","offset","exceededLimit","feedStore","setFeedLoop","setLoop","prev","exceedLimit","restart","resetIndexState","skipNextIndexUpdate","render_m","forceUpdate","_updateElementsState","setAllViewElementsValues_m","useCreative_m","updateElementsCurrentIndex","addToQueue","bind","i","has","id","set","visible","currentState","get","animationState","inDuration","outDuration","outDurationStart","isAtStartOfElement","isAtEndOfElement","startTime","cancelAnimationFrame","env_m","ANIMATED_CREATIVE_JS","destroy","clearEvents","Color","color","stops","setColor","red","green","blue","hue","saturation","lightness","alpha","hsl","l","angle","atan2","end","PI","copy","toJSON","addColorStop","defaultValue","HEX_COLOR_PATTERN","IMPLICIT_HEX_COLOR_PATTERN","RGBA_COLOR_PATTERN","RGB_COLOR_PATTERN","parseColor","cachedColor","hex","parseInt","RGBToHSL","fromHEX","fromRGBAstring","rgb","fromRGBstring","linearGradient","splitStr","lastIndexOf","shift","rad","cos","sin","data","colorStr","trim","extractColorStopPositionFromAngle","createGradientFromString","fromLinearGradient","fromRGBA","r","g","rgba","mixColor","baseColor","colors","targetColor","redOffset","greenOffset","blueOffset","alphaOffset","startPositionOffset","endPositionOffset","startOffset","endOffset","c","amount","index","startColors","endColors","tintColor","offsetY","d","roundChannel","channel","channelToHex","toUpperCase","toHEX","toRGBA","toLinearGradient","stopColor","positionOrOffset","decodeFeedPath","isSpaceLikeCharacter","ch","isVariableSpan","span","isNewlineLikeCharacter","forEachSpan","text","spans","lastIndex","getHorizontalFlexAlignment","horizontalAlignment","getVerticalFlexAlignment","verticalAlignment","createRichTextFromString","style","createSpansFromString","concat","content","top","left","lineHeight","attributes","dir","properties","copyStyleFn","styleId","styleIds","previousStyleIds","previousStyleIdToHistoryIndexMap","currentTextSpan","lastSpanType","variable","charCodeAt","String","fromCharCode","clone","__previousStyleIds","__previousStyleIdToHistoryIndexMap","newStyle","shouldRenderNumber","isVersionedText","property","propertyValue","parsed","JSON","parse","styles","hasSameStyleIds","source","sourceDesignId","sourceStyleId","entries","hasSameStyleProperty","treatMissingAsFalse","targetValue","sourceValue","targetStyle","sourceStyle","fontFamilyId","weight","targetPadding","sourcePadding","bottom","right","sourceShadows","targetShadows","sourceShadow","targetShadow","blur","offsetX","spread","copySpans","result","copySpan","contentSpanCopy","styleCopy","WidgetEvent","CreativeEvent","TimelineEvent","FONT_SERVICE_TEXT_PARAMETER","getFontServiceParamsFromString","distinctText","textParams","BaseDataNode","locked","hidden","BaseDataNodeWithChildren","input","_elements","_nodes","name","kind","nodes","setNodes_m","Object","freeze","_duration","node","_applyParentToNode","_setFlatViewElementsList","closestAncestor","__parentNode","__rootNode","includeGroups","group","n","nodeIterator_m","CreativeDataNode","_reverseNodes","nodeWithChildren","reverse","addNode_m","atIndex","newNodeList","remove_m","parent","parentNodeIndex","findIndex","removeNodeById_m","findNodeById_m","nodeId","newNodeTree","noEmit","callbacks","guidelines","fill","textColor","gifExport","frames","show","preloadImage","socialGuide","getFirstPreloadImageFrame","getStopTime_m","subscribe_m","unsubscribe_m","destroy_m","isNodeWithKind","Boolean","buildIsNodeKind","kinds","testKind","isTextNode","isVideoNode","isImageNode","isWidgetNode","isViewElementNode","isSelectionVisibleAtTime","isHidden","createDefaultTextProperties","padding","maxRows","Infinity","textOverflow","characterSpacing","__fontFamilyId","characters","currentCidIndex","createElementCid","numberSystem","numerals","currentNumber","remainder","getNumberSystemEncoding","resetNodeCid","forEachElement","atTime","forEachNode","forEachDataElement","groupNode","toFlatElementNodeList","flatNodeList","hasHiddenParent","hasHiddenAncestor","parentNode","getElementTextProperties","characterProperty","createViewElement","viewElement","elementCid","cidIndex","ratio","font","feed","customProperties","isFormulaValue","formulaToValue","formula","dependencies","validation","canvasSize","propertyName","rotationX","rotationY","rotationZ","creativeWidth","creativeHeight","getCacheValidationObject","getCacheValidationKey","evalCacheValidationMap","evalCacheValueMap","delete","getCachedEval","mainValue","boundingBox","props","edgePoint","edge","elementSize","roundTo","dx","dy","vertical","horizontal","getEdgePointBasedOnAngle","transition","expression","formulaToEvalExpression","parsedValue","isNaN","AdditiveProperties","mergeStates","timeStates","lerpAdditive","merged","timeState","rate","p","currentValue","unit","currentOrElementValue","isAdditiveProperty","mergeNumbers","mergeProperty","topLeft","topRight","bottomLeft","bottomRight","mergeRadius","mergeColors","fromShadows","toShadows","shadows","fromColor","toColor","mergeShadows","Set","keys","memo","default","mergeFilters","thickness","mergeBorders","tint","limitNumberProperty","resolveStateFormulaValue","getViewElementProperty","mergedState","stateValue","stateValueOrValue","numericValue","getNumericPropertyValue","isScalableProperty","scaleNumericValue","getViewElementBorder","shadow","getShadowPropertyValue","getViewElementPadding","newShadow","animationsToState","maxRate","mergeActionStates","animationStates","animationToStates","unshift","getStateById","resolveStateFormulas","resolvedState","prevState","stateId","nextState","timingFunction","getPropertyKeysInStates","additive","isEmptyState","getAdditiveStateProperties","nonAdditive","getNonAdditiveStateProperties","deserializePropertyValue","isKeyFrame","fontStyle","atob","Buffer","border","textShadows","_","step","occurrence","fallback","decodedValue","deserializeVersionedText","versionedText","msg","remappedSpans","styleIdMap","documentId","DEFAULT_TIMING_FUNCTION","getTimingFunctionValueBetween","before","after","getTimingFunctionFromKeyframe","keyframe","getTimingFunctionByKey","timingFunctions","func","linear","easeInExpo","pow","easeOutExpo","easeInOutExpo","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInElastic","easeOutElastic","easeInOutElastic","easeInBack","overshoot","easeOutBack","easeInOutBack","easeInBounce","bounce","easeOutBounce","easeInOutBounce","ActionOperationMethod","ActionTrigger","AnimationTypes","ColorType","ApprovalStatus","CreativeType","ImageSizeMode","DEFAULT_IMAGE_QUALITY","DEFAULT_IMAGE_SETTINGS","Fit","characterPropertyToUnitMap","textPropertyToUnitMap","getObjectKeys","object","textProperties","characterProperties","widgetPropertyToUnitMap","sharedPropertyToUnitMap","statePropertyToUnitMap","propertyToUnitMap","ScalableProperties","propertyMaxValues","opacity","propertyMinValues","radius","RadiusType","FilterType","FilterUnit","FILTER_MAP","Blur","icon","Length","Contrast","Percentage","Invert","Grayscale","Saturation","Sepia","MetaPlacement","TiktokPlacement","SocialNetworkType","DEFAULT_PLACEMENT_POSITION","META_PLACEMENTS","Instagram","Facebook","Messenger","FacebookReels","InstagramReels","TIKTOK_PLACEMENTS","Default","After9s","After9sWithCard","Meta","TikTok","animatableProperties","Role","LibraryWidgetState","WIDGET_PROPERTY_PREFIX","LockedDirection","NodeName","NodeKind","NodeKindIcon","VARIABLE_PREFIX","cloneDeep","cloneDeepHelper","val","seen","prototype","call","copy_1","child","copy_2","create","getPrototypeOf","cloneMapDeep","clonedMap","metadata","defineMetadata","decorations","getOwnMetadata","inject","token","option","propertyKey","parameterIndex","parameterMap","optional","forwardRef","__inject","DIContainer","__container","Container","_constructorMetadataMap","_objectMap","_instanceMap","_factoryMap","register_m","parentParameterIndex","containerParameterIndex","Function","constructorMetadata","unregister_m","maybeResolve","_recursivelyResolve","clear","resolve","isOptional","registerFactory_m","context","_recursivelyGetMetadata","args","item","cachedInstance","container","childrenWithParent","parameter","instance","enumKeyIndex","factory","BaseError","UnauthenticatedError","errorMeta","error","rejection","networkError","originalError","getPrimaryError","isInstanceOf","statusCode","message","includes","defaultErrorContext","enabled","level","handleError","errorContext","contexts","tracker","TrackerService","captureMessage","EventEmitter","_eventCallbacks","_thisArg","skipEmission","on","propOrCallback","once","temporary","apply","off","propOrArgs","err","getBoundingRectangleOfRotatedBox","corners","inset","calculateCenter","center","getBoundingCorners","minX","minY","compareSize","isSameSize","comparativeSize","sizes","every","boundsToPointRect","bounds","x1","y1","aspectRatioScale","fit","rounding","scaleFn","roundFn","getRoundingFn","alignWithinBounds","horizontalAlign","verticalAlign","alignX","alignToNumber","alignHorizontallyWithinBounds","alignY","alignVerticallyWithinBounds","roundBounds","roundPosition","roundSize","num","align","IdentityMatrix","tan","sqrt","Matrix","matrix","parse_m","_matrix","_getIdentityMatrix","matrixString","toCSS_m","multiply_m","factorMatrix","_multiplyMatrices","rotate_m","z","sinX","cosX","sinY","cosY","sinZ","cosZ","rotationMatrixX","rotationMatrixY","rotationMatrixZ","m","rotateX_m","radians","rotateY_m","rotateZ_m","skew_m","tanX","tanY","translate_m","scale_m","getTranslateX_m","_getValue","getTranslateY_m","getTranslateZ_m","getScaleX_m","_getVectorLength","getScaleY_m","perspective_m","distance","isMirrorX_m","isMirrorY_m","_multiplyMatrixAndPoint","point","c0r0","c1r0","c2r0","c3r0","c0r1","c1r1","c2r1","c3r1","c0r2","c1r2","c2r2","c3r2","c0r3","c1r3","c2r3","c3r3","matrixA","matrixB","row0","row1","row2","row3","result0","result1","result2","result3","col","row","loadImagePromise","loadHtmlElement","resolver","PromiseResolver","reject","promise","rej","iframe","iframePromise","defaultContext","pi","abs","ceil","floor","random","isSandboxed","evalMathExpression","SafeEval","code","init","contentWindow","iframeEvalMathExpression","contentDocument","isSandboxedIframe","createElement","pointerEvents","body","appendChild","iframeDoc","nonce","process","env","STUDIO_JS","evalScript","createObjectURL","Blob","scriptPromise","head","revokeObjectURL","open","write","close","removeChild","SAFE_URL_PATTERN","DATA_URL_PATTERN","sanitizeUrl","isSafeUrl","SimpleCache","clamp","minValue","MIN_SAFE_INTEGER","maxValue","MAX_SAFE_INTEGER","decimal","number","roundToNearestMultiple","deepEqual","fastDeepEqual","RegExp","flags","valueOf","hasOwnProperty","pick","obj","newObj","omit","assign","omitUndefined","xmlEntities","charToXmlEntity","charToHtmlEntity","encodeHtml","decodeXML","crcTable","makeCRCTable","getCookie","parts","cookie","rotatePosition","multiple","alphaNumericSort","emojiRegex","trimEmojis","distinctString","normalize","lerp","progress","stringLiteralArray","b64DecodeUnicode","fixedEncodeURIComponent","mod","getObjectDifference","__decorate","decorators","desc","arguments","getOwnPropertyDescriptor","Reflect","decorate","defineProperty","__param","paramIndex","decorator","__metadata","metadataKey","metadataValue","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","exports","module","__webpack_modules__","definition","o","enumerable","chunkId","all","promises","prop","done","script","needAttach","scripts","getElementsByTagName","getAttribute","charset","timeout","nc","setAttribute","onScriptComplete","clearTimeout","doneFns","setTimeout","Symbol","toStringTag","installedChunks","j","installedChunkData","errorType","realSrc","request","webpackJsonpCallback","parentChunkLoadingFunction","chunkIds","moreModules","runtime","chunkLoadingGlobal","self","isElementDescendantOfElement","parentElement","childElement","fontStyleMap","fontStyleURLMap","async","injectFontFace","fontServiceOrigin","fontURL","getFontURL","fontFace","preloadedFontURL","load","FontFace","injectFontStyle","fontFamily","fontType","fontStyleSheet","fontPreloadLink","rel","as","crossOrigin","textContent","fontUrl","IN_TEST","bfstudio","FONTS_AZURE_STORAGE_CDN_ORIGIN","_performanceMark","performance","mark","AdEvents","decodeCharacterRangeMap","L_BIDI_CHAR_RANGE_MAP","R_AND_AL_BIDI_CHAR_RANGE_MAP","encodedMap","conditions","condition","trimmedCondition","range","FALLBACK_FONT_FAMILY","RichText","text_m","rootElement_m","_option","editorState_m","editor_m","_fontFamilies","selectionSpanElements_m","lineToSpanDecorationLineElementMap_m","lineToSpanDecorationBackgroundLineElementMap_m","reachedTruncationLine_m","spans_m","lastVerticalMargin_m","wordWidth_m","variableSpanMap_m","rows_m","blurSuspensionListeners_m","_centerElements","_scale","_widestWord","_currentLineWidth","_distributeOneSpanAcrossTextLines","editableSpan","textLines","abortSignal","useDomIntrospection","restOfSpans","forceAppendToCurrentContentLine","forcedFontSize","_currentContentLine","_createContentLine","spanSize","_introspectSpan","fontSize","resizedElementFontSize_m","_calculateCurrentContentLineDimensions","isLastLine","_addScrollHeight","_lastBreakIndex","appendEndSpan","_previousSpanType","endsWithNewline","appendNewlineSpan","relativeFontSize","saveSpanPositionLeftAndSpanType","belowMaxRows","inEditMode","spinOffSpans","nextLineSpans","lineSpan","_addSpansAndTruncateCurrentContentLine","appendSpansThatExceedsCurrentContentLine","lineWidth","appendSpanToCurrentContentLine","preContentSpan","postContentSpan","lastOffset","copyOfSpan","introspectSpan","marginRight","widthWithoutMargins","splitSpan_m","splitWordOverflowedSpan","newRestOfSpans","shouldAbort","_emptyTextLines","handleWordsBiggerThanWidthOfElement","_onClick","inShowcaseMode","inPreviewMode","activePage","currentTarget","feedStore_m","feededElement","variableSpans","spanId","feedValue","getFeedValue","preventDefault","stopPropagation","targetUrl","_elementStyle","_syncProperties","_renderTextContainers","renderUnderscoreLayer_m","renderUnderscoreLayer","element_m","viewElement_m","_skipFontLoad","skipFontLoad","textSelection_m","selection","zoom_m","zoom","selectedCharacters","feedData","getFeed","feedElement","line","column","init_m","renderTextIntrospecter_m","initTask_m","_applyFontInRootElement","runTextPipeline_m","backgroundColor","centerElement_m","classList","add","display","alignItems","justifyContent","textElement_m","outline","spellcheck","resetDirtyContent","__dirtyContent","setText","keepSelection","reinitialize","keepStyle","normalizeTextLineSpans_m","getText_m","stopEdit","blurSuspension","removeEventListener","_removeTextIntrospecter","mouseBindings","onMouseUp","onMouseMove","computedStyle","getComputedStyle","paddingTop","paddingBottom","paddingLeft","paddingRight","boundingRect","getBoundingClientRect","firstChar","getBidiDirection_m","_recalibrateScale","_calibratorElement","applyFontInRootElement","textLineElementToLineMap_m","lineToTextLineElementMap_m","children","storeSelectionCharacterPositions","reselectText","expandedSpans","expandVariableSpans_m","_segmentBidiCharacters","_applyJointCharacters","distributeAllSpansAcrossTextLines_m","resizeText","_applyInferredTextDirections","_applyLeftToSpans","renderTextWithDecorations_m","isLeftAligned","textLine","textLines_m","currentRtlSpans","currentLtrSpans","lastLtrSpan","lastRtlSpan","prevDir","nextDir","isFirstSpan","isLastSpan","getSpanLength_m","startJoint","endJoint","curSpan","nextSpan","currentSpan","charAtZero","currentDirection","char","direction","_getSpansFromTextLines","_linearlyScaleText","widthOccupation","_longestLine","heightOccuptation","_scrollHeight","_scaleTextLineMetadata","trailingSpaceWidth","_getInlineContentArea","area","elementHeight","elementWidth","elementArea","resizeOccupationFactors","inFirstLoop","contentWidth","contentHeight","heightOccupation","contentArea","noOverflow","_resetResizeMetadata","newResettedFontSize","fontSizeDiff_m","_redistributeAllSpansAcrossLines","fontSizeDiffFactor","areaRatio","ratioRatio","areaRatioWeight","ratioRatioWeight","occupationFactor","bestOccupation","bestFontSize","resizeOccupationFactor","setStyle_m","preContent","postContent","styleIndex","removeDecorationLayers_m","centerElement","contains","fontFaceId","_getAllFontsInSpans","fontStyleIds","characterStyles","_textIntrospecter","ownerDocument","canvas","getContext","remove","maxFontSize","characterWidth","_truncateCurrentContentLine","outer","ellipsisWidth","introspectSpanSize","spanWidth","isFirstSpanInLine","newLineHeight","currentStyle","_previousContentLine","lastLine","useDom","fs","ff","_resolveCssFontFamily","isCapitalized","uppercase","metrics","measureText","toLocaleUpperCase","charSpacePixels","renderTextLines_m","newTextLines","currentTextLine","lastSpan","isMergeable_m","_hasSameStyleAndAttributes","sourceAttributes","targetAttributes","attribute","Date","now","variableSpan","feedSpans","_getElementTextProperties","resolvedText","inDesignView","styleResolver","getResolvedText","_resetTextMetadata","_getNegativeLineHeightMargin","applyStyleOnElement_m","innerHTML","WeakMap","overflow","textAlign","lineFragment","createDocumentFragment","lineElement","className","currentDir","whiteSpace","letterSpacing","marginTop","marginBottom","lastDir","bidiDirectionContainer","unicodeBidi","spanIndex","spanElement","__viewElement","STYLE_INDEX_MARGIN_RIGHT","shouldSkipRenderDecoration","_getStringSpanType","rootId","keyboardBindings","inputId","marginLeft","addFeedElement","addEventListener","compositionSpanElement","textDecoration","underline","strikethrough","spanStyle","useRelativeFontSize","animated","styleAttribute","handledTextDecorationProperty","characterStyleProperties","cssTextDecoration","textTransform","textShadow","cursor","applyOnlyAnimatedStyleOnElement_m","mergedStyle","isOfNodeSpanType_m","nodeType","dataset","getSpanTypeString_m","setStateOrElementStyle_m","stateStyle","rangeMap","isInCharacterRange_m","HTMLDivElement","AnimatorLite","_time","_delay","_timingFunction","_paused","_onCompletedCallbacks","onCompleted","_lastTimestamp","timestampDiff","_updateTarget","fromTo","_applySettings","_fromValue","_filterAnimatableProperties","_toValue","revert","delay","_onTick","_getCompletionRate","timing","_getTimingValue","isCompleted","ErrorMessage","makeRoundedShape","tl","tr","br","bl","SVG_IMAGE_OPTIONS","stretch","SVG_NAMESPACE","XLINK_NAMESPACE","IdSuffix","SvgShadowType","ImageError","setPrototypeOf","SVGBackground","_window","_element","_env","_shadowFilterElements","_shadowUseElements","_gradientElementStops","_shadows","_shadowType","None","_getSvgFillOption","_document","_baseUrl","querySelector","hash","_id","_shape","_getShape","_data","_createSVG","setViewBox","_svgElement","setResponsive","_width","_height","groupElement","createElementNS","shapeElement","defsElement","svgElement","zIndex","_shouldAddOutline","Shape","Group","_shapeElement","_defsElement","_groupElement","_foreignObject","_createForeignObject","__rootElement","prepend","foreignObject","_showLoader","_loaderElement","svgNamespace","wrapperGroup","circleGroup","circleElement","pathElement","animateTransform","backgroundElement","createSVGLoaderImage","_styles","_hideLoader","IN_IMAGE_GENERATOR","overrides","_setImageUrl","_setFill","_setBorder","_setSizeAndRadius","_setShadows","_getShadowOverflow","_imageElement","_setBorderSize","_setGradientSize","_setShadowSize","_setRadius","_setImageSize","_gradientElement","_gradientPosition","_fillToPosition","_createLinearGradient","gradientId","LinearGradient","gradientElement","firstStop","secondStop","calculateRadius","maxRadiusValue","applyMaxCap","currentRadius","_radius","_borderElement","colorString","_color","stopElement","_createBorderAndClipElement","borderId","Border","clipId","Clip","borderElement","_clipPathElement","clipUseElement","setAttributeNS","_borderUseElement","clipPathURL","thicknessChange","_border","boxShadow","BoxShadow","_setCssShadows","willChange","DropShadow","dropShadows","newShadows","shadowType","_getShadowType","changed","old","_shadowSize","_setSvgOverflow","groupId","svgShadowLength","SvgShadow","use","filterId","Shadow","filterElement","useElement","setPosition","afterNode","newNode","transformOrigin","insertBefore","nextSibling","colorMatrix","transform","_url","img","__loading","_loadImage","_clearImageElement","version","_imageLoadPromise","promiseResolver","ImageLoadingFailed","imageWasRemoved","ImageRemovedDuringLoad","removeAttributeNS","removeAttribute","imageElement","fillOption","isCropped","fitPosition","_getSvgImagePosition","_image","shadowWidth","shadowHeight","shadowSize","clip","isFeeded","overflowX","overflowY","_getAllShadowsFromDataElement","acc","curr","xString","yString","visitOneNode","visitor","visitCreative_m","visitRectangle_m","visitEllipse_m","visitImage_m","visitText_m","visitButton_m","visitWidget_m","visitVideo_m","visitAllNodes","visitOnlyTextLikeNodes","visitAllChildren","instanceCounter","Renderer","creativeDocument","WidgetRenderer","ad","styleRules_m","time_m","storedViewElements","destroyed_m","_htmlElements","_toggledStatesMap","_preventNextClickThrough_m","_imageDebounceTimeouts","preloadingElements","logger","app","_onCreativeMouseMove","isEditorMode","viewTree","__actionListeners","actionListener","actionStateEnabled","getAdditionalStates_m","additionalState","deepLinkUrl","_triggerClickActions","updateViewElementValues","setCreativeDocument","elements_m","versions_m","versions","_inDesignView","_browserDocument","_styleElement","_styleSheet","sheet","_fragment","_resetViewTree","canvasSize_m","creativeSize","_creativeDocument","getNodeIndex_m","_isPlaying","getViewElementById","inDV","_scopeId","_scopeIndex","rootElement","_scaleViewTree","insertStyle_m","boxSizing","setBackgroundElement_m","rectangle","_createViewElementFromDataElement","_createClickListener","ellipse","visitTextNode_m","button","getDefaultStyle_m","inServer","_renderText","image","_createClickListenerWithFeed","widgetDataElement","creativeElement","createWidget","videoDataElement","skipVideoRenderer","createVideoRenderer","__videoRenderer","onClick","onElementClick","actionListeners","al","listener","__svgBackground","verbose","setCreativeStyle","styleKey","styleProperty","_getImageUrl","DESIGN_VIEW","inMV","_debouncedGetImageUrl","addAdditionalState_m","_getAdditionalState","clearAdditionalStates_m","elementId","_getDataElementById","removeAdditionalStates_m","removeAdditionalState_m","stateMap","activeStates","renderElement","renderElement_m","textElement","richTextRenderer","__richTextRenderer","textDataElement","rerender","_onlyRenderTextWithoutFontLoad","createRichText","onElementInteractionsStarted","onElementInteractionsEnded","onElementDestroyed","onSpanClicked","onTextClick","setViewElementValues_m","setStyle","isLoop","additionalAnimationStates","isVisible","_shouldHideOverlapElement","_setViewElementValuesWithState","_renderStyleOnViewElement","debug","isWidget","originX","originY","mirrorX","mirrorY","filters","perspective","_getPerspective","imgElement","textPropertyChangedMap","previousProps","dynamicProperties","dirty","updateVideo","__widget","viewEndTime","styleRule","current","previous","previousStyle","rawStyleValue","changedStyles","styleProperties","backfaceVisibility","sizeChanged","elementIsFeeded","shouldRerender_m","shouldRerender","updateCreativeValues","renderElementById_m","setActions_m","el","_isTouchEvent_m","MouseEvent","relatedTarget","operation","_setActionState","passive","stateTargetViewElement","stateTargetDataElement","templateId","pressedAction","targetAction","ops","currentTimeState","targetState","rerender_m","_clearElementHandlers","_mountPoint","_removeStyles","_setBaseStyles","updateElementOrder_m","creativeApi","_resetInitialState","onlyRenderTextWithoutFontLoad","resetNodeId","_insertStyles","initialize","mountPoint","originalWidth","_calculateScale","_setScale","_initResizeObserver","render","destroyElement_m","isDefinitivelyDestroyed","documentNode","cid","_removeStyle","imageTimeout","nodeElement","__safari3dElement","_resizeObserver","disconnect","_createElement","_group","_moveViewElementInDom","bringElementToTop_m","MAX_VALUE","newIndex","domElement","tagName","currentIndex","elementIsVisibleAtTime","filterString","filterUnit","toFixed","isIOS","getPositionAndSizeStyle_m","borderRadius","visibility","rerenderText_m","getTransformMatrix_m","getTransformString_m","excludeTranslate","_getScaleOfElement","transformString","rule","cssRules","selectorText","deleteRule","styleSheet","insertRule","selector","rules","_getStyleValues","htmlElement","wrapper3d","fonts","getScale_m","_setScaleAndUpdate","host","responsive","ResizeObserver","observerEntries","entry","box","borderBoxSize","inlineSize","newScale","observe","hideElement_m","showElement_m","Creative","createRenderer","renderer_m","animator_m","registerFeaturesByFiles","files","registerTasks","file","registerWidgetFeature","registerFeedStoreFeature","registerVideoFeature","FeedStore","FeedStoreC","factoryContainer","brandId","renderer","WidgetRendererC","AdApi","AdApiC","CreativeApi","CreativeApiC","TimelineApi","TimelineApiC","VideoRenderer","VideoRendererC","animator","AnimatedCreative","creativeData","preloadAssets","_onLoadCallback","_preloadedFeeds","_preloadAssets","feeds","_stoppedOmniRenderRecording","_inSandboxedIframe","destroyed","_insertCreativeStyles","_rootElement","_getRootElement","adContainer","creativeDataNode","creativeContainer","richText","createFeedStore","widgetRenderer","createCreativeContainer","createCreative","selectedCreative","getOrigin","IMAGE_OPTIMIZER_ORIGIN","_getDpr","brand","overriddenFeedData","intervalInSeconds","interval","overridden","_preloadFeeds","_initEventBubbling","_preloadFonts","preloadElements","values","allSettled","status","reason","_handleError","_checkForWidgetElementNodes","widgetInitializingPromises","widgetLoadingPromises","_isPixelVisible","_showIframe","_initPlayback","_pixelVisibleInterval","setInterval","clearInterval","_getClickUrl","tracking","click","_setEnvironments","preloadAsset","_createIframe","_iframe","_onIframeWindowLoad","testElement","hasWidgetElements","autoplay","shouldAutoplay","isOmniRender","viewability","pauseOutsideView","ViewEnter","ViewLeave","Stop","parameters","_shouldStartFromPreloadFrame","preloadFrame","CUSTOM_AD_DOMAIN","ge","minWidth","maxWidth","minHeight","scrolling","shouldFadeIn","doc","creativeStylesRef","redirectUrl","getRedirectUrl","getTargetUrl","iframeWindow","readyState","onLoad","Loop","_getAnimatorEventData","Pause","Play","Seek","preloadFeeds","loadFontsBasedOnFeedData","encodedChars","feedCharacters","fontCharacterCache","textCharacters","FONTSERVICE_API_ORIGIN","sentry","Sentry"],"sourceRoot":""}