@ddd-ts/shape 0.0.0-compute-timeout-on-process.3 → 0.0.0-compute-timeout-on-process.4

package/dist/_.d.ts

@@ -0,0 +1,38 @@
+import { ClassShorthand, IClass } from "./class.js";
+import { DictShorthand, IDict } from "./dict.js";
+import { Primitive, PrimitiveShorthand } from "./primitive.js";
+import { IMultiple, MultipleShorthand } from "./multiple.js";
+import { Nothing, NothingShorthand } from "./nothing.js";
+import { ILiteral, LiteralShorthand } from "./literal.js";
+
+//#region src/_.d.ts
+declare abstract class Empty {}
+interface Constructor<T = any, P extends any[] = any[]> {
+  new (...args: P): T;
+}
+type AbstractConstructor<T = any, P extends any[] = any[]> = abstract new (...args: P) => T;
+interface Definition {
+  $shape: string;
+  $inline: any;
+  $serialize(value: any): any;
+  $deserialize(value: any): any;
+}
+type MakeAbstract<T> = T extends (new (...params: infer P) => infer R) ? Omit<T, ""> & (abstract new (...params: P) => R) : never;
+type Concrete<T extends AbstractConstructor<any>> = T extends (abstract new (...params: infer P) => infer R) ? Omit<T, ""> & {
+  new (...params: P): R;
+} : never;
+type Shorthand = Definition | DictShorthand | PrimitiveShorthand | MultipleShorthand | NothingShorthand | ClassShorthand | LiteralShorthand;
+type DefinitionOf<T extends Shorthand | Definition, B extends AbstractConstructor<{}> = typeof Empty> = T extends LiteralShorthand ? ILiteral<T, B> : T extends undefined ? ReturnType<typeof Nothing<B>> : T extends PrimitiveShorthand ? ReturnType<typeof Primitive<T, B>> : T extends MultipleShorthand ? IMultiple<T[0], B> : T extends ClassShorthand ? IClass<T, B> : T extends Definition ? T : T extends DictShorthand ? IDict<T, B> : never;
+declare function Shape<const S extends Definition | Shorthand, B extends AbstractConstructor<{}> = typeof Empty>(shorthand: S, base?: B): DefinitionOf<S, B>;
+type Expand<T> = T extends {
+  serialize(): any;
+} ? T : T extends Date ? T : T extends Record<string, any> ? { [key in keyof T]: Expand<T[key]> } : T;
+declare function forward<T extends AbstractConstructor<{
+  value: any;
+}>, const Forward extends (T extends AbstractConstructor<{
+  value: infer U;
+}> ? (keyof U)[] : never)>(base: T, forward: Forward): MakeAbstract<T & (new (...args: ConstructorParameters<T>) => InstanceType<T> & { [K in Forward[number]]: InstanceType<T>["value"][K] })>;
+type MergeClasses<B extends AbstractConstructor, Current extends AbstractConstructor> = abstract new (...args: ConstructorParameters<Current>) => InstanceType<B> & InstanceType<Current>;
+//#endregion
+export { AbstractConstructor, Concrete, Constructor, Definition, DefinitionOf, Empty, Expand, MakeAbstract, MergeClasses, Shape, Shorthand, forward };
+//# sourceMappingURL=_.d.ts.map

package/dist/_.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_.d.ts","names":[],"sources":["../src/_.ts"],"mappings":";;;;;;;;uBAOsB,KAAA;AAAA,UAEL,WAAA;EAAA,QACP,IAAA,EAAM,CAAA,GAAI,CAAA;AAAA;AAAA,KAER,mBAAA,sDAGS,IAAA,EAAM,CAAA,KAAM,CAAA;AAAA,UAEhB,UAAA;EACf,MAAA;EACA,OAAA;EACA,UAAA,CAAW,KAAA;EACX,YAAA,CAAa,KAAA;AAAA;AAAA,KAGH,YAAA,MAAkB,CAAA,kBACzB,MAAA,yBAED,IAAA,CAAK,CAAA,0BAA2B,MAAA,EAAQ,CAAA,KAAM,CAAA;AAAA,KAGtC,QAAA,WAAmB,mBAAA,SAC7B,CAAA,2BACK,MAAA,yBAED,IAAA,CAAK,CAAA;EAAA,QACK,MAAA,EAAQ,CAAA,GAAI,CAAA;AAAA;AAAA,KAIhB,SAAA,GACR,UAAA,GACA,aAAA,GACA,kBAAA,GACA,iBAAA,GACA,gBAAA,GACA,cAAA,GACA,gBAAA;AAAA,KAEQ,YAAA,WACA,SAAA,GAAY,UAAA,YACZ,mBAAA,cAAiC,KAAA,IACzC,CAAA,SAAU,gBAAA,GACV,QAAA,CAAS,CAAA,EAAG,CAAA,IACZ,CAAA,qBACE,UAAA,QAAkB,OAAA,CAAQ,CAAA,KAC1B,CAAA,SAAU,kBAAA,GACR,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,CAAA,KAC/B,CAAA,SAAU,iBAAA,GACR,SAAA,CAAU,CAAA,KAAM,CAAA,IAChB,CAAA,SAAU,cAAA,GACR,MAAA,CAAO,CAAA,EAAG,CAAA,IACV,CAAA,SAAU,UAAA,GACR,CAAA,GACA,CAAA,SAAU,aAAA,GACR,KAAA,CAAM,CAAA,EAAG,CAAA;AAAA,iBAGT,KAAA,iBACE,UAAA,GAAa,SAAA,YACnB,mBAAA,cAAiC,KAAA,CAAA,CAC3C,SAAA,EAAW,CAAA,EAAG,IAAA,GAAM,CAAA,GAAmB,YAAA,CAAa,CAAA,EAAG,CAAA;AAAA,KAuC7C,MAAA,MAAY,CAAA;EAAY,SAAA;AAAA,IAChC,CAAA,GACA,CAAA,SAAU,IAAA,GACR,CAAA,GACA,CAAA,SAAU,MAAA,gCACQ,CAAA,GAAI,MAAA,CAAO,CAAA,CAAE,GAAA,OAC7B,CAAA;AAAA,iBAEQ,OAAA,WACJ,mBAAA;EAAsB,KAAA;AAAA,2BACV,CAAA,SAAU,mBAAA;EAAsB,KAAA;AAAA,YAC3C,CAAA,aAAA,CAGX,IAAA,EAAM,CAAA,EACN,OAAA,EAAS,OAAA,GACR,YAAA,CACD,CAAA,YAEO,IAAA,EAAM,qBAAA,CAAsB,CAAA,MAC5B,YAAA,CAAa,CAAA,YACV,OAAA,WAAkB,YAAA,CAAa,CAAA,WAAY,CAAA;AAAA,KAa3C,YAAA,WACA,mBAAA,kBACM,mBAAA,qBAEb,IAAA,EAAM,qBAAA,CAAsB,OAAA,MAC5B,YAAA,CAAa,CAAA,IAAK,YAAA,CAAa,OAAA"}

package/dist/_.js

@@ -0,0 +1,37 @@
+import { Class } from "./class.js";
+import { Dict } from "./dict.js";
+import { Primitive } from "./primitive.js";
+import { Multiple } from "./multiple.js";
+import { Nothing } from "./nothing.js";
+import { Literal } from "./literal.js";
+
+//#region src/_.ts
+var Empty = class {};
+function Shape(shorthand, base = Empty) {
+	if (typeof shorthand === "string" || typeof shorthand === "number") return Literal(shorthand, base);
+	if (shorthand && "$shape" in shorthand && "name" in shorthand && typeof shorthand.name === "string") {
+		if (shorthand.name.startsWith("$")) return shorthand;
+		return Class(shorthand, base);
+	}
+	if (shorthand === void 0) return Nothing(void 0, base);
+	if ([
+		String,
+		Number,
+		Date,
+		Boolean
+	].includes(shorthand)) return Primitive(shorthand, base);
+	if (shorthand && "prototype" in shorthand) return Class(shorthand, base);
+	if (Array.isArray(shorthand)) return Multiple(shorthand[0], base);
+	if (typeof shorthand === "object") return Dict(shorthand, base);
+	throw new Error(`Could not determine longhand from shorthand ${JSON.stringify(shorthand)}`);
+}
+function forward(base, forward) {
+	for (const key of forward) Object.defineProperty(base.prototype, key, { get() {
+		return this.value[key].bind(this.value);
+	} });
+	return base;
+}
+
+//#endregion
+export { Empty, Shape, forward };
+//# sourceMappingURL=_.js.map

