@goast/kotlin 0.5.7 → 0.5.9-beta.1

package/src/src/assets.ts

@@ -1,9 +0,0 @@
-import { AssetManager } from '@goast/core';
-import { pathToFileURL, URL } from 'node:url';
-
-declare const __filename: string | undefined;
-const scriptUrl = typeof __filename === 'undefined' ? import.meta.url : pathToFileURL(__filename);
-
-const manager = new AssetManager(new URL('../assets/', scriptUrl));
-export const getAssetFileContent = manager.getAssetFileContent.bind(manager);
-export const copyAssetFile = manager.copyAssetFile.bind(manager);

package/src/src/ast/_index.ts

@@ -1,66 +0,0 @@
-export { type KtAccessModifier as AccessModifier } from './common.js';
-export { KtNode as Node } from './node.js';
-export {
-  KtAnnotation as Annotation,
-  ktAnnotation as annotation,
-  type KtAnnotationTarget as AnnotationTarget,
-} from './nodes/annotation.js';
-export { KtArgument as Argument, ktArgument as argument } from './nodes/argument.js';
-export { KtCall as Call, ktCall as call } from './nodes/call.js';
-export {
-  KtClass as Class,
-  ktClass as class,
-  type KtClassKind as ClassKind,
-  type KtClassMember as ClassMember,
-} from './nodes/class.js';
-export {
-  KtCollectionLiteral as CollectionLiteral,
-  ktCollectionLiteral as collectionLiteral,
-} from './nodes/collection-literal.js';
-export {
-  KtConstructor as Constructor,
-  ktConstructor as constructor,
-  type KtDelegateTarget as DelegateTarget,
-} from './nodes/constructor.js';
-export { KtDocTag as DocTag, ktDocTag as docTag } from './nodes/doc-tag.js';
-export { KtDoc as Doc, ktDoc as doc } from './nodes/doc.js';
-export {
-  KtEnumValue as EnumValue,
-  ktEnumValue as enumValue,
-  type KtEnumValueMember as EnumValueMember,
-} from './nodes/enum-value.js';
-export { KtEnum as Enum, ktEnum as enum, type KtEnumMember as EnumMember } from './nodes/enum.js';
-export { KtFunction as Function, ktFunction as function } from './nodes/function.js';
-export {
-  KtGenericParameter as GenericParameter,
-  ktGenericParameter as genericParameter,
-} from './nodes/generic-parameter.js';
-export { KtInitBlock as InitBlock, ktInitBlock as initBlock } from './nodes/init-block.js';
-export {
-  KtInterface as Interface,
-  ktInterface as interface,
-  type KtInterfaceMember as InterfaceMember,
-} from './nodes/interface.js';
-export { KtLambdaType as LambdaType, ktLambdaType as lambdaType } from './nodes/lambda-type.js';
-export { KtLambda as Lambda, ktLambda as lambda } from './nodes/lambda.js';
-export { KtObject as Object, ktObject as object, type KtObjectMember as ObjectMember } from './nodes/object.js';
-export { KtParameter as Parameter, ktParameter as parameter } from './nodes/parameter.js';
-export {
-  KtProperty as Property,
-  ktProperty as property,
-  KtPropertyAccessor as PropertyAccessor,
-  KtPropertyGetter as PropertyGetter,
-  KtPropertySetter as PropertySetter,
-} from './nodes/property.js';
-export {
-  type KtGenericReferenceFactory as GenericReferenceFactory,
-  KtReference as Reference,
-  ktReference as reference,
-  type KtReferenceFactory as ReferenceFactory,
-} from './nodes/reference.js';
-export { KtString as String, ktString as string } from './nodes/string.js';
-export { type KtType as Type, type KtValue as Value } from './nodes/types.js';
-export * as refs from './references/index.js';
-export { getKotlinBuilderOptions as getBuilderOptions } from './utils/get-kotlin-builder-options.js';
-export { toKtNode as toNode } from './utils/to-kt-node.js';
-export { writeKtNode as writeNode, writeKtNodes as writeNodes } from './utils/write-kt-node.js';

package/src/src/ast/common.ts

@@ -1 +0,0 @@
-export type KtAccessModifier = 'public' | 'protected' | 'internal' | 'private';

