durcno 1.0.0-alpha.0

package/dist/src/migration/index.d.mts

@@ -0,0 +1,15 @@
+import { MIGRATION_NAME_REGEX } from "./consts.mjs";
+import { Snapshot, SnapshotColumn, SnapshotColumnRef, SnapshotEnum, SnapshotSequence, SnapshotTable, SnapshotTableCheck, SnapshotTableIndex, SnapshotTablePrimaryKey, SnapshotTableUnique, createEmptySnapshot, snapshot } from "./snapshot.mjs";
+import { CustomStatement, DDLStatement } from "./statement.mjs";
+import { ddl } from "./ddl.mjs";
+
+//#region src/migration/index.d.ts
+/**
+ * Migration options that can be exported from up.ts/down.ts
+ */
+interface MigrationOptions {
+  /** Whether to wrap statements in BEGIN...COMMIT (default: true) */
+  transaction?: boolean;
+}
+//#endregion
+export { CustomStatement, DDLStatement, MIGRATION_NAME_REGEX, MigrationOptions, type Snapshot, type SnapshotColumn, type SnapshotColumnRef, type SnapshotEnum, type SnapshotSequence, type SnapshotTable, type SnapshotTableCheck, type SnapshotTableIndex, type SnapshotTablePrimaryKey, type SnapshotTableUnique, createEmptySnapshot, ddl, snapshot };

package/dist/src/migration/index.mjs

@@ -0,0 +1,5 @@
+import { MIGRATION_NAME_REGEX } from "./consts.mjs";
+import { CustomStatement, DDLStatement } from "./statement.mjs";
+import { ddl } from "./ddl.mjs";
+import { createEmptySnapshot, snapshot } from "./snapshot.mjs";
+export { CustomStatement, DDLStatement, MIGRATION_NAME_REGEX, createEmptySnapshot, ddl, snapshot };

package/dist/src/migration/snapshot.d.mts