package/dist/_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_.js","names":[],"sources":["../src/_.ts"],"sourcesContent":["import { Class, IClass, ClassShorthand } from \"./class\";\nimport { Dict, IDict, DictShorthand } from \"./dict\";\nimport { Primitive, PrimitiveShorthand } from \"./primitive\";\nimport { Multiple, IMultiple, MultipleShorthand } from \"./multiple\";\nimport { Nothing, NothingShorthand } from \"./nothing\";\nimport { Literal, ILiteral, LiteralShorthand } from \"./literal\";\n\nexport abstract class Empty {}\n\nexport interface Constructor<T = any, P extends any[] = any[]> {\n  new (...args: P): T;\n}\nexport type AbstractConstructor<\n  T = any,\n  P extends any[] = any[],\n> = abstract new (...args: P) => T;\n\nexport interface Definition {\n  $shape: string;\n  $inline: any;\n  $serialize(value: any): any;\n  $deserialize(value: any): any;\n}\n\nexport type MakeAbstract<T> = T extends new (\n  ...params: infer P\n) => infer R\n  ? Omit<T, \"\"> & (abstract new (...params: P) => R)\n  : never;\n\nexport type Concrete<T extends AbstractConstructor<any>> =\n  T extends abstract new (\n    ...params: infer P\n  ) => infer R\n    ? Omit<T, \"\"> & {\n        new (...params: P): R;\n      }\n    : never;\n\nexport type Shorthand =\n  | Definition\n  | DictShorthand\n  | PrimitiveShorthand\n  | MultipleShorthand\n  | NothingShorthand\n  | ClassShorthand\n  | LiteralShorthand;\n\nexport type DefinitionOf<\n  T extends Shorthand | Definition,\n  B extends AbstractConstructor<{}> = typeof Empty,\n> = T extends LiteralShorthand\n  ? ILiteral<T, B>\n  : T extends undefined\n    ? ReturnType<typeof Nothing<B>>\n    : T extends PrimitiveShorthand\n      ? ReturnType<typeof Primitive<T, B>>\n      : T extends MultipleShorthand\n        ? IMultiple<T[0], B>\n        : T extends ClassShorthand\n          ? IClass<T, B>\n          : T extends Definition\n            ? T\n            : T extends DictShorthand\n              ? IDict<T, B>\n              : never;\n\nexport function Shape<\n  const S extends Definition | Shorthand,\n  B extends AbstractConstructor<{}> = typeof Empty,\n>(shorthand: S, base: B = Empty as any): DefinitionOf<S, B> {\n  if (typeof shorthand === \"string\" || typeof shorthand === \"number\") {\n    return Literal(shorthand, base) as any;\n  }\n\n  if (\n    shorthand &&\n    \"$shape\" in shorthand &&\n    \"name\" in shorthand &&\n    typeof shorthand.name === \"string\"\n  ) {\n    if ((shorthand as any).name.startsWith(\"$\")) {\n      return shorthand as any;\n    }\n    return Class(shorthand as any, base) as any;\n  }\n  if (shorthand === undefined) {\n    return Nothing(undefined, base) as any;\n  }\n  if ([String, Number, Date, Boolean].includes(shorthand as any)) {\n    return Primitive(shorthand as any, base) as any;\n  }\n  if (shorthand && \"prototype\" in shorthand) {\n    return Class(shorthand as any, base) as any;\n  }\n\n  if (Array.isArray(shorthand)) {\n    return (Multiple as any)(shorthand[0] as any, base);\n  }\n\n  if (typeof shorthand === \"object\") {\n    return Dict(shorthand as any, base) as any;\n  }\n\n  throw new Error(\n    `Could not determine longhand from shorthand ${JSON.stringify(shorthand)}`,\n  );\n}\n\nexport type Expand<T> = T extends { serialize(): any }\n  ? T\n  : T extends Date\n    ? T\n    : T extends Record<string, any>\n      ? { [key in keyof T]: Expand<T[key]> }\n      : T;\n\nexport function forward<\n  T extends AbstractConstructor<{ value: any }>,\n  const Forward extends T extends AbstractConstructor<{ value: infer U }>\n    ? (keyof U)[]\n    : never,\n>(\n  base: T,\n  forward: Forward,\n): MakeAbstract<\n  T &\n    (new (\n      ...args: ConstructorParameters<T>\n    ) => InstanceType<T> & {\n      [K in Forward[number]]: InstanceType<T>[\"value\"][K];\n    })\n> {\n  for (const key of forward) {\n    Object.defineProperty(base.prototype, key, {\n      get() {\n        return (this.value as any)[key].bind(this.value);\n      },\n    });\n  }\n  return base as any;\n}\n\nexport type MergeClasses<\n  B extends AbstractConstructor,\n  Current extends AbstractConstructor,\n> = abstract new (\n  ...args: ConstructorParameters<Current>\n) => InstanceType<B> & InstanceType<Current>;\n"],"mappings":";;;;;;;;AAOA,IAAsB,QAAtB,MAA4B;AA4D5B,SAAgB,MAGd,WAAc,OAAU,OAAkC;AAC1D,KAAI,OAAO,cAAc,YAAY,OAAO,cAAc,SACxD,QAAO,QAAQ,WAAW,KAAK;AAGjC,KACE,aACA,YAAY,aACZ,UAAU,aACV,OAAO,UAAU,SAAS,UAC1B;AACA,MAAK,UAAkB,KAAK,WAAW,IAAI,CACzC,QAAO;AAET,SAAO,MAAM,WAAkB,KAAK;;AAEtC,KAAI,cAAc,OAChB,QAAO,QAAQ,QAAW,KAAK;AAEjC,KAAI;EAAC;EAAQ;EAAQ;EAAM;EAAQ,CAAC,SAAS,UAAiB,CAC5D,QAAO,UAAU,WAAkB,KAAK;AAE1C,KAAI,aAAa,eAAe,UAC9B,QAAO,MAAM,WAAkB,KAAK;AAGtC,KAAI,MAAM,QAAQ,UAAU,CAC1B,QAAQ,SAAiB,UAAU,IAAW,KAAK;AAGrD,KAAI,OAAO,cAAc,SACvB,QAAO,KAAK,WAAkB,KAAK;AAGrC,OAAM,IAAI,MACR,+CAA+C,KAAK,UAAU,UAAU,GACzE;;AAWH,SAAgB,QAMd,MACA,SAQA;AACA,MAAK,MAAM,OAAO,QAChB,QAAO,eAAe,KAAK,WAAW,KAAK,EACzC,MAAM;AACJ,SAAQ,KAAK,MAAc,KAAK,KAAK,KAAK,MAAM;IAEnD,CAAC;AAEJ,QAAO"}

package/dist/addons/microsecond-timestamp.d.ts

@@ -0,0 +1,27 @@
+//#region src/addons/microsecond-timestamp.d.ts
+declare class MicrosecondTimestamp {
+  readonly micros: bigint;
+  static MILLISECOND: MicrosecondTimestamp;
+  static SECOND: MicrosecondTimestamp;
+  static MINUTE: MicrosecondTimestamp;
+  static HOUR: MicrosecondTimestamp;
+  static DAY: MicrosecondTimestamp;
+  static WEEK: MicrosecondTimestamp;
+  static MONTH: MicrosecondTimestamp;
+  constructor(micros: bigint);
+  isAfter(other: MicrosecondTimestamp): boolean;
+  equals(other: MicrosecondTimestamp): boolean;
+  isBefore(other: MicrosecondTimestamp): boolean;
+  add(micros: bigint | MicrosecondTimestamp): MicrosecondTimestamp;
+  sub(micros: bigint | MicrosecondTimestamp): MicrosecondTimestamp;
+  mult(factor: number): MicrosecondTimestamp;
+  static now(): MicrosecondTimestamp;
+  static fromNanoseconds(nanoseconds: bigint): MicrosecondTimestamp;
+  static fromMicroseconds(microseconds: bigint): MicrosecondTimestamp;
+  static deserialize(serialized: Date | MicrosecondTimestamp | bigint): MicrosecondTimestamp;
+  serialize(): Date;
+  static sort(left: MicrosecondTimestamp, right: MicrosecondTimestamp): number;
+}
+//#endregion
+export { MicrosecondTimestamp };
+//# sourceMappingURL=microsecond-timestamp.d.ts.map

package/dist/addons/microsecond-timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microsecond-timestamp.d.ts","names":[],"sources":["../../src/addons/microsecond-timestamp.ts"],"mappings":";cAAa,oBAAA;EAAA,SASU,MAAA;EAAA,OARd,WAAA,EAAW,oBAAA;EAAA,OACX,MAAA,EAAM,oBAAA;EAAA,OACN,MAAA,EAAM,oBAAA;EAAA,OACN,IAAA,EAAI,oBAAA;EAAA,OACJ,GAAA,EAAG,oBAAA;EAAA,OACH,IAAA,EAAI,oBAAA;EAAA,OACJ,KAAA,EAAK,oBAAA;cAES,MAAA;EAErB,OAAA,CAAQ,KAAA,EAAO,oBAAA;EAIf,MAAA,CAAO,KAAA,EAAO,oBAAA;EAId,QAAA,CAAS,KAAA,EAAO,oBAAA;EAIhB,GAAA,CAAI,MAAA,WAAiB,oBAAA,GAAuB,oBAAA;EAM5C,GAAA,CAAI,MAAA,WAAiB,oBAAA,GAAuB,oBAAA;EAM5C,IAAA,CAAK,MAAA,WAAiB,oBAAA;EAAA,OAIf,GAAA,CAAA,GAAO,oBAAA;EAAA,OAIP,eAAA,CAAgB,WAAA,WAAsB,oBAAA;EAAA,OAItC,gBAAA,CAAiB,YAAA,WAAuB,oBAAA;EAAA,OAIxC,WAAA,CACL,UAAA,EAAY,IAAA,GAAO,oBAAA,YAClB,oBAAA;EAmBH,SAAA,CAAA,GAAS,IAAA;EAAA,OAMF,IAAA,CAAK,IAAA,EAAM,oBAAA,EAAsB,KAAA,EAAO,oBAAA;AAAA"}

package/dist/addons/microsecond-timestamp.js