package/src/src/ast/index.ts

@@ -1 +0,0 @@
-export * as kt from './_index.js';

package/src/src/ast/node.ts

@@ -1,10 +0,0 @@
-import { AstNode, type AstNodeOptions, type SourceBuilder } from '@goast/core';
-
-export abstract class KtNode<TBuilder extends SourceBuilder, TInjects extends string = never> extends AstNode<
-  TBuilder,
-  TInjects
-> {
-  constructor(options: AstNodeOptions<typeof AstNode<TBuilder, TInjects>>) {
-    super(options);
-  }
-}

package/src/src/ast/nodes/annotation.ts

@@ -1,79 +0,0 @@
-import { type AstNodeOptions, notNullish, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtAnnotations } from '../utils/write-kt-annotations.js';
-import { writeKtNode } from '../utils/write-kt-node.js';
-import { type KtArgument, ktArgument } from './argument.js';
-import type { KtType, KtValue } from './types.js';
-
-type Injects = 'class' | 'target' | 'arguments';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    class: KtType<TBuilder>;
-    arguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
-    target?: Nullable<KtAnnotationTarget>;
-  }
->;
-
-export type KtAnnotationTarget =
-  | 'file'
-  | 'property'
-  | 'field'
-  | 'get'
-  | 'set'
-  | 'receiver'
-  | 'param'
-  | 'setparam'
-  | 'delegate';
-
-export class KtAnnotation<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public class: KtType<TBuilder>;
-  public arguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
-  public target: KtAnnotationTarget | null;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.class = options.class;
-    this.arguments = options.arguments?.filter(notNullish) ?? [];
-    this.target = options.target ?? null;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append('@');
-
-    if (this.target) {
-      builder.append(this.inject.beforeTarget);
-      builder.append(this.target);
-      builder.append(this.inject.afterTarget);
-      builder.append(':');
-    }
-
-    builder.append(this.inject.beforeClass);
-    writeKtNode(builder, this.class);
-    builder.append(this.inject.afterClass);
-
-    if (this.arguments.length > 0) {
-      builder.append(this.inject.beforeArguments);
-      ktArgument.write(builder, this.arguments);
-      builder.append(this.inject.afterArguments);
-    }
-  }
-}
-
-const createAnnotation = <TBuilder extends SourceBuilder>(
-  $class: Options<TBuilder>['class'],
-  $arguments?: Options<TBuilder>['arguments'],
-  options?: Prettify<Omit<Options<TBuilder>, 'class' | 'arguments'>>,
-): KtAnnotation<TBuilder> => new KtAnnotation<TBuilder>({ ...options, class: $class, arguments: $arguments });
-
-export const ktAnnotation: typeof createAnnotation & { write: typeof writeKtAnnotations } = Object.assign(
-  createAnnotation,
-  {
-    write: writeKtAnnotations,
-  },
-);

package/src/src/ast/nodes/argument.ts

@@ -1,62 +0,0 @@
-import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtArguments } from '../utils/write-kt-arguments.js';
-import { writeKtNode } from '../utils/write-kt-node.js';
-import type { KtValue } from './types.js';
-
-type Injects = 'name' | 'value';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    name?: Nullable<string>;
-    value: KtValue<TBuilder>;
-  }
->;
-
-export class KtArgument<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public name: string | null;
-  public value: KtValue<TBuilder>;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options?.name ?? null;
-    this.value = options.value;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    if (this.name) {
-      builder.append(this.inject.beforeName);
-      builder.append(this.name);
-      builder.append(this.inject.afterName);
-      builder.append(' = ');
-    }
-
-    builder.append(this.inject.beforeValue);
-    writeKtNode(builder, this.value);
-    builder.append(this.inject.afterValue);
-  }
-}
-
-const createArgument = <TBuilder extends SourceBuilder>(
-  value: Options<TBuilder>['value'],
-  options?: Prettify<Omit<Options<TBuilder>, 'value'>>,
-): KtArgument<TBuilder> => new KtArgument<TBuilder>({ ...options, value });
-
-const createNamedArgument = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  value: Options<TBuilder>['value'],
-  options?: Prettify<Omit<Options<TBuilder>, 'value' | 'name'>>,
-): KtArgument<TBuilder> => new KtArgument<TBuilder>({ ...options, value, name });
-
-export const ktArgument: typeof createArgument & {
-  named: typeof createNamedArgument;
-  write: typeof writeKtArguments;
-} = Object.assign(createArgument, {
-  named: createNamedArgument,
-  write: writeKtArguments,
-});