@@ -0,0 +1,169 @@
+import { OnDeleteAction } from "../columns/common.mjs";
+import { SnapshotCheckExpr } from "../constraints/check.mjs";
+import { IndexType } from "../indexes.mjs";
+
+//#region src/migration/snapshot.d.ts
+/**
+ * Full database snapshot containing all tracked schema objects.
+ *
+ * A snapshot is a point-in-time representation of the database schema
+ * used by the migration system to compute diffs and generate DDL.
+ */
+interface Snapshot {
+  /** All tracked tables, keyed by `"schema.name"`. */
+  tables: Record<string, SnapshotTable>;
+  /** All tracked enum types, keyed by `"schema.name"`. */
+  enums: Record<string, SnapshotEnum>;
+  /** All tracked sequences, keyed by `"schema.name"`. */
+  sequences: Record<string, SnapshotSequence>;
+}
+/**
+ * Snapshot of a single table including columns, indexes, and constraints.
+ */
+interface SnapshotTable {
+  /** The PostgreSQL schema this table belongs to (e.g. `"public"`). */
+  schema: string;
+  /** The table name. */
+  name: string;
+  /** Columns in the table, keyed by column name. */
+  columns: Record<string, SnapshotColumn>;
+  /** Indexes on the table, keyed by index name. */
+  indexes: Record<string, SnapshotTableIndex>;
+  /** CHECK constraints, keyed by constraint name. */
+  checkConstraints: Record<string, SnapshotTableCheck>;
+  /** UNIQUE constraints (table-level), keyed by constraint name. */
+  uniqueConstraints: Record<string, SnapshotTableUnique>;
+  /** Composite PRIMARY KEY constraint, if defined. */
+  primaryKeyConstraint?: SnapshotTablePrimaryKey;
+}
+/**
+ * A foreign-key column reference used in {@link SnapshotColumn["references"]}.
+ */
+interface SnapshotColumnRef {
+  /** Schema of the referenced table. */
+  schema: string;
+  /** Name of the referenced table. */
+  table: string;
+  /** Name of the referenced column. */
+  column: string;
+  /** The `ON DELETE` action for this foreign key. */
+  onDelete: OnDeleteAction;
+}
+/**
+ * Snapshot of a single column's metadata.
+ */
+interface SnapshotColumn {
+  /** The SQL type of the column (e.g. `"varchar(255)"`, `"integer"`). */
+  type: string;
+  /** Whether the column has a `NOT NULL` constraint. */
+  notNull?: true;
+  /** Whether the column is the table's primary key. */
+  primaryKey?: true;
+  /** Whether the column has a `UNIQUE` constraint. */
+  unique?: true;
+  /** The column's `DEFAULT` expression, as a raw SQL string. */
+  default?: string;
+  /** The `GENERATED` clause (e.g. `"ALWAYS"` or `"BY DEFAULT"`). */
+  generated?: string;
+  /** The `AS` expression for generated columns. */
+  as?: string;
+  /** Foreign key reference, if this column references another table. */
+  references?: SnapshotColumnRef;
+}
+/**
+ * Snapshot of a PostgreSQL `ENUM` type.
+ */
+interface SnapshotEnum {
+  /** The schema the enum belongs to. */
+  schema: string;
+  /** The enum type name. */
+  name: string;
+  /** Ordered list of allowed values. */
+  values: string[];
+}
+/**
+ * Snapshot of a PostgreSQL `SEQUENCE`.
+ */
+interface SnapshotSequence {
+  /** The schema the sequence belongs to. */
+  schema: string;
+  /** The sequence name. */
+  name: string;
+  /** `START WITH` value. */
+  startWith?: number;
+  /** `INCREMENT BY` value. */
+  increment?: number;
+  /** `MINVALUE` value. */
+  minValue?: number;
+  /** `MAXVALUE` value. */
+  maxValue?: number;
+  /** Whether the sequence wraps around (`CYCLE`). */
+  cycle?: boolean;
+  /** Number of sequence values to pre-allocate (`CACHE`). */
+  cache?: number;
+}
+/**
+ * Snapshot of a table index.
+ */
+interface SnapshotTableIndex {
+  /** The index name. */
+  name: string;
+  /** The `"schema.table"` key of the owning table. */
+  table: string;
+  /** Column names included in the index. */
+  columns: string[];
+  /** The index method (e.g. `"btree"`, `"hash"`, `"gin"`, `"gist"`). */
+  type: IndexType;
+  /** Whether this is a unique index. */
+  unique: boolean;
+}
+/**
+ * Snapshot of a CHECK constraint.
+ */
+interface SnapshotTableCheck {
+  /** The constraint name. */
+  name: string;
+  /** The `"schema.table"` key of the owning table. */
+  table: string;
+  /** The check expression. */
+  expr: SnapshotCheckExpr;
+}
+/**
+ * Snapshot of a table-level UNIQUE constraint.
+ */
+interface SnapshotTableUnique {
+  /** The constraint name. */
+  name: string;
+  /** The `"schema.table"` key of the owning table. */
+  table: string;
+  /** Column names that form the unique key. */
+  columns: string[];
+}
+/**
+ * Snapshot of a table-level PRIMARY KEY constraint.
+ */
+interface SnapshotTablePrimaryKey {
+  /** The constraint name. */
+  name: string;
+  /** The `"schema.table"` key of the owning table. */
+  table: string;
+  /** Column names that form the primary key. */
+  columns: string[];
+}
+/**
+ * Creates an empty {@link Snapshot} with no tables, enums, or sequences.
+ *
+ * @returns A new empty snapshot object.
+ */
+declare function createEmptySnapshot(): Snapshot;
+/**
+ * Generates a {@link Snapshot} from an array of Durcno entities (tables, enums, sequences).
+ *
+ * This function introspects the provided entities to extract their schema metadata
+ * and constructs a snapshot object that represents the current state of the database schema.
+ * @param entities - An array of Durcno entities (tables, enums, sequences) to include in the snapshot.
+ * @returns A {@link Snapshot} object representing the current state of the database schema.
+ */
+declare function snapshot(entities: unknown[]): Snapshot;
+//#endregion
+export { Snapshot, SnapshotColumn, SnapshotColumnRef, SnapshotEnum, SnapshotSequence, SnapshotTable, SnapshotTableCheck, SnapshotTableIndex, SnapshotTablePrimaryKey, SnapshotTableUnique, createEmptySnapshot, snapshot };

package/dist/src/migration/snapshot.mjs