@@ -0,0 +1,62 @@
+//#region src/addons/microsecond-timestamp.ts
+var MicrosecondTimestamp = class MicrosecondTimestamp {
+	static MILLISECOND = new MicrosecondTimestamp(BigInt(1e3));
+	static SECOND = this.MILLISECOND.mult(1e3);
+	static MINUTE = this.SECOND.mult(60);
+	static HOUR = this.MINUTE.mult(60);
+	static DAY = this.HOUR.mult(24);
+	static WEEK = this.DAY.mult(7);
+	static MONTH = this.DAY.mult(30);
+	constructor(micros) {
+		this.micros = micros;
+	}
+	isAfter(other) {
+		return this.micros > other.micros;
+	}
+	equals(other) {
+		return this.micros === other.micros;
+	}
+	isBefore(other) {
+		return this.micros < other.micros;
+	}
+	add(micros) {
+		const value = micros instanceof MicrosecondTimestamp ? micros.micros : micros;
+		return new MicrosecondTimestamp(this.micros + value);
+	}
+	sub(micros) {
+		const value = micros instanceof MicrosecondTimestamp ? micros.micros : micros;
+		return new MicrosecondTimestamp(this.micros - value);
+	}
+	mult(factor) {
+		return new MicrosecondTimestamp(this.micros * BigInt(factor));
+	}
+	static now() {
+		return new MicrosecondTimestamp(BigInt(Date.now()) * BigInt(1e3));
+	}
+	static fromNanoseconds(nanoseconds) {
+		return new MicrosecondTimestamp(nanoseconds / BigInt(1e3));
+	}
+	static fromMicroseconds(microseconds) {
+		return new MicrosecondTimestamp(microseconds);
+	}
+	static deserialize(serialized) {
+		if (serialized instanceof MicrosecondTimestamp) return serialized;
+		if (typeof serialized === "bigint") return new MicrosecondTimestamp(serialized);
+		if ("microseconds" in serialized && typeof serialized.microseconds === "bigint") return new MicrosecondTimestamp(serialized.microseconds);
+		return new MicrosecondTimestamp(BigInt(serialized.getTime()) * BigInt(1e3));
+	}
+	serialize() {
+		const date = new Date(Number(this.micros / BigInt(1e3)));
+		date.microseconds = this.micros;
+		return date;
+	}
+	static sort(left, right) {
+		if (left.isAfter(right)) return 1;
+		if (left.isBefore(right)) return -1;
+		return 0;
+	}
+};
+
+//#endregion
+export { MicrosecondTimestamp };
+//# sourceMappingURL=microsecond-timestamp.js.map

package/dist/addons/microsecond-timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"microsecond-timestamp.js","names":[],"sources":["../../src/addons/microsecond-timestamp.ts"],"sourcesContent":["export class MicrosecondTimestamp {\n  static MILLISECOND = new MicrosecondTimestamp(BigInt(1_000));\n  static SECOND = this.MILLISECOND.mult(1000);\n  static MINUTE = this.SECOND.mult(60);\n  static HOUR = this.MINUTE.mult(60);\n  static DAY = this.HOUR.mult(24);\n  static WEEK = this.DAY.mult(7);\n  static MONTH = this.DAY.mult(30);\n\n  constructor(readonly micros: bigint) {}\n\n  isAfter(other: MicrosecondTimestamp): boolean {\n    return this.micros > other.micros;\n  }\n\n  equals(other: MicrosecondTimestamp): boolean {\n    return this.micros === other.micros;\n  }\n\n  isBefore(other: MicrosecondTimestamp): boolean {\n    return this.micros < other.micros;\n  }\n\n  add(micros: bigint | MicrosecondTimestamp): MicrosecondTimestamp {\n    const value =\n      micros instanceof MicrosecondTimestamp ? micros.micros : micros;\n    return new MicrosecondTimestamp(this.micros + value);\n  }\n\n  sub(micros: bigint | MicrosecondTimestamp): MicrosecondTimestamp {\n    const value =\n      micros instanceof MicrosecondTimestamp ? micros.micros : micros;\n    return new MicrosecondTimestamp(this.micros - value);\n  }\n\n  mult(factor: number): MicrosecondTimestamp {\n    return new MicrosecondTimestamp(this.micros * BigInt(factor));\n  }\n\n  static now(): MicrosecondTimestamp {\n    return new MicrosecondTimestamp(BigInt(Date.now()) * BigInt(1000));\n  }\n\n  static fromNanoseconds(nanoseconds: bigint): MicrosecondTimestamp {\n    return new MicrosecondTimestamp(nanoseconds / BigInt(1000));\n  }\n\n  static fromMicroseconds(microseconds: bigint): MicrosecondTimestamp {\n    return new MicrosecondTimestamp(microseconds);\n  }\n\n  static deserialize(\n    serialized: Date | MicrosecondTimestamp | bigint,\n  ): MicrosecondTimestamp {\n    if (serialized instanceof MicrosecondTimestamp) {\n      return serialized;\n    }\n    if (typeof serialized === \"bigint\") {\n      return new MicrosecondTimestamp(serialized);\n    }\n\n    if (\n      \"microseconds\" in serialized &&\n      typeof serialized.microseconds === \"bigint\"\n    ) {\n      return new MicrosecondTimestamp(serialized.microseconds);\n    }\n\n    const micros = BigInt(serialized.getTime()) * BigInt(1000);\n    return new MicrosecondTimestamp(micros);\n  }\n\n  serialize() {\n    const date = new Date(Number(this.micros / BigInt(1000)));\n    (date as any).microseconds = this.micros;\n    return date;\n  }\n\n  static sort(left: MicrosecondTimestamp, right: MicrosecondTimestamp): number {\n    if (left.isAfter(right)) {\n      return 1;\n    }\n    if (left.isBefore(right)) {\n      return -1;\n    }\n    return 0;\n  }\n}\n"],"mappings":";AAAA,IAAa,uBAAb,MAAa,qBAAqB;CAChC,OAAO,cAAc,IAAI,qBAAqB,OAAO,IAAM,CAAC;CAC5D,OAAO,SAAS,KAAK,YAAY,KAAK,IAAK;CAC3C,OAAO,SAAS,KAAK,OAAO,KAAK,GAAG;CACpC,OAAO,OAAO,KAAK,OAAO,KAAK,GAAG;CAClC,OAAO,MAAM,KAAK,KAAK,KAAK,GAAG;CAC/B,OAAO,OAAO,KAAK,IAAI,KAAK,EAAE;CAC9B,OAAO,QAAQ,KAAK,IAAI,KAAK,GAAG;CAEhC,YAAY,AAAS,QAAgB;EAAhB;;CAErB,QAAQ,OAAsC;AAC5C,SAAO,KAAK,SAAS,MAAM;;CAG7B,OAAO,OAAsC;AAC3C,SAAO,KAAK,WAAW,MAAM;;CAG/B,SAAS,OAAsC;AAC7C,SAAO,KAAK,SAAS,MAAM;;CAG7B,IAAI,QAA6D;EAC/D,MAAM,QACJ,kBAAkB,uBAAuB,OAAO,SAAS;AAC3D,SAAO,IAAI,qBAAqB,KAAK,SAAS,MAAM;;CAGtD,IAAI,QAA6D;EAC/D,MAAM,QACJ,kBAAkB,uBAAuB,OAAO,SAAS;AAC3D,SAAO,IAAI,qBAAqB,KAAK,SAAS,MAAM;;CAGtD,KAAK,QAAsC;AACzC,SAAO,IAAI,qBAAqB,KAAK,SAAS,OAAO,OAAO,CAAC;;CAG/D,OAAO,MAA4B;AACjC,SAAO,IAAI,qBAAqB,OAAO,KAAK,KAAK,CAAC,GAAG,OAAO,IAAK,CAAC;;CAGpE,OAAO,gBAAgB,aAA2C;AAChE,SAAO,IAAI,qBAAqB,cAAc,OAAO,IAAK,CAAC;;CAG7D,OAAO,iBAAiB,cAA4C;AAClE,SAAO,IAAI,qBAAqB,aAAa;;CAG/C,OAAO,YACL,YACsB;AACtB,MAAI,sBAAsB,qBACxB,QAAO;AAET,MAAI,OAAO,eAAe,SACxB,QAAO,IAAI,qBAAqB,WAAW;AAG7C,MACE,kBAAkB,cAClB,OAAO,WAAW,iBAAiB,SAEnC,QAAO,IAAI,qBAAqB,WAAW,aAAa;AAI1D,SAAO,IAAI,qBADI,OAAO,WAAW,SAAS,CAAC,GAAG,OAAO,IAAK,CACnB;;CAGzC,YAAY;EACV,MAAM,OAAO,IAAI,KAAK,OAAO,KAAK,SAAS,OAAO,IAAK,CAAC,CAAC;AACzD,EAAC,KAAa,eAAe,KAAK;AAClC,SAAO;;CAGT,OAAO,KAAK,MAA4B,OAAqC;AAC3E,MAAI,KAAK,QAAQ,MAAM,CACrB,QAAO;AAET,MAAI,KAAK,SAAS,MAAM,CACtB,QAAO;AAET,SAAO"}

package/dist/choice.d.ts

@@ -0,0 +1,28 @@
+import { AbstractConstructor, Constructor, Empty } from "./_.js";
+
+//#region src/choice.d.ts
+type ChoiceMatcher<S extends string[]> = { [key in S[number]]: () => any } | ({
+  _: () => any;
+} & { [key in S[number]]?: () => any });
+type ChoiceMatcherResult<M extends ChoiceMatcher<any>> = M[keyof M] extends (() => infer R) ? R : never;
+declare const Choice: <const S extends string[], B extends AbstractConstructor<{}> = typeof Empty>(config: S, base?: B) => IChoice<S, B>;
+type IChoice<S extends string[], B extends AbstractConstructor<{}> = typeof Empty> = Omit<B, ""> & {
+  $shape: "choice";
+  $of: S;
+  values: S;
+  deserialize<T extends Constructor>(this: T, value: S[number]): InstanceType<T>;
+  $deserialize<T>(this: T, value: S[number]): S[number];
+  $serialize<T>(this: T, value: S[number]): S[number];
+  $inline: S[number];
+} & (abstract new (value: S[number]) => InstanceType<B> & {
+  value: S[number];
+  is<TH, T extends S[number]>(this: TH, value: T): this is Omit<TH, "serialize" | "value"> & {
+    value: T;
+    serialize(): T;
+  };
+  match<M extends ChoiceMatcher<S>>(matcher: M): ChoiceMatcherResult<M>;
+  serialize(): S[number];
+}) & { [K in S[number]]: <T extends Constructor>(this: T) => InstanceType<T> };
+//#endregion
+export { Choice, ChoiceMatcher, ChoiceMatcherResult, IChoice };
+//# sourceMappingURL=choice.d.ts.map

