@goast/kotlin 0.6.0 → 0.7.0-beta.1

package/{esm → dist}/src/ast/nodes/doc-tag.js

@@ -3,30 +3,14 @@ import { isKotlinAppendValue } from '../../file-builder.js';
 import { KtNode } from '../node.js';
 import { writeKtNodes } from '../utils/write-kt-node.js';
 export class KtDocTag extends KtNode {
+    tag;
+    args;
+    description;
     constructor(options) {
-        var _a, _b, _c;
         super(options);
-        Object.defineProperty(this, "tag", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "args", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.tag = options.tag;
-        this.args = (_b = (_a = options.args) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
-        this.description = (_c = options.description) !== null && _c !== void 0 ? _c : null;
+        this.args = options.args?.filter(notNullish) ?? [];
+        this.description = options.description ?? null;
     }
     onWrite(builder) {
         builder.append('@', this.tag);

package/{esm → dist}/src/ast/nodes/doc.d.ts

@@ -1,9 +1,9 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtDocTag } from './doc-tag.js';
-import { KtGenericParameter } from './generic-parameter.js';
-import { KtParameter } from './parameter.js';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import { type KtDocTag } from './doc-tag.ts';
+import { KtGenericParameter } from './generic-parameter.ts';
+import { KtParameter } from './parameter.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     description?: Nullable<BasicAppendValue<TBuilder>>;
@@ -15,7 +15,7 @@ export declare class KtDoc<TBuilder extends SourceBuilder, TInjects extends stri
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createDoc: <TBuilder extends SourceBuilder>(description?: Options<TBuilder>["description"], tags?: Options<TBuilder>["tags"], options?: Prettify<Omit<Options<TBuilder>, "description" | "tags">>) => KtDoc<TBuilder>;
+declare const createDoc: <TBuilder extends SourceBuilder>(description?: Options<TBuilder>['description'], tags?: Options<TBuilder>['tags'], options?: Prettify<Omit<Options<TBuilder>, 'description' | 'tags'>>) => KtDoc<TBuilder>;
 declare function getDoc<TBuilder extends SourceBuilder>(baseDoc: KtDoc<TBuilder> | null, options: {
     parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
     generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
@@ -25,4 +25,3 @@ export declare const ktDoc: typeof createDoc & {
     get: typeof getDoc;
 };
 export {};
-//# sourceMappingURL=doc.d.ts.map

package/{esm → dist}/src/ast/nodes/doc.js

@@ -5,23 +5,12 @@ import { ktDocTag } from './doc-tag.js';
 import { KtGenericParameter } from './generic-parameter.js';
 import { KtParameter } from './parameter.js';
 export class KtDoc extends KtNode {
+    description;
+    tags;
     constructor(options) {
-        var _a, _b, _c;
         super(options);
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "tags", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.description = (_a = options.description) !== null && _a !== void 0 ? _a : null;
-        this.tags = (_c = (_b = options.tags) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.description = options.description ?? null;
+        this.tags = options.tags?.filter(notNullish) ?? [];
     }
     onWrite(builder) {
         if (!this.description && this.tags.length === 0)
@@ -38,12 +27,17 @@ export class KtDoc extends KtNode {
             .appendLine();
     }
 }
-const createDoc = (description, tags, options) => new KtDoc({ ...options, description, tags: tags !== null && tags !== void 0 ? tags : undefined });
+const createDoc = (description, tags, options) => new KtDoc({ ...options, description, tags: tags ?? undefined });
 function getDoc(baseDoc, options) {
-    var _a, _b, _c, _d, _e, _f;
-    const paramsWithDesc = (_b = (_a = options.parameters) === null || _a === void 0 ? void 0 : _a.filter(getIsInstanceOf((KtParameter))).filter((x) => !!x.description)) !== null && _b !== void 0 ? _b : [];
-    const classParamsWithPropertyDesc = (_d = (_c = options.parameters) === null || _c === void 0 ? void 0 : _c.filter(getIsInstanceOf((KtParameter))).filter((x) => !!x.property && !!x.propertyDescription)) !== null && _d !== void 0 ? _d : [];
-    const genericsWithDesc = (_f = (_e = options.generics) === null || _e === void 0 ? void 0 : _e.filter(getIsInstanceOf((KtGenericParameter))).filter((x) => !!x.description)) !== null && _f !== void 0 ? _f : [];
+    const paramsWithDesc = options.parameters
+        ?.filter(getIsInstanceOf(KtParameter))
+        .filter((x) => !!x.description) ?? [];
+    const classParamsWithPropertyDesc = options.parameters
+        ?.filter(getIsInstanceOf(KtParameter))
+        .filter((x) => !!x.property && !!x.propertyDescription) ?? [];
+    const genericsWithDesc = options.generics
+        ?.filter(getIsInstanceOf(KtGenericParameter))
+        .filter((x) => !!x.description) ?? [];
     if (baseDoc === null &&
         paramsWithDesc.length === 0 &&
         genericsWithDesc.length === 0 &&

package/{script → dist}/src/ast/nodes/enum-value.d.ts

@@ -1,11 +1,11 @@
 import { type AppendValue, type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtEnumValues } from '../utils/write-kt-enum-values.js';
-import { type KtAnnotation } from './annotation.js';
-import { type KtArgument } from './argument.js';
-import type { KtDoc } from './doc.js';
-import type { KtFunction } from './function.js';
-import type { KtParameter } from './parameter.js';
+import { KtNode } from '../node.ts';
+import { writeKtEnumValues } from '../utils/write-kt-enum-values.ts';
+import { type KtAnnotation } from './annotation.ts';
+import { type KtArgument } from './argument.ts';
+import type { KtDoc } from './doc.ts';
+import type { KtFunction } from './function.ts';
+import type { KtParameter } from './parameter.ts';
 type Injects = 'doc' | 'annotations' | 'name' | 'arguments' | 'body' | 'members';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     name: string;
@@ -24,9 +24,8 @@ export declare class KtEnumValue<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createEnumValue: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => KtEnumValue<TBuilder>;
+declare const createEnumValue: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtEnumValue<TBuilder>;
 export declare const ktEnumValue: typeof createEnumValue & {
     write: typeof writeKtEnumValues;
 };
 export {};
-//# sourceMappingURL=enum-value.d.ts.map

package/{esm → dist}/src/ast/nodes/enum-value.js

@@ -5,49 +5,22 @@ import { writeKtMembers } from '../utils/write-kt-members.js';
 import { ktAnnotation } from './annotation.js';
 import { ktArgument } from './argument.js';
 export class KtEnumValue extends KtNode {
+    name;
+    doc;
+    annotations;
+    arguments;
+    members;
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g;
         super(options);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "doc", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "annotations", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "arguments", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "members", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.name = options.name;
-        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
-        this.annotations = (_c = (_b = options.annotations) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
-        this.arguments = (_e = (_d = options.arguments) === null || _d === void 0 ? void 0 : _d.filter(notNullish)) !== null && _e !== void 0 ? _e : [];
-        this.members = (_g = (_f = options.members) === null || _f === void 0 ? void 0 : _f.filter(notNullish)) !== null && _g !== void 0 ? _g : [];
+        this.doc = options.doc ?? null;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.arguments = options.arguments?.filter(notNullish) ?? [];
+        this.members = options.members?.filter(notNullish) ?? [];
     }
     onWrite(builder) {
-        var _a;
         builder.append(this.inject.beforeDoc);
-        (_a = this.doc) === null || _a === void 0 ? void 0 : _a.write(builder);
+        this.doc?.write(builder);
         builder.append(this.inject.afterDoc);
         builder.append(this.inject.beforeAnnotations);
         ktAnnotation.write(builder, this.annotations, { multiline: true });

package/{script → dist}/src/ast/nodes/enum.d.ts

@@ -1,18 +1,18 @@
 import { type AppendValue, type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation } from './annotation.js';
-import type { KtClass } from './class.js';
-import type { KtConstructor } from './constructor.js';
-import { type KtDoc } from './doc.js';
-import { type KtEnumValue } from './enum-value.js';
-import type { KtFunction } from './function.js';
-import { type KtInitBlock } from './init-block.js';
-import type { KtInterface } from './interface.js';
-import type { KtObject } from './object.js';
-import type { KtProperty } from './property.js';
-import type { KtType } from './types.js';
+import type { KtAccessModifier } from '../common.ts';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import { type KtAnnotation } from './annotation.ts';
+import type { KtClass } from './class.ts';
+import type { KtConstructor } from './constructor.ts';
+import { type KtDoc } from './doc.ts';
+import { type KtEnumValue } from './enum-value.ts';
+import type { KtFunction } from './function.ts';
+import { type KtInitBlock } from './init-block.ts';
+import type { KtInterface } from './interface.ts';
+import type { KtObject } from './object.ts';
+import type { KtProperty } from './property.ts';
+import type { KtType } from './types.ts';
 type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'primaryConstructor' | 'implements' | 'body' | 'values' | 'members';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     name: string;
@@ -39,9 +39,8 @@ export declare class KtEnum<TBuilder extends SourceBuilder, TInjects extends str
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createEnum: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], values?: Options<TBuilder>["values"], options?: Prettify<Omit<Options<TBuilder>, "name" | "values">>) => KtEnum<TBuilder>;
+declare const createEnum: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], values?: Options<TBuilder>['values'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'values'>>) => KtEnum<TBuilder>;
 export declare const ktEnum: typeof createEnum & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=enum.d.ts.map

package/dist/src/ast/nodes/enum.js

@@ -0,0 +1,86 @@
+import { createOverwriteProxy, notNullish, } from '@goast/core';
+import { KtNode } from '../node.js';
+import { writeKtMembers } from '../utils/write-kt-members.js';
+import { writeKtNodes } from '../utils/write-kt-node.js';
+import { ktAnnotation } from './annotation.js';
+import { ktDoc } from './doc.js';
+import { ktEnumValue } from './enum-value.js';
+import { ktInitBlock } from './init-block.js';
+export class KtEnum extends KtNode {
+    name;
+    doc;
+    annotations;
+    accessModifier;
+    primaryConstructor;
+    implements;
+    values;
+    members;
+    companionObject;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.doc = options.doc ?? null;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.accessModifier = options.accessModifier ?? null;
+        this.primaryConstructor = options.primaryConstructor ?? null;
+        this.implements = options.implements?.filter(notNullish) ?? [];
+        this.values = options.values ?? [];
+        this.members = options.members?.filter(notNullish) ?? [];
+        this.companionObject = options.companionObject ?? null;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        ktDoc.get(this.doc, { parameters: this.primaryConstructor?.parameters })?.write(builder);
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeAnnotations);
+        ktAnnotation.write(builder, this.annotations, { multiline: true });
+        builder.append(this.inject.afterAnnotations);
+        builder.append(this.inject.beforeModifiers);
+        if (this.accessModifier)
+            builder.append(this.accessModifier, ' ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('enum class ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.primaryConstructor) {
+            builder.append(this.inject.beforePrimaryConstructor);
+            this.primaryConstructor.writeAsPrimary(builder);
+            builder.append(this.inject.afterPrimaryConstructor);
+        }
+        if (this.implements.length > 0) {
+            builder.append(' : ');
+            builder.append(this.inject.beforeImplements);
+            writeKtNodes(builder, this.implements, { separator: ', ' });
+            builder.append(this.inject.afterImplements);
+        }
+        const allMembers = [
+            this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
+            this.primaryConstructor?.body ? ktInitBlock(this.primaryConstructor?.body) : null,
+            ...this.members,
+        ].filter(notNullish);
+        if (this.values.length > 0 || allMembers.length > 0) {
+            builder.append(' ');
+            builder.append(this.inject.beforeBody);
+            builder.parenthesize('{}', (b) => {
+                if (this.values.length > 0) {
+                    b.append(this.inject.beforeValues);
+                    ktEnumValue.write(b, this.values);
+                    if (allMembers.length > 0) {
+                        b.append(';\n\n');
+                    }
+                    b.append(this.inject.afterValues);
+                }
+                if (allMembers.length > 0) {
+                    b.append(this.inject.beforeMembers);
+                    writeKtMembers(b, allMembers);
+                    b.append(this.inject.afterMembers);
+                }
+            }, { multiline: true });
+            builder.append(this.inject.afterBody);
+        }
+        builder.appendLine();
+    }
+}
+const createEnum = (name, values, options) => new KtEnum({ ...options, name, values: values ?? undefined });
+export const ktEnum = Object.assign(createEnum, {
+    write: writeKtNodes,
+});

package/{esm → dist}/src/ast/nodes/function.d.ts

@@ -1,12 +1,12 @@
 import { type AppendValue, type AstNodeOptions, type BasicAppendValue, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation } from './annotation.js';
-import { type KtDoc } from './doc.js';
-import { type KtGenericParameter } from './generic-parameter.js';
-import { type KtParameter } from './parameter.js';
-import type { KtType } from './types.js';
+import type { KtAccessModifier } from '../common.ts';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import { type KtAnnotation } from './annotation.ts';
+import { type KtDoc } from './doc.ts';
+import { type KtGenericParameter } from './generic-parameter.ts';
+import { type KtParameter } from './parameter.ts';
+import type { KtType } from './types.ts';
 type Injects = 'doc' | 'annotations' | 'modifiers' | 'generics' | 'receiverAnnotations' | 'receiverType' | 'name' | 'parameters' | 'returnType';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     name: string;
@@ -52,9 +52,8 @@ export declare class KtFunction<TBuilder extends SourceBuilder, TInjects extends
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createFunction: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => KtFunction<TBuilder>;
+declare const createFunction: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtFunction<TBuilder>;
 export declare const ktFunction: typeof createFunction & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=function.d.ts.map

package/dist/src/ast/nodes/function.js

@@ -0,0 +1,120 @@
+import { notNullish, } from '@goast/core';
+import { KtNode } from '../node.js';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
+import { ktAnnotation } from './annotation.js';
+import { ktDoc } from './doc.js';
+import { ktGenericParameter } from './generic-parameter.js';
+import { KtInterface } from './interface.js';
+import { ktParameter } from './parameter.js';
+export class KtFunction extends KtNode {
+    name;
+    generics;
+    parameters;
+    doc;
+    returnType;
+    body;
+    accessModifier;
+    annotations;
+    receiverType;
+    receiverAnnotations;
+    singleExpression;
+    open;
+    inline;
+    infix;
+    tailrec;
+    suspend;
+    operator;
+    override;
+    abstract;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.generics = options.generics?.filter(notNullish) ?? [];
+        this.parameters = options.parameters?.filter(notNullish) ?? [];
+        this.doc = options.doc ?? null;
+        this.returnType = options.returnType ?? null;
+        this.body = options.body ?? null;
+        this.accessModifier = options.accessModifier ?? null;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.receiverType = options.receiverType ?? null;
+        this.receiverAnnotations = options.receiverAnnotations?.filter(notNullish) ?? [];
+        this.singleExpression = options.singleExpression ?? false;
+        this.open = options.open ?? false;
+        this.inline = options.inline ?? false;
+        this.infix = options.infix ?? false;
+        this.tailrec = options.tailrec ?? false;
+        this.suspend = options.suspend ?? false;
+        this.operator = options.operator ?? false;
+        this.override = options.override ?? false;
+        this.abstract = options.abstract ?? false;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        ktDoc.get(this.doc, { generics: this.generics, parameters: this.parameters })?.write(builder);
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeAnnotations);
+        ktAnnotation.write(builder, this.annotations, { multiline: true });
+        builder.append(this.inject.afterAnnotations);
+        builder.append(this.inject.beforeModifiers);
+        if (this.accessModifier)
+            builder.append(this.accessModifier, ' ');
+        if (this.inline)
+            builder.append('inline ');
+        if (this.infix)
+            builder.append('infix ');
+        if (this.tailrec)
+            builder.append('tailrec ');
+        if (this.suspend)
+            builder.append('suspend ');
+        if (this.open)
+            builder.append('open ');
+        if (this.override)
+            builder.append('override ');
+        if (this.abstract)
+            builder.append('abstract ');
+        if (this.operator)
+            builder.append('operator ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('fun ');
+        builder.append(this.inject.beforeGenerics);
+        ktGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        if (this.generics.length > 0)
+            builder.append(' ');
+        if (this.receiverType) {
+            builder.append(this.inject.beforeReceiverAnnotations);
+            ktAnnotation.write(builder, this.receiverAnnotations, { multiline: false });
+            builder.append(this.inject.afterReceiverAnnotations);
+            builder.append(this.inject.beforeReceiverType);
+            writeKtNode(builder, this.receiverType);
+            builder.append(this.inject.afterReceiverType);
+            builder.append('.');
+        }
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        builder.append(this.inject.beforeParameters);
+        ktParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParameters);
+        if (this.returnType) {
+            builder.append(': ');
+            builder.append(this.inject.beforeReturnType);
+            writeKtNode(builder, this.returnType);
+            builder.append(this.inject.afterReturnType);
+        }
+        const isInInterface = this.getParentNode(builder) instanceof KtInterface;
+        if (!this.abstract && (this.body || !isInInterface)) {
+            builder.append(' ');
+            if (this.singleExpression && this.body) {
+                builder.append('= ');
+                builder.indent(this.body);
+            }
+            else {
+                builder.parenthesize('{}', this.body, { multiline: !!this.body });
+            }
+        }
+        builder.appendLine();
+    }
+}
+const createFunction = (name, options) => new KtFunction({ ...options, name });
+export const ktFunction = Object.assign(createFunction, {
+    write: writeKtNodes,
+});

package/{esm → dist}/src/ast/nodes/generic-parameter.d.ts

@@ -1,7 +1,7 @@
 import type { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtGenericParameters } from '../utils/write-kt-generic-parameters.js';
-import type { KtType } from './types.js';
+import { KtNode } from '../node.ts';
+import { writeKtGenericParameters } from '../utils/write-kt-generic-parameters.ts';
+import type { KtType } from './types.ts';
 type Injects = 'name' | 'constraint';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     name: string;
@@ -15,9 +15,8 @@ export declare class KtGenericParameter<TBuilder extends SourceBuilder, TInjects
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createGenericParameter: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => KtGenericParameter<TBuilder>;
+declare const createGenericParameter: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtGenericParameter<TBuilder>;
 export declare const ktGenericParameter: typeof createGenericParameter & {
     write: typeof writeKtGenericParameters;
 };
 export {};
-//# sourceMappingURL=generic-parameter.d.ts.map

package/dist/src/ast/nodes/generic-parameter.js

@@ -0,0 +1,27 @@
+import { KtNode } from '../node.js';
+import { writeKtGenericParameters } from '../utils/write-kt-generic-parameters.js';
+import { writeKtNode } from '../utils/write-kt-node.js';
+export class KtGenericParameter extends KtNode {
+    name;
+    description;
+    constraint;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.description = options.description ?? null;
+        this.constraint = options.constraint ?? null;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.constraint) {
+            builder.append(' : ');
+            builder.append(this.inject.beforeConstraint);
+            writeKtNode(builder, this.constraint);
+            builder.append(this.inject.afterConstraint);
+        }
+    }
+}
+const createGenericParameter = (name, options) => new KtGenericParameter({ ...options, name });
+export const ktGenericParameter = Object.assign(createGenericParameter, {
+    write: writeKtGenericParameters,
+});

package/{esm → dist}/src/ast/nodes/init-block.d.ts

@@ -1,6 +1,6 @@
 import type { AppendValue, AstNodeOptions, Prettify, SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     body: AppendValue<TBuilder>;
@@ -10,9 +10,8 @@ export declare class KtInitBlock<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createInitBlock: <TBuilder extends SourceBuilder>(body: Options<TBuilder>["body"], options?: Prettify<Omit<Options<TBuilder>, "body">>) => KtInitBlock<TBuilder>;
+declare const createInitBlock: <TBuilder extends SourceBuilder>(body: Options<TBuilder>['body'], options?: Prettify<Omit<Options<TBuilder>, 'body'>>) => KtInitBlock<TBuilder>;
 export declare const ktInitBlock: typeof createInitBlock & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=init-block.d.ts.map

package/{esm → dist}/src/ast/nodes/init-block.js

@@ -1,14 +1,9 @@
 import { KtNode } from '../node.js';
 import { writeKtNodes } from '../utils/write-kt-node.js';
 export class KtInitBlock extends KtNode {
+    body;
     constructor(options) {
         super(options);
-        Object.defineProperty(this, "body", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.body = options.body;
     }
     onWrite(builder) {

package/{esm → dist}/src/ast/nodes/interface.d.ts

@@ -1,16 +1,16 @@
 import { type AppendValue, type AstNodeOptions, type BasicAppendValue, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation } from './annotation.js';
-import type { KtClass } from './class.js';
-import { type KtDoc } from './doc.js';
-import type { KtEnum } from './enum.js';
-import type { KtFunction } from './function.js';
-import { type KtGenericParameter } from './generic-parameter.js';
-import type { KtObject } from './object.js';
-import type { KtProperty } from './property.js';
-import type { KtType } from './types.js';
+import type { KtAccessModifier } from '../common.ts';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import { type KtAnnotation } from './annotation.ts';
+import type { KtClass } from './class.ts';
+import { type KtDoc } from './doc.ts';
+import type { KtEnum } from './enum.ts';
+import type { KtFunction } from './function.ts';
+import { type KtGenericParameter } from './generic-parameter.ts';
+import type { KtObject } from './object.ts';
+import type { KtProperty } from './property.ts';
+import type { KtType } from './types.ts';
 type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'generics' | 'extends' | 'body' | 'members';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     doc?: Nullable<KtDoc<TBuilder>>;
@@ -35,9 +35,8 @@ export declare class KtInterface<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createInterface: <TBuilder extends SourceBuilder>(name: KtInterface<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => KtInterface<TBuilder>;
+declare const createInterface: <TBuilder extends SourceBuilder>(name: KtInterface<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtInterface<TBuilder>;
 export declare const ktInterface: typeof createInterface & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=interface.d.ts.map