@@ -0,0 +1,123 @@
+import { is } from "../entity.mjs";
+import { primaryKeyConstraint } from "../constraints/primary-key.mjs";
+import { uniqueConstraint } from "../constraints/unique.mjs";
+import { Table } from "../table.mjs";
+import { Enum } from "../enumtype.mjs";
+import { Sequence } from "../sequence.mjs";
+import { CheckBuilder, check } from "../constraints/check.mjs";
+import chalk from "../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.mjs";
+//#region src/migration/snapshot.ts
+const { red } = chalk;
+/**
+* Creates an empty {@link Snapshot} with no tables, enums, or sequences.
+*
+* @returns A new empty snapshot object.
+*/
+function createEmptySnapshot() {
+	return {
+		enums: {},
+		tables: {},
+		sequences: {}
+	};
+}
+/**
+* Generates a {@link Snapshot} from an array of Durcno entities (tables, enums, sequences).
+*
+* This function introspects the provided entities to extract their schema metadata
+* and constructs a snapshot object that represents the current state of the database schema.
+* @param entities - An array of Durcno entities (tables, enums, sequences) to include in the snapshot.
+* @returns A {@link Snapshot} object representing the current state of the database schema.
+*/
+function snapshot(entities) {
+	const ss = {
+		enums: {},
+		tables: {},
+		sequences: {}
+	};
+	for (const entity of entities) if (is(entity, Enum)) {
+		const enm = entity;
+		ss.enums[`${enm.schema}.${enm.name}`] = {
+			schema: enm.schema,
+			name: enm.name,
+			values: [...enm.values]
+		};
+	} else if (is(entity, Table)) {
+		const table = entity;
+		ss.tables[`${table._.schema}.${table._.name}`] = {
+			schema: table._.schema,
+			name: table._.name,
+			columns: {},
+			indexes: {},
+			checkConstraints: {},
+			uniqueConstraints: {}
+		};
+		Object.entries(table._.columns).forEach(([_, col]) => {
+			const { referencesCol, referencesOnDelete } = col;
+			ss.tables[`${table._.schema}.${table._.name}`].columns[col.nameSnake] = {
+				type: col.sqlType,
+				default: col.defaultToSQL(),
+				primaryKey: col.isPrimaryKey || void 0,
+				references: referencesCol !== null ? {
+					schema: referencesCol.table._.schema,
+					table: referencesCol.table._.name,
+					column: referencesCol.nameSnake,
+					onDelete: referencesOnDelete ?? "CASCADE"
+				} : void 0,
+				unique: col.isUnique || void 0,
+				notNull: col.isNotNull || void 0,
+				generated: col.generated,
+				as: col.as ?? (col.generated ? "IDENTITY" : void 0)
+			};
+		});
+		(table._.extra.indexes?.(table) ?? []).forEach((index) => {
+			ss.tables[`${table._.schema}.${table._.name}`].indexes[index._.getName(table)] = {
+				name: index._.getName(table),
+				table: table._.fullName,
+				columns: index._.getColumns().map((col) => col.nameSnake),
+				type: index._.getUsing(),
+				unique: index._.getUnique()
+			};
+		});
+		(table._.extra.checkConstraints?.(table, check, new CheckBuilder()) ?? []).forEach((chk) => {
+			ss.tables[`${table._.schema}.${table._.name}`].checkConstraints[chk.getName()] = {
+				name: chk.getName(),
+				table: table._.fullName,
+				expr: chk.toSnapshotExpr()
+			};
+		});
+		(table._.extra.uniqueConstraints?.(table, uniqueConstraint) ?? []).forEach((uc) => {
+			ss.tables[`${table._.schema}.${table._.name}`].uniqueConstraints[uc.getName(table)] = {
+				name: uc.getName(table),
+				table: table._.fullName,
+				columns: uc.getColumns()
+			};
+		});
+		const pkConstraint = table._.extra.primaryKeyConstraint?.(table, primaryKeyConstraint);
+		if (pkConstraint) {
+			if (Object.values(ss.tables[`${table._.schema}.${table._.name}`].columns).some((col) => col.primaryKey)) {
+				console.error(red(`[Error] Table "${table._.schema}"."${table._.name}" has both a column-level primaryKey and a table-level primaryKeyConstraint. Remove one of them.`));
+				process.exit(1);
+			}
+			ss.tables[`${table._.schema}.${table._.name}`].primaryKeyConstraint = {
+				name: pkConstraint.getName(table),
+				table: table._.fullName,
+				columns: pkConstraint.getColumns()
+			};
+		}
+	} else if (is(entity, Sequence)) {
+		const seq = entity;
+		ss.sequences[`${seq.schema}.${seq.name}`] = {
+			schema: seq.schema,
+			name: seq.name,
+			startWith: seq.config.startWith,
+			increment: seq.config.increment,
+			minValue: seq.config.minValue,
+			maxValue: seq.config.maxValue,
+			cycle: seq.config.cycle,
+			cache: seq.config.cache
+		};
+	}
+	return ss;
+}
+//#endregion
+export { createEmptySnapshot, snapshot };

package/dist/src/migration/statement.d.mts

