@duetds/components 8.6.9 → 8.7.0

package/lib/collection/utils/math.utils.spec.js

@@ -1,140 +0,0 @@
-/*!
- * Built with Duet Design System
- */
-import { clamp, roundTo, SafeParseFloat } from "./math.utils";
-describe("math utils", () => {
-    describe("roundTo", () => {
-        it("should round to whole numbers", () => {
-            expect(roundTo(123, 5)).toBe(125);
-            expect(roundTo(111, 5)).toBe(110);
-        });
-        it("should round to negative whole numbers", () => {
-            expect(roundTo(-123, 5)).toBe(-125);
-            expect(roundTo(-111, 5)).toBe(-110);
-        });
-        it("should round to decimal numbers", () => {
-            expect(roundTo(1.3, 0.5)).toBe(1.5);
-            expect(roundTo(1.2, 0.5)).toBe(1);
-            expect(roundTo(1.2, 1.5)).toBe(1.5);
-        });
-        it("should round to negative decimal numbers", () => {
-            expect(roundTo(-1.3, 0.5)).toBe(-1.5);
-            expect(roundTo(-1.2, 0.5)).toBe(-1);
-            expect(roundTo(-1.2, 1.5)).toBe(-1.5);
-        });
-    });
-    describe("clamp", () => {
-        it("should return value if in range", () => {
-            expect(clamp(5, 0, 10)).toBe(5);
-        });
-        it("should return min if value < min", () => {
-            expect(clamp(-5, 0, 10)).toBe(0);
-        });
-        it("should return max if value > max", () => {
-            expect(clamp(15, 0, 10)).toBe(10);
-        });
-        it("should return max if value > max for negative min", () => {
-            expect(clamp(15, -10, 10)).toBe(10);
-        });
-        it("should return min if value < min for negative min", () => {
-            expect(clamp(-15, -10, 10)).toBe(-10);
-        });
-    });
-    describe("SafeParseFloat with locale", () => {
-        it("should parse numbers in Swedish locale", () => {
-            expect(SafeParseFloat("12345,67", "sv-SE")).toBe(12345.67);
-            expect(SafeParseFloat("12 345,67", "sv-SE")).toBe(12345.67);
-            expect(SafeParseFloat("12 345,67€", "sv-SE")).toBe(12345.67);
-        });
-        it("should parse numbers in Finnish locale", () => {
-            expect(SafeParseFloat("12345,67", "fi-FI")).toBe(12345.67);
-            expect(SafeParseFloat("12 345,67", "fi-FI")).toBe(12345.67);
-            expect(SafeParseFloat("12 345,67€", "fi-FI")).toBe(12345.67);
-        });
-        it("should parse numbers in English locale", () => {
-            expect(SafeParseFloat("12345.67", "en-GB")).toBe(12345.67);
-            expect(SafeParseFloat("12,345.67", "en-GB")).toBe(12345.67);
-            expect(SafeParseFloat("12,345.67€", "en-GB")).toBe(12345.67);
-        });
-        it("should throw if something not a number is supplied", () => {
-            // @ts-ignore
-            expect(() => SafeParseFloat("definitely not a 10100 number ", "it-IT")).toThrow(Error);
-        });
-        it("should support negqative values", () => {
-            // @ts-ignore
-            expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
-            expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
-            expect(SafeParseFloat("-1€", "fi-FI")).toBe(-1);
-            expect(SafeParseFloat("-1", "fi-FI")).toBe(-1);
-            expect(SafeParseFloat("-1 €", "fi-FI")).toBe(-1);
-            expect(SafeParseFloat("-1 ", "fi-FI")).toBe(-1);
-            expect(SafeParseFloat("-10 ", "fi-FI")).toBe(-10);
-            expect(SafeParseFloat("- 10 ", "fi-FI")).toBe(-10);
-        });
-    });
-});
-describe("math-utils negative numbers", () => {
-    describe("roundTo", () => {
-        it("should round to negative decimal numbers", () => {
-            expect(roundTo(-1.3, 0.5)).toBe(-1.5);
-            expect(roundTo(-1.2, 0.5)).toBe(-1);
-            expect(roundTo(-1.2, 1.5)).toBe(-1.5);
-        });
-    });
-    describe("clamp", () => {
-        it("should return value if in range", () => {
-            expect(clamp(5, 0, 10)).toBe(5);
-        });
-        it("should return min if value < min", () => {
-            expect(clamp(-5, 0, 10)).toBe(0);
-        });
-        it("should return max if value > max", () => {
-            expect(clamp(15, 0, 10)).toBe(10);
-        });
-        it("should return max if value > max for negative min", () => {
-            expect(clamp(15, -10, 10)).toBe(10);
-        });
-        it("should return min if value < min for negative min", () => {
-            expect(clamp(-15, -10, 10)).toBe(-10);
-        });
-    });
-    describe("SafeParseFloat", () => {
-        it("should parse numbers in Swedish locale", () => {
-            expect(SafeParseFloat("-2", "sv-SE")).toBe(-2);
-            expect(SafeParseFloat("-2 €", "sv-SE")).toBe(-2);
-            expect(SafeParseFloat("-2€", "sv-SE")).toBe(-2);
-            expect(SafeParseFloat("- 2 €", "sv-SE")).toBe(-2);
-        });
-        it("should parse numbers in Finnish locale", () => {
-            expect(SafeParseFloat("-2", "fi-FI")).toBe(-2);
-            expect(SafeParseFloat("-2 €", "fi-FI")).toBe(-2);
-            expect(SafeParseFloat("-2€", "fi-FI")).toBe(-2);
-            expect(SafeParseFloat("- 2 €", "fi-FI")).toBe(-2);
-        });
-        it("should parse numbers in English locale", () => {
-            expect(SafeParseFloat("-2", "en-GB")).toBe(-2);
-            expect(SafeParseFloat("-2 €", "en-GB")).toBe(-2);
-            expect(SafeParseFloat("-2€", "en-GB")).toBe(-2);
-            expect(SafeParseFloat("- 2 €", "en-GB")).toBe(-2);
-        });
-        it("should not throw if unknown locale supplied", () => {
-            // @ts-ignore
-            expect(() => SafeParseFloat("12.345,67", "enokian")).not.toThrow(TypeError);
-        });
-        it("should support negative values", () => {
-            // @ts-ignore
-            expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
-            expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
-            expect(SafeParseFloat("-12 345.67€", "en-GB")).toBe(-12345.67);
-            expect(SafeParseFloat("-12 345,67€", "fi-FI")).toBe(-12345.67);
-            expect(SafeParseFloat("-12 345,67€", "sv-SE")).toBe(-12345.67);
-            expect(SafeParseFloat("-12,345.67€", "en-GB")).toBe(-12345.67);
-            expect(SafeParseFloat("-1€", "fi-FI")).toBe(-1);
-            expect(SafeParseFloat("-1", "fi-FI")).toBe(-1);
-            expect(SafeParseFloat("-1 €", "fi-FI")).toBe(-1);
-            expect(SafeParseFloat("-1 ", "fi-FI")).toBe(-1);
-            expect(SafeParseFloat("-10 ", "fi-FI")).toBe(-10);
-            expect(SafeParseFloat("- 10 ", "fi-FI")).toBe(-10);
-        });
-    });
-});

