@adaas/are 0.0.2 → 0.0.4

package/tests/AreInstruction.test.ts

@@ -0,0 +1,73 @@
+import { A_Entity } from '@adaas/a-concept';
+import { AreInstruction } from '@adaas/are/instruction/AreInstruction.entity';
+import { AreDeclaration } from '@adaas/are/instruction/types/AreDeclaration.instruction';
+import { AreMutation } from '@adaas/are/instruction/types/AreMutation.instruction';
+
+jest.retryTimes(0);
+
+
+describe('AreDeclaration', () => {
+    it('Should be an instance of AreInstruction', () => {
+        const decl = new AreDeclaration('createElement', { tag: 'div' });
+        expect(decl).toBeInstanceOf(AreInstruction);
+    });
+
+    it('Should be an instance of A_Entity', () => {
+        const decl = new AreDeclaration('createElement', { tag: 'div' });
+        expect(decl).toBeInstanceOf(A_Entity);
+    });
+
+    it('Should store the payload', () => {
+        const decl = new AreDeclaration('createElement', { tag: 'div' });
+        expect(decl.payload).toEqual({ tag: 'div' });
+    });
+
+    it('Should have no parent when created standalone', () => {
+        const decl = new AreDeclaration('createElement', { tag: 'div' });
+        expect(decl.parent).toBeUndefined();
+    });
+
+    it('Should generate an id', () => {
+        const decl = new AreDeclaration('createElement', {});
+        expect(decl.id).toBeDefined();
+        expect(typeof decl.id).toBe('string');
+    });
+
+    it('Should use DefaultName when no name is given', () => {
+        const decl = new AreDeclaration();
+        expect(decl.id).toBeDefined();
+    });
+});
+
+
+describe('AreMutation', () => {
+    it('Should be an instance of AreInstruction', () => {
+        const host = new AreDeclaration('createElement', { tag: 'div' });
+        const mutation = new AreMutation('setAttribute', host, { name: 'class', value: 'foo' });
+        expect(mutation).toBeInstanceOf(AreInstruction);
+    });
+
+    it('Should be an instance of A_Entity', () => {
+        const host = new AreDeclaration('createElement', { tag: 'span' });
+        const mutation = new AreMutation('setAttribute', host, { name: 'id', value: 'bar' });
+        expect(mutation).toBeInstanceOf(A_Entity);
+    });
+
+    it('Should store the payload', () => {
+        const host = new AreDeclaration('createElement', { tag: 'p' });
+        const mutation = new AreMutation('setAttribute', host, { name: 'class', value: 'active' });
+        expect(mutation.payload).toEqual({ name: 'class', value: 'active' });
+    });
+
+    it('Should reference the parent declaration ASEID', () => {
+        const host = new AreDeclaration('createElement', { tag: 'div' });
+        const mutation = new AreMutation('setAttribute', host, {});
+        expect(mutation.parent).toBe(host.aseid.toString());
+    });
+
+    it('Should use the parent declaration as group', () => {
+        const host = new AreDeclaration('createElement', { tag: 'div' });
+        const mutation = new AreMutation('setAttribute', host, {});
+        expect(mutation.group).toBe(host.aseid.toString());
+    });
+});

package/tests/AreScene.test.ts

@@ -0,0 +1,62 @@
+import { A_Fragment } from '@adaas/a-concept';
+import { AreScene } from '@adaas/are/scene/AreScene.context';
+import { AreSceneStatuses } from '@adaas/are/scene/AreScene.constants';
+
+jest.retryTimes(0);
+
+
+describe('AreScene', () => {
+    it('Should be an instance of A_Fragment', () => {
+        const scene = new AreScene('test-scene');
+        expect(scene).toBeInstanceOf(A_Fragment);
+    });
+
+    it('Should expose the id passed in constructor', () => {
+        const scene = new AreScene('my-scene-id');
+        expect(scene.id).toBe('my-scene-id');
+    });
+
+    it('Should start in Active status by default', () => {
+        const scene = new AreScene('test-active');
+        expect(scene.isActive).toBe(true);
+        expect(scene.isInactive).toBe(false);
+    });
+
+    it('deactivate() should set status to Inactive', () => {
+        const scene = new AreScene('deactivate-test');
+        scene.deactivate();
+        expect(scene.isActive).toBe(false);
+        expect(scene.isInactive).toBe(true);
+        expect(scene.status).toBe(AreSceneStatuses.Inactive);
+    });
+
+    it('activate() should restore Active status after deactivation', () => {
+        const scene = new AreScene('reactivate-test');
+        scene.deactivate();
+        scene.activate();
+        expect(scene.isActive).toBe(true);
+        expect(scene.status).toBe(AreSceneStatuses.Active);
+    });
+
+    it('planned should be empty initially', () => {
+        const scene = new AreScene('empty-plan');
+        expect(scene.planned).toHaveLength(0);
+    });
+
+    it('applied should be empty initially', () => {
+        const scene = new AreScene('empty-state');
+        expect(scene.applied).toHaveLength(0);
+    });
+
+    it('host should be undefined initially', () => {
+        const scene = new AreScene('no-host');
+        expect(scene.host).toBeUndefined();
+    });
+
+    it('changes should show empty toApply and toRevert initially', () => {
+        const scene = new AreScene('empty-changes');
+        const changes = scene.changes;
+        expect(changes.toApply).toHaveLength(0);
+        expect(changes.toRevert).toHaveLength(0);
+    });
+});

