@tslite/printer 0.5.6 → 1.12.0

package/dist/utilities.js

@@ -0,0 +1,427 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/utilities.ts e src/compiler/transformer.ts: o namespace virou
+// módulo ES, com os imports explícitos. Os writers do printer — o de texto, o de uma linha só e o que adia o ponto e
+// vírgula final —, a escrita dos comentários e a notificação que não faz nada.
+import { CharacterCodes, NewLineKind, computeLineAndCharacterOfPosition, computeLineStarts, filter, getIndentSize, getIndentString, getLeadingCommentRanges, getLineOfLocalPositionFromLineMap, isPinnedComment, isWhiteSpaceLike, isWhiteSpaceSingleLine, last, noop, skipTrivia, } from "./_namespaces/ts.js";
+const stringWriter = createSingleLineStringWriter();
+function createSingleLineStringWriter() {
+    let str = "";
+    const writeText = text => str += text;
+    return {
+        getText: () => str,
+        write: writeText,
+        rawWrite: writeText,
+        writeKeyword: writeText,
+        writeOperator: writeText,
+        writePunctuation: writeText,
+        writeSpace: writeText,
+        writeStringLiteral: writeText,
+        writeLiteral: writeText,
+        writeParameter: writeText,
+        writeProperty: writeText,
+        writeSymbol: (s, _) => writeText(s),
+        writeTrailingSemicolon: writeText,
+        writeComment: writeText,
+        getTextPos: () => str.length,
+        getLine: () => 0,
+        getColumn: () => 0,
+        getIndent: () => 0,
+        isAtStartOfLine: () => false,
+        hasTrailingComment: () => false,
+        hasTrailingWhitespace: () => !!str.length && isWhiteSpaceLike(str.charCodeAt(str.length - 1)),
+        // Completely ignore indentation for string writers.  And map newlines to
+        // a single space.
+        writeLine: () => str += " ",
+        increaseIndent: noop,
+        decreaseIndent: noop,
+        clear: () => str = "",
+        trackSymbol: noop,
+        reportInaccessibleThisError: noop,
+        reportInaccessibleUniqueSymbolError: noop,
+    };
+}
+export function usingSingleLineStringWriter(action) {
+    const oldString = stringWriter.getText();
+    try {
+        action(stringWriter);
+        return stringWriter.getText();
+    }
+    finally {
+        stringWriter.clear();
+        stringWriter.writeKeyword(oldString);
+    }
+}
+/**
+ * Returns a value indicating whether a name is unique globally or within the current file.
+ * Note: This does not consider whether a name appears as a free identifier or not, so at the expression `x.y` this includes both `x` and `y`.
+ */
+export function isFileLevelUniqueName(sourceFile, name, hasGlobalName) {
+    return !(hasGlobalName && hasGlobalName(name)) && !sourceFile.identifiers.has(name);
+}
+export function createTextWriter(newLine) {
+    let output;
+    let indent;
+    let lineStart;
+    let lineCount;
+    let linePos;
+    let hasTrailingComment = false;
+    function updateLineCountAndPosFor(s) {
+        const lineStartsOfS = computeLineStarts(s);
+        if (lineStartsOfS.length > 1) {
+            lineCount = lineCount + lineStartsOfS.length - 1;
+            linePos = output.length - s.length + last(lineStartsOfS);
+            lineStart = (linePos - output.length) === 0;
+        }
+        else {
+            lineStart = false;
+        }
+    }
+    function writeText(s) {
+        if (s && s.length) {
+            if (lineStart) {
+                s = getIndentString(indent) + s;
+                lineStart = false;
+            }
+            output += s;
+            updateLineCountAndPosFor(s);
+        }
+    }
+    function write(s) {
+        if (s)
+            hasTrailingComment = false;
+        writeText(s);
+    }
+    function writeComment(s) {
+        if (s)
+            hasTrailingComment = true;
+        writeText(s);
+    }
+    function reset() {
+        output = "";
+        indent = 0;
+        lineStart = true;
+        lineCount = 0;
+        linePos = 0;
+        hasTrailingComment = false;
+    }
+    function rawWrite(s) {
+        if (s !== undefined) {
+            output += s;
+            updateLineCountAndPosFor(s);
+            hasTrailingComment = false;
+        }
+    }
+    function writeLiteral(s) {
+        if (s && s.length) {
+            write(s);
+        }
+    }
+    function writeLine(force) {
+        if (!lineStart || force) {
+            output += newLine;
+            lineCount++;
+            linePos = output.length;
+            lineStart = true;
+            hasTrailingComment = false;
+        }
+    }
+    function getTextPosWithWriteLine() {
+        return lineStart ? output.length : (output.length + newLine.length);
+    }
+    reset();
+    return {
+        write,
+        rawWrite,
+        writeLiteral,
+        writeLine,
+        increaseIndent: () => { indent++; },
+        decreaseIndent: () => { indent--; },
+        getIndent: () => indent,
+        getTextPos: () => output.length,
+        getLine: () => lineCount,
+        getColumn: () => lineStart ? indent * getIndentSize() : output.length - linePos,
+        getText: () => output,
+        isAtStartOfLine: () => lineStart,
+        hasTrailingComment: () => hasTrailingComment,
+        hasTrailingWhitespace: () => !!output.length && isWhiteSpaceLike(output.charCodeAt(output.length - 1)),
+        clear: reset,
+        reportInaccessibleThisError: noop,
+        reportInaccessibleUniqueSymbolError: noop,
+        trackSymbol: noop,
+        writeKeyword: write,
+        writeOperator: write,
+        writeParameter: write,
+        writeProperty: write,
+        writePunctuation: write,
+        writeSpace: write,
+        writeStringLiteral: write,
+        writeSymbol: (s, _) => write(s),
+        writeTrailingSemicolon: write,
+        writeComment,
+        getTextPosWithWriteLine
+    };
+}
+export function getTrailingSemicolonDeferringWriter(writer) {
+    let pendingTrailingSemicolon = false;
+    function commitPendingTrailingSemicolon() {
+        if (pendingTrailingSemicolon) {
+            writer.writeTrailingSemicolon(";");
+            pendingTrailingSemicolon = false;
+        }
+    }
+    return {
+        ...writer,
+        writeTrailingSemicolon() {
+            pendingTrailingSemicolon = true;
+        },
+        writeLiteral(s) {
+            commitPendingTrailingSemicolon();
+            writer.writeLiteral(s);
+        },
+        writeStringLiteral(s) {
+            commitPendingTrailingSemicolon();
+            writer.writeStringLiteral(s);
+        },
+        writeSymbol(s, sym) {
+            commitPendingTrailingSemicolon();
+            writer.writeSymbol(s, sym);
+        },
+        writePunctuation(s) {
+            commitPendingTrailingSemicolon();
+            writer.writePunctuation(s);
+        },
+        writeKeyword(s) {
+            commitPendingTrailingSemicolon();
+            writer.writeKeyword(s);
+        },
+        writeOperator(s) {
+            commitPendingTrailingSemicolon();
+            writer.writeOperator(s);
+        },
+        writeParameter(s) {
+            commitPendingTrailingSemicolon();
+            writer.writeParameter(s);
+        },
+        writeSpace(s) {
+            commitPendingTrailingSemicolon();
+            writer.writeSpace(s);
+        },
+        writeProperty(s) {
+            commitPendingTrailingSemicolon();
+            writer.writeProperty(s);
+        },
+        writeComment(s) {
+            commitPendingTrailingSemicolon();
+            writer.writeComment(s);
+        },
+        writeLine() {
+            commitPendingTrailingSemicolon();
+            writer.writeLine();
+        },
+        increaseIndent() {
+            commitPendingTrailingSemicolon();
+            writer.increaseIndent();
+        },
+        decreaseIndent() {
+            commitPendingTrailingSemicolon();
+            writer.decreaseIndent();
+        },
+    };
+}
+export function emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments) {
+    emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, node.pos, leadingComments);
+}
+export function emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, pos, leadingComments) {
+    // If the leading comments start on different line than the start of node, write new line
+    if (leadingComments && leadingComments.length && pos !== leadingComments[0].pos &&
+        getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, leadingComments[0].pos)) {
+        writer.writeLine();
+    }
+}
+export function emitNewLineBeforeLeadingCommentOfPosition(lineMap, writer, pos, commentPos) {
+    // If the leading comments start on different line than the start of node, write new line
+    if (pos !== commentPos &&
+        getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, commentPos)) {
+        writer.writeLine();
+    }
+}
+export function emitComments(text, lineMap, writer, comments, leadingSeparator, trailingSeparator, newLine, writeComment) {
+    if (comments && comments.length > 0) {
+        if (leadingSeparator) {
+            writer.writeSpace(" ");
+        }
+        let emitInterveningSeparator = false;
+        for (const comment of comments) {
+            if (emitInterveningSeparator) {
+                writer.writeSpace(" ");
+                emitInterveningSeparator = false;
+            }
+            writeComment(text, lineMap, writer, comment.pos, comment.end, newLine);
+            if (comment.hasTrailingNewLine) {
+                writer.writeLine();
+            }
+            else {
+                emitInterveningSeparator = true;
+            }
+        }
+        if (emitInterveningSeparator && trailingSeparator) {
+            writer.writeSpace(" ");
+        }
+    }
+}
+/**
+ * Detached comment is a comment at the top of file or function body that is separated from
+ * the next statement by space.
+ */
+export function emitDetachedComments(text, lineMap, writer, writeComment, node, newLine, removeComments) {
+    let leadingComments;
+    let currentDetachedCommentInfo;
+    if (removeComments) {
+        // removeComments is true, only reserve pinned comment at the top of file
+        // For example:
+        //      /*! Pinned Comment */
+        //
+        //      var x = 10;
+        if (node.pos === 0) {
+            leadingComments = filter(getLeadingCommentRanges(text, node.pos), isPinnedCommentLocal);
+        }
+    }
+    else {
+        // removeComments is false, just get detached as normal and bypass the process to filter comment
+        leadingComments = getLeadingCommentRanges(text, node.pos);
+    }
+    if (leadingComments) {
+        const detachedComments = [];
+        let lastComment;
+        for (const comment of leadingComments) {
+            if (lastComment) {
+                const lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, lastComment.end);
+                const commentLine = getLineOfLocalPositionFromLineMap(lineMap, comment.pos);
+                if (commentLine >= lastCommentLine + 2) {
+                    // There was a blank line between the last comment and this comment.  This
+                    // comment is not part of the copyright comments.  Return what we have so
+                    // far.
+                    break;
+                }
+            }
+            detachedComments.push(comment);
+            lastComment = comment;
+        }
+        if (detachedComments.length) {
+            // All comments look like they could have been part of the copyright header.  Make
+            // sure there is at least one blank line between it and the node.  If not, it's not
+            // a copyright header.
+            const lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, last(detachedComments).end);
+            const nodeLine = getLineOfLocalPositionFromLineMap(lineMap, skipTrivia(text, node.pos));
+            if (nodeLine >= lastCommentLine + 2) {
+                // Valid detachedComments
+                emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments);
+                emitComments(text, lineMap, writer, detachedComments, /*leadingSeparator*/ false, /*trailingSeparator*/ true, newLine, writeComment);
+                currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: last(detachedComments).end };
+            }
+        }
+    }
+    return currentDetachedCommentInfo;
+    function isPinnedCommentLocal(comment) {
+        return isPinnedComment(text, comment.pos);
+    }
+}
+export function writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine) {
+    if (text.charCodeAt(commentPos + 1) === CharacterCodes.asterisk) {
+        const firstCommentLineAndCharacter = computeLineAndCharacterOfPosition(lineMap, commentPos);
+        const lineCount = lineMap.length;
+        let firstCommentLineIndent;
+        for (let pos = commentPos, currentLine = firstCommentLineAndCharacter.line; pos < commentEnd; currentLine++) {
+            const nextLineStart = (currentLine + 1) === lineCount
+                ? text.length + 1
+                : lineMap[currentLine + 1];
+            if (pos !== commentPos) {
+                // If we are not emitting first line, we need to write the spaces to adjust the alignment
+                if (firstCommentLineIndent === undefined) {
+                    firstCommentLineIndent = calculateIndent(text, lineMap[firstCommentLineAndCharacter.line], commentPos);
+                }
+                // These are number of spaces writer is going to write at current indent
+                const currentWriterIndentSpacing = writer.getIndent() * getIndentSize();
+                // Number of spaces we want to be writing
+                // eg: Assume writer indent
+                // module m {
+                //         /* starts at character 9 this is line 1
+                //    * starts at character pos 4 line                        --1  = 8 - 8 + 3
+                //   More left indented comment */                            --2  = 8 - 8 + 2
+                //     class c { }
+                // }
+                // module m {
+                //     /* this is line 1 -- Assume current writer indent 8
+                //      * line                                                --3 = 8 - 4 + 5
+                //            More right indented comment */                  --4 = 8 - 4 + 11
+                //     class c { }
+                // }
+                const spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(text, pos, nextLineStart);
+                if (spacesToEmit > 0) {
+                    let numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize();
+                    const indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize());
+                    // Write indent size string ( in eg 1: = "", 2: "" , 3: string with 8 spaces 4: string with 12 spaces
+                    writer.rawWrite(indentSizeSpaceString);
+                    // Emit the single spaces (in eg: 1: 3 spaces, 2: 2 spaces, 3: 1 space, 4: 3 spaces)
+                    while (numberOfSingleSpacesToEmit) {
+                        writer.rawWrite(" ");
+                        numberOfSingleSpacesToEmit--;
+                    }
+                }
+                else {
+                    // No spaces to emit write empty string
+                    writer.rawWrite("");
+                }
+            }
+            // Write the comment line text
+            writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart);
+            pos = nextLineStart;
+        }
+    }
+    else {
+        // Single line comment of style //....
+        writer.writeComment(text.substring(commentPos, commentEnd));
+    }
+}
+function writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart) {
+    const end = Math.min(commentEnd, nextLineStart - 1);
+    const currentLineText = text.substring(pos, end).replace(/^\s+|\s+$/g, "");
+    if (currentLineText) {
+        // trimmed forward and ending spaces text
+        writer.writeComment(currentLineText);
+        if (end !== commentEnd) {
+            writer.writeLine();
+        }
+    }
+    else {
+        // Empty string - make sure we write empty line
+        writer.rawWrite(newLine);
+    }
+}
+function calculateIndent(text, pos, end) {
+    let currentLineIndent = 0;
+    for (; pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++) {
+        if (text.charCodeAt(pos) === CharacterCodes.tab) {
+            // Tabs = TabSize = indent size and go to next tabStop
+            currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize());
+        }
+        else {
+            // Single space
+            currentLineIndent++;
+        }
+    }
+    return currentLineIndent;
+}
+const carriageReturnLineFeed = "\r\n";
+const lineFeed = "\n";
+export function getNewLineCharacter(options, getNewLine) {
+    switch (options.newLine) {
+        case NewLineKind.CarriageReturnLineFeed:
+            return carriageReturnLineFeed;
+        case NewLineKind.LineFeed:
+            return lineFeed;
+    }
+    return getNewLine ? getNewLine() : carriageReturnLineFeed;
+}
+export function noEmitNotification(hint, node, callback) {
+    callback(hint, node);
+}

