@jondotsoy/don 0.0.2

package/lib/esm/document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.js","sourceRoot":"","sources":["../../src/document.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAS,MAAM,SAAS,CAAC;AAEtD,MAAM,OAAO,SAAS;IAET;IACA;IACA;IAHX,YACW,IAAW,EACX,IAAa,EACb,QAAqB;QAFrB,SAAI,GAAJ,IAAI,CAAO;QACX,SAAI,GAAJ,IAAI,CAAS;QACb,aAAQ,GAAR,QAAQ,CAAa;IAC7B,CAAC;IAEJ,MAAM,CAAC,WAAW,CAAC,GAAY;QAC7B,OAAO,GAAG,YAAY,SAAS,CAAC;IAClC,CAAC;CACF;AAED,MAAM,OAAO,QAAQ;IACE;IAArB,YAAqB,QAAqB;QAArB,aAAQ,GAAR,QAAQ,CAAa;IAAG,CAAC;IAE9C,MAAM,CAAC,UAAU,CAAC,GAAY;QAC5B,OAAO,GAAG,YAAY,QAAQ,CAAC;IACjC,CAAC;CACF;AAUD,MAAM,OAAO,eAAe;IAC1B,MAAM,CAAC,KAAqD;QAC1D,MAAM,MAAM,GACV,KAAK,YAAY,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,YAAY,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACrE,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAEzC,mCAAmC;QACnC,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAE9C,yBAAyB;QACzB,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC1E,OAAO,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IAEO,iBAAiB,CAAC,MAAe;QACvC,MAAM,MAAM,GAAmB,EAAE,CAAC;QAClC,MAAM,KAAK,GAAyD,EAAE,CAAC;QAEvE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY;gBAAE,SAAS;YAEpD,MAAM,KAAK,GAAG,KAAK,CAAC,GAAkB,CAAC;YAEvC,IAAI,KAAK,KAAK,GAAG,EAAE,CAAC;gBAClB,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;YAC/C,CAAC;iBAAM,IAAI,KAAK,KAAK,GAAG,EAAE,CAAC;gBACzB,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;gBACzB,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBACnC,MAAM,CAAC,IAAI,CAAC;wBACV,SAAS,EAAE,IAAI,CAAC,SAAS;wBACzB,UAAU,EAAE,CAAC;wBACb,IAAI,EAAE,QAAQ;qBACf,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;iBAAM,IAAI,KAAK,KAAK,GAAG,EAAE,CAAC;gBACzB,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;YACjD,CAAC;iBAAM,IAAI,KAAK,KAAK,GAAG,EAAE,CAAC;gBACzB,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;gBACzB,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBACrC,MAAM,CAAC,IAAI,CAAC;wBACV,SAAS,EAAE,IAAI,CAAC,SAAS;wBACzB,UAAU,EAAE,CAAC;wBACb,IAAI,EAAE,UAAU;qBACjB,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,eAAe,CACrB,MAAe,EACf,UAAkB,EAClB,QAAgB,EAChB,MAAsB;QAEtB,MAAM,UAAU,GAAgB,EAAE,CAAC;QACnC,IAAI,CAAC,GAAG,UAAU,CAAC;QAEnB,OAAO,CAAC,GAAG,QAAQ,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,KAAK;gBAAE,MAAM;YAElB,gBAAgB;YAChB,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC7B,CAAC,EAAE,CAAC;gBACJ,SAAS;YACX,CAAC;YAED,+CAA+C;YAC/C,IACE,KAAK,CAAC,IAAI,KAAK,YAAY;gBAC3B,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,IAAI,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,EACxC,CAAC;gBACD,MAAM;YACR,CAAC;YAED,mFAAmF;YACnF,IACE,KAAK,CAAC,IAAI,KAAK,SAAS;gBACxB,KAAK,CAAC,IAAI,KAAK,QAAQ;gBACvB,KAAK,CAAC,IAAI,KAAK,QAAQ;gBACvB,KAAK,CAAC,IAAI,KAAK,SAAS,EACxB,CAAC;gBACD,MAAM,IAAI,GAAG,KAAK,CAAC;gBACnB,MAAM,IAAI,GAAY,EAAE,CAAC;gBACzB,CAAC,EAAE,CAAC;gBAEJ,uDAAuD;gBACvD,OAAO,CAAC,GAAG,QAAQ,EAAE,CAAC;oBACpB,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;oBAC3B,IACE,CAAC,QAAQ;wBACT,QAAQ,CAAC,IAAI,KAAK,SAAS;wBAC3B,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,IAAI,QAAQ,CAAC,GAAG,KAAK,GAAG,CAAC;wBACxD,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,IAAI,QAAQ,CAAC,GAAG,KAAK,GAAG,CAAC,EACxD,CAAC;wBACD,MAAM;oBACR,CAAC;oBACD,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;oBACpB,CAAC,EAAE,CAAC;oBAEJ,wDAAwD;oBACxD,mDAAmD;oBACnD,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;wBAChC,MAAM;oBACR,CAAC;gBACH,CAAC;gBAED,sEAAsE;gBACtE,IAAI,QAAQ,GAAgB,EAAE,CAAC;gBAC/B,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CACvB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ,CAChD,CAAC;gBAEF,IAAI,KAAK,EAAE,CAAC;oBACV,gDAAgD;oBAChD,QAAQ,GAAG,IAAI,CAAC,eAAe,CAC7B,MAAM,EACN,KAAK,CAAC,SAAS,GAAG,CAAC,EACnB,KAAK,CAAC,UAAU,EAChB,MAAM,CACP,CAAC;oBACF,CAAC,GAAG,KAAK,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,4BAA4B;oBAEtD,+DAA+D;oBAC/D,IAAI,CAAC,GAAG,QAAQ,EAAE,CAAC;wBACjB,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;wBAC5B,IAAI,SAAS,IAAI,SAAS,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;4BAC9C,MAAM,IAAI,KAAK,CACb,wEAAwE,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,GAAG,GAAG,CAC5G,CAAC;wBACJ,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,UAAU,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;YACvD,CAAC;iBAAM,CAAC;gBACN,8CAA8C;gBAC9C,MAAM,IAAI,KAAK,CACb,+FAA+F,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,GAAG,GAAG,CAC3H,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;CACF"}