package/tests/AreSignals.test.ts

@@ -0,0 +1,55 @@
+import { A_Signal } from '@adaas/a-utils/a-signal';
+import { AreSignal } from '@adaas/are/signals/AreSignal.entity';
+import { AreInit } from '@adaas/are/signals/entities/AreInit.signal';
+import { AreRoute } from '@adaas/are/signals/entities/AreRoute.signal';
+
+jest.retryTimes(0);
+
+
+describe('AreSignal', () => {
+    it('Should be an instance of A_Signal', () => {
+        const signal = new AreSignal({ data: {} });
+        expect(signal).toBeInstanceOf(A_Signal);
+    });
+});
+
+
+describe('AreInit', () => {
+    it('Should be an instance of AreSignal', () => {
+        const signal = new AreInit({ data: {} });
+        expect(signal).toBeInstanceOf(AreSignal);
+    });
+
+    it('Should be an instance of A_Signal', () => {
+        const signal = new AreInit({ data: {} });
+        expect(signal).toBeInstanceOf(A_Signal);
+    });
+
+    it('AreInit.default() should return an AreInit instance', () => {
+        const signal = AreInit.default();
+        expect(signal).toBeInstanceOf(AreInit);
+    });
+
+    it('AreInit.default() should have ready: false', () => {
+        const signal = AreInit.default()!;
+        expect(signal.data).toHaveProperty('ready', false);
+    });
+});
+
+
+describe('AreRoute', () => {
+    it('Should be an instance of AreSignal', () => {
+        const signal = new AreRoute('/test');
+        expect(signal).toBeInstanceOf(AreSignal);
+    });
+
+    it('Should be an instance of A_Signal', () => {
+        const signal = new AreRoute('/test');
+        expect(signal).toBeInstanceOf(A_Signal);
+    });
+
+    it('Should expose the route path via .route', () => {
+        const signal = new AreRoute('/home');
+        expect(signal.route).toBeDefined();
+    });
+});

package/tests/AreTokenizer.test.ts