package/lib/collection/utils/string-utils.spec.js

@@ -1,39 +0,0 @@
-/*!
- * Built with Duet Design System
- */
-import { parsePossibleJSON } from "./string-utils";
-describe("string-utils", () => {
-    describe("parsePossibleString", () => {
-        it("returns exact same object, if object is passed", () => {
-            const object = { hello: "world" };
-            expect(parsePossibleJSON(object)).toBe(object);
-        });
-        it("returns exact same array, if array is passed", () => {
-            const array = [{ hello: "world" }];
-            expect(parsePossibleJSON(array)).toBe(array);
-        });
-        it("parses string arguments as JSON", () => {
-            const object = { hello: "world" };
-            const stringifiedObject = JSON.stringify(object);
-            expect(parsePossibleJSON(stringifiedObject)).toEqual(object);
-        });
-        it("gracefully handles malformed/invalid JSON", () => {
-            // spy on console.warn so we can assert it was called, and avoid mess in test output
-            const spy = jest.spyOn(global.console, "warn").mockImplementation(() => jest.fn());
-            // intentionally invalid JSON - unquoted property name
-            const stringifiedObject = '{ hello: "world" }';
-            expect(parsePossibleJSON(stringifiedObject)).toBe(undefined);
-            expect(console.warn).toHaveBeenCalled();
-            spy.mockRestore();
-        });
-        it("returns undefined for other types of data", () => {
-            expect(parsePossibleJSON(null)).toBe(undefined);
-            expect(parsePossibleJSON(undefined)).toBe(undefined);
-            expect(parsePossibleJSON(function () {
-                /*intentionally empty*/
-            })).toBe(undefined);
-            expect(parsePossibleJSON(true)).toBe(undefined);
-            expect(parsePossibleJSON(12345)).toBe(undefined);
-        });
-    });
-});

