@design-edito/tools 0.4.4 → 0.4.6

package/agnostic/html/hyper-json/utils/index.js

@@ -1,24 +1,516 @@
-import {
-  Utils
-} from "../../../../chunks/chunk-X4YSGOKG.js";
-import "../../../../chunks/chunk-B4HGXMP3.js";
-import "../../../../chunks/chunk-O32IRXDX.js";
-import "../../../../chunks/chunk-XEQ2PBT2.js";
-import "../../../../chunks/chunk-RJRNYRPM.js";
-import "../../../../chunks/chunk-HYGUIF2O.js";
-import "../../../../chunks/chunk-MSU7JU63.js";
-import "../../../../chunks/chunk-XA4HVHJ4.js";
-import "../../../../chunks/chunk-LEBGVBYD.js";
-import "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-XNF5MLCQ.js";
-import "../../../../chunks/chunk-E6MSDKON.js";
-import "../../../../chunks/chunk-YDIBNEGA.js";
-import "../../../../chunks/chunk-6XL25OZX.js";
-import "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-57YKZBJR.js";
-import "../../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  Utils
-};
+import * as Window from '../../../misc/crossenv/window/index.js';
+import { isRecord } from '../../../objects/is-record/index.js';
+import { recordMap } from '../../../objects/record-map/index.js';
+import * as Outcome from '../../../misc/outcome/index.js';
+import { isInEnum } from '../../../objects/enums/is-in-enum/index.js';
+import { Method } from '../method/index.js';
+import { Transformer } from '../transformer/index.js';
+import { Tree as TreeNamespace } from '../tree/index.js';
+import { Types } from '../types/index.js';
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Utils;
+(function (Utils) {
+    function clone(value) {
+        const { Element, Text, NodeList, document } = Window.get();
+        if (typeof value === 'string'
+            || typeof value === 'number'
+            || typeof value === 'boolean'
+            || value === null)
+            return value;
+        if (value instanceof Text)
+            return value.cloneNode(true);
+        if (value instanceof NodeList) {
+            const frag = document.createDocumentFragment();
+            const nodes = Array.from(value).map(e => (e).cloneNode(true));
+            frag.append(...nodes);
+            return frag.childNodes;
+        }
+        if (value instanceof Element)
+            return value.cloneNode(true);
+        if (value instanceof Transformer)
+            return Transformer.clone(value);
+        if (value instanceof Method)
+            return Method.clone(value);
+        if (Array.isArray(value))
+            return [...value.map(clone)];
+        if (isRecord(value))
+            return recordMap(value, prop => clone(prop));
+        throw new Error(`Cannot clone value: ${value}`);
+    }
+    Utils.clone = clone;
+    function coalesceValues(currentValue, subpath, toCoalesce) {
+        const { Element, Text, NodeList, document } = Window.get();
+        // If toCoalesce is a Transformer, apply it then continue the process
+        if (toCoalesce instanceof Transformer) {
+            const transformer = toCoalesce;
+            const transformationResult = transformer.apply(currentValue);
+            if (!transformationResult.success) {
+                console.warn({ ...transformationResult.error });
+                return currentValue;
+            }
+            const evaluated = transformationResult.payload;
+            if (transformer.mode === 'isolation') {
+                toCoalesce = evaluated; // We set toCoalesce to the result of the evaluation, and process this result below as a non-Transformer value
+            }
+            else {
+                return evaluated; // If mode is coalescion, the reduced value is the output of the Transformer
+            }
+        }
+        if (Array.isArray(currentValue))
+            return [...currentValue, toCoalesce];
+        if (currentValue === null)
+            return toCoalesce;
+        if (typeof currentValue === 'boolean')
+            return toCoalesce;
+        if (typeof currentValue === 'number')
+            return toCoalesce;
+        if (currentValue instanceof Transformer)
+            return toCoalesce;
+        if (currentValue instanceof Method)
+            return toCoalesce;
+        if (typeof currentValue === 'string') {
+            if (toCoalesce === null
+                || typeof toCoalesce === 'boolean'
+                || typeof toCoalesce === 'number'
+                || typeof toCoalesce === 'string')
+                return `${currentValue}${toCoalesce}`;
+            if (toCoalesce instanceof Text)
+                return `${currentValue}${toCoalesce.textContent}`;
+            if (toCoalesce instanceof Element) {
+                const frag = document.createDocumentFragment();
+                frag.append(currentValue, Utils.clone(toCoalesce));
+                return frag.childNodes;
+            }
+            if (toCoalesce instanceof NodeList) {
+                const frag = document.createDocumentFragment();
+                frag.append(currentValue, ...Array.from(Utils.clone(toCoalesce)));
+                return frag.childNodes;
+            }
+            return toCoalesce;
+        }
+        if (currentValue instanceof Text) {
+            if (toCoalesce === null
+                || typeof toCoalesce === 'boolean'
+                || typeof toCoalesce === 'number'
+                || typeof toCoalesce === 'string')
+                return document.createTextNode(`${currentValue.textContent}${toCoalesce}`);
+            if (toCoalesce instanceof Text)
+                return document.createTextNode(`${currentValue.textContent}${toCoalesce.textContent}`);
+            if (toCoalesce instanceof Element) {
+                const frag = document.createDocumentFragment();
+                frag.append(clone(currentValue), clone(toCoalesce));
+                return frag.childNodes;
+            }
+            if (toCoalesce instanceof NodeList) {
+                const frag = document.createDocumentFragment();
+                frag.append(clone(currentValue), ...Array.from(clone(toCoalesce)));
+                return frag.childNodes;
+            }
+            return toCoalesce;
+        }
+        if (currentValue instanceof Element) {
+            if (toCoalesce === null
+                || typeof toCoalesce === 'boolean'
+                || typeof toCoalesce === 'number'
+                || typeof toCoalesce === 'string') {
+                const frag = document.createDocumentFragment();
+                frag.append(clone(currentValue), `${toCoalesce}`);
+                return frag.childNodes;
+            }
+            if (toCoalesce instanceof Text || toCoalesce instanceof Element) {
+                const frag = document.createDocumentFragment();
+                frag.append(clone(currentValue), clone(toCoalesce));
+                return frag.childNodes;
+            }
+            if (toCoalesce instanceof NodeList) {
+                const frag = document.createDocumentFragment();
+                frag.append(clone(currentValue), ...Array.from(clone(toCoalesce)));
+                return frag.childNodes;
+            }
+            return toCoalesce;
+        }
+        if (currentValue instanceof NodeList) {
+            if (toCoalesce === null
+                || typeof toCoalesce === 'boolean'
+                || typeof toCoalesce === 'number'
+                || typeof toCoalesce === 'string') {
+                const frag = document.createDocumentFragment();
+                frag.append(...Array.from(clone(currentValue)), `${toCoalesce}`);
+                return frag.childNodes;
+            }
+            if (toCoalesce instanceof Text || toCoalesce instanceof Element) {
+                const frag = document.createDocumentFragment();
+                frag.append(...Array.from(clone(currentValue)), clone(toCoalesce));
+                return frag.childNodes;
+            }
+            if (toCoalesce instanceof NodeList) {
+                const frag = document.createDocumentFragment();
+                frag.append(...Array.from(clone(currentValue)), ...Array.from(clone(toCoalesce)));
+                return frag.childNodes;
+            }
+            return toCoalesce;
+        }
+        // current value is a record here
+        if (typeof subpath === 'number')
+            return { ...currentValue };
+        return {
+            ...currentValue,
+            [subpath]: toCoalesce
+        };
+    }
+    Utils.coalesceValues = coalesceValues;
+    Utils.toHyperJson = (value) => {
+        // [WIP] finish this
+        const { document, Element, Text, NodeList } = Window.get();
+        if (value instanceof Text) {
+            const elt = document.createElement('text');
+            elt.innerHTML = value.textContent ?? '';
+            return elt;
+        }
+        if (value instanceof Element)
+            return value.cloneNode(true);
+        if (value instanceof NodeList) {
+            const elt = document.createElement('nodelist');
+            elt.append(...Array.from(value).map(e => e.cloneNode(true)));
+            return elt;
+        }
+        if (value === null)
+            return document.createElement('null');
+        if (typeof value === 'string'
+            || typeof value === 'number'
+            || typeof value === 'boolean') {
+            const elt = document.createElement(typeof value);
+            elt.innerHTML = `${value}`;
+            return elt;
+        }
+        if (Array.isArray(value)) {
+            const elt = document.createElement('array');
+            elt.append(...value.map(e => Utils.toHyperJson(e)));
+            return elt;
+        }
+        if (value instanceof Transformer)
+            return clone(value.sourceTree.node);
+        if (value instanceof Method)
+            return clone(value.transformer.sourceTree.node);
+        // Value is record
+        const elt = document.createElement('record');
+        Object.entries(value).forEach(([key, val]) => {
+            const hjVal = Utils.toHyperJson(val);
+            if (hjVal instanceof Text)
+                return;
+            hjVal.setAttribute(TreeNamespace.Tree.keyAttribute, key);
+            elt.append(hjVal);
+        });
+        return elt;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    let Transformations;
+    (function (Transformations) {
+        // eslint-disable-next-line @typescript-eslint/no-namespace
+        let TypeChecks;
+        (function (TypeChecks) {
+            function getType(value) {
+                if (singleTypeCheck(value, 'null'))
+                    return 'null';
+                if (singleTypeCheck(value, 'boolean'))
+                    return 'boolean';
+                if (singleTypeCheck(value, 'number'))
+                    return 'number';
+                if (singleTypeCheck(value, 'string'))
+                    return 'string';
+                if (singleTypeCheck(value, 'element'))
+                    return 'element';
+                if (singleTypeCheck(value, 'text'))
+                    return 'text';
+                if (singleTypeCheck(value, 'nodelist'))
+                    return 'nodelist';
+                if (singleTypeCheck(value, 'method'))
+                    return 'method';
+                if (singleTypeCheck(value, 'array'))
+                    return 'array';
+                if (singleTypeCheck(value, 'record'))
+                    return 'record';
+                return undefined;
+            }
+            TypeChecks.getType = getType;
+            TypeChecks.everyTypeName = [
+                'null', 'boolean', 'number', 'string', 'text',
+                'nodelist', 'element', 'method', 'array',
+                'record'
+            ];
+            function singleTypeCheck(value, type) {
+                const { Element, Text, NodeList } = Window.get();
+                if (type === 'null' && value === null)
+                    return true;
+                if (type === 'boolean' && typeof value === 'boolean')
+                    return true;
+                if (type === 'number' && typeof value === 'number')
+                    return true;
+                if (type === 'string' && typeof value === 'string')
+                    return true;
+                if (type === 'element' && value instanceof Element)
+                    return true;
+                if (type === 'text' && value instanceof Text)
+                    return true;
+                if (type === 'nodelist' && value instanceof NodeList) {
+                    const children = Array.from(value);
+                    return children.every(child => child instanceof Element || child instanceof Text);
+                }
+                if (type === 'method' && value instanceof Method)
+                    return true;
+                if (type === 'array' && Array.isArray(value)) {
+                    const childrenOk = value.every(child => typeCheck(child, ...TypeChecks.everyTypeName).success);
+                    return childrenOk;
+                }
+                if (type === 'record' && isRecord(value)) {
+                    const childrenOk = Object.values(value).every(child => typeCheck(child, ...TypeChecks.everyTypeName).success);
+                    return childrenOk;
+                }
+                return false;
+            }
+            TypeChecks.singleTypeCheck = singleTypeCheck;
+            function typeCheck(value, ...types) {
+                const matchesOneType = types.some(type => singleTypeCheck(value, type));
+                if (matchesOneType)
+                    return Outcome.makeSuccess(value);
+                return Outcome.makeFailure({
+                    expected: types.join(' | '),
+                    found: getType(value) ?? 'undefined'
+                });
+            }
+            TypeChecks.typeCheck = typeCheck;
+            function typeCheckMany(values, ...types) {
+                for (const [pos, val] of Object.entries(values)) {
+                    const checked = typeCheck(val, ...types);
+                    if (checked.success)
+                        continue;
+                    return Outcome.makeFailure({ position: parseInt(pos), ...checked.error });
+                }
+                return Outcome.makeSuccess(values);
+            }
+            TypeChecks.typeCheckMany = typeCheckMany;
+        })(TypeChecks = Transformations.TypeChecks || (Transformations.TypeChecks = {}));
+    })(Transformations = Utils.Transformations || (Utils.Transformations = {}));
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    let Tree;
+    (function (Tree) {
+        function mergeNodes(nodes) {
+            const { document, Text, Element } = Window.get();
+            const clones = nodes.map(node => node.cloneNode(true));
+            const allChildren = [];
+            clones.forEach(node => {
+                const actionAttribute = node.getAttribute(TreeNamespace.Tree.actionAttribute)?.trim().toLowerCase();
+                const actionAttrIsValid = isInEnum(Types.Tree.Merge.Action, actionAttribute ?? '');
+                const nodeAction = actionAttrIsValid
+                    ? actionAttribute
+                    : Types.Tree.Merge.Action.APPEND;
+                const children = Array
+                    .from(node.childNodes)
+                    .filter((child) => child instanceof Text || child instanceof Element)
+                    .map(child => {
+                    if (child instanceof Text)
+                        return { node: child, key: undefined };
+                    const childKey = child.getAttribute(TreeNamespace.Tree.keyAttribute) ?? undefined;
+                    return { node: child, key: childKey };
+                });
+                if (nodeAction === Types.Tree.Merge.Action.REPLACE) {
+                    allChildren.splice(0, allChildren.length);
+                }
+                else if (nodeAction === Types.Tree.Merge.Action.PREPEND) {
+                    allChildren.unshift(...children);
+                }
+                else {
+                    allChildren.push(...children);
+                }
+            });
+            const mergedChildren = [];
+            allChildren.forEach(childData => {
+                if (childData.key === undefined)
+                    mergedChildren.push(childData);
+                else {
+                    const childKey = childData.key;
+                    const alreadyMerged = mergedChildren.find(dat => dat.key === childKey);
+                    if (alreadyMerged !== undefined)
+                        return;
+                    const toMerge = allChildren.filter(dat => dat.key === childKey);
+                    if (toMerge.length === 0)
+                        return;
+                    const merged = mergeNodes(toMerge.map(dat => dat.node));
+                    mergedChildren.push({ node: merged, key: childKey });
+                }
+            });
+            const allAttributes = clones.reduce((attributes, node) => ([
+                ...Array.from(attributes),
+                ...Array.from(node.attributes)
+            ]), []);
+            const outWrapper = (clones[0]?.cloneNode() ?? document.createElement('div'));
+            allAttributes.forEach(attr => outWrapper.setAttribute(attr.name, attr.value));
+            outWrapper.append(...mergedChildren.map(e => e.node));
+            return outWrapper;
+        }
+        Tree.mergeNodes = mergeNodes;
+        function getInitialValueFromTypeName(name) {
+            const { document } = Window.get();
+            if (name === 'null')
+                return null;
+            if (name === 'boolean')
+                return false;
+            if (name === 'number')
+                return 0;
+            if (name === 'string')
+                return '';
+            if (name === 'text')
+                return document.createTextNode('');
+            if (name === 'nodelist')
+                return document.createDocumentFragment().childNodes;
+            if (name === 'element')
+                return document.createElement('div');
+            if (name === 'array')
+                return [];
+            if (name === 'record')
+                return {};
+            throw new Error(`Unknown value type name: ${name}`);
+        }
+        Tree.getInitialValueFromTypeName = getInitialValueFromTypeName;
+        // eslint-disable-next-line @typescript-eslint/no-namespace
+        let TypeChecks;
+        (function (TypeChecks) {
+            function getType(value) {
+                if (singleTypeCheck(value, 'null'))
+                    return 'null';
+                if (singleTypeCheck(value, 'boolean'))
+                    return 'boolean';
+                if (singleTypeCheck(value, 'number'))
+                    return 'number';
+                if (singleTypeCheck(value, 'string'))
+                    return 'string';
+                if (singleTypeCheck(value, 'element'))
+                    return 'element';
+                if (singleTypeCheck(value, 'text'))
+                    return 'text';
+                if (singleTypeCheck(value, 'nodelist'))
+                    return 'nodelist';
+                if (singleTypeCheck(value, 'transformer'))
+                    return 'transformer';
+                if (singleTypeCheck(value, 'method'))
+                    return 'method';
+                if (singleTypeCheck(value, 'array'))
+                    return 'array';
+                if (singleTypeCheck(value, 'record'))
+                    return 'record';
+                return undefined;
+            }
+            TypeChecks.getType = getType;
+            TypeChecks.everyTypeName = [
+                'null', 'boolean', 'number', 'string', 'text',
+                'nodelist', 'element', 'transformer', 'method',
+                'array', 'record'
+            ];
+            function singleTypeCheck(value, type) {
+                const { Element, Text, NodeList } = Window.get();
+                if (type === 'null' && value === null)
+                    return true;
+                if (type === 'boolean' && typeof value === 'boolean')
+                    return true;
+                if (type === 'number' && typeof value === 'number')
+                    return true;
+                if (type === 'string' && typeof value === 'string')
+                    return true;
+                if (type === 'element' && value instanceof Element)
+                    return true;
+                if (type === 'text' && value instanceof Text)
+                    return true;
+                if (type === 'nodelist' && value instanceof NodeList) {
+                    const children = Array.from(value);
+                    return children.every(child => child instanceof Element || child instanceof Text);
+                }
+                if (type === 'transformer' && value instanceof Transformer)
+                    return true;
+                if (type === 'method' && value instanceof Method)
+                    return true;
+                if (type === 'array' && Array.isArray(value)) {
+                    const childrenOk = value.every(child => typeCheck(child, ...TypeChecks.everyTypeName).success);
+                    return childrenOk;
+                }
+                if (type === 'record' && isRecord(value)) {
+                    const childrenOk = Object.values(value).every(child => typeCheck(child, ...TypeChecks.everyTypeName).success);
+                    return childrenOk;
+                }
+                return false;
+            }
+            TypeChecks.singleTypeCheck = singleTypeCheck;
+            function typeCheck(value, ...types) {
+                const matchesOneType = types.some(type => singleTypeCheck(value, type));
+                if (matchesOneType)
+                    return Outcome.makeSuccess(value);
+                return Outcome.makeFailure({
+                    expected: types.join(' | '),
+                    found: getType(value) ?? 'undefined'
+                });
+            }
+            TypeChecks.typeCheck = typeCheck;
+            function typeCheckMany(values, ...types) {
+                for (const [pos, val] of Object.entries(values)) {
+                    const checked = typeCheck(val, ...types);
+                    if (checked.success)
+                        continue;
+                    return Outcome.makeFailure({ position: parseInt(pos), ...checked.error });
+                }
+                return Outcome.makeSuccess(values);
+            }
+            TypeChecks.typeCheckMany = typeCheckMany;
+            function typeCheckManyWithLength(values, minLength, maxLength, ...types) {
+                if (minLength !== undefined && values.length < minLength)
+                    return Outcome.makeFailure({
+                        position: values.length + 1,
+                        expected: `min length: ${minLength}`,
+                        found: `length: ${values.length}`
+                    });
+                if (maxLength !== undefined && values.length > maxLength)
+                    return Outcome.makeFailure({
+                        position: maxLength + 1,
+                        expected: `max length: ${maxLength}`,
+                        found: `length: ${values.length}`
+                    });
+                return typeCheckMany(values, ...types);
+            }
+            TypeChecks.typeCheckManyWithLength = typeCheckManyWithLength;
+            TypeChecks.isTreeMode = (name) => name === 'isolation' || name === 'coalescion';
+            TypeChecks.isValueTypeName = (name) => {
+                const list = [
+                    'null', 'boolean', 'number', 'string',
+                    'text', 'nodelist', 'element',
+                    'transformer', 'method',
+                    'array', 'record'
+                ];
+                return list.includes(name);
+            };
+        })(TypeChecks = Tree.TypeChecks || (Tree.TypeChecks = {}));
+    })(Tree = Utils.Tree || (Utils.Tree = {}));
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    let SmartTags;
+    (function (SmartTags) {
+        SmartTags.expectEmptyArgs = (args) => {
+            if (args.length === 0)
+                return Outcome.makeSuccess([]);
+            return Outcome.makeFailure({
+                expected: 'length: 0',
+                found: `length: ${args.length}`
+            });
+        };
+        SmartTags.makeMainValueError = (expected, found, details) => ({
+            expected,
+            found,
+            details
+        });
+        SmartTags.makeArgsValueError = (expected, found, position, details) => ({
+            expected,
+            found,
+            position,
+            details
+        });
+        SmartTags.makeTransformationError = (details) => ({
+            details
+        });
+    })(SmartTags = Utils.SmartTags || (Utils.SmartTags = {}));
+})(Utils || (Utils = {}));

package/agnostic/html/index.d.ts

@@ -1,8 +1,8 @@
 export * as getNodeAncestors from './get-node-ancestors/index.js'
-export * as insertNode from './insert-node/index.js'
 export * as hyperJson from './hyper-json/index.js'
 export * as getPositionInsideParent from './get-position-inside-parent/index.js'
+export * as insertNode from './insert-node/index.js'
 export * as placeholders from './placeholders/index.js'
 export * as replaceInElement from './replace-in-element/index.js'
-export * as selectorToElement from './selector-to-element/index.js'
 export * as stringToNodes from './string-to-nodes/index.js'
+export * as selectorToElement from './selector-to-element/index.js'

package/agnostic/html/index.js

@@ -1,8 +1,8 @@
 export * as getNodeAncestors from './get-node-ancestors/index.js'
-export * as insertNode from './insert-node/index.js'
 export * as hyperJson from './hyper-json/index.js'
 export * as getPositionInsideParent from './get-position-inside-parent/index.js'
+export * as insertNode from './insert-node/index.js'
 export * as placeholders from './placeholders/index.js'
 export * as replaceInElement from './replace-in-element/index.js'
-export * as selectorToElement from './selector-to-element/index.js'
 export * as stringToNodes from './string-to-nodes/index.js'
+export * as selectorToElement from './selector-to-element/index.js'

package/agnostic/html/insert-node/index.js

@@ -1,7 +1,28 @@
-import {
-  insertNode
-} from "../../../chunks/chunk-XA4HVHJ4.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  insertNode
-};
+/**
+ * Inserts a DOM node at a specific position relative to a reference node.
+ *
+ * @param {Node} node - The node to insert.
+ * @param {InsertNodePosition} position - The insertion position relative to the reference node.
+ * @param {Node} reference - The reference node used to determine the insertion point.
+ * @returns {void}
+ */
+export function insertNode(node, position, reference) {
+    if (position === 'after') {
+        if (reference.nextSibling !== null)
+            reference.parentNode?.insertBefore(node, reference.nextSibling);
+        else
+            reference.parentNode?.appendChild(node);
+    }
+    else if (position === 'before') {
+        reference.parentNode?.insertBefore(node, reference);
+    }
+    else if (position === 'startof') {
+        if (reference.firstChild !== null)
+            reference.insertBefore(node, reference.firstChild);
+        else
+            reference.appendChild(node);
+    }
+    else {
+        reference.appendChild(node);
+    }
+}