@@ -0,0 +1,254 @@
+import { A_Scope } from '@adaas/a-concept';
+import { AreNode } from '@adaas/are/node/AreNode.entity';
+import { AreSyntax } from '@adaas/are/syntax/AreSyntax.context';
+import { AreSyntaxInitOptions, AreSyntaxTokenMatch } from '@adaas/are/syntax/AreSyntax.types';
+import { AreTokenizer } from '@adaas/are/tokenizer/AreTokenizer.component';
+import { AreContext } from '@adaas/are/component/Are.context';
+
+jest.retryTimes(0);
+
+
+function htmlElementMatcher(
+    source: string,
+    from: number,
+    to: number,
+    build: (raw: string, content: string, position: number, closing: string) => AreSyntaxTokenMatch
+): AreSyntaxTokenMatch | null {
+    let index = from
+
+    while (index < to) {
+        const tagStart = source.indexOf('<', index)
+        if (tagStart === -1 || tagStart >= to) return null
+
+        // skip comments, closing tags, doctype, processing instructions
+        if (source.startsWith('<!--', tagStart)) { index = tagStart + 1; continue }
+        if (source[tagStart + 1] === '/') { index = tagStart + 1; continue }
+        if (source[tagStart + 1] === '!' || source[tagStart + 1] === '?') { index = tagStart + 1; continue }
+
+        const tagNameMatch = source.slice(tagStart).match(/^<([a-zA-Z][a-zA-Z0-9-]*)/)
+        if (!tagNameMatch) { index = tagStart + 1; continue }
+
+        const tagName = tagNameMatch[1]
+        const openingTagEnd = source.indexOf('>', tagStart)
+        if (openingTagEnd === -1) return null
+
+        // self-closing: <br/> or <input/>
+        if (source[openingTagEnd - 1] === '/') {
+            const raw = source.slice(tagStart, openingTagEnd + 1)
+            const content = source.slice(tagStart + tagNameMatch[0].length, openingTagEnd - 1)
+            const match = build(raw, content, tagStart, '/>')
+            match.payload = { tagName, selfClose: true }
+            return match
+        }
+
+        // find matching closing tag respecting nesting
+        const closingTag = `</${tagName}>`
+        let level = 0
+        let searchIndex = openingTagEnd + 1
+        let closingStart = -1
+
+        while (searchIndex < to) {
+            const nextOpen = source.indexOf(`<${tagName}`, searchIndex)
+            const nextClose = source.indexOf(closingTag, searchIndex)
+            if (nextClose === -1) break
+
+            if (nextOpen !== -1 && nextOpen < nextClose) {
+                const charAfter = source[nextOpen + tagName.length + 1]
+                if (charAfter === ' ' || charAfter === '>' || charAfter === '/') {
+                    level++
+                    searchIndex = nextOpen + tagName.length + 1
+                    continue
+                }
+            }
+
+            if (level === 0) { closingStart = nextClose; break }
+            level--
+            searchIndex = nextClose + closingTag.length
+        }
+
+        if (closingStart === -1) return null
+
+        const fullTag = source.slice(tagStart, closingStart + closingTag.length)
+        const content = source.slice(openingTagEnd + 1, closingStart)
+        const match = build(fullTag, content, tagStart, closingTag)
+        match.payload = { tagName, selfClose: false }
+        return match
+    }
+    return null
+}
+
+// ── HTML Config ───────────────────────────────────────────────────────────────
+
+class TextNode extends AreNode {}
+
+class InterpolationNode extends AreNode {}
+
+const HTML_CONFIG: AreSyntaxInitOptions = {
+    trimWhitespace: true,
+    strictMode: true,
+    rules: [
+        // HTML comments <!-- ... --> — priority 10, not nested
+        {
+            opening: '<!--',
+            closing: '-->',
+            component: AreNode,
+            priority: 10,
+            nested: false,
+            extract: (raw) => ({ content: raw.slice(4, -3).trim() }),
+        },
+        // interpolations {{ expr }} — priority 9, not nested
+        {
+            opening: '{{',
+            closing: '}}',
+            component: InterpolationNode,
+            priority: 9,
+            nested: false,
+            extract: (_, match) => ({ key: match.content }),
+        },
+        // HTML elements — custom matcher handles tag-aware open/close detection
+        {
+            matcher: htmlElementMatcher,
+            component: AreNode,
+            priority: 4,
+        },
+        // plain text fallback
+        {
+            component: TextNode,
+            priority: 0,
+        },
+    ],
+}
+
+describe('AreTokenizer Tests', () => {
+    it('Should tokenize AreNode Correctly', async () => {
+        const node = new AreNode({
+            /** Full matched string including delimiters */
+            raw: `<custom></custom>`,
+            /** Content between delimiters */
+            content: '<div> <span>  Hello </span> Test</div>',
+            /** The opening delimiter that matched */
+            opening: '<',
+            /** The closing delimiter that matched */
+            closing: '>',
+            /** Start position in source string */
+            position: 0,
+            /** Data extracted via rule.extract */
+            payload: {
+                entity: 'custom'
+            }
+        });
+
+        const testCope = new A_Scope({
+            name: 'test',
+            entities: [node],
+            components: [AreTokenizer],
+            fragments: [new AreSyntax(HTML_CONFIG), new AreContext('<root><custom> </custom></root>')],
+        });
+
+        node.tokenize();
+
+        expect(node.children.length).toBe(1);
+        const divNode = node.children[0];
+        expect(divNode.content).toBe('<span>  Hello </span> Test');
+
+        divNode.tokenize();
+
+        expect(divNode.children.length).toBe(2);
+        const spanNode = divNode.children[0];
+        expect(spanNode.content).toBe('Hello');
+        const textNode = divNode.children[1];
+        expect(textNode.content).toBe('Test');
+    });
+    it('Should return no children on empty content', async () => {
+        const node = new AreNode({
+            /** Full matched string including delimiters */
+            raw: `<custom></custom>`,
+            /** Content between delimiters */
+            content: '',
+            /** The opening delimiter that matched */
+            opening: '<',
+            /** The closing delimiter that matched */
+            closing: '>',
+            /** Start position in source string */
+            position: 0,
+            /** Data extracted via rule.extract */
+            payload: {
+                entity: 'custom'
+            }
+        });
+
+        const testCope = new A_Scope({
+            name: 'test',
+            entities: [node],
+            components: [AreTokenizer],
+            fragments: [new AreSyntax(HTML_CONFIG), new AreContext('<root><custom> </custom></root>')],
+        });
+
+        node.tokenize();
+
+        expect(node.children.length).toBe(0);
+    });
+    it('Should return no children on empty content', async () => {
+        const node = new AreNode({
+            /** Full matched string including delimiters */
+            raw: `<custom></custom>`,
+            /** Content between delimiters */
+            content: '',
+            /** The opening delimiter that matched */
+            opening: '<',
+            /** The closing delimiter that matched */
+            closing: '>',
+            /** Start position in source string */
+            position: 0,
+            /** Data extracted via rule.extract */
+            payload: {
+                entity: 'custom'
+            }
+        });
+
+        const testCope = new A_Scope({
+            name: 'test',
+            entities: [node],
+            components: [AreTokenizer],
+            fragments: [new AreSyntax(HTML_CONFIG), new AreContext('<root><custom> </custom></root>')],
+        });
+
+        node.tokenize();
+
+        expect(node.children.length).toBe(0);
+    });
+
+    it('Should return nested nodes based on content', async () => {
+        const node = new AreNode({
+            /** Full matched string including delimiters */
+            raw: `<custom></custom>`,
+            /** Content between delimiters */
+            content: 'Do:  {{btn2}}  </span> Make </span> <div> <span>  Hello </span> Test</div>',
+            /** The opening delimiter that matched */
+            opening: '<',
+            /** The closing delimiter that matched */
+            closing: '>',
+            /** Start position in source string */
+            position: 0,
+            /** Data extracted via rule.extract */
+            payload: {
+                entity: 'custom'
+            }
+        });
+
+        const testCope = new A_Scope({
+            name: 'test',
+            entities: [node],
+            components: [AreTokenizer],
+            fragments: [new AreSyntax(HTML_CONFIG), new AreContext('<root><custom> </custom></root>')],
+        });
+
+        node.tokenize();
+
+
+        expect(node.children.length).toBe(4);
+        expect(node.children[0]).toBeInstanceOf(TextNode);
+        expect(node.children[1]).toBeInstanceOf(InterpolationNode);
+
+    });
+});