package/dist/choice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"choice.d.ts","names":[],"sources":["../src/choice.ts"],"mappings":";;;KAEY,aAAA,iCAEE,CAAA;EAGR,CAAA;AAAA,cAEQ,CAAA;AAAA,KAGF,mBAAA,WAA8B,aAAA,SACxC,CAAA,OAAQ,CAAA,4BAA2B,CAAA;AAAA,cAExB,MAAA,uCAED,mBAAA,cAAuB,KAAA,EAAA,MAAA,EAEzB,CAAA,EAAC,IAAA,GACH,CAAA,KACL,OAAA,CAAQ,CAAA,EAAG,CAAA;AAAA,KAiEF,OAAA,+BAEA,mBAAA,cAAiC,KAAA,IACzC,IAAA,CAAK,CAAA;EACP,MAAA;EACA,GAAA,EAAK,CAAA;EACL,MAAA,EAAQ,CAAA;EACR,WAAA,WAAsB,WAAA,EACpB,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,CAAA,WACN,YAAA,CAAa,CAAA;EAChB,YAAA,IAAgB,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,WAAY,CAAA;EAC5C,UAAA,IAAc,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,WAAY,CAAA;EAC1C,OAAA,EAAS,CAAA;AAAA,mBAEP,KAAA,EAAO,CAAA,aACJ,YAAA,CAAa,CAAA;EAChB,KAAA,EAAO,CAAA;EACP,EAAA,eAAiB,CAAA,UACf,IAAA,EAAM,EAAA,EACN,KAAA,EAAO,CAAA,WACE,IAAA,CAAK,EAAA;IACd,KAAA,EAAO,CAAA;IACP,SAAA,IAAa,CAAA;EAAA;EAEf,KAAA,WAAgB,aAAA,CAAc,CAAA,GAAI,OAAA,EAAS,CAAA,GAAI,mBAAA,CAAoB,CAAA;EACnE,SAAA,IAAa,CAAA;AAAA,aAEP,CAAA,sBAAuB,WAAA,EAAa,IAAA,EAAM,CAAA,KAAM,YAAA,CAAa,CAAA"}

package/dist/choice.js

@@ -0,0 +1,45 @@
+import { Empty } from "./_.js";
+
+//#region src/choice.ts
+const Choice = (config, base = Empty) => {
+	class $Choice extends base {
+		static $shape = "choice";
+		static $of = config;
+		static values = config;
+		constructor(value) {
+			super();
+			this.value = value;
+		}
+		is(value) {
+			return this.value === value;
+		}
+		match(matcher) {
+			const handler = matcher[this.value];
+			if (handler) return handler();
+			return matcher._();
+		}
+		serialize() {
+			return this.value;
+		}
+		static deserialize(value) {
+			return new this(value);
+		}
+		static $deserialize(value) {
+			return value;
+		}
+		static $serialize(value) {
+			return value;
+		}
+		static $inline;
+		static {
+			for (const choice of config) this[choice] = function() {
+				return new this(choice);
+			};
+		}
+	}
+	return $Choice;
+};
+
+//#endregion
+export { Choice };
+//# sourceMappingURL=choice.js.map

package/dist/choice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"choice.js","names":[],"sources":["../src/choice.ts"],"sourcesContent":["import { AbstractConstructor, Empty, Expand, Constructor } from \"./_\";\n\nexport type ChoiceMatcher<S extends string[]> =\n  | {\n      [key in S[number]]: () => any;\n    }\n  | ({\n      _: () => any;\n    } & {\n      [key in S[number]]?: () => any;\n    });\n\nexport type ChoiceMatcherResult<M extends ChoiceMatcher<any>> =\n  M[keyof M] extends () => infer R ? R : never;\n\nexport const Choice = <\n  const S extends string[],\n  B extends AbstractConstructor<{}> = typeof Empty,\n>(\n  config: S,\n  base: B = Empty as any,\n): IChoice<S, B> => {\n  type Inline = S[number];\n\n  abstract class $Choice extends (base as any as Constructor<{}>) {\n    static $shape = \"choice\" as const;\n\n    static $of = config;\n    static values = config;\n\n    constructor(public value: Expand<Inline>) {\n      super();\n    }\n\n    is<T extends Inline>(\n      value: T,\n    ): this is Omit<this, \"value\" | \"serialize\"> & {\n      value: T;\n      serialize(): T;\n    } {\n      return this.value === value;\n    }\n\n    match<M extends ChoiceMatcher<S>>(matcher: M): ChoiceMatcherResult<M> {\n      const handler = matcher[this.value];\n      if (handler) return handler();\n      return (matcher as { _: () => any })._();\n    }\n\n    serialize(): Inline {\n      return this.value;\n    }\n\n    static deserialize<T extends typeof $Choice>(\n      this: T,\n      value: Inline,\n    ): InstanceType<T> {\n      return new (this as any)(value as any) as InstanceType<T>;\n    }\n    static $deserialize<T extends typeof $Choice>(\n      this: T,\n      value: Inline,\n    ): Inline {\n      return value;\n    }\n    static $serialize<T extends typeof $Choice>(\n      this: T,\n      value: Inline,\n    ): Inline {\n      return value;\n    }\n\n    static $inline: Inline;\n\n    static {\n      for (const choice of config) {\n        (this as any)[choice] = function <T extends Constructor>(this: T) {\n          return new this(choice as any);\n        };\n      }\n    }\n  }\n\n  return $Choice as any;\n};\n\nexport type IChoice<\n  S extends string[],\n  B extends AbstractConstructor<{}> = typeof Empty,\n> = Omit<B, \"\"> & {\n  $shape: \"choice\";\n  $of: S;\n  values: S;\n  deserialize<T extends Constructor>(\n    this: T,\n    value: S[number],\n  ): InstanceType<T>;\n  $deserialize<T>(this: T, value: S[number]): S[number];\n  $serialize<T>(this: T, value: S[number]): S[number];\n  $inline: S[number];\n} & (abstract new (\n    value: S[number],\n  ) => InstanceType<B> & {\n    value: S[number];\n    is<TH, T extends S[number]>(\n      this: TH,\n      value: T,\n    ): this is Omit<TH, \"serialize\" | \"value\"> & {\n      value: T;\n      serialize(): T;\n    };\n    match<M extends ChoiceMatcher<S>>(matcher: M): ChoiceMatcherResult<M>;\n    serialize(): S[number];\n  }) & {\n    [K in S[number]]: <T extends Constructor>(this: T) => InstanceType<T>;\n  };\n//# sourceMappingURL=choice.d.ts.map\n"],"mappings":";;;AAeA,MAAa,UAIX,QACA,OAAU,UACQ;CAGlB,MAAe,gBAAiB,KAAgC;EAC9D,OAAO,SAAS;EAEhB,OAAO,MAAM;EACb,OAAO,SAAS;EAEhB,YAAY,AAAO,OAAuB;AACxC,UAAO;GADU;;EAInB,GACE,OAIA;AACA,UAAO,KAAK,UAAU;;EAGxB,MAAkC,SAAoC;GACpE,MAAM,UAAU,QAAQ,KAAK;AAC7B,OAAI,QAAS,QAAO,SAAS;AAC7B,UAAQ,QAA6B,GAAG;;EAG1C,YAAoB;AAClB,UAAO,KAAK;;EAGd,OAAO,YAEL,OACiB;AACjB,UAAO,IAAK,KAAa,MAAa;;EAExC,OAAO,aAEL,OACQ;AACR,UAAO;;EAET,OAAO,WAEL,OACQ;AACR,UAAO;;EAGT,OAAO;EAEP;AACE,QAAK,MAAM,UAAU,OACnB,CAAC,KAAa,UAAU,WAA0C;AAChE,WAAO,IAAI,KAAK,OAAc;;;;AAMtC,QAAO"}

package/dist/class.d.ts

@@ -0,0 +1,27 @@
+import { AbstractConstructor, Constructor, Empty, Expand } from "./_.js";
+
+//#region src/class.d.ts
+type ClassShorthand = Constructor<{
+  serialize(): any;
+}> & {
+  deserialize(value: any): any;
+};
+declare const Class: <S extends Constructor<{
+  serialize(): any;
+}> & {
+  deserialize(value: any): any;
+}, B extends AbstractConstructor<any> = typeof Empty>(of: S, base?: typeof Empty) => IClass<S, B>;
+type IClass<S extends ClassShorthand, B extends AbstractConstructor<any> = typeof Empty> = (abstract new (value: InstanceType<B>) => {
+  value: InstanceType<B>;
+  serialize<T>(this: T): Expand<ReturnType<InstanceType<S>["serialize"]>>;
+}) & {
+  $shape: "class";
+  $of: S;
+  deserialize<T extends Constructor<any>>(this: T, value: Expand<Parameters<S["deserialize"]>[0]>): InstanceType<T>;
+  $deserialize(value: Parameters<S["deserialize"]>[0]): InstanceType<S>;
+  $serialize<T>(this: T, value: InstanceType<S>): ReturnType<InstanceType<S>["serialize"]>;
+  $inline: InstanceType<S>;
+};
+//#endregion
+export { Class, ClassShorthand, IClass };
+//# sourceMappingURL=class.d.ts.map

