@design-edito/tools 0.4.4 → 0.4.6

package/agnostic/html/get-node-ancestors/index.js

@@ -1,8 +1,31 @@
-import {
-  getNodeAncestors
-} from "../../../chunks/chunk-DMWGHBIL.js";
-import "../../../chunks/chunk-57YKZBJR.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  getNodeAncestors
-};
+import * as Window from '../../misc/crossenv/window/index.js';
+/**
+ * Returns the list of ancestor nodes for a given DOM node, including the node
+ * itself, walking up through parent elements.
+ *
+ * By default, traversal stops at shadow root boundaries. When
+ * `traverseShadowRoots` is `true`, the traversal continues from a `ShadowRoot`
+ * to its host element.
+ *
+ * @param {Node} node - The starting DOM node.
+ * @param {boolean} [traverseShadowRoots] - Whether to traverse through shadow roots via their host elements.
+ * @returns {Node[]} An array of ancestor nodes, starting with the provided node.
+ */
+export function getNodeAncestors(node, traverseShadowRoots) {
+    const returned = [];
+    let currentNode = node;
+    const { ShadowRoot } = Window.get();
+    while (currentNode !== null) {
+        returned.push(currentNode);
+        const parentNode = currentNode.parentNode;
+        if (parentNode instanceof ShadowRoot) {
+            returned.push(parentNode);
+            currentNode = traverseShadowRoots === true
+                ? parentNode.host
+                : null;
+            continue;
+        }
+        currentNode = currentNode.parentElement;
+    }
+    return returned;
+}

package/agnostic/html/get-node-ancestors/index.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { JSDOM } from 'jsdom';
+import { getNodeAncestors } from './index.js';
+import * as Window from '../../misc/crossenv/window/index.js';
+describe('getNodeAncestors', () => {
+    beforeEach(() => Window.set(new JSDOM('', { url: 'http://localhost/' }).window));
+    afterEach(() => Window.unset());
+    it('returns the node itself as first element', () => {
+        const { document } = Window.get();
+        const div = document.createElement('div');
+        const result = getNodeAncestors(div);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toBe(div);
+    });
+    it('returns all ancestors including the node', () => {
+        const { document } = Window.get();
+        const grandparent = document.createElement('div');
+        const parent = document.createElement('div');
+        const child = document.createElement('div');
+        grandparent.appendChild(parent);
+        parent.appendChild(child);
+        const result = getNodeAncestors(child);
+        expect(result).toHaveLength(3);
+        expect(result[0]).toBe(child);
+        expect(result[1]).toBe(parent);
+        expect(result[2]).toBe(grandparent);
+    });
+    it('stops at document.documentElement', () => {
+        const { document } = Window.get();
+        const div = document.createElement('div');
+        document.body.appendChild(div);
+        const result = getNodeAncestors(div);
+        expect(result.length).toBeGreaterThan(1);
+        expect(result.at(-1)).toBe(document.documentElement);
+    });
+    it('does not traverse shadow roots by default', () => {
+        const { document } = Window.get();
+        const host = document.createElement('div');
+        const shadowRoot = host.attachShadow({ mode: 'open' });
+        const shadowChild = document.createElement('span');
+        shadowRoot.appendChild(shadowChild);
+        const result = getNodeAncestors(shadowChild);
+        expect(result).toContain(shadowChild);
+        expect(result).toContain(shadowRoot);
+        expect(result).not.toContain(host);
+    });
+    it('traverses shadow roots when traverseShadowRoots is true', () => {
+        const { document } = Window.get();
+        const host = document.createElement('div');
+        const shadowRoot = host.attachShadow({ mode: 'open' });
+        const shadowChild = document.createElement('span');
+        shadowRoot.appendChild(shadowChild);
+        const result = getNodeAncestors(shadowChild, true);
+        expect(result).toContain(shadowChild);
+        expect(result).toContain(shadowRoot);
+        expect(result).toContain(host);
+    });
+});

package/agnostic/html/get-position-inside-parent/index.js