package/lib/collection/utils/template-utils.spec.js

@@ -1,39 +0,0 @@
-/*!
- * Built with Duet Design System
- */
-import { generateTemplateFn } from "./template-utils";
-describe("Template functions", () => {
-    it("works with dom nodes", () => {
-        document.body.innerHTML = '<div id="testing"><div>${name} <span>${someOther}</span></div> </div>';
-        const variables = {
-            name: "duet",
-            someOther: "other",
-        };
-        const testingDom = document.getElementById("testing");
-        const objectString = "<div>${name} <span>${someOther}</span></div>";
-        const domString = testingDom.firstElementChild.outerHTML;
-        const templateFn = generateTemplateFn(domString);
-        const templateOrig = generateTemplateFn(objectString);
-        const renderedTemplate = templateFn(variables);
-        const renderedTemplateOrig = templateOrig(variables);
-        expect(renderedTemplate).toBe(`<div>${variables.name} <span>${variables.someOther}</span></div>`);
-        expect(renderedTemplate).toBe(renderedTemplateOrig);
-    });
-    it("returns same string as string literals", () => {
-        const variables = {
-            name: "duet",
-            someOther: "other",
-        };
-        const objectString = "<div>${name} <span>${someOther}</span></div>";
-        const templateFn = generateTemplateFn(objectString);
-        expect(templateFn(variables)).toBe(`<div>${variables.name} <span>${variables.someOther}</span></div>`);
-    });
-    it("returns object with undefined string if none are given", () => {
-        const variables = {
-            name: "duet",
-        };
-        const objectString = "<div>${name} <span>${someOther}</span></div>";
-        const templateFn = generateTemplateFn(objectString);
-        expect(templateFn(variables)).toBe("<div>duet <span>undefined</span></div>");
-    });
-});

package/lib/collection/utils/token-utils.spec.js

