@ttsc/factory 0.15.7 → 0.15.9

package/lib/factory/names/createTrue.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTrue = void 0;
+const syntax_1 = require("../../syntax");
 const createToken_1 = require("./createToken");
 /**
  * Create the `true` keyword as a {@link Token}.
@@ -17,6 +18,6 @@ const createToken_1 = require("./createToken");
  * @author Jeongho Nam - https://github.com/samchon
  * @returns The created {@link Token}.
  */
-const createTrue = () => (0, createToken_1.createToken)("true" /* SyntaxKind.TrueKeyword */);
+const createTrue = () => (0, createToken_1.createToken)(syntax_1.SyntaxKind.TrueKeyword);
 exports.createTrue = createTrue;
 //# sourceMappingURL=createTrue.js.map

package/lib/factory/names/createTrue.js.map

@@ -1 +1 @@
-{"version":3,"file":"createTrue.js","sourceRoot":"","sources":["../../../src/factory/names/createTrue.ts"],"names":[],"mappings":";;;AAEA,+CAA4C;AAE5C;;;;;;;;;;;;;;GAcG;AACI,MAAM,UAAU,GAAG,GAAU,EAAE,CAAC,IAAA,yBAAW,sCAAwB,CAAC;AAA9D,QAAA,UAAU,GAAV,UAAU,CAAoD"}
+{"version":3,"file":"createTrue.js","sourceRoot":"","sources":["../../../src/factory/names/createTrue.ts"],"names":[],"mappings":";;;AACA,yCAA0C;AAC1C,+CAA4C;AAE5C;;;;;;;;;;;;;;GAcG;AACI,MAAM,UAAU,GAAG,GAAU,EAAE,CAAC,IAAA,yBAAW,EAAC,mBAAU,CAAC,WAAW,CAAC,CAAC;AAA9D,QAAA,UAAU,GAAV,UAAU,CAAoD"}

package/lib/factory/statements/createVariableDeclarationList.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVariableDeclarationList = void 0;
+const syntax_1 = require("../../syntax");
 const make_1 = require("../internal/make");
 /**
  * Create a {@link VariableDeclarationList}: the `const x = 1` group.
@@ -22,6 +23,6 @@ const make_1 = require("../internal/make");
  * @param flags The declaration flags (`const` / `let` / `var`).
  * @returns The created {@link VariableDeclarationList}.
  */
-const createVariableDeclarationList = (declarations, flags = "" /* NodeFlags.None */) => (0, make_1.make)("VariableDeclarationList", { declarations, flags });
+const createVariableDeclarationList = (declarations, flags = syntax_1.NodeFlags.None) => (0, make_1.make)("VariableDeclarationList", { declarations, flags });
 exports.createVariableDeclarationList = createVariableDeclarationList;
 //# sourceMappingURL=createVariableDeclarationList.js.map

package/lib/factory/statements/createVariableDeclarationList.js.map

@@ -1 +1 @@
-{"version":3,"file":"createVariableDeclarationList.js","sourceRoot":"","sources":["../../../src/factory/statements/createVariableDeclarationList.ts"],"names":[],"mappings":";;;AAEA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;GAmBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,YAA4C,EAC5C,KAAK,0BAA4B,EACR,EAAE,CAC3B,IAAA,WAAI,EAAC,yBAAyB,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;AAJ9C,QAAA,6BAA6B,GAA7B,6BAA6B,CAIiB"}
+{"version":3,"file":"createVariableDeclarationList.js","sourceRoot":"","sources":["../../../src/factory/statements/createVariableDeclarationList.ts"],"names":[],"mappings":";;;AACA,yCAAyC;AACzC,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;GAmBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,YAA4C,EAC5C,KAAK,GAAc,kBAAS,CAAC,IAAI,EACR,EAAE,CAC3B,IAAA,WAAI,EAAC,yBAAyB,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC,CAAC;AAJ9C,QAAA,6BAA6B,GAA7B,6BAA6B,CAIiB"}

package/lib/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setSyntheticTrailingComments = exports.setSyntheticLeadingComments = exports.getSyntheticTrailingComments = exports.getSyntheticLeadingComments = exports.addSyntheticTrailingComment = exports.addSyntheticLeadingComment = exports.TsPrinter = exports.factory = void 0;
+exports.setSyntheticTrailingComments = exports.setSyntheticLeadingComments = exports.getSyntheticTrailingComments = exports.getSyntheticLeadingComments = exports.addSyntheticTrailingComment = exports.addSyntheticLeadingComment = exports.TsPrinter = exports.NodeFlags = exports.SyntaxKind = exports.factory = void 0;
 const factory = __importStar(require("./factory/index"));
 /**
  * Hand-written, dependency-free re-implementation of the legacy TypeScript AST
@@ -55,6 +55,9 @@ const factory = __importStar(require("./factory/index"));
  * @author Jeongho Nam - https://github.com/samchon
  */
 exports.factory = __importStar(require("./factory/index"));