package/package.json

@@ -1,60 +1,39 @@
 {
   "name": "@tslite/printer",
-  "version": "0.5.6",
-  "description": "TSLite printer — emits JavaScript source from an AST (and from the hybrid #expr JSON form)",
+  "version": "1.12.0",
+  "description": "The tsc 3.9.10 printer, copied from the tag and cut down to the TSLite Language: prints a parse tree node, a list or a file as text, with the writers it prints through",
+  "author": "Anderson D. Rosa <andersondrosa@outlook.com>",
+  "license": "Apache-2.0",
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "types": "./dist/_namespaces/ts.d.ts",
+      "import": "./dist/_namespaces/ts.js"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE",
+    "NOTICE"
   ],
-  "sideEffects": false,
-  "engines": {
-    "node": ">=18"
+  "dependencies": {
+    "@tslite/parser": "1.12.0"
+  },
+  "devDependencies": {
+    "@tslite/oracle": "0.1.1"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/andersondrosa/tslite.git",
     "directory": "packages/printer"
   },
-  "keywords": [
-    "ast",
-    "estree",
-    "codegen",
-    "printer",
-    "emit",
-    "code-generation",
-    "typescript"
-  ],
-  "author": "Anderson D. Rosa <andersondrosa@outlook.com>",
-  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@tslite/core": "0.10.0",
-    "@tslite/sanitize": "0.1.11",
-    "@tslite/capability": "0.6.0"
-  },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node ../../scripts/copy-declarations.mjs dist",
     "clean": "rm -rf dist",