@@ -1,178 +0,0 @@
-/*!
- * Built with Duet Design System
- */
-import * as tokens from "@duetds/tokens";
-import { convertToColorName, getColorByName, getFontSizeByName, getFontWeightByName, isCamelCase, isDashCase, rgbaColorFromRgb, shadeRGBColor, } from "./token-utils";
-describe("token-utils", () => {
-    describe("isCamelCase", () => {
-        it("checks for camelCase", () => {
-            expect(isCamelCase("primaryDark")).toEqual(true);
-            expect(isCamelCase("colorPrimaryDark")).toEqual(true);
-            expect(isCamelCase("primary-dark")).toEqual(false);
-            expect(isCamelCase("color-primary-dark")).toEqual(false);
-            expect(isCamelCase("colorPrimary-Dark")).toEqual(false);
-            expect(isCamelCase("-colorPrimary")).toEqual(false);
-            expect(isCamelCase("color_Primary")).toEqual(false);
-            expect(isCamelCase("color Primary")).toEqual(false);
-        });
-    });
-    describe("isDashCase", () => {
-        it("checks for dash case", () => {
-            expect(isDashCase("primary-dark")).toEqual(true);
-            expect(isDashCase("color-primary-dark")).toEqual(true);
-            expect(isDashCase("colorPrimary-Dark")).toEqual(true);
-            expect(isDashCase("primaryDark")).toEqual(false);
-            expect(isDashCase("colorPrimaryDark")).toEqual(false);
-            expect(isDashCase("-colorPrimary")).toEqual(false);
-            expect(isDashCase("color_Primary")).toEqual(false);
-            expect(isDashCase("color Primary")).toEqual(false);
-        });
-    });
-    describe("convertToColorName", () => {
-        it("converts primaryDark to a consistent format", () => {
-            expect(convertToColorName("primaryDark")).toEqual("colorPrimaryDark");
-        });
-        it("converts primary-dark to a consistent format", () => {
-            expect(convertToColorName("primary-dark")).toEqual("colorPrimaryDark");
-        });
-        it("converts color-primary-dark to a consistent format", () => {
-            expect(convertToColorName("color-primary-dark")).toEqual("colorPrimaryDark");
-        });
-        it("converts colorPrimaryDark to a consistent format", () => {
-            expect(convertToColorName("colorPrimaryDark")).toEqual("colorPrimaryDark");
-        });
-    });
-    describe("convertToColorName with theme", () => {
-        it("converts primaryDark to a consistent format", () => {
-            expect(convertToColorName("primaryDark", "turva")).toEqual("colorPrimaryDarkTurva");
-        });
-        it("converts primary-dark to a consistent format", () => {
-            expect(convertToColorName("primary-dark", "turva")).toEqual("colorPrimaryDarkTurva");
-        });
-        it("converts color-primary-dark to a consistent format", () => {
-            expect(convertToColorName("color-primary-dark", "turva")).toEqual("colorPrimaryDarkTurva");
-        });
-        it("converts colorPrimaryDark to a consistent format", () => {
-            expect(convertToColorName("colorPrimaryDark", "turva")).toEqual("colorPrimaryDarkTurva");
-        });
-    });
-    describe("getColorByName", () => {
-        it("returns undefined if no name supplied", () => {
-            expect(getColorByName("")).toBe(undefined);
-            // @ts-ignore - ensure behaves correctly outside of TS environments
-            expect(getColorByName()).toBe(undefined);
-        });
-        it("returns undefined for non-existent color name", () => {
-            expect(getColorByName("a-color-i-just-made-up")).toBe(undefined);
-        });
-        it("gets primaryDark token by name", () => {
-            expect(getColorByName("primaryDark")).toEqual(tokens.colorPrimaryDark);
-        });
-        it("gets primary-dark token by name", () => {
-            expect(getColorByName("primary-dark")).toEqual(tokens.colorPrimaryDark);
-        });
-        it("gets color-primary-dark token by name", () => {
-            expect(getColorByName("color-primary-dark")).toEqual(tokens.colorPrimaryDark);
-        });
-        it("gets colorPrimaryDark token by name", () => {
-            expect(getColorByName("colorPrimaryDark")).toEqual(tokens.colorPrimaryDark);
-        });
-        it("gets undefined token by name with theme", () => {
-            expect(getColorByName("", "turva")).toBe(undefined);
-            expect(getColorByName(undefined, undefined)).toBe(undefined);
-            expect(getColorByName(null, undefined)).toBe(undefined);
-        });
-        it("gets colorPrimaryDark token by name with theme", () => {
-            expect(getColorByName("colorPrimaryDark", "turva")).toEqual(tokens.colorPrimaryDarkTurva);
-        });
-        it("gets primaryDark token by name with theme", () => {
-            expect(getColorByName("primaryDark", "turva")).toEqual(tokens.colorPrimaryDarkTurva);
-        });
-        it("gets color-primary-dark token by name with theme", () => {
-            expect(getColorByName("color-primary-dark", "turva")).toEqual(tokens.colorPrimaryDarkTurva);
-        });
-        it("gets primary-dark token by name with theme", () => {
-            expect(getColorByName("primary-dark", "turva")).toEqual(tokens.colorPrimaryDarkTurva);
-        });
-        it("gets the color token by name with empty theme", () => {
-            expect(getColorByName("primaryDark", "")).toEqual(tokens.colorPrimaryDark);
-            expect(getColorByName("primary-dark", "")).toEqual(tokens.colorPrimaryDark);
-            expect(getColorByName("color-primary-dark", "")).toEqual(tokens.colorPrimaryDark);
-            expect(getColorByName("colorPrimaryDark", "")).toEqual(tokens.colorPrimaryDark);
-        });
-    });
-    describe("getColorByName with additional colors", () => {
-        it("gets the color names for complex colors", () => {
-            expect(getColorByName("color-category-vehicle", "")).toEqual(tokens.colorCategoryVehicle);
-            expect(getColorByName("color-category-finance", "")).toEqual(tokens.colorCategoryFinance);
-            expect(getColorByName("color-category-pet", "")).toEqual(tokens.colorCategoryPet);
-            expect(getColorByName("color-category-travel", "")).toEqual(tokens.colorCategoryTravel);
-        });
-        it("gets the color names for complex colors with empty theme", () => {
-            expect(getColorByName("color-category-vehicle")).toEqual(tokens.colorCategoryVehicle);
-            expect(getColorByName("color-category-finance")).toEqual(tokens.colorCategoryFinance);
-            expect(getColorByName("color-category-pet")).toEqual(tokens.colorCategoryPet);
-            expect(getColorByName("color-category-travel")).toEqual(tokens.colorCategoryTravel);
-        });
-        it("gets the color names for complex colors with turva theme", () => {
-            expect(getColorByName("color-category-vehicle", "turva")).toEqual(tokens.colorCategoryVehicleTurva);
-            expect(getColorByName("color-category-travel", "turva")).toEqual(tokens.colorCategoryTravelTurva);
-        });
-        it("gets the color names for complex colors from default if they dont exist in theme", () => {
-            expect(getColorByName("color-category-finance", "turva")).toEqual(tokens.colorCategoryFinance);
-            expect(getColorByName("color-category-pet", "turva")).toEqual(tokens.colorCategoryPet);
-        });
-    });
-    describe("getFontSizeByName", () => {
-        it("returns undefined if no name supplied", () => {
-            expect(getFontSizeByName("")).toBe(undefined);
-            // @ts-ignore - ensure behaves correctly outside of TS environments
-            expect(getFontSizeByName()).toBe(undefined);
-        });
-        it("returns undefined for non-existent", () => {
-            expect(getFontSizeByName("wrong")).toBe(undefined);
-        });
-        test.each(["xLarge", "x-large", "font-size-x-large", "fontSizeXLarge"])("gets fontSizeXLarge token by name", name => {
-            expect(getFontSizeByName(name)).toEqual(tokens.fontSizeXLarge);
-        });
-    });
-    describe("getFontWeightByName", () => {
-        it("returns undefined if no name supplied", () => {
-            expect(getFontWeightByName("")).toBe(undefined);
-            // @ts-ignore - ensure behaves correctly outside of TS environments
-            expect(getFontWeightByName()).toBe(undefined);
-        });
-        it("returns undefined for non-existent", () => {
-            expect(getFontWeightByName("wrong")).toBe(undefined);
-        });
-        test.each(["extraBold", "extra-bold", "font-weight-extra-bold", "fontWeightExtraBold"])("gets fontWeightExtraBold token by name", name => {
-            expect(getFontWeightByName(name)).toEqual(tokens.fontWeightExtraBold);
-        });
-    });
-    describe("rgbaColorFromRgb", () => {
-        test.each([
-            ["rgb(255, 255, 255)", "rgba(255,255,255,0)", 0],
-            ["rgb(255, 255, 255)", "rgba(255,255,255,0.1)", 0.1],
-            ["rgb(1, 1, 1)", "rgba(1,1,1,1)", 1],
-            [null, undefined, 1],
-            [undefined, undefined, 1],
-            ["", undefined, 1],
-            ["rgb(1, 1, 1)", undefined, undefined],
-            ["rgb(1, 1, 1)", undefined, null],
-        ])("shades rgb color correctly", (color, expected, opacity) => {
-            expect(rgbaColorFromRgb(color, opacity)).toEqual(expected);
-        });
-    });
-    describe("shadeRGBColor", () => {
-        test.each([
-            ["rgb(255, 255, 255)", "rgb(230,230,230)", -0.1],
-            ["rgb(255, 255, 255)", "rgb(255,255,255)", 0.1],
-            ["rgb(1, 1, 1)", "rgb(0,0,0)", -0.6],
-            ["rgb(224, 42, 13)", "rgb(202,38,12)", -0.1],
-            ["rgb(999, 999, 999)", "rgb(255,255,255)", 1],
-            ["rgb(-999, -999, -999)", "rgb(0,0,0)", -1],
-        ])("shades rgb color correctly", (rgb, shadedRgb, amount) => {
-            expect(shadeRGBColor(rgb, amount)).toEqual(shadedRgb);
-        });
-    });
-});