+var syntax_1 = require("./syntax");
+Object.defineProperty(exports, "SyntaxKind", { enumerable: true, get: function () { return syntax_1.SyntaxKind; } });
+Object.defineProperty(exports, "NodeFlags", { enumerable: true, get: function () { return syntax_1.NodeFlags; } });
 var TsPrinter_1 = require("./TsPrinter");
 Object.defineProperty(exports, "TsPrinter", { enumerable: true, get: function () { return TsPrinter_1.TsPrinter; } });
 var comments_1 = require("./comments");

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,MAAY,OAAO,4CAAwB;AAE3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAY,OAAO,4CAAwB;AAE3C,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAElB,uCAOoB;AANlB,sHAAA,0BAA0B,OAAA;AAC1B,uHAAA,2BAA2B,OAAA;AAC3B,uHAAA,2BAA2B,OAAA;AAC3B,wHAAA,4BAA4B,OAAA;AAC5B,uHAAA,2BAA2B,OAAA;AAC3B,wHAAA,4BAA4B,OAAA;kBAQf,OAAO"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,MAAY,OAAO,4CAAwB;AAE3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAY,OAAO,4CAAwB;AAC3C,mCAAiD;AAAxC,oGAAA,UAAU,OAAA;AAAE,mGAAA,SAAS,OAAA;AAC9B,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAElB,uCAOoB;AANlB,sHAAA,0BAA0B,OAAA;AAC1B,uHAAA,2BAA2B,OAAA;AAC3B,uHAAA,2BAA2B,OAAA;AAC3B,wHAAA,4BAA4B,OAAA;AAC5B,uHAAA,2BAA2B,OAAA;AAC3B,wHAAA,4BAA4B,OAAA;kBAQf,OAAO"}

package/lib/syntax/NodeFlags.d.ts

@@ -6,12 +6,12 @@
  * value is the keyword it implies (`Let = "let"`, `Const = "const"`), so the
  * printer reads it directly. `Namespace` is accepted for API parity — the
  * printer renders the `module` / `namespace` keyword from the module name kind,