package/lib/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { LexerEncoder, Lexema, Token, TokenExpression } from "./lexer.js";
+export { Directive, Document, DocumentEncoder } from "./document.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/lib/esm/index.js

@@ -0,0 +1,3 @@
+export { LexerEncoder, Lexema, Token, TokenExpression } from "./lexer.js";
+export { Directive, Document, DocumentEncoder } from "./document.js";
+//# sourceMappingURL=index.js.map

package/lib/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/lib/esm/lexer.d.ts

@@ -0,0 +1,38 @@
+import { ChunkList } from "./chunk";
+export declare class Token {
+    readonly type: string;
+    readonly raw: string;
+    constructor(type: string, raw: string);
+}
+export declare class Lexema {
+    readonly length: number;
+    readonly tokens: Iterable<Token>;
+    constructor(length: number, tokens: Iterable<Token>);
+}
+declare class MatchTokenExpressionResult {
+    readonly matched: ChunkList;
+    readonly length: number;
+    constructor(matched: ChunkList, length: number);
+}
+export declare class TokenExpression {
+    readonly test: (chunks: ChunkList, fromIndex: number) => () => null | MatchTokenExpressionResult;
+    constructor(test: (chunks: ChunkList, fromIndex: number) => () => null | MatchTokenExpressionResult);
+    match(chunks: ChunkList, fromIndex: number): null | MatchTokenExpressionResult;
+    static stringLiteral: TokenExpression;
+    static keyword: TokenExpression;
+    static punctuator: TokenExpression;
+    static newline: TokenExpression;
+    static booleanLiteral: TokenExpression;
+    static nullLiteral: TokenExpression;
+    static numberLiteral: TokenExpression;
+    static singleComment: TokenExpression;
+    static multilineComment: TokenExpression;
+    static heredoc: TokenExpression;
+    static whitespace: TokenExpression;
+}
+export declare class LexerEncoder {
+    encode(inpt: string | Iterable<number> | ChunkList): Lexema;
+    private findMatchingExpression;
+}
+export {};
+//# sourceMappingURL=lexer.d.ts.map