package/dist/class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class.d.ts","names":[],"sources":["../src/class.ts"],"mappings":";;;KAEY,cAAA,GAAiB,WAAA;EAAc,SAAA;AAAA;EACzC,WAAA,CAAY,KAAA;AAAA;AAAA,cAGD,KAAA,aACD,WAAA;EAAc,SAAA;AAAA;EACtB,WAAA,CAAY,KAAA;AAAA,aAEJ,mBAAA,eAAwB,KAAA,EAAA,EAAA,EAE9B,CAAA,EAAC,IAAA,UAAA,KAAA,KAEJ,MAAA,CAAO,CAAA,EAAG,CAAA;AAAA,KAwCD,MAAA,WACA,cAAA,YACA,mBAAA,eAAkC,KAAA,mBAE5C,KAAA,EAAO,YAAA,CAAa,CAAA;EAEpB,KAAA,EAAO,YAAA,CAAa,CAAA;EACpB,SAAA,IAAa,IAAA,EAAM,CAAA,GAAI,MAAA,CAAO,UAAA,CAAW,YAAA,CAAa,CAAA;AAAA;EAEtD,MAAA;EACA,GAAA,EAAK,CAAA;EACL,WAAA,WAAsB,WAAA,OACpB,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,MAAA,CAAO,UAAA,CAAW,CAAA,uBACxB,YAAA,CAAa,CAAA;EAChB,YAAA,CAAa,KAAA,EAAO,UAAA,CAAW,CAAA,sBAAuB,YAAA,CAAa,CAAA;EACnE,UAAA,IACE,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,YAAA,CAAa,CAAA,IACnB,UAAA,CAAW,YAAA,CAAa,CAAA;EAC3B,OAAA,EAAS,YAAA,CAAa,CAAA;AAAA"}

package/dist/class.js

@@ -0,0 +1,31 @@
+import { Empty } from "./_.js";
+
+//#region src/class.ts
+const Class = (of, base = Empty) => {
+	class $Class extends base {
+		static $shape = "class";
+		static $of = of;
+		constructor(value) {
+			super();
+			this.value = value;
+		}
+		static deserialize(value) {
+			return new this(of.deserialize(value));
+		}
+		serialize() {
+			return this.value.serialize();
+		}
+		static $deserialize(value) {
+			return of.deserialize(value);
+		}
+		static $serialize(value) {
+			return value.serialize();
+		}
+		static $inline;
+	}
+	return $Class;
+};
+
+//#endregion
+export { Class };
+//# sourceMappingURL=class.js.map

package/dist/class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class.js","names":[],"sources":["../src/class.ts"],"sourcesContent":["import { AbstractConstructor, Empty, Constructor, Expand } from \"./_\";\n\nexport type ClassShorthand = Constructor<{ serialize(): any }> & {\n  deserialize(value: any): any;\n};\n\nexport const Class = <\n  S extends Constructor<{ serialize(): any }> & {\n    deserialize(value: any): any;\n  },\n  B extends AbstractConstructor<any> = typeof Empty,\n>(\n  of: S,\n  base = Empty,\n): IClass<S, B> => {\n  type Serialized = ReturnType<InstanceType<S>[\"serialize\"]>;\n  type Inline = InstanceType<S>;\n\n  abstract class $Class extends base {\n    static $shape = \"class\" as const;\n    static $of = of;\n\n    constructor(public value: InstanceType<B>) {\n      super();\n    }\n\n    static deserialize<T extends Constructor<any>>(\n      this: T,\n      value: Expand<Parameters<S[\"deserialize\"]>[0]>,\n    ): InstanceType<T> {\n      return new this(of.deserialize(value)) as InstanceType<T>;\n    }\n\n    serialize<T extends $Class>(this: T): Expand<Serialized> {\n      return this.value.serialize();\n    }\n\n    static $deserialize(value: Parameters<S[\"deserialize\"]>[0]): Inline {\n      return of.deserialize(value);\n    }\n\n    static $serialize<T extends typeof $Class>(\n      this: T,\n      value: Inline,\n    ): Serialized {\n      return value.serialize();\n    }\n\n    static $inline: Inline;\n  }\n\n  return $Class as any;\n};\n\nexport type IClass<\n  S extends ClassShorthand,\n  B extends AbstractConstructor<any> = typeof Empty,\n> = (abstract new (\n  value: InstanceType<B>,\n) => {\n  value: InstanceType<B>;\n  serialize<T>(this: T): Expand<ReturnType<InstanceType<S>[\"serialize\"]>>;\n}) & {\n  $shape: \"class\";\n  $of: S;\n  deserialize<T extends Constructor<any>>(\n    this: T,\n    value: Expand<Parameters<S[\"deserialize\"]>[0]>,\n  ): InstanceType<T>;\n  $deserialize(value: Parameters<S[\"deserialize\"]>[0]): InstanceType<S>;\n  $serialize<T>(\n    this: T,\n    value: InstanceType<S>,\n  ): ReturnType<InstanceType<S>[\"serialize\"]>;\n  $inline: InstanceType<S>;\n};\n"],"mappings":";;;AAMA,MAAa,SAMX,IACA,OAAO,UACU;CAIjB,MAAe,eAAe,KAAK;EACjC,OAAO,SAAS;EAChB,OAAO,MAAM;EAEb,YAAY,AAAO,OAAwB;AACzC,UAAO;GADU;;EAInB,OAAO,YAEL,OACiB;AACjB,UAAO,IAAI,KAAK,GAAG,YAAY,MAAM,CAAC;;EAGxC,YAAyD;AACvD,UAAO,KAAK,MAAM,WAAW;;EAG/B,OAAO,aAAa,OAAgD;AAClE,UAAO,GAAG,YAAY,MAAM;;EAG9B,OAAO,WAEL,OACY;AACZ,UAAO,MAAM,WAAW;;EAG1B,OAAO;;AAGT,QAAO"}

package/dist/dict.d.ts

@@ -0,0 +1,38 @@
+import { AbstractConstructor, Constructor, DefinitionOf, Empty, Expand, Shorthand } from "./_.js";
+
+//#region src/dict.d.ts
+type DictShorthand = {
+  [key: string]: Shorthand;
+};
+type Internal<S extends DictShorthand, B extends AbstractConstructor<{}>> = {
+  Definition: { -readonly [K in keyof S]: DefinitionOf<S[K]> };
+  Serialized: (B extends {
+    $name: infer U;
+  } ? {
+    $name: U;
+  } : {}) & { -readonly [K in keyof S]: ReturnType<DefinitionOf<S[K]>["$serialize"]> };
+  Deserializing: (B extends {
+    $name: infer U;
+  } ? {
+    $name: U;
+  } : {}) & { -readonly [K in keyof S]: Parameters<DefinitionOf<S[K]>["$deserialize"]>[0] };
+  Inline: { -readonly [K in keyof S]: DefinitionOf<S[K]>["$inline"] };
+};
+declare const Dict: <const S extends {
+  [key: string]: any;
+}, B extends AbstractConstructor<{}> = typeof Empty>(of: S, base?: B) => IDict<S, B>;
+type IDict<S extends {
+  [key: string]: any;
+}, B extends AbstractConstructor<{}> = typeof Empty> = Omit<B, ""> & {
+  $shape: "dict";
+  $of: S;
+  deserialize<T extends Constructor>(this: T, value: Expand<Internal<S, B>["Serialized"]>): InstanceType<T>;
+  $deserialize<T>(this: T, value: Internal<S, B>["Deserializing"]): Internal<S, B>["Inline"];
+  $serialize<T extends Constructor>(this: T, value: InstanceType<T>): Internal<S, B>["Serialized"];
+  $inline: Internal<S, B>["Inline"];
+} & (abstract new (value: Expand<Internal<S, B>["Inline"]>) => InstanceType<B> & {
+  serialize(): Expand<Internal<S, B>["Serialized"]>;
+} & Internal<S, B>["Inline"]);
+//#endregion
+export { Dict, DictShorthand, IDict };
+//# sourceMappingURL=dict.d.ts.map

package/dist/dict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dict.d.ts","names":[],"sources":["../src/dict.ts"],"mappings":";;;KAUY,aAAA;EAAA,CAAmB,GAAA,WAAc,SAAA;AAAA;AAAA,KAExC,QAAA,WAAmB,aAAA,YAAyB,mBAAA;EAC/C,UAAA,0BAAoC,CAAA,GAAI,YAAA,CAAa,CAAA,CAAE,CAAA;EACvD,UAAA,GAAa,CAAA;IAAY,KAAA;EAAA;IAAqB,KAAA,EAAO,CAAA;EAAA,kCAC7B,CAAA,GAAI,UAAA,CAAW,YAAA,CAAa,CAAA,CAAE,CAAA;EAEtD,aAAA,GAAgB,CAAA;IAAY,KAAA;EAAA;IAAqB,KAAA,EAAO,CAAA;EAAA,kCAChC,CAAA,GAAI,UAAA,CAAW,YAAA,CAAa,CAAA,CAAE,CAAA;EAEtD,MAAA,0BACwB,CAAA,GAAI,YAAA,CAAa,CAAA,CAAE,CAAA;AAAA;AAAA,cAIhC,IAAA;EAAA,CACQ,GAAA;AAAA,aACT,mBAAA,cAAuB,KAAA,EAAA,EAAA,EAE7B,CAAA,EAAC,IAAA,GACC,CAAA,KACL,KAAA,CAAM,CAAA,EAAG,CAAA;AAAA,KAwDA,KAAA;EAAA,CAEP,GAAA;AAAA,aAEO,mBAAA,cAAiC,KAAA,IACzC,IAAA,CAAK,CAAA;EACP,MAAA;EACA,GAAA,EAAK,CAAA;EACL,WAAA,WAAsB,WAAA,EACpB,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,MAAA,CAAO,QAAA,CAAS,CAAA,EAAG,CAAA,mBACzB,YAAA,CAAa,CAAA;EAChB,YAAA,IACE,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,QAAA,CAAS,CAAA,EAAG,CAAA,qBAClB,QAAA,CAAS,CAAA,EAAG,CAAA;EACf,UAAA,WAAqB,WAAA,EACnB,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,YAAA,CAAa,CAAA,IACnB,QAAA,CAAS,CAAA,EAAG,CAAA;EACf,OAAA,EAAS,QAAA,CAAS,CAAA,EAAG,CAAA;AAAA,mBAEnB,KAAA,EAAO,MAAA,CAAO,QAAA,CAAS,CAAA,EAAG,CAAA,iBACvB,YAAA,CAAa,CAAA;EAChB,SAAA,IAAa,MAAA,CAAO,QAAA,CAAS,CAAA,EAAG,CAAA;AAAA,IAC9B,QAAA,CAAS,CAAA,EAAG,CAAA"}