package/tests/jest.setup.ts

@@ -0,0 +1,30 @@
+// import { A_Context } from '@adaas/a-concept/a-context';
+// import fs from 'fs';
+
+// /**
+//  * Base hooks for tests
+//  */
+// beforeAll(async () => {
+
+//     return Promise.resolve();
+// });
+
+// afterAll(async () => {
+//     try {
+//         fs.unlinkSync('a-concept.conf.json');
+
+//     } catch (error) {
+
+//     }
+//     return Promise.resolve();
+// });
+
+// beforeEach(async () => {
+//     A_Context.reset();
+//     return Promise.resolve();
+// });
+
+// afterEach(async () => {
+//     A_Context.reset();
+//     return Promise.resolve();
+// });

package/tsconfig.json

@@ -1,6 +1,5 @@
 {
   "extends": "./.conf/tsconfig.base.json",
-
   "compilerOptions": {
     "rootDir": "./",
     "baseUrl": ".",
@@ -13,7 +12,7 @@
       "@adaas/are/constants/*": ["src/constants/*"],
 
       //  A-Concept specific paths aliases
-      "@adaas/are/channels/*": ["src/channels/*"],
+      // "@adaas/are/channels/*": ["src/channels/*"],
       // "@adaas/are/entities/*": ["src/entities/*"],
       // "@adaas/are/context/*": ["src/context/*"],
       // "@adaas/are/components/*": ["src/components/*"],
@@ -21,25 +20,26 @@
 
 
       //  main library exports
-      "@adaas/are/app": ["src/lib/AreApp/index.ts"],
-      "@adaas/are/compiler": ["src/lib/AreCompiler/index.ts"],
-      "@adaas/are/component": ["src/lib/AreComponent/index.ts"],
-      "@adaas/are/event": ["src/lib/AreEvent/index.ts"],
-      "@adaas/are/index": ["src/lib/AreIndex/index.ts"],
-      "@adaas/are/node": ["src/lib/AreNode/index.ts"],
-      "@adaas/are/props": ["src/lib/AreProps/index.ts"],
-      "@adaas/are/store": ["src/lib/AreStore/index.ts"],
-      "@adaas/are/root": ["src/lib/AreRoot/index.ts"],
-      "@adaas/are/router": ["src/lib/AreRouter/index.ts"],
-      "@adaas/are/scene": ["src/lib/AreScene/index.ts"],
-      "@adaas/are/scene-instruction": ["src/lib/AreSceneInstruction/index.ts"],
-      "@adaas/are/slot": ["src/lib/AreSlot/index.ts"],
-      "@adaas/are/syntax": ["src/lib/AreSyntax/index.ts"],
-      "@adaas/are/signals": ["src/signals/index.ts"],
-
+      "@adaas/are/loader/*": ["src/lib/AreLoader/*"],
+      "@adaas/are/tokenizer/*": ["src/lib/AreTokenizer/*"],
+      "@adaas/are/compiler/*": ["src/lib/AreCompiler/*"],
+      "@adaas/are/transformer/*": ["src/lib/AreTransformer/*"],
+      "@adaas/are/interpreter/*": ["src/lib/AreInterpreter/*"],
+      "@adaas/are/lifecycle/*": ["src/lib/AreLifecycle/*"],
+      "@adaas/are/component/*": ["src/lib/AreComponent/*"],
+      "@adaas/are/event/*": ["src/lib/AreEvent/*"],
+      "@adaas/are/node/*": ["src/lib/AreNode/*"],
+      "@adaas/are/store/*": ["src/lib/AreStore/*"],
+      "@adaas/are/scene/*": ["src/lib/AreScene/*"],
+      "@adaas/are/instruction/*": ["src/lib/AreInstruction/*"],
+      "@adaas/are/syntax/*": ["src/lib/AreSyntax/*"],
+      "@adaas/are/attribute/*": ["src/lib/AreAttribute/*"],
+      "@adaas/are/watcher/*": ["src/lib/AreWatcher/*"],
+      "@adaas/are/signals/*": ["src/lib/AreSignals/*"],
+      "@adaas/are/engine/*": ["src/lib/AreEngine/*"],
 
       //  exported engines
-      "@adaas/are/engines/html": ["src/engines/html/index.ts"],
+      "@adaas/are/engines/html/*": ["src/engines/html/*"],
     },
 
     /* ===============================

package/tsup.config.ts

@@ -38,6 +38,9 @@ export default defineConfig([
 
     // Emit .d.ts files
     dts: true,
+
+    // Exclude peer dependencies from the bundle
+    external: ['@adaas/a-concept', '@adaas/a-frame', '@adaas/a-utils'],
   },
 
   /**
@@ -74,5 +77,8 @@ export default defineConfig([
 
     // Emit .d.ts files (shared shape)
     dts: true,
+
+    // Exclude peer dependencies from the bundle
+    external: ['@adaas/a-concept', '@adaas/a-frame', '@adaas/a-utils'],
   },
 ]);

package/dist/node/engines/html/AreHTML.compiler.d.mts

@@ -1,114 +0,0 @@
-import { A_Scope } from '@adaas/a-concept';
-import { AreCompiler } from '../../lib/AreCompiler/AreCompiler.component.mjs';
-import { b as AreNode, c as AreScene } from '../../index-DMXWCL7R.mjs';
-import { AddAttributeInstruction } from '../../lib/AreSceneInstruction/types/AddAttribute.instruction.mjs';
-import { AddDirectiveInstruction } from '../../lib/AreSceneInstruction/types/AddDirective.instruction.mjs';
-import { AddStyleInstruction } from '../../lib/AreSceneInstruction/types/AddStyle.instruction.mjs';
-import { AttachListenerInstruction } from '../../lib/AreSceneInstruction/types/AttachListener.instruction.mjs';
-import { AttachRootNodeInstruction } from '../../lib/AreSceneInstruction/types/AttachRootNode.instruction.mjs';
-import { MountNodeInstruction } from '../../lib/AreSceneInstruction/types/MountNode.instruction.mjs';
-import { ReplaceInterpolationInstruction } from '../../lib/AreSceneInstruction/types/ReplaceInterpolation.instruction.mjs';
-import { UnmountNodeInstruction } from '../../lib/AreSceneInstruction/types/UnmountNode.instruction.mjs';
-import { AreSyntax } from '../../lib/AreSyntax/AreSyntax.component.mjs';
-import { A_ExecutionContext } from '@adaas/a-utils/a-execution';
-import { A_Logger } from '@adaas/a-utils/a-logger';
-import '@adaas/a-utils/a-signal';
-import '../../lib/AreComponent/Are.component.mjs';
-import '../../lib/AreComponent/Are.context.mjs';
-import '../../lib/AreProps/AreProps.context.mjs';
-import '../../lib/AreStore/AreStore.context.mjs';
-import '../../lib/AreEvent/AreEvent.types.mjs';
-import '../../lib/AreNode/AreNode.types.mjs';
-import '../../lib/AreScene/AreScene.types.mjs';
-import '../../lib/AreSyntax/AreSyntax.types.mjs';
-import '../../lib/AreSyntax/AreSyntax.context.mjs';
-
-declare class AreHTMLCompiler extends AreCompiler {
-    /**
-     * Get DOM element by string path from root element
-     * Works with paths generated by the string-based parser
-     */
-    getElementByPath(root: Element, path?: string): Element | undefined;
-    /**
-     * Get DOM element by AreNode based on its scene path
-     *
-     * @param node
-     * @returns
-     */
-    getElementByNode(node: AreNode): Element | undefined;
-    /**
-     * Insert DOM element at specified path within root element
-     *
-     * @param root
-     * @param path
-     * @param element
-     */
-    insertElementAtPath(root: Element, path: string, element: Element): void;
-    /**
-     * Insert DOM element corresponding to AreNode at its scene path
-     *
-     * @param node
-     * @param element
-     */
-    insertElementByNode(node: AreNode, element: Element): void;
-    /**
-     * Index the elements of the given AreNode within its scene
-     *
-     * @param node
-     */
-    index(node: AreNode): void;
-    /**
-     * Create a position-based mapping by parsing the original template with DOM
-     * This ensures 1:1 correspondence between DOM structure and original markup
-     */
-    private createPositionBasedMarkupMap;
-    /**
-     * Recursively map DOM positions to their exact original markup
-     */
-    private mapDOMPositions;
-    /**
-     * Index elements using actual DOM structure with position-based markup mapping
-     */
-    private indexElementsFromDOM;
-    applyAttachRootNodeInstruction(instruction: AttachRootNodeInstruction, logger?: A_Logger): void;
-    applyMountNodeInstruction(instruction: MountNodeInstruction, context: A_ExecutionContext<{
-        element: Element;
-        mountPoint: Element;
-        content: AreScene;
-    }>, syntax: AreSyntax, logger?: A_Logger): void;
-    applyUnmountNodeInstruction(instruction: UnmountNodeInstruction, context: A_ExecutionContext<{
-        element: Element;
-        mountPoint: Element;
-        content: AreScene;
-    }>, logger?: A_Logger): void;
-    applyAddStyleInstruction(instruction: AddStyleInstruction, context: A_ExecutionContext<{
-        element: Element;
-        mountPoint: Element;
-        content: AreScene;
-    }>, logger?: A_Logger): void;
-    applyAttachListenerInstruction(instruction: AttachListenerInstruction, context: A_ExecutionContext<{
-        element: Element;
-        mountPoint: Element;
-        content: AreScene;
-    }>, logger?: A_Logger): void;
-    applyAddAttributeInstruction(instruction: AddAttributeInstruction, context: A_ExecutionContext<{
-        element: Element;
-        mountPoint: Element;
-        content: AreScene;
-    }>, scope: A_Scope, logger?: A_Logger): void;
-    revertInstruction(instruction: ReplaceInterpolationInstruction): void;
-    interpolationTextNodes: Map<string, Text>;
-    applyReplaceInterpolationInstruction(instruction: ReplaceInterpolationInstruction, context: A_ExecutionContext<{
-        element: Element;
-        mountPoint: Element;
-        content: AreScene;
-    }>, scope: A_Scope, syntax: AreSyntax, logger?: A_Logger): void;
-    initAddDirectiveInstruction(instruction: AddDirectiveInstruction, scope: A_Scope, logger?: A_Logger): void;
-    applyAddDirectiveInstruction(instruction: AddDirectiveInstruction, context: A_ExecutionContext<{
-        element: Element;
-        mountPoint: Element;
-        content: AreScene;
-    }>, scope: A_Scope, logger?: A_Logger): void;
-}
-
-export { AreHTMLCompiler };