@@ -0,0 +1,89 @@
+import { Snapshot } from "./snapshot.mjs";
+
+//#region src/migration/statement.d.ts
+/**
+ * All possible DDL statement types supported by the migration system.
+ *
+ * Each type corresponds to a concrete {@link DDLStatement} subclass:
+ *
+ * - `"createSchema"` — {@link CreateSchemaStatement}
+ * - `"dropSchema"` — {@link DropSchemaStatement}
+ * - `"createTable"` — {@link CreateTableBuilder}
+ * - `"dropTable"` — {@link DropTableStatement}
+ * - `"renameTable"` — {@link RenameTableStatement}
+ * - `"alterTable"` — {@link AlterTableBuilder}
+ * - `"createEnum"` — {@link CreateEnumStatement}
+ * - `"alterEnum"` — {@link AlterEnumAddValueStatement}
+ * - `"dropEnum"` — {@link DropEnumStatement}
+ * - `"createSequence"` — {@link CreateSequenceStatement}
+ * - `"dropSequence"` — {@link DropSequenceStatement}
+ * - `"createIndex"` — {@link CreateIndexBuilder}
+ * - `"dropIndex"` — {@link DropIndexStatement}
+ * - `"custom"` — {@link CustomStatement}
+ */
+type DDLStatementType = "createSchema" | "dropSchema" | "createTable" | "dropTable" | "renameTable" | "alterTable" | "createEnum" | "alterEnum" | "dropEnum" | "createSequence" | "dropSequence" | "createIndex" | "dropIndex" | "custom";
+/**
+ * Abstract base class for all DDL (Data Definition Language) statements.
+ *
+ * Every migration statement extends this class and must implement:
+ * - {@link DDLStatement.type | type} — a discriminant for the statement kind
+ * - {@link DDLStatements["toSQL"] | toSQL()} — generates the raw SQL string
+ * - {@link DDLStatement.applyToSnapshot | applyToSnapshot()} — mutates a {@link Snapshot} in place
+ *
+ * @example
+ * ```typescript
+ * import { ddl, type DDLStatement } from 'durcno/migration';
+ *
+ * const statements: DDLStatement[] = [
+ *   ddl.createTable('public', 'users')
+ *     .column('id', 'serial', { primaryKey: true })
+ *     .column('name', 'varchar(255)', { notNull: true }),
+ * ];
+ * ```
+ */
+declare abstract class DDLStatement {
+  /** Discriminant identifying the kind of DDL operation. */
+  abstract readonly type: DDLStatementType;
+  /** Whether this is a custom (user-defined) statement. */
+  get isCustom(): boolean;
+  /** Generate the SQL DDL string for this statement. */
+  abstract toSQL(): string;
+  /**
+   * Apply this DDL statement's changes to a snapshot object.
+   * Mutates the snapshot in place.
+   *
+   * @param snapshot - The database snapshot to mutate.
+   */
+  abstract applyToSnapshot(snapshot: Snapshot): void;
+}
+/**
+ * A wrapper for user-defined custom SQL statements.
+ *
+ * Custom statements are preserved during migration regeneration and
+ * cannot be automatically reflected in the schema snapshot.
+ *
+ * @example
+ * ```typescript
+ * import { ddl } from 'durcno/migration';
+ *
+ * const seedData = ddl.custom("INSERT INTO users (name) VALUES ('admin')");
+ * console.log(seedData.toSQL());
+ * // INSERT INTO users (name) VALUES ('admin')
+ * ```
+ */
+declare class CustomStatement extends DDLStatement {
+  private readonly sql;
+  readonly type: "custom";
+  /**
+   * @param sql - The raw SQL string to execute.
+   */
+  constructor(sql: string);
+  toSQL(): string;
+  /**
+   * Custom statements cannot be parsed, so this is a no-op.
+   * Users are responsible for ensuring custom SQL is reflected in the schema.
+   */
+  applyToSnapshot(_snapshot: Snapshot): void;
+}
+//#endregion
+export { CustomStatement, DDLStatement };

package/dist/src/migration/statement.mjs