-    "format": "prettier --write \"src/**/*.ts\"",
-    "format:check": "prettier --check \"src/**/*.ts\""
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit -p ."
   }
 }

package/dist/index.cjs

@@ -1 +0,0 @@
-'use strict';var core=require('@tslite/core'),capability=require('@tslite/capability'),sanitize=require('@tslite/sanitize');var L=t=>core.VALID_OBJECT_KEY.test(t);function m(t){let e=n=>{if(typeof n=="string")return `"${n}"`;if(typeof n!="object")return String(n);if(n===null)return "null";if(Array.isArray(n))return `[${n.map(e).join(",")}]`;let s=n;if(core.isExprMarker(s)){let{[core.EXPR_MARKER]:i,...y}=s,N={type:i,...y};return r(N)}return `{ ${Object.entries(s).map(([i,y])=>`${L(i)?i:`"${i}"`}: ${e(y)}`).join(", ")} }`};return e(t)}var u=", ",l=null,r=t=>{if(t==null)return "";if(Array.isArray(t))return t.filter(Boolean).map(r).join(u);if(typeof t!="object")return String(t);if(!t.type)return JSON.stringify(t);if(t.type in T){if(l){let e=capability.nodeViolation(t,l);if(e)throw new core.TSLiteError("node-not-allowed",`'${e}' is not allowed by the active capability profile.`,{type:t.type})}return T[t.type](t)}throw Error("Unknown type: "+t.type)},W=(t,e)=>{t&&typeof t=="object"&&!Array.isArray(t)&&sanitize.assertSafe(t,e.sanitize==="hermetic"?sanitize.HERMETIC_POLICY:void 0);let n=l;l=capability.compileProfile(e);try{return r(t)}finally{l=n;}},c=t=>`(${t})`;function b(t){if(_.has(t.type))return  true;if(t.type!=="Literal")return  false;let e=t;return !(typeof e.value=="number"||e.bigint!=null)}var _=new Set(["Identifier","ThisExpression","ArrayExpression","MemberExpression","CallExpression","TemplateLiteral"]),x=t=>{if(t.type==="TSAsExpression")return x(t.expression);let e=r(t);return b(t)?e:c(e)},M=t=>`[${r(t.elements)}]`,U=t=>`[${t.elements.map(n=>n?r(n):"").join(", ")}]`,q=t=>{let e=r(t.params),n=r(t.body),s=t.body.type!=="BlockStatement"&&n.startsWith("{"),o=t.body.type=="AssignmentExpression"||t.body.type=="BinaryExpression"||t.body.type=="ObjectExpression"||t.body.type=="JsonExpression"||s?c(n):n;return `${t.async?"async ":""}(${e}) => ${o}`},V=t=>{let e=r(t.left),n=r(t.right);return `${e} ${t.operator} ${n}`},X=t=>"await "+p(t.argument,core.Precedence.Await,false),$=t=>t.type==="TSAsExpression"?$(t.expression):t,w=t=>{let e=$(t);return e.type==="UnaryExpression"||e.type==="AwaitExpression"},A=(t,e)=>{let n=$(e);if(n.type!=="LogicalExpression")return  false;let s=n.operator;return t==="??"?s==="||"||s==="&&":t==="||"||t==="&&"?s==="??":false},K=t=>{let e=core.BinaryPrecedence[t.operator]??1/0,n=t.operator==="**",s=p(t.left,e,false,n),o=n&&(w(t.left)||s[0]==="-"||s[0]==="+")?c(s):s,i=p(t.right,e,true,n);return `${o} ${t.operator} ${i}`},z=t=>{let e=t.body.map(E).filter(Boolean).join(" ");return `{ ${e?e+" ":""}}`},Y=t=>t.label?`break ${r(t.label)}`:"break",H=t=>{let e=x(t.callee),n=t.optional?"?.":"";return `${e}${n}(${r(t.arguments)})`},G=t=>r(t.expression),S=t=>t.type==="BinaryExpression"||t.type==="LogicalExpression"?core.BinaryPrecedence[t.operator]??1/0:t.type==="ConditionalExpression"?core.Precedence.Conditional:t.type==="AssignmentExpression"?core.Precedence.Assignment:t.type==="ArrowFunctionExpression"?core.Precedence.ArrowFunction:t.type==="AwaitExpression"?core.Precedence.Await:t.type==="SequenceExpression"?core.Precedence.Sequence:t.type==="TSAsExpression"?S(t.expression):1/0,B=(t,e,n,s=false)=>{let o=S(t);return n?s?o<e:o<=e:s?o<=e:o<e},p=(t,e,n,s=false)=>{let o=r(t);return B(t,e,n,s)?c(o):o},Q=t=>`${p(t.test,core.Precedence.Conditional,false,true)} ? ${r(t.consequent)} : ${r(t.alternate)}`,Z=t=>t.label?`continue ${r(t.label)}`:"continue",d=t=>{let e=r(t.expression);return e[0]==="{"||e.startsWith("function")||e.startsWith("class")?c(e):e},tt=t=>";",et=t=>`do ${r(t.body)} while (${r(t.test)})`,rt=t=>`for (${r(t.left)} in ${r(t.right)}) ${r(t.body)}`,nt=t=>`for${t.await?" await":""} (${r(t.left)} of ${r(t.right)}) ${r(t.body)}`,st=t=>{let e=r(t.init),n=r(t.test),s=r(t.update);return `for (${e};${n?` ${n}`:""};${s?` ${s}`:""}) ${r(t.body)}`},ot=t=>{let e=t.params.map(P).join(u);return `${t.async?"async ":""}function ${r(t.id)}(${e}) ${r(t.body)}`},it=t=>{let e=r(t.params);return `${t.async?"async ":""}function ${r(t.id)}(${e}) ${r(t.body)}`},P=t=>t.name,at=t=>{throw new core.TSLiteError("incomplete-tree","Cannot print a tree with a Placeholder (hole) \u2014 fill the holes first.",{type:t.type})},pt=t=>`if (${r(t.test)}) ${r(t.consequent)}${t.alternate?` else ${r(t.alternate)}`:""}`,ct=t=>m(t.body),lt=t=>t.raw?t.raw:t.value===void 0?"undefined":t.value===null?"null":typeof t.value=="string"?JSON.stringify(t.value):typeof t.value=="boolean"?String(t.value):t.bigint?t.bigint+"n":t.regex?`/${t.regex.pattern}/${t.regex.flags}`:(t.value instanceof RegExp,String(t.value)),ut=t=>{let e=core.BinaryPrecedence[t.operator]??1/0,n=(s,o)=>A(t.operator,s)?c(r(s)):p(s,e,o);return `${n(t.left,false)} ${t.operator} ${n(t.right,true)}`},yt=t=>{let e=[x(t.object)];return t.optional&&e.push(t.computed?"?.":"?"),e.push(t.computed?"[":"."),e.push(r(t.property)),t.computed&&e.push("]"),e.join("")},mt=t=>{let e=t.properties.map(r).join(", ");return e.length==0?"{}":`{ ${e} }`},ft=t=>{let e=t.properties.map(r).join(", ");return e.length==0?"{ }":`{ ${e} }`},xt=new Set(["FunctionDeclaration","IfStatement","ForStatement","ForInStatement","ForOfStatement","WhileStatement","TryStatement","SwitchStatement","ClassDeclaration","BlockStatement"]),E=t=>{let e=r(t);return !e||e===";"?"":xt.has(t.type)?e:e+";"},$t=t=>t.body.map(E).filter(Boolean).join(" "),St=t=>t.shorthand?r(t.value):`${t.computed?`[${r(t.key)}]`:r(t.key)}: ${r(t.value)}`,Et=t=>`${r(t.left)} = ${r(t.right)}`,Tt=t=>"return "+r(t.argument),gt=t=>{let e=t.test?`case ${r(t.test)}:`:"default:",n=t.consequent.map(E).filter(Boolean).join(" ");return n?`${e} ${n}`:e},ht=t=>`switch (${r(t.discriminant)}) { ${t.cases.map(r).join(" ")} }`,bt=t=>t.value.raw,wt=t=>"`"+t.quasis.map((e,n)=>r(e)+(e.tail?"":"${"+r(t.expressions[n])+"}")).join("")+"`",At=t=>"throw "+r(t.argument),Bt=t=>{let e=`try ${r(t.block)}`;if(t.handler){let n=t.handler.param;e+=n?` catch (${r(n)}) ${r(t.handler.body)}`:` catch ${r(t.handler.body)}`;}return e+(t.finalizer?` finally ${r(t.finalizer)}`:"")},Pt=t=>{let e=p(t.argument,core.Precedence.Unary,false),n=t.operator.length>1||(t.operator==="+"||t.operator==="-")&&e[0]===t.operator?" ":"";return t.operator+n+e},It=t=>t.prefix==true?t.operator+r(t.argument):r(t.argument)+t.operator,jt=t=>`${t.kind} ${t.declarations.map(I).join(", ")}`,I=t=>t.init?`${r(t.id)} = ${r(t.init)}`:r(t.id),Ct=t=>`while (${r(t.test)}) ${r(t.body)}`,Nt=t=>{if(t.importKind==="type")return "";let e=r(t.source);if(t.specifiers.length==0)return `import ${e}`;let n=t.specifiers.find(i=>i.type==="ImportDefaultSpecifier"||i.type==="ImportNamespaceSpecifier"),s=t.specifiers.filter(i=>i.type==="ImportSpecifier"&&i.importKind!=="type");if(!n&&s.length===0)return "";let o=[];return n&&o.push(r(n)),s.length&&o.push(`{ ${s.map(j).join(u)} }`),`import ${o.join(u)} from ${e}`},Dt=t=>r(t.local),kt=t=>`* as ${r(t.local)}`,j=t=>t.imported.name===t.local.name?`${r(t.local)}`:`${r(t.imported)} as ${r(t.local)}`,Ft=t=>{if(t.declaration){let n=r(t.declaration);return n?`export ${n}`:""}return `export { ${t.specifiers.map(C).join(u)} }`},Lt=t=>`export default ${r(t.declaration)}`,C=t=>t.local.name===t.exported.name?`${r(t.local)}`:`${r(t.local)} as ${r(t.exported)}`,vt=t=>`...${r(t.argument)}`,Ot=t=>`...${r(t.argument)}`,Jt=()=>"",Rt=t=>r(t.expression),Wt=t=>r(core.desugarJSX(t)),_t=t=>r(core.desugarJSX(t)),T={print:r,JSXElement:Wt,JSXFragment:_t,ArrayExpression:M,ArrayPattern:U,ArrowFunctionExpression:q,AssignmentExpression:V,AssignmentPattern:Et,AwaitExpression:X,BinaryExpression:K,BlockStatement:z,BreakStatement:Y,CallExpression:H,ChainExpression:G,ConditionalExpression:Q,ContinueStatement:Z,DoWhileStatement:et,EmptyStatement:tt,ExpressionStatement:d,ForInStatement:rt,ForOfStatement:nt,ForStatement:st,FunctionDeclaration:ot,FunctionExpression:it,Identifier:P,Placeholder:at,IfStatement:pt,ImportDeclaration:Nt,ImportDefaultSpecifier:Dt,ImportNamespaceSpecifier:kt,ImportSpecifier:j,ExportNamedDeclaration:Ft,ExportDefaultDeclaration:Lt,ExportSpecifier:C,JsonExpression:ct,Literal:lt,LogicalExpression:ut,MemberExpression:yt,ObjectExpression:mt,ObjectPattern:ft,Program:$t,Property:St,ReturnStatement:Tt,SwitchCase:gt,SwitchStatement:ht,TemplateElement:bt,TemplateLiteral:wt,ThrowStatement:At,TryStatement:Bt,UnaryExpression:Pt,UpdateExpression:It,VariableDeclaration:jt,VariableDeclarator:I,WhileStatement:Ct,SpreadElement:vt,RestElement:Ot,TSTypeAliasDeclaration:Jt,TSAsExpression:Rt};exports.getExpressionPrecedence=S;exports.isPrimaryOperand=b;exports.mixesCoalesce=A;exports.needsParens=B;exports.print=r;exports.printJson=m;exports.printWithProfile=W;exports.unaryLike=w;