package/lib/esm/lexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../src/lexer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,SAAS,EAAE,MAAM,SAAS,CAAC;AAElD,qBAAa,KAAK;IAEd,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM;gBADX,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM;CAEvB;AAED,qBAAa,MAAM;IAEf,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC;gBADvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC;CAEnC;AAED,cAAM,0BAA0B;IAE5B,QAAQ,CAAC,OAAO,EAAE,SAAS;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM;gBADd,OAAO,EAAE,SAAS,EAClB,MAAM,EAAE,MAAM;CAE1B;AAED,qBAAa,eAAe;IAExB,QAAQ,CAAC,IAAI,EAAE,CACb,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,MAAM,KACd,MAAM,IAAI,GAAG,0BAA0B;gBAHnC,IAAI,EAAE,CACb,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,MAAM,KACd,MAAM,IAAI,GAAG,0BAA0B;IAG9C,KAAK,CACH,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,MAAM,GAChB,IAAI,GAAG,0BAA0B;IAKpC,MAAM,CAAC,aAAa,kBAqElB;IAEF,MAAM,CAAC,OAAO,kBAmEZ;IAEF,MAAM,CAAC,UAAU,kBA4Bf;IAEF,MAAM,CAAC,OAAO,kBA0BZ;IAEF,MAAM,CAAC,cAAc,kBA0BnB;IAEF,MAAM,CAAC,WAAW,kBA0BhB;IAEF,MAAM,CAAC,aAAa,kBA8DlB;IAEF,MAAM,CAAC,aAAa,kBA+ElB;IAEF,MAAM,CAAC,gBAAgB,kBAqFrB;IAEF,MAAM,CAAC,OAAO,kBA4KZ;IAEF,MAAM,CAAC,UAAU,kBA2Bf;CACH;AAED,qBAAa,YAAY;IACvB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,GAAG,MAAM;IAwE3D,OAAO,CAAC,sBAAsB;CAiB/B"}

package/lib/esm/lexer.js