package/dist/dict.js

@@ -0,0 +1,42 @@
+import { Empty, Shape } from "./_.js";
+
+//#region src/dict.ts
+const Dict = (of, base = Empty) => {
+	class $Dict extends base {
+		static $shape = "dict";
+		static $of = of;
+		constructor(...args) {
+			super();
+			Object.assign(this, args[0]);
+		}
+		serialize() {
+			return $Dict.$serialize(this);
+		}
+		static deserialize(value) {
+			const runtime = this.$deserialize(value);
+			return new this(runtime);
+		}
+		static $deserialize(value) {
+			const transform = Object.entries(of).map(([key, child]) => {
+				return [key, Shape(child).$deserialize(value[key])];
+			});
+			return Object.fromEntries(transform);
+		}
+		static $serialize(value) {
+			const transform = Object.entries(of).map(([key, child]) => {
+				return [key, Shape(child).$serialize(value[key])];
+			});
+			const merge = Object.fromEntries(transform);
+			if ("$name" in base) return {
+				...merge,
+				$name: base.$name
+			};
+			return merge;
+		}
+	}
+	return $Dict;
+};
+
+//#endregion
+export { Dict };
+//# sourceMappingURL=dict.js.map

package/dist/dict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dict.js","names":[],"sources":["../src/dict.ts"],"sourcesContent":["import {\n  DefinitionOf,\n  Shorthand,\n  Shape,\n  Expand,\n  AbstractConstructor,\n  Constructor,\n  Empty,\n} from \"./_\";\n\nexport type DictShorthand = { [key: string]: Shorthand };\n\ntype Internal<S extends DictShorthand, B extends AbstractConstructor<{}>> = {\n  Definition: { -readonly [K in keyof S]: DefinitionOf<S[K]> };\n  Serialized: (B extends { $name: infer U } ? { $name: U } : {}) & {\n    -readonly [K in keyof S]: ReturnType<DefinitionOf<S[K]>[\"$serialize\"]>;\n  };\n  Deserializing: (B extends { $name: infer U } ? { $name: U } : {}) & {\n    -readonly [K in keyof S]: Parameters<DefinitionOf<S[K]>[\"$deserialize\"]>[0];\n  };\n  Inline: {\n    -readonly [K in keyof S]: DefinitionOf<S[K]>[\"$inline\"];\n  };\n};\n\nexport const Dict = <\n  const S extends { [key: string]: any },\n  B extends AbstractConstructor<{}> = typeof Empty,\n>(\n  of: S,\n  base: B = Empty as any,\n): IDict<S, B> => {\n  abstract class $Dict extends (base as any as AbstractConstructor<{}>) {\n    static $shape = \"dict\" as const;\n    static $of = of;\n\n    constructor(...args: any[]) {\n      super();\n      Object.assign(this, args[0]);\n    }\n\n    serialize() {\n      return $Dict.$serialize(this as any) as any;\n    }\n\n    static deserialize<T extends Constructor>(\n      this: T,\n      value: any,\n    ): InstanceType<T> {\n      const runtime = (this as any).$deserialize(value as any);\n      return new this(runtime as any) as any;\n    }\n\n    static $deserialize<T extends typeof $Dict>(this: T, value: any): any {\n      const split = Object.entries(of);\n      const transform = split.map(([key, child]) => {\n        const longhand = Shape(child) as any;\n        const deserialized = longhand.$deserialize((value as any)[key]);\n        return [key, deserialized];\n      });\n      const merge = Object.fromEntries(transform);\n      return merge;\n    }\n\n    static $serialize<T extends typeof $Dict>(\n      this: T,\n      value: InstanceType<T>,\n    ): any {\n      const split = Object.entries(of);\n      const transform = split.map(([key, child]) => {\n        const longhand = Shape(child as any) as any;\n        const serialized = longhand.$serialize((value as any)[key]);\n        return [key, serialized];\n      });\n      const merge = Object.fromEntries(transform);\n\n      if (\"$name\" in base) {\n        return { ...merge, $name: base.$name } as any;\n      }\n\n      return merge as any;\n    }\n  }\n\n  return $Dict as any;\n};\n\nexport type IDict<\n  S extends {\n    [key: string]: any;\n  },\n  B extends AbstractConstructor<{}> = typeof Empty,\n> = Omit<B, \"\"> & {\n  $shape: \"dict\";\n  $of: S;\n  deserialize<T extends Constructor>(\n    this: T,\n    value: Expand<Internal<S, B>[\"Serialized\"]>,\n  ): InstanceType<T>;\n  $deserialize<T>(\n    this: T,\n    value: Internal<S, B>[\"Deserializing\"],\n  ): Internal<S, B>[\"Inline\"];\n  $serialize<T extends Constructor>(\n    this: T,\n    value: InstanceType<T>,\n  ): Internal<S, B>[\"Serialized\"];\n  $inline: Internal<S, B>[\"Inline\"];\n} & (abstract new (\n    value: Expand<Internal<S, B>[\"Inline\"]>,\n  ) => InstanceType<B> & {\n    serialize(): Expand<Internal<S, B>[\"Serialized\"]>;\n  } & Internal<S, B>[\"Inline\"]);\n"],"mappings":";;;AAyBA,MAAa,QAIX,IACA,OAAU,UACM;CAChB,MAAe,cAAe,KAAwC;EACpE,OAAO,SAAS;EAChB,OAAO,MAAM;EAEb,YAAY,GAAG,MAAa;AAC1B,UAAO;AACP,UAAO,OAAO,MAAM,KAAK,GAAG;;EAG9B,YAAY;AACV,UAAO,MAAM,WAAW,KAAY;;EAGtC,OAAO,YAEL,OACiB;GACjB,MAAM,UAAW,KAAa,aAAa,MAAa;AACxD,UAAO,IAAI,KAAK,QAAe;;EAGjC,OAAO,aAA8C,OAAiB;GAEpE,MAAM,YADQ,OAAO,QAAQ,GAAG,CACR,KAAK,CAAC,KAAK,WAAW;AAG5C,WAAO,CAAC,KAFS,MAAM,MAAM,CACC,aAAc,MAAc,KAAK,CACrC;KAC1B;AAEF,UADc,OAAO,YAAY,UAAU;;EAI7C,OAAO,WAEL,OACK;GAEL,MAAM,YADQ,OAAO,QAAQ,GAAG,CACR,KAAK,CAAC,KAAK,WAAW;AAG5C,WAAO,CAAC,KAFS,MAAM,MAAa,CACR,WAAY,MAAc,KAAK,CACnC;KACxB;GACF,MAAM,QAAQ,OAAO,YAAY,UAAU;AAE3C,OAAI,WAAW,KACb,QAAO;IAAE,GAAG;IAAO,OAAO,KAAK;IAAO;AAGxC,UAAO;;;AAIX,QAAO"}

package/dist/discriminated-union.d.ts

