@goast/kotlin 0.6.0 → 0.7.0-beta.2

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

@@ -0,0 +1,70 @@
+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 { ktGenericParameter } from './generic-parameter.js';
+export class KtInterface extends KtNode {
+    doc;
+    annotations;
+    accessModifier;
+    name;
+    generics;
+    extends;
+    members;
+    companionObject;
+    constructor(options) {
+        super(options);
+        this.doc = options.doc ?? null;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.accessModifier = options.accessModifier ?? null;
+        this.name = options.name;
+        this.generics = options.generics?.filter(notNullish) ?? [];
+        this.extends = options.extends?.filter(notNullish) ?? [];
+        this.members = options.members?.filter(notNullish) ?? [];
+        this.companionObject = options.companionObject ?? null;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        ktDoc.get(this.doc, { generics: this.generics })?.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('interface ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        builder.append(this.inject.beforeGenerics);
+        ktGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        if (this.extends.length > 0) {
+            builder.append(' : ');
+            builder.append(this.inject.beforeExtends);
+            writeKtNodes(builder, this.extends, { separator: ', ' });
+            builder.append(this.inject.afterExtends);
+        }
+        const allMembers = [
+            this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
+            ...this.members,
+        ].filter(notNullish);
+        if (allMembers.length > 0) {
+            builder.append(' ');
+            builder.append(this.inject.beforeBody);
+            builder.parenthesize('{}', (b) => {
+                b.append(this.inject.beforeMembers);
+                writeKtMembers(b, allMembers);
+                b.append(this.inject.afterMembers);
+            }, { multiline: true });
+            builder.append(this.inject.afterBody);
+        }
+        builder.appendLine();
+    }
+}
+const createInterface = (name, options) => new KtInterface({ ...options, name });
+export const ktInterface = Object.assign(createInterface, {
+    write: writeKtNodes,
+});

package/{esm → dist}/src/ast/nodes/lambda-type.d.ts

@@ -1,7 +1,7 @@
 import { type AstNodeOptions, type Nullable, type SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import type { KtType } from './types.js';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import type { KtType } from './types.ts';
 type Injects = 'extensionFor' | 'params' | 'returnType';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     extensionFor?: Nullable<KtType<TBuilder>>;
@@ -17,9 +17,8 @@ export declare class KtLambdaType<TBuilder extends SourceBuilder, TInjects exten
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createLambdaType: <TBuilder extends SourceBuilder>(parameters: Options<TBuilder>["parameters"], returnType: Options<TBuilder>["returnType"], options?: Omit<Options<TBuilder>, "parameters" | "returnType">) => KtLambdaType<TBuilder>;
+declare const createLambdaType: <TBuilder extends SourceBuilder>(parameters: Options<TBuilder>['parameters'], returnType: Options<TBuilder>['returnType'], options?: Omit<Options<TBuilder>, 'parameters' | 'returnType'>) => KtLambdaType<TBuilder>;
 export declare const ktLambdaType: typeof createLambdaType & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=lambda-type.d.ts.map

package/{esm → dist}/src/ast/nodes/lambda-type.js

@@ -3,37 +3,16 @@ import { KtNode } from '../node.js';
 import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
 import { ktParameter } from './parameter.js';
 export class KtLambdaType extends KtNode {
+    extensionFor;
+    parameters;
+    returnType;
+    suspend;
     constructor(options) {
-        var _a, _b, _c, _d;
         super(options);
-        Object.defineProperty(this, "extensionFor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "parameters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "returnType", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "suspend", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.extensionFor = (_a = options.extensionFor) !== null && _a !== void 0 ? _a : null;
-        this.parameters = (_c = (_b = options.parameters) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.extensionFor = options.extensionFor ?? null;
+        this.parameters = options.parameters?.filter(notNullish) ?? [];
         this.returnType = options.returnType;
-        this.suspend = (_d = options.suspend) !== null && _d !== void 0 ? _d : false;
+        this.suspend = options.suspend ?? false;
     }
     onWrite(builder) {
         if (this.suspend) {

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

@@ -1,6 +1,6 @@
 import { type AppendValue, type AstNodeOptions, type BasicAppendValue, type Nullable, type 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 = 'arguments' | 'body';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     arguments?: Nullable<Nullable<BasicAppendValue<TBuilder>>[]>;
@@ -14,9 +14,8 @@ export declare class KtLambda<TBuilder extends SourceBuilder, TInjects extends s
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createLambda: <TBuilder extends SourceBuilder>(args: Options<TBuilder>["arguments"], body: Options<TBuilder>["body"], options?: Omit<Options<TBuilder>, "arguments" | "body">) => KtLambda<TBuilder>;
+declare const createLambda: <TBuilder extends SourceBuilder>(args: Options<TBuilder>['arguments'], body: Options<TBuilder>['body'], options?: Omit<Options<TBuilder>, 'arguments' | 'body'>) => KtLambda<TBuilder>;
 export declare const ktLambda: typeof createLambda & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=lambda.d.ts.map

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

@@ -2,30 +2,14 @@ import { notNullish, } from '@goast/core';
 import { KtNode } from '../node.js';
 import { writeKtNodes } from '../utils/write-kt-node.js';
 export class KtLambda extends KtNode {
+    arguments;
+    body;
+    singleline;
     constructor(options) {
-        var _a, _b, _c, _d;
         super(options);
-        Object.defineProperty(this, "arguments", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "body", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "singleline", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.arguments = (_b = (_a = options.arguments) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
-        this.body = (_c = options.body) !== null && _c !== void 0 ? _c : null;
-        this.singleline = (_d = options.singleline) !== null && _d !== void 0 ? _d : false;
+        this.arguments = options.arguments?.filter(notNullish) ?? [];
+        this.body = options.body ?? null;
+        this.singleline = options.singleline ?? false;
     }
     onWrite(builder) {
         const singleline = this.singleline || !this.body;

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

@@ -1,11 +1,11 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type SourceBuilder } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtArgument } from './argument.js';
-import type { KtFunction } from './function.js';
-import type { KtInitBlock } from './init-block.js';
-import type { KtProperty } from './property.js';
-import type { KtType, KtValue } from './types.js';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import { type KtArgument } from './argument.ts';
+import type { KtFunction } from './function.ts';
+import type { KtInitBlock } from './init-block.ts';
+import type { KtProperty } from './property.ts';
+import type { KtType, KtValue } from './types.ts';
 type Injects = 'modifiers' | 'name' | 'inheritList' | 'body' | 'members';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     data?: boolean;
@@ -33,4 +33,3 @@ export declare const ktObject: typeof createObject & {
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=object.d.ts.map

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

@@ -0,0 +1,60 @@
+import { notNullish } from '@goast/core';
+import { KtNode } from '../node.js';
+import { writeKtMembers } from '../utils/write-kt-members.js';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
+import { ktArgument } from './argument.js';
+export class KtObject extends KtNode {
+    data;
+    name;
+    class;
+    classArguments;
+    implements;
+    members;
+    companion;
+    constructor(options) {
+        super(options);
+        this.data = options.data ?? false;
+        this.name = options.name ?? null;
+        this.class = options.class ?? null;
+        this.classArguments = options.classArguments?.filter(notNullish) ?? [];
+        this.implements = options.implements?.filter(notNullish) ?? [];
+        this.members = options.members?.filter(notNullish) ?? [];
+        this.companion = options.companion ?? false;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeModifiers);
+        if (this.data)
+            builder.append('data ');
+        if (this.companion)
+            builder.append('companion ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('object');
+        if (this.name) {
+            builder.append(' ', this.inject.beforeName, this.name, this.inject.afterName);
+        }
+        if (this.class || this.implements.length > 0) {
+            builder.append(' : ', this.inject.beforeInheritList);
+            if (this.class) {
+                writeKtNode(builder, this.class);
+                ktArgument.write(builder, this.classArguments);
+                if (this.implements.length > 0)
+                    builder.append(', ');
+            }
+            writeKtNodes(builder, this.implements, { separator: ', ' });
+            builder.append(this.inject.afterInheritList);
+        }
+        builder.append(' ', this.inject.beforeBody);
+        builder.parenthesize('{}', (b) => {
+            builder.append(this.inject.beforeMembers);
+            writeKtMembers(b, this.members);
+            builder.append(this.inject.afterMembers);
+        }, { multiline: this.members.length > 0 });
+        builder.append(this.inject.afterBody);
+        if (this.name)
+            builder.appendLine();
+    }
+}
+const createObject = (options) => new KtObject(options ?? {});
+export const ktObject = Object.assign(createObject, {
+    write: writeKtNodes,
+});

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

@@ -1,9 +1,9 @@
 import { 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 { writeKtParameters } from '../utils/write-kt-parameters.js';
-import { type KtAnnotation } from './annotation.js';
-import type { KtType, KtValue } from './types.js';
+import type { KtAccessModifier } from '../common.ts';
+import { KtNode } from '../node.ts';
+import { writeKtParameters } from '../utils/write-kt-parameters.ts';
+import { type KtAnnotation } from './annotation.ts';
+import type { KtType, KtValue } from './types.ts';
 type Injects = 'modifiers' | 'annotations' | 'name' | 'type' | 'default';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     name: string;
@@ -31,11 +31,10 @@ export declare class KtParameter<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createParameter: <TBuilder extends SourceBuilder>(name: KtParameter<TBuilder>["name"], type: KtParameter<TBuilder>["type"], options?: Prettify<Omit<Options<TBuilder>, "name" | "type" | "accessModifier" | "property" | "propertyDescription" | "override">>) => KtParameter<TBuilder>;
-declare const createClassParameter: <TBuilder extends SourceBuilder>(name: KtParameter<TBuilder>["name"], type: KtParameter<TBuilder>["type"], options?: Prettify<Omit<Options<TBuilder>, "name" | "type">>) => KtParameter<TBuilder>;
+declare const createParameter: <TBuilder extends SourceBuilder>(name: KtParameter<TBuilder>['name'], type: KtParameter<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type' | 'accessModifier' | 'property' | 'propertyDescription' | 'override'>>) => KtParameter<TBuilder>;
+declare const createClassParameter: <TBuilder extends SourceBuilder>(name: KtParameter<TBuilder>['name'], type: KtParameter<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type'>>) => KtParameter<TBuilder>;
 export declare const ktParameter: typeof createParameter & {
     class: typeof createClassParameter;
     write: typeof writeKtParameters;
 };
 export {};
-//# sourceMappingURL=parameter.d.ts.map

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

@@ -0,0 +1,63 @@
+import { notNullish, } from '@goast/core';
+import { KtNode } from '../node.js';
+import { writeKtNode } from '../utils/write-kt-node.js';
+import { writeKtParameters } from '../utils/write-kt-parameters.js';
+import { ktAnnotation } from './annotation.js';
+export class KtParameter extends KtNode {
+    name;
+    type;
+    annotations;
+    default;
+    vararg;
+    description;
+    // class parameter options
+    accessModifier;
+    property;
+    propertyDescription;
+    override;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.default = options.default ?? null;
+        this.vararg = options.vararg ?? false;
+        this.description = options.description ?? null;
+        this.accessModifier = options.accessModifier ?? null;
+        this.property = options.property ?? null;
+        this.propertyDescription = options.propertyDescription ?? null;
+        this.override = options.override ?? false;
+    }
+    onWrite(builder) {
+        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 && this.property)
+            builder.append(this.accessModifier, ' ');
+        if (this.override && this.property)
+            builder.append('override ');
+        if (this.vararg)
+            builder.append('vararg ');
+        builder.append(this.inject.afterModifiers);
+        if (this.property)
+            builder.append(this.property === 'mutable' ? 'var' : 'val', ' ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        builder.append(': ');
+        builder.append(this.inject.beforeType);
+        writeKtNode(builder, this.type);
+        builder.append(this.inject.afterType);
+        if (this.default) {
+            builder.append(' = ');
+            builder.append(this.inject.beforeDefault);
+            writeKtNode(builder, this.default);
+            builder.append(this.inject.afterDefault);
+        }
+    }
+}
+const createParameter = (name, type, options) => new KtParameter({ ...options, name, type });
+const createClassParameter = (name, type, options) => new KtParameter({ ...options, name, type });
+export const ktParameter = Object.assign(createParameter, {
+    class: createClassParameter,
+    write: writeKtParameters,
+});

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

@@ -1,11 +1,11 @@
 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 KtArgument } from './argument.js';
-import type { KtDoc } from './doc.js';
-import type { KtType, KtValue } 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 KtArgument } from './argument.ts';
+import type { KtDoc } from './doc.ts';
+import type { KtType, KtValue } from './types.ts';
 type AccessorInjects = 'annotations' | 'modifiers' | 'params' | 'body';
 type AccessorOptions<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | AccessorInjects>, {
     accessModifier?: Nullable<KtAccessModifier>;
@@ -23,10 +23,10 @@ export declare abstract class KtPropertyAccessor<TBuilder extends SourceBuilder,
     protected onWrite(builder: TBuilder): void;
 }
 export declare class KtPropertyGetter<TBuilder extends SourceBuilder> extends KtPropertyAccessor<TBuilder> {
-    readonly kind: "get";
+    readonly kind: 'get';
 }
 export declare class KtPropertySetter<TBuilder extends SourceBuilder> extends KtPropertyAccessor<TBuilder> {
-    readonly kind: "set";
+    readonly kind: 'set';
 }
 type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'type' | 'default' | 'delegate';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
@@ -69,11 +69,10 @@ export declare class KtProperty<TBuilder extends SourceBuilder, TInjects extends
 }
 declare const createPropertyGetter: <TBuilder extends SourceBuilder>(options?: AccessorOptions<TBuilder>) => KtPropertyGetter<TBuilder>;
 declare const createPropertySetter: <TBuilder extends SourceBuilder>(options?: AccessorOptions<TBuilder>) => KtPropertySetter<TBuilder>;
-declare const createProperty: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => KtProperty<TBuilder>;
+declare const createProperty: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtProperty<TBuilder>;
 export declare const ktProperty: typeof createProperty & {
     getter: typeof createPropertyGetter;
     setter: typeof createPropertySetter;
     write: typeof writeKtNodes;
 };
 export {};
-//# sourceMappingURL=property.d.ts.map

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

@@ -0,0 +1,144 @@
+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 { ktArgument } from './argument.js';
+export class KtPropertyAccessor extends KtNode {
+    accessModifier;
+    annotations;
+    body;
+    singleExpression;
+    constructor(options) {
+        super(options);
+        this.accessModifier = options.accessModifier ?? null;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.body = options.body ?? null;
+        this.singleExpression = options.singleExpression ?? false;
+    }
+    onWrite(builder) {
+        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(this.kind);
+        if (this.body) {
+            builder.append(this.inject.beforeParams);
+            builder.append(this.kind === 'set' ? '(value)' : '()');
+            builder.append(this.inject.afterParams);
+            if (this.singleExpression) {
+                builder.append(' = ', this.inject.beforeBody);
+                builder.indent(this.body);
+            }
+            else {
+                builder.append(' ', this.inject.beforeBody);
+                builder.parenthesize('{}', this.body, { multiline: true });
+            }
+            builder.append(this.inject.afterBody);
+        }
+        builder.appendLine();
+    }
+}
+export class KtPropertyGetter extends KtPropertyAccessor {
+    kind = 'get';
+}
+export class KtPropertySetter extends KtPropertyAccessor {
+    kind = 'set';
+}
+export class KtProperty extends KtNode {
+    doc;
+    name;
+    type;
+    annotations;
+    accessModifier;
+    getter;
+    setter;
+    default;
+    delegate;
+    delegateArguments;
+    mutable;
+    const;
+    lateinit;
+    open;
+    override;
+    abstract;
+    constructor(options) {
+        super(options);
+        this.doc = options.doc ?? null;
+        this.name = options.name;
+        this.type = options.type ?? null;
+        this.annotations = options.annotations?.filter(notNullish) ?? [];
+        this.accessModifier = options.accessModifier ?? null;
+        this.getter = options.getter ?? null;
+        this.setter = options.setter ?? null;
+        this.default = options.default ?? null;
+        this.delegate = options.delegate ?? null;
+        this.delegateArguments = options.delegateArguments?.filter(notNullish) ?? null;
+        this.mutable = options.mutable ?? false;
+        this.const = options.const ?? false;
+        this.lateinit = options.lateinit ?? false;
+        this.open = options.open ?? false;
+        this.override = options.override ?? false;
+        this.abstract = options.abstract ?? false;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        this.doc?.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.const)
+            builder.append('const ');
+        if (this.lateinit)
+            builder.append('lateinit ');
+        if (this.abstract)
+            builder.append('abstract ');
+        if (this.override)
+            builder.append('override ');
+        if (this.open)
+            builder.append('open ');
+        builder.append(this.inject.afterModifiers);
+        builder.append(this.mutable || !!this.setter ? 'var ' : 'val ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.type || (!this.default && !this.getter?.body)) {
+            builder.append(': ', this.inject.beforeType);
+            writeKtNode(builder, this.type ?? 'Any?');
+            builder.append(this.inject.afterType);
+        }
+        if (this.default) {
+            builder.append(' = ', this.inject.beforeDefault);
+            writeKtNode(builder, this.default);
+            builder.append(this.inject.afterDefault);
+        }
+        if (this.delegate) {
+            builder.append(' by ', this.inject.beforeDelegate);
+            writeKtNode(builder, this.delegate);
+            if (this.delegateArguments) {
+                ktArgument.write(builder, this.delegateArguments);
+            }
+            builder.append(this.inject.afterDelegate);
+        }
+        builder.appendLine();
+        if (this.getter || this.setter) {
+            builder.indent((b) => {
+                this.getter?.write(b);
+                this.setter?.write(b);
+            });
+        }
+        builder.ensureCurrentLineEmpty();
+    }
+}
+const createPropertyGetter = (options) => new KtPropertyGetter(options ?? {});
+const createPropertySetter = (options) => new KtPropertySetter(options ?? {});
+const createProperty = (name, options) => new KtProperty({ ...options, name });
+export const ktProperty = Object.assign(createProperty, {
+    getter: createPropertyGetter,
+    setter: createPropertySetter,
+    write: writeKtNodes,
+});

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

@@ -1,8 +1,8 @@
 import { type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder, type TupleWithCount } from '@goast/core';
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import type { KtType } from './types.js';
-import type { KtCall } from './call.js';
+import { KtNode } from '../node.ts';
+import { writeKtNodes } from '../utils/write-kt-node.ts';
+import type { KtType } from './types.ts';
+import type { KtCall } from './call.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
     name: string;
@@ -29,7 +29,7 @@ export declare class KtReference<TBuilder extends SourceBuilder, TInjects extend
     protected onWrite(builder: TBuilder): void;
     static registerAddImportHandler<TBuilder extends SourceBuilder>(builderClass: _AddImportHandler<TBuilder>['builderClass'], handler: _AddImportHandler<TBuilder>['handler']): void;
 }
-declare const createReference: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], packageName?: Options<TBuilder>["packageName"], options?: Prettify<Omit<Options<TBuilder>, "name" | "packageName">>) => KtReference<TBuilder>;
+declare const createReference: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], packageName?: Options<TBuilder>['packageName'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>) => KtReference<TBuilder>;
 export type KtReferenceFactory = (<TBuilder extends SourceBuilder>(options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>) => KtReference<TBuilder>) & {
     refName: string;
     packageName: Nullable<string>;
@@ -51,4 +51,3 @@ export declare const ktReference: typeof createReference & {
     import: typeof importRefs;
 };
 export {};
-//# sourceMappingURL=reference.d.ts.map