@@ -1,11 +1,14 @@
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
-// src/agnostic/html/get-position-inside-parent/index.ts
-function getPositionInsideParent(node) {
-  if (node.parentNode === null) return null;
-  const childNodes = Array.from(node.parentNode.childNodes);
-  return childNodes.indexOf(node);
+/**
+ * Returns the index position of a node within its parent’s `childNodes` list.
+ *
+ * @param {Node} node - The DOM node whose position is to be determined.
+ * @returns {number | null}
+ * - The zero-based index of the node within its parent’s `childNodes`.
+ * - `null` if the node has no parent.
+ */
+export function getPositionInsideParent(node) {
+    if (node.parentNode === null)
+        return null;
+    const childNodes = Array.from(node.parentNode.childNodes);
+    return childNodes.indexOf(node);
 }
-export {
-  getPositionInsideParent
-};

package/agnostic/html/get-position-inside-parent/index.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { JSDOM } from 'jsdom';
+import * as Window from '../../misc/crossenv/window/index.js';
+import { getPositionInsideParent } from './index.js';
+describe('getPositionInsideParent', () => {
+    beforeEach(() => Window.set(new JSDOM().window));
+    afterEach(() => Window.unset());
+    it('returns 0 for first child', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const firstChild = document.createElement('span');
+        parent.appendChild(firstChild);
+        expect(getPositionInsideParent(firstChild)).toBe(0);
+    });
+    it('returns correct index for middle child', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const child1 = document.createElement('span');
+        const child2 = document.createElement('span');
+        const child3 = document.createElement('span');
+        parent.appendChild(child1);
+        parent.appendChild(child2);
+        parent.appendChild(child3);
+        expect(getPositionInsideParent(child2)).toBe(1);
+        expect(getPositionInsideParent(child3)).toBe(2);
+    });
+    it('returns null for node without parent', () => {
+        const { document } = Window.get();
+        const orphan = document.createElement('div');
+        expect(getPositionInsideParent(orphan)).toBe(null);
+    });
+    it('counts text nodes in position', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const text1 = document.createTextNode('text1');
+        const element = document.createElement('span');
+        const text2 = document.createTextNode('text2');
+        parent.appendChild(text1);
+        parent.appendChild(element);
+        parent.appendChild(text2);
+        expect(getPositionInsideParent(element)).toBe(1);
+    });
+    it('returns correct position after node removal', () => {
+        const { document } = Window.get();
+        const parent = document.createElement('div');
+        const child1 = document.createElement('span');
+        const child2 = document.createElement('span');
+        const child3 = document.createElement('span');
+        parent.appendChild(child1);
+        parent.appendChild(child2);
+        parent.appendChild(child3);
+        parent.removeChild(child1);
+        expect(getPositionInsideParent(child2)).toBe(0);
+        expect(getPositionInsideParent(child3)).toBe(1);
+    });
+});

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