package/agnostic/html/insert-node/index.test.js

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { insertNode } from './index.js';
+import { JSDOM } from 'jsdom';
+import * as Window from '../../misc/crossenv/window/index.js';
+describe('insertNode', () => {
+    beforeEach(() => Window.set(new JSDOM().window));
+    afterEach(() => Window.unset());
+    it('inserts node before reference node', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const reference = document.createElement('span');
+        const node = document.createElement('p');
+        parent.appendChild(reference);
+        insertNode(node, 'before', reference);
+        expect(parent.childNodes[0]).toBe(node);
+        expect(parent.childNodes[1]).toBe(reference);
+    });
+    it('inserts node after reference node', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const reference = document.createElement('span');
+        const node = document.createElement('p');
+        parent.appendChild(reference);
+        insertNode(node, 'after', reference);
+        expect(parent.childNodes[0]).toBe(reference);
+        expect(parent.childNodes[1]).toBe(node);
+    });
+    it('inserts node at end when inserting after last child', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const reference = document.createElement('span');
+        const node = document.createElement('p');
+        parent.appendChild(reference);
+        insertNode(node, 'after', reference);
+        expect(parent.lastChild).toBe(node);
+    });
+    it('inserts node as first child with startof', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const existing = document.createElement('span');
+        const node = document.createElement('p');
+        parent.appendChild(existing);
+        insertNode(node, 'startof', parent);
+        expect(parent.firstChild).toBe(node);
+        expect(parent.childNodes[1]).toBe(existing);
+    });
+    it('inserts node as last child with endof', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const existing = document.createElement('span');
+        const node = document.createElement('p');
+        parent.appendChild(existing);
+        insertNode(node, 'endof', parent);
+        expect(parent.lastChild).toBe(node);
+        expect(parent.firstChild).toBe(existing);
+    });
+    it('inserts node in empty parent with startof', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const node = document.createElement('p');
+        insertNode(node, 'startof', parent);
+        expect(parent.firstChild).toBe(node);
+        expect(parent.lastChild).toBe(node);
+    });
+    it('inserts node in empty parent with endof', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const node = document.createElement('p');
+        insertNode(node, 'endof', parent);
+        expect(parent.firstChild).toBe(node);
+        expect(parent.lastChild).toBe(node);
+    });
+});