package/lib/dist-custom-elements/p-33937fd7.js

@@ -1,183 +0,0 @@
-/*!
- * Built with Duet Design System
- */
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/snabbdom/snabbdom/blob/master/LICENSE
- *
- * Modified for Stencil's renderer and slot projection
- */
-/**
- * Check whether a value is a 'complex type', defined here as an object or a
- * function.
- *
- * @param o the value to check
- * @returns whether it's a complex type or not
- */
-const isComplexType = (o) => {
-    // https://jsperf.com/typeof-fn-object/5
-    o = typeof o;
-    return o === 'object' || o === 'function';
-};
-/**
- * Production h() function based on Preact by
- * Jason Miller (@developit)
- * Licensed under the MIT License
- * https://github.com/developit/preact/blob/master/LICENSE
- *
- * Modified for Stencil's compiler and vdom
- */
-// export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, child?: d.ChildType): d.VNode;
-// export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, ...children: d.ChildType[]): d.VNode;
-const h = (nodeName, vnodeData, ...children) => {
-    let child = null;
-    let key = null;
-    let slotName = null;
-    let simple = false;
-    let lastSimple = false;
-    const vNodeChildren = [];
-    const walk = (c) => {
-        for (let i = 0; i < c.length; i++) {
-            child = c[i];
-            if (Array.isArray(child)) {
-                walk(child);
-            }
-            else if (child != null && typeof child !== 'boolean') {
-                if ((simple = typeof nodeName !== 'function' && !isComplexType(child))) {
-                    child = String(child);
-                }
-                if (simple && lastSimple) {
-                    // If the previous child was simple (string), we merge both
-                    vNodeChildren[vNodeChildren.length - 1].$text$ += child;
-                }
-                else {
-                    // Append a new vNode, if it's text, we create a text vNode
-                    vNodeChildren.push(simple ? newVNode(null, child) : child);
-                }
-                lastSimple = simple;
-            }
-        }
-    };
-    walk(children);
-    if (vnodeData) {
-        if (vnodeData.key) {
-            key = vnodeData.key;
-        }
-        if (vnodeData.name) {
-            slotName = vnodeData.name;
-        }
-        // normalize class / className attributes
-        {
-            const classData = vnodeData.className || vnodeData.class;
-            if (classData) {
-                vnodeData.class =
-                    typeof classData !== 'object'
-                        ? classData
-                        : Object.keys(classData)
-                            .filter((k) => classData[k])
-                            .join(' ');
-            }
-        }
-    }
-    if (typeof nodeName === 'function') {
-        // nodeName is a functional component
-        return nodeName(vnodeData === null ? {} : vnodeData, vNodeChildren, vdomFnUtils);
-    }
-    const vnode = newVNode(nodeName, null);
-    vnode.$attrs$ = vnodeData;
-    if (vNodeChildren.length > 0) {
-        vnode.$children$ = vNodeChildren;
-    }
-    {
-        vnode.$key$ = key;
-    }
-    {
-        vnode.$name$ = slotName;
-    }
-    return vnode;
-};
-/**
- * A utility function for creating a virtual DOM node from a tag and some
- * possible text content.
- *
- * @param tag the tag for this element
- * @param text possible text content for the node
- * @returns a newly-minted virtual DOM node
- */
-const newVNode = (tag, text) => {
-    const vnode = {
-        $flags$: 0,
-        $tag$: tag,
-        $text$: text,
-        $elm$: null,
-        $children$: null,
-    };
-    {
-        vnode.$attrs$ = null;
-    }
-    {
-        vnode.$key$ = null;
-    }
-    {
-        vnode.$name$ = null;
-    }
-    return vnode;
-};
-/**
- * Implementation of {@link d.FunctionalUtilities} for Stencil's VDom.
- *
- * Note that these functions convert from {@link d.VNode} to
- * {@link d.ChildNode} to give functional component developers a friendly
- * interface.
- */
-const vdomFnUtils = {
-    forEach: (children, cb) => children.map(convertToPublic).forEach(cb),
-    map: (children, cb) => children.map(convertToPublic).map(cb).map(convertToPrivate),
-};
-/**
- * Convert a {@link d.VNode} to a {@link d.ChildNode} in order to present a
- * friendlier public interface (hence, 'convertToPublic').
- *
- * @param node the virtual DOM node to convert
- * @returns a converted child node
- */
-const convertToPublic = (node) => ({
-    vattrs: node.$attrs$,
-    vchildren: node.$children$,
-    vkey: node.$key$,
-    vname: node.$name$,
-    vtag: node.$tag$,
-    vtext: node.$text$,
-});
-/**
- * Convert a {@link d.ChildNode} back to an equivalent {@link d.VNode} in
- * order to use the resulting object in the virtual DOM. The initial object was
- * likely created as part of presenting a public API, so converting it back
- * involved making it 'private' again (hence, `convertToPrivate`).
- *
- * @param node the child node to convert
- * @returns a converted virtual DOM node
- */
-const convertToPrivate = (node) => {
-    if (typeof node.vtag === 'function') {
-        const vnodeData = Object.assign({}, node.vattrs);
-        if (node.vkey) {
-            vnodeData.key = node.vkey;
-        }
-        if (node.vname) {
-            vnodeData.name = node.vname;
-        }
-        return h(node.vtag, vnodeData, ...(node.vchildren || []));
-    }
-    const vnode = newVNode(node.vtag, node.vtext);
-    vnode.$attrs$ = node.vattrs;
-    vnode.$children$ = node.vchildren;
-    vnode.$key$ = node.vkey;
-    vnode.$name$ = node.vname;
-    return vnode;
-};
-const Fragment = (_, children) => children;
-
-export { Fragment as F, h };