@@ -1,24 +1,137 @@
-import {
-  Cast
-} 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 {
-  Cast
-};
+import { isRecord } from '../../../objects/is-record/index.js';
+import * as Window from '../../../misc/crossenv/window/index.js';
+import { Utils } from '../utils/index.js';
+import { Method } from '../method/index.js';
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Cast;
+(function (Cast) {
+    Cast.toNull = () => null;
+    Cast.toBoolean = (input) => {
+        const { Text } = Window.get();
+        if (input === null)
+            return false;
+        if (typeof input === 'boolean')
+            return input;
+        if (typeof input === 'number')
+            return input !== 0;
+        if (typeof input === 'string' || input instanceof Text) {
+            const strInput = Cast.toString(input);
+            if (strInput.trim() === '')
+                return false;
+            if (strInput.trim().toLowerCase() === 'false')
+                return false;
+            return true;
+        }
+        return true;
+    };
+    Cast.toNumber = (input) => {
+        const { Text } = Window.get();
+        if (typeof input === 'boolean')
+            return input ? 1 : 0;
+        if (typeof input === 'number')
+            return input;
+        if (typeof input === 'string')
+            return parseFloat(`${input}`);
+        if (input instanceof Text)
+            return parseFloat(`${input.textContent}`);
+        return 0;
+    };
+    Cast.toString = (input) => {
+        if (typeof input === 'string')
+            return input;
+        if (typeof input === 'number'
+            || typeof input === 'boolean'
+            || input === null)
+            return `${input}`;
+        const { Element, Text, NodeList } = Window.get();
+        if (input instanceof Element)
+            return input.outerHTML;
+        if (input instanceof Text)
+            return input.textContent ?? '';
+        if (input instanceof NodeList)
+            return Array.from(input).map(e => {
+                if (e instanceof Element)
+                    return e.outerHTML;
+                return e.textContent;
+            }).join('');
+        if (Array.isArray(input))
+            return input.map(Cast.toString).join('');
+        if (input instanceof Method)
+            return `[Method:${input.transformer.name}]`;
+        return `{${Object.entries(input).map(([key, val]) => `${key}:"${Cast.toString(val)}"`).join(',')}}`;
+    };
+    Cast.toText = (input) => {
+        const { Text, document } = Window.get();
+        if (input instanceof Text)
+            return input.cloneNode(true);
+        return document.createTextNode(Cast.toString(input));
+    };
+    Cast.toElement = (input, tagName) => {
+        const { Element, Text, NodeList, document } = Window.get();
+        if (input instanceof Element)
+            return input.cloneNode(true);
+        const returned = document.createElement(tagName ?? 'div');
+        if (input instanceof Text) {
+            returned.append(input.cloneNode(true));
+            return returned;
+        }
+        if (input instanceof NodeList) {
+            returned.append(...Array.from(input).map(e => e.cloneNode(true)));
+            return returned;
+        }
+        if (Array.isArray(input))
+            return returned;
+        if (isRecord(input))
+            return returned;
+        returned.innerHTML = `${input}`;
+        return returned;
+    };
+    Cast.toNodeList = (input) => {
+        const { Element, Text, NodeList, document } = Window.get();
+        const parentDiv = document.createElement('div');
+        if (input instanceof NodeList) {
+            parentDiv.append(...Array.from(input).map(i => i.cloneNode(true)));
+            return parentDiv.childNodes;
+        }
+        if (input instanceof Element
+            || input instanceof Text) {
+            parentDiv.append(input.cloneNode(true));
+            return parentDiv.childNodes;
+        }
+        if (Array.isArray(input)) {
+            input.forEach(item => {
+                if (typeof item === 'number' || typeof item === 'boolean' || item === null)
+                    parentDiv.append(`${item}`);
+                else if (typeof item === 'string' || item instanceof Text || item instanceof Element)
+                    parentDiv.append(item);
+                else if (item instanceof NodeList)
+                    parentDiv.append(...Array.from(item));
+                else if (Array.isArray(item))
+                    parentDiv.append(...Array.from(Cast.toNodeList(item)));
+                else
+                    parentDiv.append(Cast.toString(item));
+            });
+            return parentDiv.childNodes;
+        }
+        if (isRecord(input)) {
+            parentDiv.append(Cast.toString(input));
+            return parentDiv.childNodes;
+        }
+        parentDiv.innerHTML = `${input}`;
+        return parentDiv.childNodes;
+    };
+    Cast.toArray = (input) => {
+        const { NodeList } = Window.get();
+        if (Array.isArray(input))
+            return [...input];
+        if (input instanceof NodeList)
+            return Array.from(input);
+        return [input];
+    };
+    Cast.toRecord = (input) => {
+        const isRecord = Utils.Tree.TypeChecks.typeCheck(input, 'record');
+        if (isRecord.success)
+            return { ...isRecord.payload };
+        return {};
+    };
+})(Cast || (Cast = {}));

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