package/src/src/ast/nodes/call.ts

@@ -1,75 +0,0 @@
-import {
-  type ArrayItem,
-  type AstNodeOptions,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtArgument, ktArgument } from './argument.js';
-import type { KtType, KtValue } from './types.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    path: Nullable<KtType<TBuilder> | KtValue<TBuilder>>[];
-    arguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
-    infix?: boolean;
-  }
->;
-
-export class KtCall<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public path: (KtType<TBuilder> | KtValue<TBuilder>)[];
-  public arguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[] | null;
-  public infix: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.path = options.path.filter(notNullish);
-    this.arguments = options.arguments?.filter(notNullish) ?? null;
-    this.infix = options.infix ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    if (this.infix && this.arguments?.length === 1 && this.path.length > 1) {
-      writeKtNodes(builder, this.path.slice(0, 1), { separator: '.' });
-      builder.append(' ');
-      writeKtNode(builder, this.path.at(-1));
-      builder.append(' ');
-      writeKtNode(builder, this.arguments[0]);
-    } else {
-      if (this.path.length > 2) {
-        writeKtNode(builder, this.path[0]);
-        builder.ensureCurrentLineEmpty();
-        builder.indent((builder) => {
-          builder.append('.');
-          writeKtNodes(builder, this.path.slice(1), { separator: '\n.' });
-        });
-      } else {
-        writeKtNodes(builder, this.path, { separator: '.' });
-      }
-
-      if (this.arguments) {
-        ktArgument.write(builder, this.arguments);
-      }
-    }
-  }
-}
-
-const createCall = <TBuilder extends SourceBuilder>(
-  path: Options<TBuilder>['path'] | ArrayItem<Options<TBuilder>['path']>,
-  args?: Options<TBuilder>['arguments'],
-  options?: Prettify<Omit<Options<TBuilder>, 'path' | 'arguments'>>,
-): KtCall<TBuilder> => new KtCall<TBuilder>({ ...options, path: Array.isArray(path) ? path : [path], arguments: args });
-
-export const ktCall: typeof createCall & { write: typeof writeKtNodes } = Object.assign(createCall, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/class.ts

@@ -1,178 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  type BasicAppendValue,
-  createOverwriteProxy,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtMembers } from '../utils/write-kt-members.js';
-import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation, ktAnnotation } from './annotation.js';
-import { ktArgument } from './argument.js';
-import type { KtConstructor } from './constructor.js';
-import { type KtDoc, ktDoc } from './doc.js';
-import type { KtEnum } from './enum.js';
-import type { KtFunction } from './function.js';
-import { type KtGenericParameter, ktGenericParameter } from './generic-parameter.js';
-import { type KtInitBlock, 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';
-
-type Injects =
-  | 'doc'
-  | 'annotations'
-  | 'modifiers'
-  | 'name'
-  | 'generics'
-  | 'primaryConstructor'
-  | 'inheritList'
-  | 'body'
-  | 'members';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    doc?: Nullable<KtDoc<TBuilder>>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    accessModifier?: Nullable<KtAccessModifier>;
-    open?: Nullable<boolean>;
-    abstract?: Nullable<boolean>;
-    classKind?: Nullable<KtClassKind>;
-    name: string;
-    generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    primaryConstructor?: Nullable<KtConstructor<TBuilder>>;
-    extends?: Nullable<KtType<TBuilder>>;
-    implements?: Nullable<Nullable<KtType<TBuilder>>[]>;
-    companionObject?: Nullable<KtObject<TBuilder>>;
-    members?: Nullable<Nullable<KtClassMember<TBuilder>>[]>;
-  }
->;
-
-export type KtClassKind = 'data' | 'value' | 'annotation' | 'sealed';
-export type KtClassMember<TBuilder extends SourceBuilder> =
-  | KtConstructor<TBuilder>
-  | KtEnum<TBuilder>
-  | KtInitBlock<TBuilder>
-  | KtInterface<TBuilder>
-  | KtProperty<TBuilder>
-  | KtFunction<TBuilder>
-  | KtClass<TBuilder>
-  | AppendValue<TBuilder>;
-
-export class KtClass<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public doc: KtDoc<TBuilder> | null;
-  public annotations: KtAnnotation<TBuilder>[];
-  public accessModifier: KtAccessModifier | null;
-  public open: boolean;
-  public abstract: boolean;
-  public classKind: KtClassKind | null;
-  public name: string;
-  public generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public primaryConstructor: KtConstructor<TBuilder> | null;
-  public extends: KtType<TBuilder> | null;
-  public implements: KtType<TBuilder>[];
-  public members: KtClassMember<TBuilder>[];
-  public companionObject: Nullable<KtObject<TBuilder>>;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.doc = options.doc ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.accessModifier = options.accessModifier ?? null;
-    this.open = options.open ?? false;
-    this.abstract = options.abstract ?? false;
-    this.classKind = options.classKind ?? null;
-    this.name = options.name;
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.primaryConstructor = options.primaryConstructor ?? null;
-    this.extends = options.extends ?? null;
-    this.implements = options.implements?.filter(notNullish) ?? [];
-    this.members = options.members?.filter(notNullish) ?? [];
-    this.companionObject = options.companionObject;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeDoc);
-    ktDoc.get(this.doc, { generics: this.generics, 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, ' ');
-    if (this.open) builder.append('open ');
-    if (this.abstract) builder.append('abstract ');
-    if (this.classKind) builder.append(this.classKind, ' ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append('class ');
-    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.primaryConstructor) {
-      builder.append(this.inject.beforePrimaryConstructor);
-      this.primaryConstructor.writeAsPrimary(builder);
-      builder.append(this.inject.afterPrimaryConstructor);
-    }
-
-    if (this.extends || this.implements.length > 0) {
-      builder.append(' : ');
-      builder.append(this.inject.beforeInheritList);
-      writeKtNode(builder, this.extends);
-      if (this.extends && this.primaryConstructor?.delegateTarget === 'super') {
-        ktArgument.write(builder, this.primaryConstructor.delegateArguments);
-      }
-      if (this.extends && this.implements.length > 0) {
-        builder.append(', ');
-      }
-      writeKtNodes(builder, this.implements, { separator: ', ' });
-      builder.append(this.inject.afterInheritList);
-    }
-
-    if (this.members.length > 0 || this.primaryConstructor?.body || this.companionObject) {
-      builder.append(' ');
-      builder.append(this.inject.beforeBody);
-      builder.parenthesize(
-        '{}',
-        (b) => {
-          b.append(this.inject.beforeMembers);
-          writeKtMembers(b, [
-            this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
-            this.primaryConstructor?.body ? ktInitBlock(this.primaryConstructor?.body) : null,
-            ...this.members,
-          ]);
-          b.append(this.inject.afterMembers);
-        },
-        { multiline: true },
-      );
-      builder.append(this.inject.afterBody);
-    }
-
-    builder.appendLine();
-  }
-}
-
-const createClass = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): KtClass<TBuilder> => new KtClass<TBuilder>({ ...options, name });
-
-export const ktClass: typeof createClass & { write: typeof writeKtNodes } = Object.assign(createClass, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/collection-literal.ts

@@ -1,49 +0,0 @@
-import { type AstNodeOptions, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import type { KtValue } from './types.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    elements: Nullable<Nullable<KtValue<TBuilder>>[]>;
-  }
->;
-
-export class KtCollectionLiteral<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public elements: KtValue<TBuilder>[];
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.elements = options.elements?.filter(notNullish) ?? [];
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    const multiline = this.elements.length > 2;
-    builder.parenthesize(
-      '[]',
-      (b) => {
-        writeKtNodes(b, this.elements, { separator: multiline ? ',\n' : ', ' });
-      },
-      { multiline },
-    );
-  }
-}
-
-const createCollectionLiteral = <TBuilder extends SourceBuilder>(
-  elements: Options<TBuilder>['elements'],
-  options?: Omit<Options<TBuilder>, 'elements'>,
-): KtCollectionLiteral<TBuilder> => new KtCollectionLiteral<TBuilder>({ ...options, elements });
-
-export const ktCollectionLiteral: typeof createCollectionLiteral & { write: typeof writeKtNodes } = Object.assign(
-  createCollectionLiteral,
-  {
-    write: writeKtNodes,
-  },
-);