- * not from this flag. A string-valued `const enum`, so references inline with
- * no runtime object.
+ * not from this flag. A string-valued enum (deliberately not `const enum`, so
+ * consumers compiled with `isolatedModules` can still reference its members).
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare const enum NodeFlags {
+export declare enum NodeFlags {
     None = "",
     Let = "let",
     Const = "const",

package/lib/syntax/NodeFlags.js

@@ -1,3 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeFlags = void 0;
+/**
+ * Flags for {@link factory.createVariableDeclarationList} and
+ * {@link factory.createModuleDeclaration}.
+ *
+ * An outline of the relevant subset of the legacy `ts.NodeFlags`. Each member's
+ * value is the keyword it implies (`Let = "let"`, `Const = "const"`), so the
+ * printer reads it directly. `Namespace` is accepted for API parity — the
+ * printer renders the `module` / `namespace` keyword from the module name kind,
+ * not from this flag. A string-valued enum (deliberately not `const enum`, so
+ * consumers compiled with `isolatedModules` can still reference its members).
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+var NodeFlags;
+(function (NodeFlags) {
+    NodeFlags["None"] = "";
+    NodeFlags["Let"] = "let";
+    NodeFlags["Const"] = "const";
+    NodeFlags["Namespace"] = "namespace";
+})(NodeFlags || (exports.NodeFlags = NodeFlags = {}));
 //# sourceMappingURL=NodeFlags.js.map

package/lib/syntax/NodeFlags.js.map

@@ -1 +1 @@
-{"version":3,"file":"NodeFlags.js","sourceRoot":"","sources":["../../src/syntax/NodeFlags.ts"],"names":[],"mappings":""}
+{"version":3,"file":"NodeFlags.js","sourceRoot":"","sources":["../../src/syntax/NodeFlags.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;GAYG;AACH,IAAY,SAKX;AALD,WAAY,SAAS;IACnB,sBAAS,CAAA;IACT,wBAAW,CAAA;IACX,4BAAe,CAAA;IACf,oCAAuB,CAAA;AACzB,CAAC,EALW,SAAS,aAAT,SAAS,GAAT,SAAS,QAKpB"}

package/lib/syntax/SyntaxKind.d.ts

@@ -5,12 +5,12 @@
  * modifier / operator tokens this hand-written factory and printer understand.
  * Each member's value is its **own source text** (e.g. `QuestionToken = "?"`),
  * so a token renders to source by reading its value directly — no lookup table.
- * It is a string-valued `const enum`, so references inline to the literal with
- * no runtime object.
+ * It is a string-valued enum (deliberately not `const enum`, so consumers
+ * compiled with `isolatedModules` can still reference its members).
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export declare const enum SyntaxKind {
+export declare enum SyntaxKind {
     AnyKeyword = "any",
     UnknownKeyword = "unknown",
     NumberKeyword = "number",

package/lib/syntax/SyntaxKind.js

@@ -1,3 +1,111 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyntaxKind = void 0;
+/**
+ * Token kinds used by {@link factory} and {@link TsPrinter}.
+ *
+ * An outline of the legacy `ts.SyntaxKind`: it enumerates only the keyword /
+ * modifier / operator tokens this hand-written factory and printer understand.
+ * Each member's value is its **own source text** (e.g. `QuestionToken = "?"`),
+ * so a token renders to source by reading its value directly — no lookup table.
+ * It is a string-valued enum (deliberately not `const enum`, so consumers
+ * compiled with `isolatedModules` can still reference its members).
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+var SyntaxKind;
+(function (SyntaxKind) {
+    // keyword type nodes & literal keywords
+    SyntaxKind["AnyKeyword"] = "any";
+    SyntaxKind["UnknownKeyword"] = "unknown";
+    SyntaxKind["NumberKeyword"] = "number";
+    SyntaxKind["BigIntKeyword"] = "bigint";
+    SyntaxKind["ObjectKeyword"] = "object";
+    SyntaxKind["BooleanKeyword"] = "boolean";
+    SyntaxKind["StringKeyword"] = "string";
+    SyntaxKind["SymbolKeyword"] = "symbol";
+    SyntaxKind["VoidKeyword"] = "void";
+    SyntaxKind["UndefinedKeyword"] = "undefined";
+    SyntaxKind["NullKeyword"] = "null";
+    SyntaxKind["NeverKeyword"] = "never";
+    SyntaxKind["TrueKeyword"] = "true";
+    SyntaxKind["FalseKeyword"] = "false";
+    SyntaxKind["ThisKeyword"] = "this";
+    // modifiers
+    SyntaxKind["ExportKeyword"] = "export";
+    SyntaxKind["DefaultKeyword"] = "default";
+    SyntaxKind["DeclareKeyword"] = "declare";
+    SyntaxKind["AbstractKeyword"] = "abstract";
+    SyntaxKind["AsyncKeyword"] = "async";
+    SyntaxKind["ConstKeyword"] = "const";
+    SyntaxKind["PublicKeyword"] = "public";
+    SyntaxKind["PrivateKeyword"] = "private";
+    SyntaxKind["ProtectedKeyword"] = "protected";
+    SyntaxKind["ReadonlyKeyword"] = "readonly";
+    SyntaxKind["StaticKeyword"] = "static";
+    SyntaxKind["OverrideKeyword"] = "override";
+    SyntaxKind["AccessorKeyword"] = "accessor";
+    // heritage / type operators / word operators
+    SyntaxKind["ExtendsKeyword"] = "extends";
+    SyntaxKind["ImplementsKeyword"] = "implements";
+    SyntaxKind["KeyOfKeyword"] = "keyof";
+    SyntaxKind["UniqueKeyword"] = "unique";
+    SyntaxKind["AssertsKeyword"] = "asserts";
+    SyntaxKind["AwaitKeyword"] = "await";
+    SyntaxKind["ImportKeyword"] = "import";
+    SyntaxKind["NewKeyword"] = "new";
+    SyntaxKind["SuperKeyword"] = "super";
+    SyntaxKind["InKeyword"] = "in";
+    SyntaxKind["InstanceOfKeyword"] = "instanceof";
+    SyntaxKind["AsKeyword"] = "as";
+    SyntaxKind["SatisfiesKeyword"] = "satisfies";
+    SyntaxKind["TypeOfKeyword"] = "typeof";
+    // punctuation
+    SyntaxKind["DotDotDotToken"] = "...";
+    SyntaxKind["QuestionToken"] = "?";
+    SyntaxKind["QuestionDotToken"] = "?.";
+    SyntaxKind["ColonToken"] = ":";
+    SyntaxKind["CommaToken"] = ",";
+    SyntaxKind["EqualsGreaterThanToken"] = "=>";
+    // arithmetic / unary
+    SyntaxKind["PlusToken"] = "+";
+    SyntaxKind["MinusToken"] = "-";
+    SyntaxKind["AsteriskToken"] = "*";
+    SyntaxKind["AsteriskAsteriskToken"] = "**";
+    SyntaxKind["SlashToken"] = "/";
+    SyntaxKind["PercentToken"] = "%";
+    SyntaxKind["PlusPlusToken"] = "++";
+    SyntaxKind["MinusMinusToken"] = "--";
+    SyntaxKind["ExclamationToken"] = "!";
+    SyntaxKind["TildeToken"] = "~";
+    // bitwise
+    SyntaxKind["AmpersandToken"] = "&";
+    SyntaxKind["BarToken"] = "|";
+    SyntaxKind["CaretToken"] = "^";
+    SyntaxKind["LessThanLessThanToken"] = "<<";
+    SyntaxKind["GreaterThanGreaterThanToken"] = ">>";
+    SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = ">>>";
+    // relational / equality / logical
+    SyntaxKind["LessThanToken"] = "<";
+    SyntaxKind["LessThanEqualsToken"] = "<=";
+    SyntaxKind["GreaterThanToken"] = ">";
+    SyntaxKind["GreaterThanEqualsToken"] = ">=";
+    SyntaxKind["EqualsEqualsToken"] = "==";
+    SyntaxKind["EqualsEqualsEqualsToken"] = "===";
+    SyntaxKind["ExclamationEqualsToken"] = "!=";
+    SyntaxKind["ExclamationEqualsEqualsToken"] = "!==";
+    SyntaxKind["AmpersandAmpersandToken"] = "&&";
+    SyntaxKind["BarBarToken"] = "||";
+    SyntaxKind["QuestionQuestionToken"] = "??";
+    // assignment
+    SyntaxKind["EqualsToken"] = "=";
+    SyntaxKind["PlusEqualsToken"] = "+=";
+    SyntaxKind["MinusEqualsToken"] = "-=";
+    SyntaxKind["AsteriskEqualsToken"] = "*=";
+    SyntaxKind["SlashEqualsToken"] = "/=";
+    SyntaxKind["QuestionQuestionEqualsToken"] = "??=";
+    // comment trivia (not real tokens; unique sentinels for the comment API)
+    SyntaxKind["SingleLineCommentTrivia"] = "//";
+    SyntaxKind["MultiLineCommentTrivia"] = "/*";
+})(SyntaxKind || (exports.SyntaxKind = SyntaxKind = {}));
 //# sourceMappingURL=SyntaxKind.js.map

package/lib/syntax/SyntaxKind.js.map

@@ -1 +1 @@
-{"version":3,"file":"SyntaxKind.js","sourceRoot":"","sources":["../../src/syntax/SyntaxKind.ts"],"names":[],"mappings":""}
+{"version":3,"file":"SyntaxKind.js","sourceRoot":"","sources":["../../src/syntax/SyntaxKind.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;GAWG;AACH,IAAY,UAqGX;AArGD,WAAY,UAAU;IACpB,wCAAwC;IACxC,gCAAkB,CAAA;IAClB,wCAA0B,CAAA;IAC1B,sCAAwB,CAAA;IACxB,sCAAwB,CAAA;IACxB,sCAAwB,CAAA;IACxB,wCAA0B,CAAA;IAC1B,sCAAwB,CAAA;IACxB,sCAAwB,CAAA;IACxB,kCAAoB,CAAA;IACpB,4CAA8B,CAAA;IAC9B,kCAAoB,CAAA;IACpB,oCAAsB,CAAA;IACtB,kCAAoB,CAAA;IACpB,oCAAsB,CAAA;IACtB,kCAAoB,CAAA;IAEpB,YAAY;IACZ,sCAAwB,CAAA;IACxB,wCAA0B,CAAA;IAC1B,wCAA0B,CAAA;IAC1B,0CAA4B,CAAA;IAC5B,oCAAsB,CAAA;IACtB,oCAAsB,CAAA;IACtB,sCAAwB,CAAA;IACxB,wCAA0B,CAAA;IAC1B,4CAA8B,CAAA;IAC9B,0CAA4B,CAAA;IAC5B,sCAAwB,CAAA;IACxB,0CAA4B,CAAA;IAC5B,0CAA4B,CAAA;IAE5B,6CAA6C;IAC7C,wCAA0B,CAAA;IAC1B,8CAAgC,CAAA;IAChC,oCAAsB,CAAA;IACtB,sCAAwB,CAAA;IACxB,wCAA0B,CAAA;IAC1B,oCAAsB,CAAA;IACtB,sCAAwB,CAAA;IACxB,gCAAkB,CAAA;IAClB,oCAAsB,CAAA;IACtB,8BAAgB,CAAA;IAChB,8CAAgC,CAAA;IAChC,8BAAgB,CAAA;IAChB,4CAA8B,CAAA;IAC9B,sCAAwB,CAAA;IAExB,cAAc;IACd,oCAAsB,CAAA;IACtB,iCAAmB,CAAA;IACnB,qCAAuB,CAAA;IACvB,8BAAgB,CAAA;IAChB,8BAAgB,CAAA;IAChB,2CAA6B,CAAA;IAE7B,qBAAqB;IACrB,6BAAe,CAAA;IACf,8BAAgB,CAAA;IAChB,iCAAmB,CAAA;IACnB,0CAA4B,CAAA;IAC5B,8BAAgB,CAAA;IAChB,gCAAkB,CAAA;IAClB,kCAAoB,CAAA;IACpB,oCAAsB,CAAA;IACtB,oCAAsB,CAAA;IACtB,8BAAgB,CAAA;IAEhB,UAAU;IACV,kCAAoB,CAAA;IACpB,4BAAc,CAAA;IACd,8BAAgB,CAAA;IAChB,0CAA4B,CAAA;IAC5B,gDAAkC,CAAA;IAClC,4DAA8C,CAAA;IAE9C,kCAAkC;IAClC,iCAAmB,CAAA;IACnB,wCAA0B,CAAA;IAC1B,oCAAsB,CAAA;IACtB,2CAA6B,CAAA;IAC7B,sCAAwB,CAAA;IACxB,6CAA+B,CAAA;IAC/B,2CAA6B,CAAA;IAC7B,kDAAoC,CAAA;IACpC,4CAA8B,CAAA;IAC9B,gCAAkB,CAAA;IAClB,0CAA4B,CAAA;IAE5B,aAAa;IACb,+BAAiB,CAAA;IACjB,oCAAsB,CAAA;IACtB,qCAAuB,CAAA;IACvB,wCAA0B,CAAA;IAC1B,qCAAuB,CAAA;IACvB,iDAAmC,CAAA;IAEnC,yEAAyE;IACzE,4CAA8B,CAAA;IAC9B,2CAA6B,CAAA;AAC/B,CAAC,EArGW,UAAU,aAAV,UAAU,GAAV,UAAU,QAqGrB"}

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@ttsc/factory",
-  "version": "0.15.7",
+  "version": "0.15.9",
   "description": "Self-contained legacy-style TypeScript AST factory and printer for source code generation, surviving the TypeScript-Go (tsgo) migration. Zero dependencies, no `typescript` import.",
   "main": "lib/index.js",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
-      "import": "./lib/index.mjs",
       "default": "./lib/index.js"
     },
     "./package.json": "./package.json"
@@ -57,9 +56,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib && tsgo -p . && rollup -c",
+    "build": "rimraf lib && tsgo -p .",
     "dev": "tsgo -p . --watch"
   },
-  "module": "lib/index.mjs",
   "types": "lib/index.d.ts"
 }

package/src/syntax/NodeFlags.ts

@@ -6,12 +6,12 @@
  * value is the keyword it implies (`Let = "let"`, `Const = "const"`), so the
  * printer reads it directly. `Namespace` is accepted for API parity — the
  * printer renders the `module` / `namespace` keyword from the module name kind,
- * not from this flag. A string-valued `const enum`, so references inline with
- * no runtime object.
+ * not from this flag. A string-valued enum (deliberately not `const enum`, so
+ * consumers compiled with `isolatedModules` can still reference its members).
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export const enum NodeFlags {
+export enum NodeFlags {
   None = "",
   Let = "let",
   Const = "const",

package/src/syntax/SyntaxKind.ts

@@ -5,12 +5,12 @@
  * modifier / operator tokens this hand-written factory and printer understand.
  * Each member's value is its **own source text** (e.g. `QuestionToken = "?"`),
  * so a token renders to source by reading its value directly — no lookup table.
- * It is a string-valued `const enum`, so references inline to the literal with
- * no runtime object.
+ * It is a string-valued enum (deliberately not `const enum`, so consumers
+ * compiled with `isolatedModules` can still reference its members).
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export const enum SyntaxKind {
+export enum SyntaxKind {
   // keyword type nodes & literal keywords
   AnyKeyword = "any",
   UnknownKeyword = "unknown",