@@ -0,0 +1,63 @@
+import { ClassShorthand } from "./class.js";
+import { DictShorthand } from "./dict.js";
+import { AbstractConstructor, Definition, DefinitionOf, Empty, Expand, Shorthand } from "./_.js";
+
+//#region src/discriminated-union.d.ts
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type PopUnion<U> = UnionToOvlds<U> extends ((a: infer A) => void) ? A : never;
+type UnionToArray<T, A extends unknown[] = []> = IsUnion<T> extends true ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]> : [T, ...A];
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+type CountUnion<T> = UnionToArray<T> extends infer U extends any[] ? U["length"] : never;
+type UnshiftUnion<U> = UnionToArray<U> extends [infer F, ...any[]] ? F : never;
+type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+type IsStringLiteral<T> = T extends string ? string extends T ? false : true : false;
+type FindBestKeyForMatching<FromUnion> = UnshiftUnion<keyof FromUnion extends infer K ? K extends keyof FromUnion ? CountUnion<Pick<FromUnion, K>[K]> extends CountUnion<FromUnion> ? [IsStringLiteral<FromUnion[K]>] extends [true] ? K : never : never : never : never>;
+type MatcherConfig = {
+  [key: string]: any;
+};
+type ExhaustiveMatcher<C> = C extends MatcherConfig ? { [key in keyof C]: (value: Expand<DefinitionOf<C[key]>["$inline"]>) => any } : never;
+type UnsafeFallthroughMatcher<C> = C extends MatcherConfig ? { [key in keyof C]?: (value: Expand<DefinitionOf<C[key]>["$inline"]>) => any } & {
+  _: (value: Expand<DefinitionOf<C[keyof C]>["$inline"]>) => any;
+} : never;
+type PartialMatcher<C> = C extends MatcherConfig ? { [key in keyof C]?: (value: Expand<DefinitionOf<C[key]>["$inline"]>) => any } : never;
+type Matcher<C> = C extends MatcherConfig ? ExhaustiveMatcher<C> | UnsafeFallthroughMatcher<C> | PartialMatcher<C> : never;
+type Config = DictShorthandInput | ClassInput | ClassDictInput | DictInput;
+type ClassInput = ClassShorthand;
+type ClassDictInput = ClassShorthand & {
+  $of: {};
+};
+type DictInput = {
+  $of: {};
+};
+type DictShorthandInput = DictShorthand;
+type Access<T, K> = K extends keyof T ? T[K] : never;
+type Entries<T extends readonly any[], K> = UnionToIntersection<{ [i in keyof T]: Access<GetShape<T[i]>, K> extends infer U extends string ? IsStringLiteral<U> extends true ? { [key in U]: T[i] extends DictShorthandInput ? DefinitionOf<T[i]> : T[i] } : never : never }[number]>;
+type GetShape<S extends Config> = S extends DictInput ? S["$of"] : S extends ClassInput ? Access<S, "prototype"> : S;
+type BestKey<S extends readonly Config[]> = { [key in keyof S]: GetShape<S[key]> }[number] extends infer U ? FindBestKeyForMatching<U> : never;
+type DiscriminatedUnionConfiguration = readonly Config[];
+declare function findBestKey(config: DiscriminatedUnionConfiguration): string;
+declare function prepareShapeMap(config: DiscriminatedUnionConfiguration, key: string): {
+  [key: string]: Definition;
+};
+type Internal<S extends DiscriminatedUnionConfiguration, K extends BestKey<S>> = {
+  Map: Entries<S, K>;
+  Serialized: ReturnType<DefinitionOf<S[number]>["$serialize"]>;
+  Inline: DefinitionOf<S[number]>["$inline"];
+};
+declare const DiscriminatedUnion: <S extends DiscriminatedUnionConfiguration, K extends BestKey<S>, const B extends AbstractConstructor = typeof Empty>(of: S, base?: B | undefined) => IDiscriminatedUnion<S, K, B>;
+type IDiscriminatedUnion<S extends DiscriminatedUnionConfiguration, K extends BestKey<S>, B extends AbstractConstructor = typeof Empty> = Omit<B, "prototype"> & {
+  $shape: "discriminated-union";
+  $of: S;
+  serialized: Internal<S, K>["Serialized"];
+  deserialize<T>(this: T, value: Expand<Internal<S, K>["Serialized"]>): T extends AbstractConstructor ? InstanceType<T> : any;
+  $deserialize<T>(this: T, value: Internal<S, K>["Serialized"]): Internal<S, K>["Inline"];
+  $serialize<T extends AbstractConstructor>(this: T, value: InstanceType<T>): Internal<S, K>["Serialized"];
+  $inline: Internal<S, K>["Inline"];
+} & (abstract new (value: Internal<S, K>["Inline"]) => InstanceType<B> & {
+  value: Internal<S, K>["Inline"];
+  serialize(): Internal<S, K>["Serialized"];
+  match<M extends Matcher<Internal<S, K>["Map"]>, F extends (M extends ExhaustiveMatcher<Internal<S, K>["Map"]> ? [] : M extends UnsafeFallthroughMatcher<Internal<S, K>["Map"]> ? [] : M extends PartialMatcher<Internal<S, K>["Map"]> ? [fallback: (value: Omit<Internal<S, K>["Map"], keyof M>[keyof Omit<Internal<S, K>["Map"], keyof M>] extends infer U extends Shorthand ? Expand<DefinitionOf<U>["$inline"]> : never) => any] : [])>(matcher: M, ...fallback_n: F): (M[keyof M] extends ((...args: any[]) => any) ? ReturnType<M[keyof M]> : never) | (F[0] extends ((...args: any[]) => any) ? ReturnType<F[0]> : never);
+});
+//#endregion
+export { BestKey, DiscriminatedUnion, DiscriminatedUnionConfiguration, IDiscriminatedUnion, findBestKey, prepareShapeMap };
+//# sourceMappingURL=discriminated-union.d.ts.map

package/dist/discriminated-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminated-union.d.ts","names":[],"sources":["../src/discriminated-union.ts"],"mappings":"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"}

package/dist/discriminated-union.js

@@ -0,0 +1,65 @@
+import { Empty, Shape } from "./_.js";
+
+//#region src/discriminated-union.ts
+function findBestKey(config) {
+	const hash = {};
+	for (const c of config) {
+		const shape = "$of" in c ? c.$of : c;
+		for (const key in shape) {
+			const k = key;
+			if (hash[key]) hash[key].add(shape[k]);
+			else hash[key] = new Set([shape[k]]);
+		}
+	}
+	const key = Object.entries(hash).map(([key, value]) => [key, value.size]).filter(([_, value]) => value === config.length).sort((a, b) => b[1] - a[1])?.[0]?.[0];
+	if (!key) throw new Error("Could not find key for DiscriminatedUnion");
+	return key;
+}
+function prepareShapeMap(config, key) {
+	return config.reduce((acc, c) => {
+		const shape = Shape(c);
+		const discriminator = key in c ? c[key] : "$of" in c ? c.$of[key] : shape.$of[key];
+		acc[discriminator] = shape;
+		return acc;
+	}, {});
+}
+const DiscriminatedUnion = (of, ...args) => {
+	const base = args[0] || Empty;
+	const key = findBestKey(of);
+	const map = prepareShapeMap(of, key);
+	class $DiscriminatedUnion extends base {
+		constructor(value) {
+			super();
+			this.value = value;
+		}
+		static $of = of;
+		static $shape = "discriminated-union";
+		serialize() {
+			return $DiscriminatedUnion.$serialize(this.value);
+		}
+		match(matcher, fallback) {
+			const element = this.value;
+			const handler = matcher[element[key]];
+			if (handler) return handler(element);
+			if (fallback) return fallback(element);
+			if (matcher._) return matcher._(element);
+			throw new Error("Non-exhaustive match");
+		}
+		static deserialize(value) {
+			return new this(this.$deserialize(value));
+		}
+		static $deserialize(value) {
+			const definition = map[value[key]];
+			if (!definition) throw new Error("Cannot deserialize DiscriminatedUnion");
+			return definition.$deserialize(value);
+		}
+		static $serialize(value) {
+			return map[value[key]].$serialize(value);
+		}
+	}
+	return $DiscriminatedUnion;
+};
+
+//#endregion
+export { DiscriminatedUnion, findBestKey, prepareShapeMap };
+//# sourceMappingURL=discriminated-union.js.map