package/src/src/ast/nodes/constructor.ts

@@ -1,126 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  type BasicAppendValue,
-  notNullish,
-  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, ktAnnotation } from './annotation.js';
-import { type KtArgument, ktArgument } from './argument.js';
-import { type KtParameter, ktParameter } from './parameter.js';
-import type { KtValue } from './types.js';
-
-type Injects = 'annotations' | 'modifiers' | 'params' | 'body' | 'delegate';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    accessModifier?: Nullable<KtAccessModifier>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    body?: Nullable<AppendValue<TBuilder>>;
-    delegateTarget?: Nullable<KtDelegateTarget>;
-    delegateArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
-  }
->;
-
-export type KtDelegateTarget = 'this' | 'super';
-
-export class KtConstructor<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public accessModifier: KtAccessModifier | null;
-  public annotations: KtAnnotation<TBuilder>[];
-  public parameters: (KtParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public body: AppendValue<TBuilder> | null;
-  public delegateTarget: KtDelegateTarget | null;
-  public delegateArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.parameters = options.parameters?.filter(notNullish) ?? [];
-    this.body = options.body ?? null;
-    this.accessModifier = options.accessModifier ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.delegateTarget = options.delegateTarget ?? null;
-    this.delegateArguments = options.delegateArguments?.filter(notNullish) ?? [];
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    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('constructor');
-
-    builder.append(this.inject.beforeParams);
-    ktParameter.write(builder, this.parameters);
-    builder.append(this.inject.afterParams);
-
-    if (this.delegateTarget) {
-      builder.append(' : ');
-      builder.append(this.inject.beforeDelegate);
-      builder.append(this.delegateTarget);
-      ktArgument.write(builder, this.delegateArguments);
-      builder.append(this.inject.afterDelegate);
-    }
-
-    builder.append(' ');
-    builder.append(this.inject.beforeBody);
-    builder.parenthesize('{}', this.body, { multiline: !!this.body });
-    builder.append(this.inject.afterBody);
-
-    builder.appendLine();
-  }
-
-  public writeAsPrimary(builder: TBuilder): void {
-    builder.append(this.inject.before);
-    this.onWriteAsPrimary(builder);
-    builder.append(this.inject.after);
-  }
-
-  protected onWriteAsPrimary(builder: TBuilder): void {
-    const needsCtorKeyword = this.annotations.length > 0 || !!this.accessModifier;
-    if (needsCtorKeyword) builder.append(' ');
-
-    builder.append(this.inject.beforeAnnotations);
-    ktAnnotation.write(builder, this.annotations);
-    builder.append(this.inject.afterAnnotations);
-
-    builder.append(this.inject.beforeModifiers);
-    if (this.accessModifier) builder.append(this.accessModifier, ' ');
-    builder.append(this.inject.afterModifiers);
-
-    if (needsCtorKeyword) builder.append('constructor');
-
-    if (needsCtorKeyword || this.parameters.length > 0) {
-      builder.append(this.inject.beforeParams);
-      ktParameter.write(builder, this.parameters);
-      builder.append(this.inject.afterParams);
-    }
-  }
-}
-
-const createConstructor = <TBuilder extends SourceBuilder>(
-  parameters?: Options<TBuilder>['parameters'],
-  body?: Options<TBuilder>['body'],
-  options?: Prettify<Omit<Options<TBuilder>, 'parameters' | 'body'>>,
-): KtConstructor<TBuilder> => new KtConstructor<TBuilder>({ ...options, parameters: parameters ?? undefined, body });
-
-export const ktConstructor: typeof createConstructor & { write: typeof writeKtNodes } = Object.assign(
-  createConstructor,
-  {
-    write: writeKtNodes,
-  },
-);