@@ -1,51 +1,24 @@
-import {
-  Cast,
-  Tree,
-  Utils
-} from "../../../chunks/chunk-X4YSGOKG.js";
-import "../../../chunks/chunk-B4HGXMP3.js";
-import {
-  Serialize
-} from "../../../chunks/chunk-O32IRXDX.js";
-import {
-  Types
-} from "../../../chunks/chunk-XEQ2PBT2.js";
-import "../../../chunks/chunk-RJRNYRPM.js";
-import "../../../chunks/chunk-HYGUIF2O.js";
-import {
-  SmartTags
-} from "../../../chunks/chunk-MSU7JU63.js";
-import "../../../chunks/chunk-XA4HVHJ4.js";
-import {
-  Transformer
-} from "../../../chunks/chunk-LEBGVBYD.js";
-import {
-  Method
-} from "../../../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";
-
-// src/agnostic/html/hyper-json/index.ts
-var HyperJson;
-((HyperJson2) => {
-  HyperJson2.Cast = Cast;
-  HyperJson2.Method = Method;
-  HyperJson2.Serialize = Serialize;
-  HyperJson2.SmartTags = SmartTags;
-  HyperJson2.Transformer = Transformer;
-  HyperJson2.Tree = Tree;
-  HyperJson2.Types = Types;
-  HyperJson2.Utils = Utils;
+import { Cast as CastNamespace } from './cast/index.js';
+import { Method as MethodClass } from './method/index.js';
+import { Serialize as SerializeNamespace } from './serialize/index.js';
+import { SmartTags as SmartTagsNamespace } from './smart-tags/index.js';
+import { Transformer as TransformerClass } from './transformer/index.js';
+import { Tree as TreeNamespace } from './tree/index.js';
+import { Types as TypesNamespace } from './types/index.js';
+import { Utils as UtilsNamespace } from './utils/index.js';
+// [WIP] missing jsdoc in all the hyper-json stuff
+// [WIP] get rid of namespaces
+// [WIP] write tests
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var HyperJson;
+(function (HyperJson) {
+    HyperJson.Cast = CastNamespace;
+    HyperJson.Method = MethodClass;
+    HyperJson.Serialize = SerializeNamespace;
+    HyperJson.SmartTags = SmartTagsNamespace;
+    HyperJson.Transformer = TransformerClass;
+    HyperJson.Tree = TreeNamespace;
+    HyperJson.Types = TypesNamespace;
+    HyperJson.Utils = UtilsNamespace;
 })(HyperJson || (HyperJson = {}));
-var parse = (nodes) => Tree.Tree.from(nodes);
-export {
-  HyperJson,
-  parse
-};
+export const parse = nodes => TreeNamespace.Tree.from(nodes);

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

@@ -1,7 +1,10 @@
-import {
-  Method
-} from "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  Method
-};
+export class Method {
+    transformer;
+    static clone(method) {
+        const { transformer } = method;
+        return new Method(transformer);
+    }
+    constructor(transformer) {
+        this.transformer = transformer;
+    }
+}

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

@@ -1,11 +1,91 @@
-import {
-  Serialize
-} from "../../../../chunks/chunk-O32IRXDX.js";
-import "../../../../chunks/chunk-LEBGVBYD.js";
-import "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-57YKZBJR.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  Serialize
-};
+import * as Window from '../../../misc/crossenv/window/index.js';
+import { Transformer } from '../transformer/index.js';
+import { Method } from '../method/index.js';
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Serialize;
+(function (Serialize) {
+    function serialize(value) {
+        const { Text, Element, NodeList } = Window.get();
+        if (value === null)
+            return { type: 'null', value: null };
+        if (typeof value === 'boolean'
+            || typeof value === 'number'
+            || typeof value === 'string')
+            return { type: typeof value, value };
+        if (value instanceof Text)
+            return { type: 'text', value: value.textContent ?? '' };
+        if (value instanceof Element)
+            return { type: 'element', value: value.outerHTML };
+        if (value instanceof NodeList)
+            return {
+                type: 'nodelist',
+                value: Array.from(value).map(serialize)
+            };
+        if (Array.isArray(value))
+            return { type: 'array', value: value.map(serialize) };
+        if (value instanceof Transformer)
+            return { type: 'transformer', value: Transformer.clone(value) };
+        if (value instanceof Method)
+            return { type: 'method', value: Method.clone(value) };
+        return {
+            type: 'record',
+            value: Object
+                .entries(value)
+                .reduce((reduced, [key, val]) => ({
+                ...reduced,
+                [key]: serialize(val)
+            }), {})
+        };
+    }
+    Serialize.serialize = serialize;
+    function deserialize(serialized) {
+        const { document } = Window.get();
+        if (serialized.type === 'null')
+            return null;
+        if (serialized.type === 'boolean')
+            return serialized.value;
+        if (serialized.type === 'number')
+            return serialized.value;
+        if (serialized.type === 'string')
+            return serialized.value;
+        if (serialized.type === 'text')
+            return document.createTextNode(serialized.value);
+        if (serialized.type === 'element') {
+            const elt = document.createElement('div');
+            elt.innerHTML = serialized.value;
+            const firstChild = elt.firstElementChild;
+            return firstChild ?? document.createElement('div');
+        }
+        if (serialized.type === 'nodelist') {
+            const frag = document.createDocumentFragment();
+            const deserialized = serialized.value
+                .filter(e => e.type === 'text' || e.type === 'element')
+                .map(deserialize);
+            deserialized.forEach(elt => frag.append(elt.cloneNode(true)));
+            return frag.childNodes;
+        }
+        if (serialized.type === 'array') {
+            const toRet = [];
+            for (const val of serialized.value) {
+                const deserialized = deserialize(val);
+                if (deserialized instanceof Transformer)
+                    continue;
+                toRet.push(deserialized);
+            }
+            return toRet;
+        }
+        if (serialized.type === 'transformer')
+            return Transformer.clone(serialized.value);
+        if (serialized.type === 'method')
+            return Method.clone(serialized.value);
+        return Object
+            .entries(serialized.value)
+            .reduce((reduced, [key, serialized]) => {
+            return {
+                ...reduced,
+                [key]: deserialize(serialized)
+            };
+        }, {});
+    }
+    Serialize.deserialize = deserialize;
+})(Serialize || (Serialize = {}));