package/dist/index.d.cts

@@ -1,64 +0,0 @@
-import { BaseNode, TSLite } from '@tslite/core';
-import { CapabilityProfile } from '@tslite/capability';
-
-type PrintInput = BaseNode | BaseNode[] | (BaseNode | null)[] | null | undefined;
-declare const print: (node: PrintInput) => string;
-/**
- * Printer **sob-contrato** (D37): emite só o que o `profile` permite e **recusa o
- * resto** (lança `node-not-allowed`). É o limite hard do lado JIT — simétrico ao
- * `evaluate(ast, env, { profile })` do interpret. O `print` padrão (standalone)
- * segue emitindo qualquer nó.
- */
-declare const printWithProfile: (ast: PrintInput, profile: CapabilityProfile) => string;
-/**
- * Uma expressão é PRIMÁRIA em posição de membro/callee? (isto é: reparsa certo
- * ali, sem parênteses)
- *
- * **Fonte única.** O `@tslite/format` faz a mesma pergunta ao imprimir a callee
- * de uma chamada, e derivá-la duas vezes já custou um defeito: o formatador
- * emitia `() => { … }()`, que o TSLite reparsa mas o **TypeScript recusa** — e a
- * promessa da plataforma é ser um subset PURO de TS.
- */
-declare function isPrimaryOperand(node: BaseNode): boolean;
-/** Operando que começa com unário/`await` (à esquerda de `**` exige parênteses). */
-declare const unaryLike: (node: BaseNode) => boolean;
-declare const mixesCoalesce: (parentOp: string, child: BaseNode) => boolean;
-/**
- * Returns the operator precedence of an expression node.
- * Higher value = binds tighter. Returns Infinity for atoms (Identifier, Literal, etc).
- */
-/** A precedência efetiva de uma expressão (erasure de `as`); `Infinity` = primária. */
-declare const getExpressionPrecedence: (node: BaseNode) => number;
-/**
- * Wraps a child node in parentheses when its precedence is lower than
- * the parent's, respecting left/right associativity rules.
- *
- * For left-associative operators (most):
- *   - left  child: parens when childPrec <  parentPrec
- *   - right child: parens when childPrec <= parentPrec
- *
- * For right-associative operators (**):
- *   - left  child: parens when childPrec <= parentPrec
- *   - right child: parens when childPrec <  parentPrec
- */
-/**
- * A DECISÃO de parentizar um operando pela precedência — exportada para quem
- * imprime por outra via (o `@tslite/emit` renderiza `Doc`, não texto) tomar a
- * mesma decisão, em vez de manter uma segunda máquina de precedência.
- */
-declare const needsParens: (node: BaseNode, parentPrec: number, isRight: boolean, rightAssociative?: boolean) => boolean;
-
-/**
- * Prints the hybrid JSON form (a value with `#expr` islands) as JS source.
- *
- * Static data is emitted as an object/array literal; each `#expr` island is
- * handed back to `print()` — the same `#expr` boundary the type layer walks.
- *
- * ```ts
- * printJson({ name: "John", init: { "#expr": "CallExpression", ... } })
- * // '{ name: "John", init: setup() }'
- * ```
- */
-declare function printJson(node: TSLite): string;
-
-export { getExpressionPrecedence, isPrimaryOperand, mixesCoalesce, needsParens, print, printJson, printWithProfile, unaryLike };