@design-edito/tools 0.4.4 → 0.4.6

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

@@ -1,9 +1,113 @@
-import {
-  Transformer
-} from "../../../../chunks/chunk-LEBGVBYD.js";
-import "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  Transformer
-};
+import * as Outcome from '../../../misc/outcome/index.js';
+import { Method } from '../method/index.js';
+export class Transformer {
+    name;
+    mode;
+    innerValue;
+    typeChecks;
+    func;
+    sourceTree;
+    static clone(transformer) {
+        const { name, mode, innerValue, typeChecks, func, sourceTree } = transformer;
+        return new Transformer(name, mode, innerValue, typeChecks, func, sourceTree);
+    }
+    constructor(name, mode, innerValue, typeChecks, func, sourceTree) {
+        this.apply = this.apply.bind(this);
+        this.getMainAndArgsValue = this.getMainAndArgsValue.bind(this);
+        this.makeMainValueError = this.makeMainValueError.bind(this);
+        this.makeArgsValueError = this.makeArgsValueError.bind(this);
+        this.makeTransformationError = this.makeTransformationError.bind(this);
+        this.toMethod = this.toMethod.bind(this);
+        this.name = name;
+        this.mode = mode;
+        this.innerValue = innerValue;
+        this.typeChecks = typeChecks;
+        this.func = func;
+        this.sourceTree = sourceTree;
+    }
+    getMainAndArgsValue(outerValue) {
+        const { mode, innerValue } = this;
+        let mainValue;
+        let argsValue;
+        if (mode === 'isolation') {
+            if (Array.isArray(innerValue)) {
+                mainValue = innerValue.at(0);
+                argsValue = innerValue.slice(1);
+            }
+            else {
+                mainValue = innerValue;
+                argsValue = [];
+            }
+        }
+        else {
+            mainValue = outerValue;
+            argsValue = Array.isArray(innerValue) ? innerValue : [innerValue];
+        }
+        return { mainValue, argsValue };
+    }
+    makeMainValueError(mainValue, argsValue, expected, found, details) {
+        const { name, sourceTree } = this;
+        return {
+            message: 'BAD_MAIN_VALUE',
+            expected,
+            found,
+            details,
+            transformerName: name,
+            path: sourceTree.pathString,
+            mainValue,
+            argsValue
+        };
+    }
+    makeArgsValueError(mainValue, argsValue, expected, found, position, details) {
+        const { name, sourceTree } = this;
+        return {
+            message: 'BAD_ARGUMENTS_VALUE',
+            expected,
+            found,
+            position,
+            details,
+            transformerName: name,
+            path: sourceTree.pathString,
+            mainValue,
+            argsValue
+        };
+    }
+    makeTransformationError(mainValue, argsValue, details) {
+        const { name, sourceTree } = this;
+        return {
+            message: 'TRANSFORMATION_ERROR',
+            details,
+            transformerName: name,
+            path: sourceTree.pathString,
+            mainValue,
+            argsValue
+        };
+    }
+    apply(outerValue) {
+        const getMainAndArgsValue = this.getMainAndArgsValue.bind(this);
+        const makeMainValueError = this.makeMainValueError.bind(this);
+        const makeArgsValueError = this.makeArgsValueError.bind(this);
+        const makeTransformationError = this.makeTransformationError.bind(this);
+        const func = this.func.bind(this);
+        const { typeChecks } = this;
+        const { mainValue, argsValue } = getMainAndArgsValue(outerValue);
+        const mainChecked = typeChecks.mainValue(mainValue);
+        if (!mainChecked.success)
+            return Outcome.makeFailure(makeMainValueError(mainValue, argsValue, mainChecked.error.expected, mainChecked.error.found));
+        const validMainValue = mainChecked.payload;
+        const argsChecked = typeChecks.argsValue(argsValue, validMainValue);
+        if (!argsChecked.success)
+            return Outcome.makeFailure(makeArgsValueError(mainValue, argsValue, argsChecked.error.expected, argsChecked.error.found, argsChecked.error.position));
+        const validArgsValue = argsChecked.payload;
+        const called = func(validMainValue, validArgsValue, {
+            name: this.name,
+            sourceTree: this.sourceTree
+        });
+        if (!called.success)
+            return Outcome.makeFailure(makeTransformationError(mainValue, argsValue, called.error));
+        return Outcome.makeSuccess(called.payload);
+    }
+    toMethod() {
+        return new Method(this);
+    }
+}

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