@@ -0,0 +1,61 @@
+//#region src/migration/statement.ts
+/**
+* Abstract base class for all DDL (Data Definition Language) statements.
+*
+* Every migration statement extends this class and must implement:
+* - {@link DDLStatement.type | type} — a discriminant for the statement kind
+* - {@link DDLStatements["toSQL"] | toSQL()} — generates the raw SQL string
+* - {@link DDLStatement.applyToSnapshot | applyToSnapshot()} — mutates a {@link Snapshot} in place
+*
+* @example
+* ```typescript
+* import { ddl, type DDLStatement } from 'durcno/migration';
+*
+* const statements: DDLStatement[] = [
+*   ddl.createTable('public', 'users')
+*     .column('id', 'serial', { primaryKey: true })
+*     .column('name', 'varchar(255)', { notNull: true }),
+* ];
+* ```
+*/
+var DDLStatement = class {
+	/** Whether this is a custom (user-defined) statement. */
+	get isCustom() {
+		return this.type === "custom";
+	}
+};
+/**
+* A wrapper for user-defined custom SQL statements.
+*
+* Custom statements are preserved during migration regeneration and
+* cannot be automatically reflected in the schema snapshot.
+*
+* @example
+* ```typescript
+* import { ddl } from 'durcno/migration';
+*
+* const seedData = ddl.custom("INSERT INTO users (name) VALUES ('admin')");
+* console.log(seedData.toSQL());
+* // INSERT INTO users (name) VALUES ('admin')
+* ```
+*/
+var CustomStatement = class extends DDLStatement {
+	type = "custom";
+	/**
+	* @param sql - The raw SQL string to execute.
+	*/
+	constructor(sql) {
+		super();
+		this.sql = sql;
+	}
+	toSQL() {
+		return this.sql;
+	}
+	/**
+	* Custom statements cannot be parsed, so this is a no-op.
+	* Users are responsible for ensuring custom SQL is reflected in the schema.
+	*/
+	applyToSnapshot(_snapshot) {}
+};
+//#endregion
+export { CustomStatement, DDLStatement };

package/dist/src/models.d.mts

@@ -0,0 +1,34 @@
+import { TableWithColumns } from "./table.mjs";
+import { BigintColumn } from "./columns/bigint.mjs";
+import { TimestampColumn } from "./columns/timestamp.mjs";
+import { VarcharColumn } from "./columns/varchar.mjs";
+
+//#region src/models.d.ts
+/**
+ * Returns a BigintColumn with { primaryKey, generated: "ALWAYS", as: "IDENTITY" }.
+ * @returns BigintColumn
+ */
+declare const pk: () => BigintColumn<{
+  primaryKey: true;
+  generated: "ALWAYS";
+  as: "IDENTITY";
+}>;
+declare const Migrations: TableWithColumns<"durcno", "migrations", {
+  id: BigintColumn<{
+    primaryKey: true;
+    generated: "ALWAYS";
+    as: "IDENTITY";
+  }>;
+  name: VarcharColumn<{
+    length: number;
+    unique: true;
+    notNull: true;
+  }>;
+  createdAt: TimestampColumn<{
+    notNull: true;
+  }> & {
+    hasDefault: true;
+  };
+}>;
+//#endregion
+export { Migrations, pk };

package/dist/src/models.mjs

@@ -0,0 +1,27 @@
+import "./columns/common.mjs";
+import { bigint } from "./columns/bigint.mjs";
+import { timestamp } from "./columns/timestamp.mjs";
+import { varchar } from "./columns/varchar.mjs";
+import { table } from "./table.mjs";
+import { now } from "./functions/index.mjs";
+//#region src/models.ts
+/**
+* Returns a BigintColumn with { primaryKey, generated: "ALWAYS", as: "IDENTITY" }.
+* @returns BigintColumn
+*/
+const pk = () => bigint({
+	primaryKey: true,
+	generated: "ALWAYS",
+	as: "IDENTITY"
+});
+const Migrations = table("durcno", "migrations", {
+	id: pk(),
+	name: varchar({
+		length: 100,
+		unique: true,
+		notNull: true
+	}),
+	createdAt: timestamp({ notNull: true }).default(now())
+});
+//#endregion
+export { Migrations, pk };

package/dist/src/node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.mjs

@@ -0,0 +1,126 @@
+import ansiStyles from "./vendor/ansi-styles/index.mjs";
+import supportsColor from "./vendor/supports-color/index.mjs";
+import { stringEncaseCRLFWithFirstIndex, stringReplaceAll } from "./utilities.mjs";
+//#region node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+const GENERATOR = Symbol("GENERATOR");
+const STYLER = Symbol("STYLER");
+const IS_EMPTY = Symbol("IS_EMPTY");
+const levelMapping = [
+	"ansi",
+	"ansi",
+	"ansi256",
+	"ansi16m"
+];
+const styles = Object.create(null);
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === void 0 ? colorLevel : options.level;
+};
+const chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === "rgb") {
+		if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
+		if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+	if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+	return ansiStyles[type][model](...arguments_);
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	styles[model] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+	const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+}
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+const chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+//#endregion
+export { chalk as default };

package/dist/src/node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.mjs

@@ -0,0 +1,29 @@
+//#region node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+//#endregion
+export { stringEncaseCRLFWithFirstIndex, stringReplaceAll };