@@ -0,0 +1,600 @@
+import { ChunkEncoder, ChunkList } from "./chunk";
+export class Token {
+    type;
+    raw;
+    constructor(type, raw) {
+        this.type = type;
+        this.raw = raw;
+    }
+}
+export class Lexema {
+    length;
+    tokens;
+    constructor(length, tokens) {
+        this.length = length;
+        this.tokens = tokens;
+    }
+}
+class MatchTokenExpressionResult {
+    matched;
+    length;
+    constructor(matched, length) {
+        this.matched = matched;
+        this.length = length;
+    }
+}
+export class TokenExpression {
+    test;
+    constructor(test) {
+        this.test = test;
+    }
+    match(chunks, fromIndex) {
+        const result = this.test(chunks, fromIndex)();
+        return result;
+    }
+    static stringLiteral = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            // Verificar que hay al menos un chunk en fromIndex
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const firstChunk = chunksArray[fromIndex];
+            if (!firstChunk) {
+                return null;
+            }
+            // Verificar que el primer chunk es una comilla de apertura (doble o simple)
+            const firstValue = Array.from(firstChunk.value);
+            const firstStr = new TextDecoder().decode(new Uint8Array(firstValue));
+            if (firstStr !== '"' && firstStr !== "'") {
+                return null;
+            }
+            const quoteType = firstStr; // Guardar el tipo de comilla para buscar la misma al cerrar
+            // Buscar la comilla de cierre del mismo tipo
+            let endIndex = fromIndex + 1;
+            let escaped = false;
+            while (endIndex < chunksArray.length) {
+                const chunk = chunksArray[endIndex];
+                if (!chunk)
+                    break;
+                const value = Array.from(chunk.value);
+                const str = new TextDecoder().decode(new Uint8Array(value));
+                if (escaped) {
+                    // El carácter anterior era un backslash, este está escapado
+                    escaped = false;
+                    endIndex++;
+                    continue;
+                }
+                if (str === "\\") {
+                    // Backslash - el siguiente carácter estará escapado
+                    escaped = true;
+                    endIndex++;
+                    continue;
+                }
+                if (str === quoteType) {
+                    // Encontramos la comilla de cierre del mismo tipo (no escapada)
+                    const matchedChunks = chunksArray.slice(fromIndex, endIndex + 1);
+                    const matchedChunkList = new ChunkList(matchedChunks.length, matchedChunks);
+                    return new MatchTokenExpressionResult(matchedChunkList, matchedChunks.length);
+                }
+                endIndex++;
+            }
+            // No se encontró comilla de cierre
+            return null;
+        };
+    });
+    static keyword = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            // Verificar que hay al menos un chunk en fromIndex
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const firstChunk = chunksArray[fromIndex];
+            if (!firstChunk) {
+                return null;
+            }
+            // Verificar que el primer chunk contiene un keyword válido
+            const firstValue = Array.from(firstChunk.value);
+            const firstStr = new TextDecoder().decode(new Uint8Array(firstValue));
+            // Un keyword debe empezar con letras, guión bajo, o ciertos símbolos (/, -)
+            const startsWithKeywordChar = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(firstStr);
+            const startsWithSymbol = /^[\/\-]$/.test(firstStr);
+            if (!startsWithKeywordChar && !startsWithSymbol) {
+                return null;
+            }
+            // Consumir chunks consecutivos (sin espacios) para formar un keyword compuesto
+            const matchedChunks = [firstChunk];
+            let currentIndex = fromIndex + 1;
+            while (currentIndex < chunksArray.length) {
+                const nextChunk = chunksArray[currentIndex];
+                if (!nextChunk)
+                    break;
+                const nextValue = Array.from(nextChunk.value);
+                const nextStr = new TextDecoder().decode(new Uint8Array(nextValue));
+                // Si es un espacio o salto de línea, terminamos
+                if (nextStr.trim() === "" || nextStr === "\n") {
+                    break;
+                }
+                // Si es un keyword válido o un símbolo (excepto delimitadores), lo agregamos
+                const isKeywordPart = /^[a-zA-Z0-9_]+$/.test(nextStr);
+                const isSymbol = nextStr.length === 1 && !/[\s\n{}[\],]/.test(nextStr);
+                if (isKeywordPart || isSymbol) {
+                    matchedChunks.push(nextChunk);
+                    currentIndex++;
+                }
+                else {
+                    // Es un delimitador, terminamos
+                    break;
+                }
+            }
+            const matchedChunkList = new ChunkList(matchedChunks.length, matchedChunks);
+            return new MatchTokenExpressionResult(matchedChunkList, matchedChunks.length);
+        };
+    });
+    static punctuator = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const chunk = chunksArray[fromIndex];
+            if (!chunk) {
+                return null;
+            }
+            const value = Array.from(chunk.value);
+            const str = new TextDecoder().decode(new Uint8Array(value));
+            if (["[", "]", "{", "}", ",", "+", "-", "/", "*", "<", ">"].includes(str)) {
+                const matchedChunks = [chunk];
+                const matchedChunkList = new ChunkList(1, matchedChunks);
+                return new MatchTokenExpressionResult(matchedChunkList, 1);
+            }
+            return null;
+        };
+    });
+    static newline = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const chunk = chunksArray[fromIndex];
+            if (!chunk) {
+                return null;
+            }
+            const value = Array.from(chunk.value);
+            const str = new TextDecoder().decode(new Uint8Array(value));
+            if (str === "\n") {
+                const matchedChunks = [chunk];
+                const matchedChunkList = new ChunkList(1, matchedChunks);
+                return new MatchTokenExpressionResult(matchedChunkList, 1);
+            }
+            return null;
+        };
+    });
+    static booleanLiteral = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const chunk = chunksArray[fromIndex];
+            if (!chunk) {
+                return null;
+            }
+            const value = Array.from(chunk.value);
+            const str = new TextDecoder().decode(new Uint8Array(value));
+            if (str === "true" || str === "false") {
+                const matchedChunks = [chunk];
+                const matchedChunkList = new ChunkList(1, matchedChunks);
+                return new MatchTokenExpressionResult(matchedChunkList, 1);
+            }
+            return null;
+        };
+    });
+    static nullLiteral = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const chunk = chunksArray[fromIndex];
+            if (!chunk) {
+                return null;
+            }
+            const value = Array.from(chunk.value);
+            const str = new TextDecoder().decode(new Uint8Array(value));
+            if (str === "null") {
+                const matchedChunks = [chunk];
+                const matchedChunkList = new ChunkList(1, matchedChunks);
+                return new MatchTokenExpressionResult(matchedChunkList, 1);
+            }
+            return null;
+        };
+    });
+    static numberLiteral = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const firstChunk = chunksArray[fromIndex];
+            if (!firstChunk) {
+                return null;
+            }
+            const firstValue = Array.from(firstChunk.value);
+            const firstStr = new TextDecoder().decode(new Uint8Array(firstValue));
+            // Debe empezar con un dígito
+            if (!/^[0-9][0-9_]*$/.test(firstStr)) {
+                return null;
+            }
+            let matchedChunks = [firstChunk];
+            let currentIndex = fromIndex + 1;
+            // Verificar si hay un punto decimal
+            if (currentIndex < chunksArray.length) {
+                const dotChunk = chunksArray[currentIndex];
+                if (dotChunk) {
+                    const dotValue = Array.from(dotChunk.value);
+                    const dotStr = new TextDecoder().decode(new Uint8Array(dotValue));
+                    if (dotStr === ".") {
+                        // Verificar que hay dígitos después del punto
+                        if (currentIndex + 1 < chunksArray.length) {
+                            const decimalChunk = chunksArray[currentIndex + 1];
+                            if (decimalChunk) {
+                                const decimalValue = Array.from(decimalChunk.value);
+                                const decimalStr = new TextDecoder().decode(new Uint8Array(decimalValue));
+                                if (/^[0-9_]+$/.test(decimalStr)) {
+                                    matchedChunks.push(dotChunk);
+                                    matchedChunks.push(decimalChunk);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const matchedChunkList = new ChunkList(matchedChunks.length, matchedChunks);
+            return new MatchTokenExpressionResult(matchedChunkList, matchedChunks.length);
+        };
+    });
+    static singleComment = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const firstChunk = chunksArray[fromIndex];
+            if (!firstChunk) {
+                return null;
+            }
+            const firstValue = Array.from(firstChunk.value);
+            const firstStr = new TextDecoder().decode(new Uint8Array(firstValue));
+            let matchedChunks = [];
+            let currentIndex = fromIndex;
+            // Verificar si empieza con # (comentario de una sola línea)
+            if (firstStr === "#") {
+                matchedChunks = [firstChunk];
+                currentIndex = fromIndex + 1;
+            }
+            // Verificar si empieza con // (comentario de una sola línea)
+            else if (firstStr === "/") {
+                // Verificar que el siguiente chunk también es /
+                if (fromIndex + 1 >= chunksArray.length) {
+                    return null;
+                }
+                const secondChunk = chunksArray[fromIndex + 1];
+                if (!secondChunk) {
+                    return null;
+                }
+                const secondValue = Array.from(secondChunk.value);
+                const secondStr = new TextDecoder().decode(new Uint8Array(secondValue));
+                if (secondStr !== "/") {
+                    return null;
+                }
+                matchedChunks = [firstChunk, secondChunk];
+                currentIndex = fromIndex + 2;
+            }
+            else {
+                return null;
+            }
+            // Capturar todo hasta el final de la línea (sin incluir \n)
+            while (currentIndex < chunksArray.length) {
+                const chunk = chunksArray[currentIndex];
+                if (!chunk)
+                    break;
+                const value = Array.from(chunk.value);
+                const str = new TextDecoder().decode(new Uint8Array(value));
+                // Si encontramos un salto de línea, terminamos (sin incluirlo)
+                if (str === "\n") {
+                    break;
+                }
+                matchedChunks.push(chunk);
+                currentIndex++;
+            }
+            const matchedChunkList = new ChunkList(matchedChunks.length, matchedChunks);
+            return new MatchTokenExpressionResult(matchedChunkList, matchedChunks.length);
+        };
+    });
+    static multilineComment = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const firstChunk = chunksArray[fromIndex];
+            if (!firstChunk) {
+                return null;
+            }
+            const firstValue = Array.from(firstChunk.value);
+            const firstStr = new TextDecoder().decode(new Uint8Array(firstValue));
+            // Debe empezar con /*
+            if (firstStr !== "/") {
+                return null;
+            }
+            // Verificar que el siguiente chunk es *
+            if (fromIndex + 1 >= chunksArray.length) {
+                return null;
+            }
+            const secondChunk = chunksArray[fromIndex + 1];
+            if (!secondChunk) {
+                return null;
+            }
+            const secondValue = Array.from(secondChunk.value);
+            const secondStr = new TextDecoder().decode(new Uint8Array(secondValue));
+            if (secondStr !== "*") {
+                return null;
+            }
+            // Capturar todo hasta encontrar */
+            let matchedChunks = [firstChunk, secondChunk];
+            let currentIndex = fromIndex + 2;
+            while (currentIndex < chunksArray.length) {
+                const chunk = chunksArray[currentIndex];
+                if (!chunk)
+                    break;
+                const value = Array.from(chunk.value);
+                const str = new TextDecoder().decode(new Uint8Array(value));
+                matchedChunks.push(chunk);
+                // Si encontramos *, verificar si el siguiente es /
+                if (str === "*") {
+                    if (currentIndex + 1 < chunksArray.length) {
+                        const nextChunk = chunksArray[currentIndex + 1];
+                        if (nextChunk) {
+                            const nextValue = Array.from(nextChunk.value);
+                            const nextStr = new TextDecoder().decode(new Uint8Array(nextValue));
+                            if (nextStr === "/") {
+                                // Encontramos el cierre */
+                                matchedChunks.push(nextChunk);
+                                const matchedChunkList = new ChunkList(matchedChunks.length, matchedChunks);
+                                return new MatchTokenExpressionResult(matchedChunkList, matchedChunks.length);
+                            }
+                        }
+                    }
+                }
+                currentIndex++;
+            }
+            // No se encontró el cierre */
+            return null;
+        };
+    });
+    static heredoc = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const firstChunk = chunksArray[fromIndex];
+            if (!firstChunk) {
+                return null;
+            }
+            const firstValue = Array.from(firstChunk.value);
+            const firstStr = new TextDecoder().decode(new Uint8Array(firstValue));
+            // Debe empezar con <<
+            if (firstStr !== "<") {
+                return null;
+            }
+            // Verificar que el siguiente chunk también es <
+            if (fromIndex + 1 >= chunksArray.length) {
+                return null;
+            }
+            const secondChunk = chunksArray[fromIndex + 1];
+            if (!secondChunk) {
+                return null;
+            }
+            const secondValue = Array.from(secondChunk.value);
+            const secondStr = new TextDecoder().decode(new Uint8Array(secondValue));
+            if (secondStr !== "<") {
+                return null;
+            }
+            let matchedChunks = [firstChunk, secondChunk];
+            let currentIndex = fromIndex + 2;
+            // Capturar el tag opcional (si existe)
+            if (currentIndex < chunksArray.length) {
+                const tagChunk = chunksArray[currentIndex];
+                if (tagChunk) {
+                    const tagValue = Array.from(tagChunk.value);
+                    const tagStr = new TextDecoder().decode(new Uint8Array(tagValue));
+                    // Si es un keyword (letras/números/guiones bajos), es el tag
+                    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tagStr)) {
+                        matchedChunks.push(tagChunk);
+                        currentIndex++;
+                    }
+                }
+            }
+            // Debe haber un salto de línea después del << o <<TAG
+            if (currentIndex >= chunksArray.length) {
+                return null;
+            }
+            const newlineChunk = chunksArray[currentIndex];
+            if (!newlineChunk) {
+                return null;
+            }
+            const newlineValue = Array.from(newlineChunk.value);
+            const newlineStr = new TextDecoder().decode(new Uint8Array(newlineValue));
+            if (newlineStr !== "\n") {
+                return null;
+            }
+            matchedChunks.push(newlineChunk);
+            currentIndex++;
+            // Determinar la indentación de la línea donde está el <<
+            let directiveIndentation = 0;
+            for (let i = fromIndex - 1; i >= 0; i--) {
+                const prevChunk = chunksArray[i];
+                if (!prevChunk)
+                    break;
+                const prevValue = Array.from(prevChunk.value);
+                const prevStr = new TextDecoder().decode(new Uint8Array(prevValue));
+                if (prevStr === "\n") {
+                    // Encontramos el inicio de la línea, contar espacios después
+                    let spaceIndex = i + 1;
+                    while (spaceIndex < fromIndex) {
+                        const spaceChunk = chunksArray[spaceIndex];
+                        if (!spaceChunk)
+                            break;
+                        const spaceValue = Array.from(spaceChunk.value);
+                        const spaceStr = new TextDecoder().decode(new Uint8Array(spaceValue));
+                        if (spaceStr.trim() === "" && spaceStr !== "\n") {
+                            directiveIndentation += spaceStr.length;
+                            spaceIndex++;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+            // Capturar contenido hasta encontrar una línea con indentación <= directiveIndentation
+            while (currentIndex < chunksArray.length) {
+                const chunk = chunksArray[currentIndex];
+                if (!chunk)
+                    break;
+                const value = Array.from(chunk.value);
+                const str = new TextDecoder().decode(new Uint8Array(value));
+                // Si encontramos un salto de línea, verificar la siguiente línea
+                if (str === "\n") {
+                    matchedChunks.push(chunk);
+                    currentIndex++;
+                    // Verificar la indentación de la siguiente línea
+                    let lineIndentation = 0;
+                    let checkIndex = currentIndex;
+                    let hasContent = false;
+                    // Contar espacios al inicio de la línea
+                    while (checkIndex < chunksArray.length) {
+                        const checkChunk = chunksArray[checkIndex];
+                        if (!checkChunk)
+                            break;
+                        const checkValue = Array.from(checkChunk.value);
+                        const checkStr = new TextDecoder().decode(new Uint8Array(checkValue));
+                        if (checkStr.trim() === "" && checkStr !== "\n") {
+                            lineIndentation += checkStr.length;
+                            checkIndex++;
+                        }
+                        else if (checkStr === "\n") {
+                            // Línea vacía, continuar con el contenido
+                            break;
+                        }
+                        else {
+                            // Hay contenido en esta línea
+                            hasContent = true;
+                            break;
+                        }
+                    }
+                    // Si hay contenido y la indentación es <= a la de la directiva, terminar
+                    if (hasContent && lineIndentation <= directiveIndentation) {
+                        break;
+                    }
+                }
+                else {
+                    matchedChunks.push(chunk);
+                    currentIndex++;
+                }
+            }
+            const matchedChunkList = new ChunkList(matchedChunks.length, matchedChunks);
+            return new MatchTokenExpressionResult(matchedChunkList, matchedChunks.length);
+        };
+    });
+    static whitespace = new TokenExpression((chunks, fromIndex) => {
+        return () => {
+            const chunksArray = Array.from(chunks.chunks);
+            if (fromIndex >= chunksArray.length) {
+                return null;
+            }
+            const chunk = chunksArray[fromIndex];
+            if (!chunk) {
+                return null;
+            }
+            const value = Array.from(chunk.value);
+            const str = new TextDecoder().decode(new Uint8Array(value));
+            // Verificar si es un espacio en blanco (sin incluir saltos de línea)
+            if (str.trim() === "" && !str.includes("\n")) {
+                const matchedChunks = [chunk];
+                const matchedChunkList = new ChunkList(1, matchedChunks);
+                return new MatchTokenExpressionResult(matchedChunkList, 1);
+            }
+            return null;
+        };
+    });
+}
+export class LexerEncoder {
+    encode(inpt) {
+        const chunkList = inpt instanceof ChunkList ? inpt : new ChunkEncoder().encode(inpt);
+        const expressions = {
+            singleComment: TokenExpression.singleComment,
+            multilineComment: TokenExpression.multilineComment,
+            whitespace: TokenExpression.whitespace,
+            heredoc: TokenExpression.heredoc,
+            string: TokenExpression.stringLiteral,
+            boolean: TokenExpression.booleanLiteral,
+            null: TokenExpression.nullLiteral,
+            number: TokenExpression.numberLiteral,
+            keyword: TokenExpression.keyword,
+            punctuator: TokenExpression.punctuator,
+            newline: TokenExpression.newline,
+        };
+        const hiddenExpressions = [
+            TokenExpression.singleComment,
+            TokenExpression.multilineComment,
+            TokenExpression.whitespace,
+        ];
+        const tokens = [];
+        const chunksArray = Array.from(chunkList.chunks);
+        let currentIndex = 0;
+        while (currentIndex < chunksArray.length) {
+            const chunk = chunksArray[currentIndex];
+            if (!chunk)
+                break;
+            // Intentar hacer match con cada expresión
+            const expressionResult = this.findMatchingExpression(expressions, chunkList, currentIndex);
+            if (!expressionResult) {
+                // Chunk desconocido - generar error
+                const unknownValue = new TextDecoder().decode(new Uint8Array(Array.from(chunk.value)));
+                throw new Error(`Unknown token at position ${chunk.pos}: "${unknownValue}"`);
+            }
+            const { tokenType, expression, result } = expressionResult;
+            const isHidden = hiddenExpressions.includes(expression);
+            // Extraer el valor del token
+            const matchedChunks = Array.from(result.matched.chunks);
+            const tokenValue = matchedChunks
+                .map((c) => {
+                const v = Array.from(c.value);
+                return new TextDecoder().decode(new Uint8Array(v));
+            })
+                .join("");
+            // Solo agregar el token si no está oculto
+            if (!isHidden) {
+                tokens.push(new Token(tokenType, tokenValue));
+            }
+            currentIndex += result.length;
+        }
+        return new Lexema(tokens.length, tokens);
+    }
+    findMatchingExpression(expressions, chunkList, currentIndex) {
+        for (const [tokenType, expression] of Object.entries(expressions)) {
+            const result = expression.match(chunkList, currentIndex);
+            if (result !== null) {
+                return { tokenType, expression, result };
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=lexer.js.map