package/dist/discriminated-union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminated-union.js","names":[],"sources":["../src/discriminated-union.ts"],"sourcesContent":["import {\n  Constructor,\n  Expand,\n  DefinitionOf,\n  AbstractConstructor,\n  Empty,\n  type Shorthand,\n  Shape,\n  type Definition,\n} from \"./_\";\nimport { ClassShorthand } from \"./class\";\nimport { type DictShorthand } from \"./dict\";\n\ntype UnionToIntersection<U> = (\n  U extends unknown\n    ? (k: U) => void\n    : never\n) extends (k: infer I) => void\n  ? I\n  : never;\ntype PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ? A : never;\n\ntype UnionToArray<T, A extends unknown[] = []> = IsUnion<T> extends true\n  ? UnionToArray<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]>\n  : [T, ...A];\ntype IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;\n\ntype CountUnion<T> = UnionToArray<T> extends infer U extends any[]\n  ? U[\"length\"]\n  : never;\n\ntype UnshiftUnion<U> = UnionToArray<U> extends [infer F, ...any[]] ? F : never;\n\ntype UnionToOvlds<U> = UnionToIntersection<\n  U extends any ? (f: U) => void : never\n>;\n\ntype IsStringLiteral<T> = T extends string\n  ? string extends T\n    ? false\n    : true\n  : false;\n\ntype FindBestKeyForMatching<FromUnion> = UnshiftUnion<\n  keyof FromUnion extends infer K\n    ? K extends keyof FromUnion\n      ? CountUnion<Pick<FromUnion, K>[K]> extends CountUnion<FromUnion>\n        ? [IsStringLiteral<FromUnion[K]>] extends [true]\n          ? K\n          : never\n        : never\n      : never\n    : never\n>;\n\ntype MatcherConfig = { [key: string]: any };\n\ntype ExhaustiveMatcher<C> = C extends MatcherConfig\n  ? {\n      [key in keyof C]: (value: Expand<DefinitionOf<C[key]>[\"$inline\"]>) => any;\n    }\n  : never;\n\ntype UnsafeFallthroughMatcher<C> = C extends MatcherConfig\n  ? {\n      [key in keyof C]?: (\n        value: Expand<DefinitionOf<C[key]>[\"$inline\"]>,\n      ) => any;\n    } & {\n      _: (value: Expand<DefinitionOf<C[keyof C]>[\"$inline\"]>) => any;\n    }\n  : never;\n\ntype PartialMatcher<C> = C extends MatcherConfig\n  ? {\n      [key in keyof C]?: (\n        value: Expand<DefinitionOf<C[key]>[\"$inline\"]>,\n      ) => any;\n    }\n  : never;\n\ntype Matcher<C> = C extends MatcherConfig\n  ? ExhaustiveMatcher<C> | UnsafeFallthroughMatcher<C> | PartialMatcher<C>\n  : never;\n\ntype Config = DictShorthandInput | ClassInput | ClassDictInput | DictInput;\n\ntype ClassInput = ClassShorthand;\n\ntype ClassDictInput = ClassShorthand & { $of: {} };\n\ntype DictInput = { $of: {} };\n\ntype DictShorthandInput = DictShorthand;\n\ntype Access<T, K> = K extends keyof T ? T[K] : never;\n\ntype Entries<T extends readonly any[], K> = UnionToIntersection<\n  {\n    [i in keyof T]: Access<GetShape<T[i]>, K> extends infer U extends string\n      ? IsStringLiteral<U> extends true\n        ? {\n            [key in U]: T[i] extends DictShorthandInput\n              ? DefinitionOf<T[i]>\n              : T[i];\n          }\n        : never\n      : never;\n  }[number]\n>;\n\ntype GetShape<S extends Config> = S extends DictInput\n  ? S[\"$of\"]\n  : S extends ClassInput\n    ? Access<S, \"prototype\">\n    : S;\n\nexport type BestKey<S extends readonly Config[]> = {\n  [key in keyof S]: GetShape<S[key]>;\n}[number] extends infer U\n  ? FindBestKeyForMatching<U>\n  : never;\n\nexport type DiscriminatedUnionConfiguration = readonly Config[];\n\nexport function findBestKey(config: DiscriminatedUnionConfiguration) {\n  const hash: Record<string, Set<string>> = {};\n\n  for (const c of config) {\n    const shape = \"$of\" in c ? c.$of : c;\n    for (const key in shape) {\n      const k = key as keyof typeof shape;\n      if (hash[key]) {\n        hash[key].add(shape[k]);\n      } else {\n        hash[key] = new Set([shape[k]]);\n      }\n    }\n  }\n\n  const key = Object.entries(hash)\n    .map(([key, value]) => [key, value.size] as const)\n    .filter(([_, value]) => value === config.length)\n    .sort((a, b) => b[1] - a[1])?.[0]?.[0];\n\n  if (!key) {\n    throw new Error(\"Could not find key for DiscriminatedUnion\");\n  }\n\n  return key;\n}\n\nexport function prepareShapeMap(\n  config: DiscriminatedUnionConfiguration,\n  key: string,\n) {\n  return config.reduce<{ [key: string]: Definition }>((acc, c) => {\n    const shape = Shape(c);\n\n    // Here, we are handling the two cases of the configuration:\n    // - the first one is when the configuration is a Definition directly.\n    //   we can access the discriminator directly from the shape $of property\n    // - the second one is when the configuration is a DictShorthand or a plain Class.\n    //   we first have to turn it into a Definition before accessing the discriminator\n    //   Dict $of property references the configuration provided, which allows us to capture the discriminator\n    //   Class $of property references the constructor of the class, which allows us to capture the discriminator\n    //   which is mandatorily defined on the static side of the class\n    const discriminator =\n      key in c\n        ? (c as any)[key]\n        : \"$of\" in c\n          ? (c as any).$of[key]\n          : (shape as any).$of[key];\n\n    acc[discriminator] = shape;\n    return acc;\n  }, {});\n}\n\ntype Internal<\n  S extends DiscriminatedUnionConfiguration,\n  K extends BestKey<S>,\n> = {\n  Map: Entries<S, K>;\n  Serialized: ReturnType<DefinitionOf<S[number]>[\"$serialize\"]>;\n  Inline: DefinitionOf<S[number]>[\"$inline\"];\n};\n\nexport const DiscriminatedUnion = <\n  S extends DiscriminatedUnionConfiguration,\n  K extends BestKey<S>,\n  const B extends AbstractConstructor = typeof Empty,\n>(\n  of: S,\n  ...args: [base?: B]\n): IDiscriminatedUnion<S, K, B> => {\n  const base = args[0] || (Empty as any);\n\n  const key = findBestKey(of);\n  const map = prepareShapeMap(of, key);\n\n  abstract class $DiscriminatedUnion extends (base as any as Constructor<{}>) {\n    constructor(public value: any) {\n      super();\n    }\n\n    static $of = of;\n    static $shape = \"discriminated-union\" as const;\n\n    serialize() {\n      return $DiscriminatedUnion.$serialize(this.value);\n    }\n\n    match(matcher: any, fallback: any) {\n      const element: any = this.value;\n      const discriminant = element[key];\n\n      const handler = matcher[discriminant];\n      if (handler) {\n        return handler(element);\n      }\n      if (fallback) {\n        return fallback(element);\n      }\n      if (matcher._) {\n        return matcher._(element);\n      }\n      throw new Error(\"Non-exhaustive match\");\n    }\n\n    static deserialize(value: any) {\n      return new (this as any)(this.$deserialize(value as any)) as any;\n    }\n\n    static $deserialize(value: any) {\n      const definition = map[value[key]];\n      if (!definition) {\n        throw new Error(\"Cannot deserialize DiscriminatedUnion\");\n      }\n      return (definition as any).$deserialize(value);\n    }\n\n    static $serialize(value: any): any {\n      return map[(value as any)[key]].$serialize(value);\n    }\n  }\n\n  return $DiscriminatedUnion as any;\n};\n\nexport type IDiscriminatedUnion<\n  S extends DiscriminatedUnionConfiguration,\n  K extends BestKey<S>,\n  B extends AbstractConstructor = typeof Empty,\n> = Omit<B, \"prototype\"> & {\n  $shape: \"discriminated-union\";\n  $of: S;\n  serialized: Internal<S, K>[\"Serialized\"];\n  deserialize<T>(\n    this: T,\n    value: Expand<Internal<S, K>[\"Serialized\"]>,\n  ):  T extends AbstractConstructor ? InstanceType<T> : any;\n  $deserialize<T>(\n    this: T,\n    value: Internal<S, K>[\"Serialized\"],\n  ): Internal<S, K>[\"Inline\"];\n  $serialize<T extends AbstractConstructor>(\n    this: T,\n    value: InstanceType<T>,\n  ): Internal<S, K>[\"Serialized\"];\n  $inline: Internal<S, K>[\"Inline\"];\n} & (abstract new (\n    value: Internal<S, K>[\"Inline\"],\n  ) => InstanceType<B> & {\n    value: Internal<S, K>[\"Inline\"];\n    serialize(): Internal<S, K>[\"Serialized\"];\n    match<\n      M extends Matcher<Internal<S, K>[\"Map\"]>,\n      F extends M extends ExhaustiveMatcher<Internal<S, K>[\"Map\"]>\n        ? []\n        : M extends UnsafeFallthroughMatcher<Internal<S, K>[\"Map\"]>\n          ? []\n          : M extends PartialMatcher<Internal<S, K>[\"Map\"]>\n            ? [\n                fallback: (\n                  value: Omit<Internal<S, K>[\"Map\"], keyof M>[keyof Omit<\n                    Internal<S, K>[\"Map\"],\n                    keyof M\n                  >] extends infer U extends Shorthand\n                    ? Expand<DefinitionOf<U>[\"$inline\"]>\n                    : never,\n                ) => any,\n              ]\n            : [],\n    >(\n      matcher: M,\n      ...fallback_n: F\n    ):\n      | (M[keyof M] extends (...args: any[]) => any\n          ? ReturnType<M[keyof M]>\n          : never)\n      | (F[0] extends (...args: any[]) => any ? ReturnType<F[0]> : never);\n  });\n"],"mappings":";;;AA6HA,SAAgB,YAAY,QAAyC;CACnE,MAAM,OAAoC,EAAE;AAE5C,MAAK,MAAM,KAAK,QAAQ;EACtB,MAAM,QAAQ,SAAS,IAAI,EAAE,MAAM;AACnC,OAAK,MAAM,OAAO,OAAO;GACvB,MAAM,IAAI;AACV,OAAI,KAAK,KACP,MAAK,KAAK,IAAI,MAAM,GAAG;OAEvB,MAAK,OAAO,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;;;CAKrC,MAAM,MAAM,OAAO,QAAQ,KAAK,CAC7B,KAAK,CAAC,KAAK,WAAW,CAAC,KAAK,MAAM,KAAK,CAAU,CACjD,QAAQ,CAAC,GAAG,WAAW,UAAU,OAAO,OAAO,CAC/C,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK;AAEtC,KAAI,CAAC,IACH,OAAM,IAAI,MAAM,4CAA4C;AAG9D,QAAO;;AAGT,SAAgB,gBACd,QACA,KACA;AACA,QAAO,OAAO,QAAuC,KAAK,MAAM;EAC9D,MAAM,QAAQ,MAAM,EAAE;EAUtB,MAAM,gBACJ,OAAO,IACF,EAAU,OACX,SAAS,IACN,EAAU,IAAI,OACd,MAAc,IAAI;AAE3B,MAAI,iBAAiB;AACrB,SAAO;IACN,EAAE,CAAC;;AAYR,MAAa,sBAKX,IACA,GAAG,SAC8B;CACjC,MAAM,OAAO,KAAK,MAAO;CAEzB,MAAM,MAAM,YAAY,GAAG;CAC3B,MAAM,MAAM,gBAAgB,IAAI,IAAI;CAEpC,MAAe,4BAA6B,KAAgC;EAC1E,YAAY,AAAO,OAAY;AAC7B,UAAO;GADU;;EAInB,OAAO,MAAM;EACb,OAAO,SAAS;EAEhB,YAAY;AACV,UAAO,oBAAoB,WAAW,KAAK,MAAM;;EAGnD,MAAM,SAAc,UAAe;GACjC,MAAM,UAAe,KAAK;GAG1B,MAAM,UAAU,QAFK,QAAQ;AAG7B,OAAI,QACF,QAAO,QAAQ,QAAQ;AAEzB,OAAI,SACF,QAAO,SAAS,QAAQ;AAE1B,OAAI,QAAQ,EACV,QAAO,QAAQ,EAAE,QAAQ;AAE3B,SAAM,IAAI,MAAM,uBAAuB;;EAGzC,OAAO,YAAY,OAAY;AAC7B,UAAO,IAAK,KAAa,KAAK,aAAa,MAAa,CAAC;;EAG3D,OAAO,aAAa,OAAY;GAC9B,MAAM,aAAa,IAAI,MAAM;AAC7B,OAAI,CAAC,WACH,OAAM,IAAI,MAAM,wCAAwC;AAE1D,UAAQ,WAAmB,aAAa,MAAM;;EAGhD,OAAO,WAAW,OAAiB;AACjC,UAAO,IAAK,MAAc,MAAM,WAAW,MAAM;;;AAIrD,QAAO"}