package/agnostic/html/hyper-json/smart-tags/coalesced/add/index.js

@@ -1,24 +1,16 @@
-import {
-  add
-} 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 {
-  add
-};
+import * as Outcome from '../../../../../misc/outcome/index.js';
+import { Cast } from '../../../cast/index.js';
+import { Utils } from '../../../utils/index.js';
+import { SmartTags } from '../../index.js';
+export const add = SmartTags.makeSmartTag({
+    name: 'add',
+    defaultMode: 'coalescion',
+    isolationInitType: 'array',
+    mainValueCheck: m => Utils.Tree.TypeChecks.typeCheck(m, 'number', 'string', 'text'),
+    argsValueCheck: a => Utils.Tree.TypeChecks.typeCheckMany(a, 'number', 'string', 'text'),
+    func: (main, args) => {
+        const numMain = Cast.toNumber(main);
+        const numArgs = args.map(Cast.toNumber);
+        return Outcome.makeSuccess(numArgs.reduce((reduced, arg) => (reduced + arg), numMain));
+    }
+});

package/agnostic/html/hyper-json/smart-tags/coalesced/addclass/index.js

@@ -1,24 +1,30 @@
-import {
-  addclass
-} 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 {
-  addclass
-};
+import * as Window from '../../../../../misc/crossenv/window/index.js';
+import * as Outcome from '../../../../../misc/outcome/index.js';
+import { Cast } from '../../../cast/index.js';
+import { Utils } from '../../../utils/index.js';
+import { SmartTags } from '../../index.js';
+export const addclass = SmartTags.makeSmartTag({
+    name: 'addclass',
+    defaultMode: 'coalescion',
+    isolationInitType: 'array',
+    mainValueCheck: m => Utils.Tree.TypeChecks.typeCheck(m, 'element', 'nodelist'),
+    argsValueCheck: a => Utils.Tree.TypeChecks.typeCheckMany(a, 'string', 'text'),
+    func: (main, args) => {
+        const { Element, document } = Window.get();
+        if (main instanceof Element) {
+            main.classList.add(...args.map(arg => Cast.toString(arg)));
+            return Outcome.makeSuccess(main);
+        }
+        const children = Array.from(main).map(child => {
+            if (child instanceof Element) {
+                child.classList.add(...args.map(arg => Cast.toString(arg)));
+                return child;
+            }
+            return child;
+        });
+        const frag = document.createDocumentFragment();
+        frag.append(...children);
+        const nodelist = frag.childNodes;
+        return Outcome.makeSuccess(nodelist);
+    }
+});