@@ -1,24 +1,423 @@
-import {
-  Tree
-} 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 {
-  Tree
-};
+/* eslint-disable @typescript-eslint/no-throw-literal */
+import * as Window from '../../../misc/crossenv/window/index.js';
+import { trimStart, trimEnd } from '../../../strings/trim/index.js';
+import { Serialize } from '../serialize/index.js';
+import { Transformer } from '../transformer/index.js';
+import { Utils } from '../utils/index.js';
+import { Cast } from '../cast/index.js';
+// Isolated smart tags
+import { any } from '../smart-tags/isolated/any/index.js';
+import { array } from '../smart-tags/isolated/array/index.js';
+import { boolean } from '../smart-tags/isolated/boolean/index.js';
+import { element } from '../smart-tags/isolated/element/index.js';
+import { get } from '../smart-tags/isolated/get/index.js';
+import { guess } from '../smart-tags/isolated/guess/index.js';
+import { nodelist } from '../smart-tags/isolated/nodelist/index.js';
+import { nullFunc } from '../smart-tags/isolated/null/index.js';
+import { number } from '../smart-tags/isolated/number/index.js';
+import { record } from '../smart-tags/isolated/record/index.js';
+import { ref } from '../smart-tags/isolated/ref/index.js';
+import { string } from '../smart-tags/isolated/string/index.js';
+import { text } from '../smart-tags/isolated/text/index.js';
+// Coalesced smart tags
+import { add } from '../smart-tags/coalesced/add/index.js';
+import { addclass } from '../smart-tags/coalesced/addclass/index.js';
+import { and } from '../smart-tags/coalesced/and/index.js';
+import { append } from '../smart-tags/coalesced/append/index.js';
+import { at } from '../smart-tags/coalesced/at/index.js';
+import { call } from '../smart-tags/coalesced/call/index.js';
+import { clone } from '../smart-tags/coalesced/clone/index.js';
+import { deleteproperties } from '../smart-tags/coalesced/deleteproperties/index.js';
+import { equals } from '../smart-tags/coalesced/equals/index.js';
+import { getattribute } from '../smart-tags/coalesced/getattribute/index.js';
+import { getproperties } from '../smart-tags/coalesced/getproperties/index.js';
+import { getproperty } from '../smart-tags/coalesced/getproperty/index.js';
+import { hjparse } from '../smart-tags/coalesced/hjparse/index.js';
+import { hjstringify } from '../smart-tags/coalesced/hjstringify/index.js';
+import { ifFunc } from '../smart-tags/coalesced/if/index.js';
+import { initialize } from '../smart-tags/coalesced/initialize/index.js';
+import { join } from '../smart-tags/coalesced/join/index.js';
+import { length } from '../smart-tags/coalesced/length/index.js';
+import { map } from '../smart-tags/coalesced/map/index.js';
+import { negate } from '../smart-tags/coalesced/negate/index.js';
+import { notrailing } from '../smart-tags/coalesced/notrailing/index.js';
+import { or } from '../smart-tags/coalesced/or/index.js';
+import { pickrandom } from '../smart-tags/coalesced/pickrandom/index.js';
+import { print } from '../smart-tags/coalesced/print/index.js';
+import { populate } from '../smart-tags/coalesced/populate/index.js';
+import { push } from '../smart-tags/coalesced/push/index.js';
+import { pusheach } from '../smart-tags/coalesced/pusheach/index.js';
+import { recordtoarray } from '../smart-tags/coalesced/recordtoarray/index.js';
+import { removeattribute } from '../smart-tags/coalesced/removeattribute/index.js';
+import { removeclass } from '../smart-tags/coalesced/removeclass/index.js';
+import { renameproperty } from '../smart-tags/coalesced/renameproperty/index.js';
+import { replace } from '../smart-tags/coalesced/replace/index.js';
+import { select } from '../smart-tags/coalesced/select/index.js';
+import { set } from '../smart-tags/coalesced/set/index.js';
+import { setattribute } from '../smart-tags/coalesced/setattribute/index.js';
+import { setproperty } from '../smart-tags/coalesced/setproperty/index.js';
+import { sorton } from '../smart-tags/coalesced/sorton/index.js';
+import { split } from '../smart-tags/coalesced/split/index.js';
+import { spread } from '../smart-tags/coalesced/spread/index.js';
+import { toarray } from '../smart-tags/coalesced/toarray/index.js';
+import { toboolean } from '../smart-tags/coalesced/toboolean/index.js';
+import { toelement } from '../smart-tags/coalesced/toelement/index.js';
+import { toggleclass } from '../smart-tags/coalesced/toggleclass/index.js';
+import { tonodelist } from '../smart-tags/coalesced/tonodelist/index.js';
+import { tonull } from '../smart-tags/coalesced/tonull/index.js';
+import { tonumber } from '../smart-tags/coalesced/tonumber/index.js';
+import { torecord } from '../smart-tags/coalesced/torecord/index.js';
+import { toref } from '../smart-tags/coalesced/toref/index.js';
+import { tostring } from '../smart-tags/coalesced/tostring/index.js';
+import { totext } from '../smart-tags/coalesced/totext/index.js';
+import { transformselected } from '../smart-tags/coalesced/transformselected/index.js';
+import { trim } from '../smart-tags/coalesced/trim/index.js';
+// [WIP] eventually just export the Tree class here
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Tree;
+(function (Tree_1) {
+    class Tree {
+        node;
+        parent;
+        parents;
+        pathFromParent;
+        root;
+        isRoot;
+        path;
+        pathString;
+        attributes;
+        isMethod;
+        tagName;
+        smartTagName;
+        smartTagsRegister;
+        smartTagData;
+        mode;
+        isPreserved;
+        isLiteral;
+        isolationInitType;
+        subtrees = new Map();
+        static actionAttribute = '_action';
+        static keyAttribute = '_key';
+        static methodAttribute = '_method';
+        static initAttribute = '_init';
+        static modeAttribute = '_mode';
+        static preserveAttribute = '_preserve';
+        static literalAttribute = '_literal';
+        static from(nodes) {
+            const merged = Utils.Tree.mergeNodes(nodes);
+            return new Tree(merged, null, null);
+        }
+        constructor(node, parent, pathFromParent) {
+            const { Element, Text, document } = Window.get();
+            // Bounds
+            this.resolve = this.resolve.bind(this);
+            this.setVariable = this.setVariable.bind(this);
+            this.getVariable = this.getVariable.bind(this);
+            this.performSafetyChecks = this.performSafetyChecks.bind(this);
+            this.computeValue = this.computeValue.bind(this);
+            this.enforceEvaluation = this.enforceEvaluation.bind(this);
+            this.getCachedValue = this.getCachedValue.bind(this);
+            this.setCachedValue = this.setCachedValue.bind(this);
+            this.evaluate = this.evaluate.bind(this);
+            // node
+            this.node = node;
+            // parent, parents, pathFromParent, root, isRoot
+            if (parent !== null && pathFromParent !== null) {
+                this.isRoot = false;
+                this.parent = parent;
+                this.parents = [parent, ...parent.parents];
+                this.pathFromParent = pathFromParent;
+                this.root = this.parent.root;
+            }
+            else {
+                this.isRoot = true;
+                this.parent = null;
+                this.parents = [];
+                this.pathFromParent = null;
+                this.root = this;
+            }
+            // path, pathString
+            const thisPath = [];
+            if (!this.isRoot) {
+                thisPath.push(...(this.parent?.path ?? []));
+                if (this.pathFromParent !== null)
+                    thisPath.push(this.pathFromParent);
+            }
+            this.path = thisPath;
+            this.pathString = `/${this.path.join('/')}`;
+            // attributes
+            this.attributes = node instanceof Element
+                ? Array.from(node.attributes)
+                : null;
+            // isMethod, tagName, smartTagName
+            if (node instanceof Element) {
+                const rawTagName = node.tagName.trim().toLowerCase();
+                const hasTrailingUnderscore = rawTagName.endsWith('_');
+                const hasMethodAttribute = this.attributes?.find(attr => attr.name === Tree.methodAttribute) !== undefined;
+                const isMethod = hasTrailingUnderscore || hasMethodAttribute;
+                this.isMethod = isMethod;
+                this.tagName = rawTagName;
+                this.smartTagName = hasTrailingUnderscore
+                    ? rawTagName.replace(/_+$/g, '')
+                    : rawTagName;
+            }
+            else {
+                this.isMethod = false;
+                this.tagName = null;
+                this.smartTagName = null;
+            }
+            // smartTagsRegister
+            this.smartTagsRegister = new Map([
+                any, array, boolean, element, get, guess, nodelist, nullFunc, number, record, ref, string, text, add, addclass,
+                and, append, at, call, clone, deleteproperties, equals, getattribute, getproperties, getproperty, hjparse, hjstringify,
+                ifFunc, initialize, join, length, map, negate, notrailing, or, pickrandom, print, populate, push, pusheach,
+                recordtoarray, removeattribute, removeclass, renameproperty, replace, select, set, setattribute, spread,
+                setproperty, sorton, split, toarray, toboolean, toelement, toggleclass, tonodelist, tonull, tonumber, toref,
+                torecord, tostring, totext, transformselected, trim
+            ]);
+            // smartTagData
+            if (this.smartTagName === null) {
+                this.smartTagData = null;
+            }
+            else {
+                this.smartTagData = this.smartTagsRegister.get(this.smartTagName) ?? null;
+            }
+            // mode
+            const hasModeAttribute = this.attributes?.find(attr => {
+                return attr.name === Tree.modeAttribute
+                    && Utils.Tree.TypeChecks.isTreeMode(attr.value);
+            });
+            this.mode = hasModeAttribute?.value
+                ?? this.smartTagData?.defaultMode
+                ?? 'isolation';
+            // isLiteral, isPreserved
+            const hasLiteralAttribute = this.attributes?.find(attr => attr.name === Tree.literalAttribute) !== undefined;
+            this.isLiteral = hasLiteralAttribute;
+            const hasPreservedAttribute = this.attributes?.find(attr => attr.name === Tree.preserveAttribute) !== undefined;
+            this.isPreserved = hasPreservedAttribute;
+            // isolationInitType
+            const hasInitAttribute = this.attributes?.find(attr => {
+                if (attr.name !== Tree.initAttribute)
+                    return false;
+                const val = attr.value.trim().toLowerCase();
+                if (!Utils.Tree.TypeChecks.isValueTypeName(val))
+                    return false;
+                if (val === 'transformer')
+                    return false;
+                if (val === 'method')
+                    return false;
+                return true;
+            });
+            if (this.mode === 'coalescion') {
+                this.isolationInitType = 'array';
+            }
+            else {
+                const initAttributeValue = hasInitAttribute?.value;
+                if (initAttributeValue !== undefined) {
+                    this.isolationInitType = initAttributeValue;
+                }
+                else if (this.smartTagData !== null) {
+                    this.isolationInitType = this.smartTagData?.isolationInitType ?? 'array';
+                }
+                else {
+                    this.isolationInitType = 'nodelist';
+                }
+            }
+            // subtrees
+            const { childNodes } = node;
+            let positionnedChildrenCount = 0;
+            const mutableSubtrees = new Map();
+            Array
+                .from(childNodes)
+                .filter((child, _, childNodes) => {
+                // Filter out non Text or Element children
+                if (child instanceof Element)
+                    return true;
+                if (child instanceof Text)
+                    return true;
+                return false;
+            })
+                .reduce((reduced, child) => {
+                // Merge neighboring Text nodes
+                if (reduced.length === 0)
+                    return [child];
+                if (child instanceof Element)
+                    return [...reduced, child];
+                const lastReducedItem = reduced[reduced.length - 1];
+                if (lastReducedItem instanceof Element)
+                    return [...reduced, child];
+                const lastReducedTrimmed = trimEnd(lastReducedItem?.textContent ?? '');
+                const childTrimmed = trimStart(child.textContent ?? '');
+                const merged = document.createTextNode(`${lastReducedTrimmed}${childTrimmed}`);
+                const returned = [...reduced];
+                returned.pop();
+                returned.push(merged);
+                return returned;
+            }, [])
+                .filter(child => {
+                // Filter out empty Text nodes after merging neighbours
+                if (child instanceof Element)
+                    return true;
+                const textContent = child.textContent ?? '';
+                return textContent.trim() !== '';
+            })
+                .forEach(childNode => {
+                if (childNode instanceof Text) {
+                    const rawTextContent = childNode.textContent ?? '';
+                    // Strips padding whitespaces (before and after)
+                    // if they contain at least one line return character
+                    const textContent = rawTextContent
+                        .replace(/^\s*\n+\s*/, '')
+                        .replace(/\s*\n+\s*$/, '');
+                    const returnedChildNode = document.createTextNode(textContent);
+                    mutableSubtrees.set(positionnedChildrenCount, new Tree(returnedChildNode, this, positionnedChildrenCount));
+                    positionnedChildrenCount += 1;
+                }
+                else {
+                    const propertyName = childNode.getAttribute(Tree.keyAttribute);
+                    if (propertyName === null) {
+                        mutableSubtrees.set(positionnedChildrenCount, new Tree(childNode, this, positionnedChildrenCount));
+                        positionnedChildrenCount += 1;
+                    }
+                    else {
+                        mutableSubtrees.set(propertyName, new Tree(childNode, this, propertyName));
+                    }
+                }
+            });
+            this.subtrees = mutableSubtrees;
+        }
+        resolve = function (path) {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            let currentTree = this;
+            for (const chunk of path) {
+                if (chunk === '.')
+                    continue;
+                if (chunk === '..') {
+                    currentTree = currentTree.parent ?? this;
+                    continue;
+                }
+                const { subtrees } = currentTree;
+                const foundSubtree = subtrees.get(chunk);
+                if (foundSubtree === undefined)
+                    return undefined;
+                currentTree = foundSubtree;
+            }
+            return currentTree;
+        };
+        // [WIP] variablesStore is actually only used on root Tree
+        variablesStore = new Map();
+        setVariable(name, value) {
+            const { root, isRoot, variablesStore } = this;
+            if (!isRoot)
+                return root.setVariable(name, value);
+            variablesStore.set(name, Serialize.serialize(value));
+        }
+        getVariable(name) {
+            const { root } = this;
+            const found = root.variablesStore.get(name);
+            if (found === undefined)
+                return undefined;
+            const deserialized = Serialize.deserialize(found);
+            if (deserialized instanceof Transformer)
+                throw 'A transformer should not be stored as a variable, this happening denotes an implementation error.';
+            return deserialized;
+        }
+        performSafetyChecks() {
+            const { node, smartTagData, isMethod, mode, isRoot } = this;
+            const { Text } = Window.get();
+            // Checks for impossible configurations
+            if (node instanceof Text || smartTagData === null) {
+                if (isMethod)
+                    throw new Error(`A Text or HTMLElement node cannot be used as a method @ ${this.pathString}`);
+                if (mode === 'coalescion')
+                    throw new Error(`A Text or HTMLElement node cannot be used in coalescion mode @ ${this.pathString}`);
+            }
+            if (isRoot && mode === 'coalescion')
+                throw new Error(`The root node cannot be used in coalescion mode @ ${this.pathString}`);
+        }
+        computeValue() {
+            const performSafetyChecks = this.performSafetyChecks.bind(this);
+            const { isolationInitType, subtrees, node, smartTagData, isMethod, mode } = this;
+            // Looks for impossible attributes configurations
+            performSafetyChecks();
+            // If node is text, returns the node itself
+            const { Text } = Window.get();
+            if (node instanceof Text)
+                return node.cloneNode(true);
+            // Inner value calculation
+            const initialInnerValue = Utils.Tree.getInitialValueFromTypeName(isolationInitType);
+            const innerValue = Array
+                .from(subtrees)
+                .reduce((reduced, [subpath, subtree]) => {
+                const subvalue = subtree.evaluate();
+                const coalesced = Utils.coalesceValues(reduced, subpath, subvalue);
+                return coalesced;
+            }, initialInnerValue);
+            // If no smartTagData, then treat it as an HTMLElement
+            if (smartTagData === null) {
+                const nodelist = Cast.toNodeList(innerValue);
+                const clone = node.cloneNode();
+                clone.append(...Array.from(nodelist));
+                return clone;
+            }
+            // If node is a SmartTag
+            const { transformer, method } = smartTagData.generator(innerValue, mode, this);
+            if (isMethod)
+                return method;
+            if (mode === 'isolation') {
+                const applied = transformer.apply(null); // null ignored by apply since isolation mode
+                if (applied.success)
+                    return applied.payload;
+                throw {
+                    error: 'Transformation error',
+                    details: applied.error,
+                    transformer: transformer.name,
+                    path: this.pathString
+                };
+            }
+            return transformer;
+        }
+        enforceEvaluation() {
+            const { isPreserved, node, isLiteral, attributes } = this;
+            const computeValue = this.computeValue.bind(this);
+            const { Element } = Window.get();
+            if (isPreserved)
+                return Utils.clone(node);
+            const evaluated = computeValue();
+            if (!isLiteral)
+                return evaluated;
+            const asLiteral = Utils.toHyperJson(evaluated);
+            if (asLiteral instanceof Element)
+                attributes?.forEach(({ name, value }) => asLiteral.setAttribute(name, value));
+            return asLiteral;
+        }
+        cachedValue = undefined;
+        getCachedValue() {
+            const { cachedValue } = this;
+            if (cachedValue === undefined)
+                return undefined;
+            const deserialized = Serialize.deserialize(cachedValue);
+            return deserialized;
+        }
+        setCachedValue(evaluated) {
+            this.cachedValue = Serialize.serialize(evaluated);
+        }
+        evaluate() {
+            const start = Date.now();
+            const getCachedValue = this.getCachedValue.bind(this);
+            const setCachedValue = this.setCachedValue.bind(this);
+            const enforceEvaluation = this.enforceEvaluation.bind(this);
+            const cached = getCachedValue();
+            if (cached !== undefined)
+                return cached;
+            const evaluated = enforceEvaluation();
+            setCachedValue(evaluated);
+            const end = Date.now();
+            const time = end - start;
+            if (time > 20)
+                console.warn(`${this.pathString} took ${time}ms to evaluate, maybe there's something wrong here`);
+            return evaluated;
+        }
+    }
+    Tree_1.Tree = Tree;
+})(Tree || (Tree = {}));

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

@@ -1,7 +1,28 @@
-import {
-  Types
-} from "../../../../chunks/chunk-XEQ2PBT2.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  Types
-};
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var Types;
+(function (Types) {
+    /* * * * * * * * * * * * * * * * * * * * * *
+     *
+     * TRANSFORMATIONS
+     *
+     * * * * * * * * * * * * * * * * * * * * * */
+    /* * * * * * * * * * * * * * * * * * * * * *
+     *
+     * TREE
+     *
+     * * * * * * * * * * * * * * * * * * * * * */
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    let Tree;
+    (function (Tree) {
+        // eslint-disable-next-line @typescript-eslint/no-namespace
+        let Merge;
+        (function (Merge) {
+            let Action;
+            (function (Action) {
+                Action["APPEND"] = "append";
+                Action["PREPEND"] = "prepend";
+                Action["REPLACE"] = "replace";
+            })(Action = Merge.Action || (Merge.Action = {}));
+        })(Merge = Tree.Merge || (Tree.Merge = {}));
+    })(Tree = Types.Tree || (Types.Tree = {}));
+})(Types || (Types = {}));