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

package/dist/either.d.ts

@@ -0,0 +1,79 @@
+import { ClassShorthand } from "./class.js";
+import { AbstractConstructor, Constructor, DefinitionOf, Empty, Expand } from "./_.js";
+
+//#region src/either.d.ts
+type Config = {
+  [key: string]: any;
+};
+type ExhaustiveMatcher<C extends Config> = { [key in keyof C]: (value: InstanceType<C[key]>) => any };
+type UnsafeFallthroughMatcher<C extends Config> = { [key in keyof C]?: (value: InstanceType<C[key]>) => any } & {
+  _: (value: InstanceType<C[keyof C]>) => any;
+};
+type PartialMatcher<C extends Config> = { [key in keyof C]?: (value: InstanceType<C[key]>) => any };
+type Matcher<C extends Config> = ExhaustiveMatcher<C> | UnsafeFallthroughMatcher<C> | PartialMatcher<C>;
+type EitherConfiguration = {
+  [key: string]: ClassShorthand;
+};
+type Internal<S extends EitherConfiguration, B extends AbstractConstructor<{}>> = {
+  Definition: DefinitionOf<S[keyof S]>;
+  Serialized: (B extends {
+    $name: infer U;
+  } ? {
+    $name: U;
+  } : {}) & {
+    _key: keyof S;
+  } & ReturnType<DefinitionOf<S[keyof S]>["$serialize"]>;
+  Deserializing: (B extends {
+    $name: infer U;
+  } ? {
+    $name: U;
+  } : {}) & {
+    _key: keyof S;
+  } & Parameters<DefinitionOf<S[keyof S]>["$deserialize"]>[0];
+  Inline: DefinitionOf<S[keyof S]>["$inline"];
+};
+declare const Either: <const S extends EitherConfiguration, const B extends AbstractConstructor<{}> = typeof Empty>(of: S, base?: B) => Omit<B, "prototype"> & Omit<(abstract new (value: DefinitionOf<S[keyof S]>["$inline"]) => {
+  value: DefinitionOf<S[keyof S], typeof Empty>["$inline"];
+  serialize(): Expand<{ [K in keyof S]: {
+    _key: K;
+  } & ReturnType<DefinitionOf<S[K]>["$serialize"]> }[keyof S]>;
+  match<M extends Matcher<S>, F extends (M extends ExhaustiveMatcher<S> ? [] : M extends UnsafeFallthroughMatcher<S> ? [] : M extends PartialMatcher<S> ? [fallback: (value: InstanceType<Omit<S, keyof M>[keyof Omit<S, keyof M>]>) => 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);
+}) & {
+  serialized: { [K in keyof S]: {
+    _key: K;
+  } & ReturnType<DefinitionOf<S[K]>["$serialize"]> }[keyof S];
+  of: S;
+  $shape: "either";
+  deserialize<T extends /*elided*/any>(this: T, value: Expand<{ [K in keyof S]: {
+    _key: K;
+  } & ReturnType<DefinitionOf<S[K]>["$serialize"]> }[keyof S]>): InstanceType<T>;
+  $deserialize<T extends /*elided*/any>(this: T, value: { [K in keyof S]: {
+    _key: K;
+  } & ReturnType<DefinitionOf<S[K]>["$serialize"]> }[keyof S]): DefinitionOf<S[keyof S]>["$inline"];
+  $serialize<T extends /*elided*/any>(this: T, value: DefinitionOf<S[keyof S]>["$inline"]): { [K in keyof S]: {
+    _key: K;
+  } & ReturnType<DefinitionOf<S[K]>["$serialize"]> }[keyof S];
+  $inline: DefinitionOf<S[keyof S]>["$inline"];
+}, "prototype"> & (abstract new (value: Expand<DefinitionOf<S[keyof S]>["$inline"]>) => InstanceType<B> & {
+  value: DefinitionOf<S[keyof S], typeof Empty>["$inline"];
+  serialize(): Expand<{ [K in keyof S]: {
+    _key: K;
+  } & ReturnType<DefinitionOf<S[K]>["$serialize"]> }[keyof S]>;
+  match<M extends Matcher<S>, F extends (M extends ExhaustiveMatcher<S> ? [] : M extends UnsafeFallthroughMatcher<S> ? [] : M extends PartialMatcher<S> ? [fallback: (value: InstanceType<Omit<S, keyof M>[keyof Omit<S, keyof M>]>) => 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);
+});
+type Either<S extends EitherConfiguration, B extends AbstractConstructor<{}> = typeof Empty> = Omit<B, "prototype"> & (abstract new (value: Internal<S, B>["Inline"]) => {
+  value: Internal<S, B>["Inline"];
+  serialize(): Internal<S, B>["Serialized"];
+  match<M extends Matcher<S>, F extends (M extends ExhaustiveMatcher<S> ? [] : M extends UnsafeFallthroughMatcher<S> ? [] : M extends PartialMatcher<S> ? [fallback: (value: InstanceType<Omit<S, keyof M>[keyof Omit<S, keyof M>]>) => 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);
+}) & {
+  serialized: Internal<S, B>["Serialized"];
+  of: S;
+  $shape: "either";
+  deserialize<T extends Constructor>(this: T, value: Internal<S, B>["Serialized"]): InstanceType<T>;
+  $deserialize<T>(this: T, value: Internal<S, B>["Serialized"]): Internal<S, B>["Inline"];
+  $serialize<T>(this: T, value: Internal<S, B>["Inline"]): Internal<S, B>["Serialized"];
+  $inline: Internal<S, B>["Inline"];
+};
+//#endregion
+export { Either, EitherConfiguration };
+//# sourceMappingURL=either.d.ts.map

package/dist/either.d.ts.map

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

package/dist/either.js

@@ -0,0 +1,52 @@
+import { Empty, Shape } from "./_.js";
+
+//#region src/either.ts
+const Either = (of, base = Empty) => {
+	const definitions = Object.fromEntries(Object.entries(of).map(([key, value]) => {
+		return [key, Shape(value)];
+	}));
+	class $Either extends base {
+		constructor(value) {
+			super();
+			this.value = value;
+		}
+		static serialized;
+		static of = of;
+		static $shape = "either";
+		serialize() {
+			return $Either.$serialize(this.value);
+		}
+		match(...[matcher, fallback]) {
+			const handler = matcher[Object.entries(of).find(([_, v]) => v === this.value.constructor)?.[0]];
+			if (handler) return handler(this.value);
+			if (fallback) return fallback(this.value);
+			if (matcher._) return matcher._(this.value);
+			throw new Error("Non-exhaustive match");
+		}
+		static deserialize(value) {
+			return new this(this.$deserialize(value));
+		}
+		static $deserialize(value) {
+			const { _key: key, ...serialized } = value;
+			const definition = definitions[key];
+			if (!definition) throw new Error("Cannot deserialize Either");
+			return definition.$deserialize(serialized);
+		}
+		static $serialize(value) {
+			const key = Object.entries(of).find(([_, v]) => v === value.constructor)?.[0];
+			if (!key) throw new Error("Cannot serialize Either, no matching key");
+			const definition = definitions[key];
+			if (!definition) throw new Error("Cannot serialize Either");
+			return {
+				...definition.$serialize(value),
+				_key: key
+			};
+		}
+		static $inline;
+	}
+	return $Either;
+};
+
+//#endregion
+export { Either };
+//# sourceMappingURL=either.js.map

package/dist/either.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"either.js","names":[],"sources":["../src/either.ts"],"sourcesContent":["import {\n  Constructor,\n  Expand,\n  DefinitionOf,\n  Shape,\n  AbstractConstructor,\n  Empty,\n} from \"./_\";\nimport { ClassShorthand } from \"./class\";\nimport { PrimitiveShorthand } from \"./primitive\";\n\ntype Config = { [key: string]: any };\n\ntype ExhaustiveMatcher<C extends Config> = {\n  [key in keyof C]: (value: InstanceType<C[key]>) => any;\n};\n\ntype UnsafeFallthroughMatcher<C extends Config> = {\n  [key in keyof C]?: (value: InstanceType<C[key]>) => any;\n} & {\n  _: (value: InstanceType<C[keyof C]>) => any;\n};\n\ntype PartialMatcher<C extends Config> = {\n  [key in keyof C]?: (value: InstanceType<C[key]>) => any;\n};\n\ntype Matcher<C extends Config> =\n  | ExhaustiveMatcher<C>\n  | UnsafeFallthroughMatcher<C>\n  | PartialMatcher<C>;\n\nexport type EitherConfiguration = {\n  [key: string]: ClassShorthand;\n};\n\ntype Internal<\n  S extends EitherConfiguration,\n  B extends AbstractConstructor<{}>,\n> = {\n  Definition: DefinitionOf<S[keyof S]>;\n  Serialized: (B extends { $name: infer U } ? { $name: U } : {}) & {\n    _key: keyof S;\n  } & ReturnType<DefinitionOf<S[keyof S]>[\"$serialize\"]>;\n  Deserializing: (B extends { $name: infer U } ? { $name: U } : {}) & {\n    _key: keyof S;\n  } & Parameters<DefinitionOf<S[keyof S]>[\"$deserialize\"]>[0];\n  Inline: DefinitionOf<S[keyof S]>[\"$inline\"];\n};\n\nexport const Either = <\n  const S extends EitherConfiguration,\n  const B extends AbstractConstructor<{}> = typeof Empty,\n>(\n  of: S,\n  base: B = Empty as any,\n) => {\n  type Serialized = {\n    [K in keyof S]: { _key: K } & ReturnType<DefinitionOf<S[K]>[\"$serialize\"]>;\n  }[keyof S];\n\n  type Inline = DefinitionOf<S[keyof S]>[\"$inline\"];\n\n  const definitions = Object.fromEntries(\n    Object.entries(of).map(([key, value]) => {\n      return [key, Shape(value)] as const;\n    }),\n  );\n\n  abstract class $Either extends (base as any as Constructor<{}>) {\n    constructor(public value: Inline) {\n      super();\n    }\n\n    static serialized: Serialized;\n\n    static of = of;\n\n    static $shape = \"either\" as const;\n\n    serialize(): Expand<Serialized> {\n      return ($Either as any).$serialize(this.value) as any;\n    }\n\n    match<\n      M extends Matcher<S>,\n      F extends M extends ExhaustiveMatcher<S>\n        ? []\n        : M extends UnsafeFallthroughMatcher<S>\n          ? []\n          : M extends PartialMatcher<S>\n            ? [\n                fallback: (\n                  value: InstanceType<Omit<S, keyof M>[keyof Omit<S, keyof M>]>,\n                ) => any,\n              ]\n            : [],\n    >(\n      ...[matcher, fallback]: [matcher: M, ...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      const key: any = Object.entries(of).find(\n        ([_, v]) => v === ((this.value as any).constructor as any),\n      )?.[0] as any;\n\n      const handler = matcher[key];\n      if (handler) {\n        return handler(this.value as any);\n      }\n      if (fallback) {\n        return fallback(this.value as any);\n      }\n      if (matcher._) {\n        return matcher._(this.value as any);\n      }\n      throw new Error(\"Non-exhaustive match\");\n    }\n\n    static deserialize<T extends typeof $Either>(\n      this: T,\n      value: Expand<Serialized>,\n    ): InstanceType<T> {\n      return new (this as any)(this.$deserialize(value as any)) as any;\n    }\n\n    static $deserialize<T extends typeof $Either>(\n      this: T,\n      value: Serialized,\n    ): Inline {\n      const { _key: key, ...serialized } = value as any;\n      const definition = definitions[key];\n      if (!definition) {\n        throw new Error(\"Cannot deserialize Either\");\n      }\n      return (definition as any).$deserialize(serialized);\n    }\n\n    static $serialize<T extends typeof $Either>(\n      this: T,\n      value: Inline,\n    ): Serialized {\n      const key = Object.entries(of).find(\n        ([_, v]) => v === ((value as any).constructor as any),\n      )?.[0];\n      if (!key) {\n        throw new Error(\"Cannot serialize Either, no matching key\");\n      }\n\n      const definition = definitions[key];\n      if (!definition) {\n        throw new Error(\"Cannot serialize Either\");\n      }\n      return { ...(definition as any).$serialize(value), _key: key } as any;\n    }\n\n    static $inline: Inline;\n  }\n\n  type EitherConstructor = abstract new (\n    value: Expand<Inline>,\n  ) => InstanceType<B> & $Either;\n  type Either = Omit<B, \"prototype\"> &\n    Omit<typeof $Either, \"prototype\"> &\n    EitherConstructor;\n\n  return $Either as Either;\n};\n\nexport type Either<\n  S extends EitherConfiguration,\n  B extends AbstractConstructor<{}> = typeof Empty,\n> = Omit<B, \"prototype\"> &\n  (abstract new (\n    value: Internal<S, B>[\"Inline\"],\n  ) => {\n    value: Internal<S, B>[\"Inline\"];\n    serialize(): Internal<S, B>[\"Serialized\"];\n    match<\n      M extends Matcher<S>,\n      F extends M extends ExhaustiveMatcher<S>\n        ? []\n        : M extends UnsafeFallthroughMatcher<S>\n          ? []\n          : M extends PartialMatcher<S>\n            ? [\n                fallback: (\n                  value: InstanceType<Omit<S, keyof M>[keyof Omit<S, keyof M>]>,\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    serialized: Internal<S, B>[\"Serialized\"];\n    of: S;\n    $shape: \"either\";\n    deserialize<T extends Constructor>(\n      this: T,\n      value: Internal<S, B>[\"Serialized\"],\n    ): InstanceType<T>;\n    $deserialize<T>(\n      this: T,\n      value: Internal<S, B>[\"Serialized\"],\n    ): Internal<S, B>[\"Inline\"];\n    $serialize<T>(\n      this: T,\n      value: Internal<S, B>[\"Inline\"],\n    ): Internal<S, B>[\"Serialized\"];\n    $inline: Internal<S, B>[\"Inline\"];\n  };\n"],"mappings":";;;AAkDA,MAAa,UAIX,IACA,OAAU,UACP;CAOH,MAAM,cAAc,OAAO,YACzB,OAAO,QAAQ,GAAG,CAAC,KAAK,CAAC,KAAK,WAAW;AACvC,SAAO,CAAC,KAAK,MAAM,MAAM,CAAC;GAC1B,CACH;CAED,MAAe,gBAAiB,KAAgC;EAC9D,YAAY,AAAO,OAAe;AAChC,UAAO;GADU;;EAInB,OAAO;EAEP,OAAO,KAAK;EAEZ,OAAO,SAAS;EAEhB,YAAgC;AAC9B,UAAQ,QAAgB,WAAW,KAAK,MAAM;;EAGhD,MAcE,GAAG,CAAC,SAAS,WAKuD;GAKpE,MAAM,UAAU,QAJC,OAAO,QAAQ,GAAG,CAAC,MACjC,CAAC,GAAG,OAAO,MAAQ,KAAK,MAAc,YACxC,GAAG;AAGJ,OAAI,QACF,QAAO,QAAQ,KAAK,MAAa;AAEnC,OAAI,SACF,QAAO,SAAS,KAAK,MAAa;AAEpC,OAAI,QAAQ,EACV,QAAO,QAAQ,EAAE,KAAK,MAAa;AAErC,SAAM,IAAI,MAAM,uBAAuB;;EAGzC,OAAO,YAEL,OACiB;AACjB,UAAO,IAAK,KAAa,KAAK,aAAa,MAAa,CAAC;;EAG3D,OAAO,aAEL,OACQ;GACR,MAAM,EAAE,MAAM,KAAK,GAAG,eAAe;GACrC,MAAM,aAAa,YAAY;AAC/B,OAAI,CAAC,WACH,OAAM,IAAI,MAAM,4BAA4B;AAE9C,UAAQ,WAAmB,aAAa,WAAW;;EAGrD,OAAO,WAEL,OACY;GACZ,MAAM,MAAM,OAAO,QAAQ,GAAG,CAAC,MAC5B,CAAC,GAAG,OAAO,MAAQ,MAAc,YACnC,GAAG;AACJ,OAAI,CAAC,IACH,OAAM,IAAI,MAAM,2CAA2C;GAG7D,MAAM,aAAa,YAAY;AAC/B,OAAI,CAAC,WACH,OAAM,IAAI,MAAM,0BAA0B;AAE5C,UAAO;IAAE,GAAI,WAAmB,WAAW,MAAM;IAAE,MAAM;IAAK;;EAGhE,OAAO;;AAUT,QAAO"}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { Class, ClassShorthand, IClass } from "./class.js";
+import { Dict, DictShorthand, IDict } from "./dict.js";
+import { IPrimitive, Primitive, PrimitiveFromConstructor, PrimitiveShorthand } from "./primitive.js";
+import { IMultiple, Multiple, MultipleConfiguration, MultipleShorthand } from "./multiple.js";
+import { Nothing, NothingShorthand } from "./nothing.js";
+import { ILiteral, Literal, LiteralShorthand } from "./literal.js";
+import { AbstractConstructor, Concrete, Constructor, Definition, DefinitionOf, Empty, Expand, MakeAbstract, MergeClasses, Shape, Shorthand, forward } from "./_.js";
+import { Choice, ChoiceMatcher, ChoiceMatcherResult, IChoice } from "./choice.js";
+import { Either, EitherConfiguration } from "./either.js";
+import { BestKey, DiscriminatedUnion, DiscriminatedUnionConfiguration, IDiscriminatedUnion, findBestKey, prepareShapeMap } from "./discriminated-union.js";
+import { Mapping, MappingConfiguration } from "./mapping.js";
+import { IOptional, Optional, OptionalConfiguration } from "./optional.js";
+import { MicrosecondTimestamp } from "./addons/microsecond-timestamp.js";
+export { AbstractConstructor, BestKey, Choice, ChoiceMatcher, ChoiceMatcherResult, Class, ClassShorthand, Concrete, Constructor, Definition, DefinitionOf, Dict, DictShorthand, DiscriminatedUnion, DiscriminatedUnionConfiguration, Either, EitherConfiguration, Empty, Expand, IChoice, IClass, IDict, IDiscriminatedUnion, ILiteral, IMultiple, IOptional, IPrimitive, Literal, LiteralShorthand, MakeAbstract, Mapping, MappingConfiguration, MergeClasses, MicrosecondTimestamp, Multiple, MultipleConfiguration, MultipleShorthand, Nothing, NothingShorthand, Optional, OptionalConfiguration, Primitive, PrimitiveFromConstructor, PrimitiveShorthand, Shape, Shorthand, findBestKey, forward, prepareShapeMap };

package/dist/index.js

@@ -0,0 +1,15 @@
+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";
+import { Empty, Shape, forward } from "./_.js";
+import { Choice } from "./choice.js";
+import { Either } from "./either.js";
+import { DiscriminatedUnion, findBestKey, prepareShapeMap } from "./discriminated-union.js";
+import { Mapping } from "./mapping.js";
+import { Optional } from "./optional.js";
+import { MicrosecondTimestamp } from "./addons/microsecond-timestamp.js";
+
+export { Choice, Class, Dict, DiscriminatedUnion, Either, Empty, Literal, Mapping, MicrosecondTimestamp, Multiple, Nothing, Optional, Primitive, Shape, findBestKey, forward, prepareShapeMap };

package/dist/literal.d.ts

@@ -0,0 +1,19 @@
+import { AbstractConstructor, Constructor, Empty, Expand } from "./_.js";
+
+//#region src/literal.d.ts
+type LiteralShorthand = string | number;
+declare const Literal: <const S extends LiteralShorthand, B extends AbstractConstructor<{}> = typeof Empty>(of: S, base?: B) => ILiteral<S, B>;
+type ILiteral<S extends LiteralShorthand, B extends AbstractConstructor<{}> = typeof Empty> = Omit<B, "prototype"> & {
+  value: S;
+  $shape: "literal";
+  deserialize<T extends Constructor>(this: T, value: S): InstanceType<T>;
+  $serialize(value: S): S;
+  $deserialize(value: S): S;
+  $inline: S;
+} & (abstract new (value: Expand<S>) => InstanceType<B> & {
+  readonly value: S;
+  serialize(): S;
+});
+//#endregion
+export { ILiteral, Literal, LiteralShorthand };
+//# sourceMappingURL=literal.d.ts.map

package/dist/literal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal.d.ts","names":[],"sources":["../src/literal.ts"],"mappings":";;;KAEY,gBAAA;AAAA,cAEC,OAAA,mBACK,gBAAA,YACN,mBAAA,cAAuB,KAAA,EAAA,EAAA,EAE7B,CAAA,EAAC,IAAA,GACC,CAAA,KACL,QAAA,CAAS,CAAA,EAAG,CAAA;AAAA,KAgCH,QAAA,WACA,gBAAA,YACA,mBAAA,cAAiC,KAAA,IACzC,IAAA,CAAK,CAAA;EACP,KAAA,EAAO,CAAA;EACP,MAAA;EACA,WAAA,WAAsB,WAAA,EAAa,IAAA,EAAM,CAAA,EAAG,KAAA,EAAO,CAAA,GAAI,YAAA,CAAa,CAAA;EACpE,UAAA,CAAW,KAAA,EAAO,CAAA,GAAI,CAAA;EACtB,YAAA,CAAa,KAAA,EAAO,CAAA,GAAI,CAAA;EACxB,OAAA,EAAS,CAAA;AAAA,mBAEP,KAAA,EAAO,MAAA,CAAO,CAAA,MACX,YAAA,CAAa,CAAA;EAAA,SACP,KAAA,EAAO,CAAA;EAChB,SAAA,IAAa,CAAA;AAAA"}

package/dist/literal.js

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

package/dist/literal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal.js","names":[],"sources":["../src/literal.ts"],"sourcesContent":["import { AbstractConstructor, Constructor, Empty, Expand } from \"./_\";\n\nexport type LiteralShorthand = string | number;\n\nexport const Literal = <\n  const S extends LiteralShorthand,\n  B extends AbstractConstructor<{}> = typeof Empty,\n>(\n  of: S,\n  base: B = Empty as any,\n): ILiteral<S, B> => {\n  type Inline = S;\n\n  abstract class $Literal extends (base as any as Constructor<{}>) {\n    public readonly value = of;\n    static value = of;\n    static $shape = \"literal\" as const;\n    serialize(): S {\n      return of;\n    }\n\n    static deserialize<T extends typeof $Literal>(\n      this: T,\n      value: Inline,\n    ): InstanceType<T> {\n      return new (this as any)() as InstanceType<T>;\n    }\n\n    static $serialize(value: Inline): Inline {\n      return of;\n    }\n\n    static $deserialize(value: Inline): Inline {\n      return of;\n    }\n\n    static $inline: Inline;\n  }\n\n  return $Literal as any;\n};\n\nexport type ILiteral<\n  S extends LiteralShorthand,\n  B extends AbstractConstructor<{}> = typeof Empty,\n> = Omit<B, \"prototype\"> & {\n  value: S;\n  $shape: \"literal\";\n  deserialize<T extends Constructor>(this: T, value: S): InstanceType<T>;\n  $serialize(value: S): S;\n  $deserialize(value: S): S;\n  $inline: S;\n} & (abstract new (\n    value: Expand<S>,\n  ) => InstanceType<B> & {\n    readonly value: S;\n    serialize(): S;\n  });\n"],"mappings":";;;AAIA,MAAa,WAIX,IACA,OAAU,UACS;CAGnB,MAAe,iBAAkB,KAAgC;EAC/D,AAAgB,QAAQ;EACxB,OAAO,QAAQ;EACf,OAAO,SAAS;EAChB,YAAe;AACb,UAAO;;EAGT,OAAO,YAEL,OACiB;AACjB,UAAO,IAAK,MAAc;;EAG5B,OAAO,WAAW,OAAuB;AACvC,UAAO;;EAGT,OAAO,aAAa,OAAuB;AACzC,UAAO;;EAGT,OAAO;;AAGT,QAAO"}

package/dist/mapping.d.ts

@@ -0,0 +1,34 @@
+import { AbstractConstructor, Constructor, Definition, DefinitionOf, Empty, Expand, Shorthand } from "./_.js";
+
+//#region src/mapping.d.ts
+type MappingLiteralKey = [[StringConstructor, string], [NumberConstructor, number]];
+type MappingKeyConstructor = MappingLiteralKey[number][0];
+type MappingKeyRuntimeFromConstructor<S extends MappingKeyConstructor> = S extends StringConstructor ? string : number;
+type MappingConfiguration = [MappingKeyConstructor, Definition | Shorthand] | [Definition | Shorthand];
+type MappingOf<C extends MappingConfiguration> = C extends [infer K extends MappingKeyConstructor, infer V extends Definition | Shorthand] ? {
+  key: K;
+  value: DefinitionOf<V>;
+} : C extends [infer V extends Definition | Shorthand] ? {
+  key: StringConstructor;
+  value: DefinitionOf<V>;
+} : never;
+type Internal<C extends MappingConfiguration, B extends AbstractConstructor<{}>> = {
+  Definition: MappingOf<C>["value"];
+  Serialized: Record<MappingKeyRuntimeFromConstructor<MappingOf<C>["key"]>, ReturnType<MappingOf<C>["value"]["$serialize"]>>;
+  Deserializing: Record<MappingKeyRuntimeFromConstructor<MappingOf<C>["key"]>, Parameters<MappingOf<C>["value"]["$deserialize"]>[0]>;
+  Inline: Record<MappingKeyRuntimeFromConstructor<MappingOf<C>["key"]>, MappingOf<C>["value"]["$inline"]>;
+};
+declare const Mapping: <C extends MappingConfiguration, B extends AbstractConstructor<{}> = typeof Empty>(config: C, base?: B) => Mapping<C, B>;
+type Mapping<C extends MappingConfiguration, B extends AbstractConstructor<{}> = typeof Empty> = Omit<B, "prototype"> & (abstract new (value: Internal<C, B>["Inline"]) => InstanceType<B> & {
+  value: Internal<C, B>["Inline"];
+  serialize(): Expand<Internal<C, B>["Serialized"]>;
+}) & {
+  $shape: "mapping";
+  deserialize<T extends Constructor>(this: T, value: Expand<Internal<C, B>["Serialized"]>): InstanceType<T>;
+  $deserialize<T>(this: T, value: Internal<C, B>["Deserializing"]): Internal<C, B>["Inline"];
+  $serialize<T>(this: T, value: Internal<C, B>["Inline"]): Internal<C, B>["Serialized"];
+  $inline: Internal<C, B>["Inline"];
+};
+//#endregion
+export { Mapping, MappingConfiguration };
+//# sourceMappingURL=mapping.d.ts.map

package/dist/mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","names":[],"sources":["../src/mapping.ts"],"mappings":";;;KAYK,iBAAA,KACF,iBAAA,YACA,iBAAA;AAAA,KAEE,qBAAA,GAAwB,iBAAA;AAAA,KACxB,gCAAA,WAA2C,qBAAA,IAC9C,CAAA,SAAU,iBAAA;AAAA,KAEA,oBAAA,IACP,qBAAA,EAAuB,UAAA,GAAa,SAAA,KACpC,UAAA,GAAa,SAAA;AAAA,KAEb,SAAA,WAAoB,oBAAA,IAAwB,CAAA,0BAC/B,qBAAA,kBACA,UAAA,GAAa,SAAA;EAEzB,GAAA,EAAK,CAAA;EAAG,KAAA,EAAO,YAAA,CAAa,CAAA;AAAA,IAC9B,CAAA,0BAA2B,UAAA,GAAa,SAAA;EACpC,GAAA,EAAK,iBAAA;EAAmB,KAAA,EAAO,YAAA,CAAa,CAAA;AAAA;AAAA,KAG/C,QAAA,WACO,oBAAA,YACA,mBAAA;EAEV,UAAA,EAAY,SAAA,CAAU,CAAA;EACtB,UAAA,EAAY,MAAA,CACV,gCAAA,CAAiC,SAAA,CAAU,CAAA,WAC3C,UAAA,CAAW,SAAA,CAAU,CAAA;EAEvB,aAAA,EAAe,MAAA,CACb,gCAAA,CAAiC,SAAA,CAAU,CAAA,WAC3C,UAAA,CAAW,SAAA,CAAU,CAAA;EAEvB,MAAA,EAAQ,MAAA,CACN,gCAAA,CAAiC,SAAA,CAAU,CAAA,WAC3C,SAAA,CAAU,CAAA;AAAA;AAAA,cAID,OAAA,aACD,oBAAA,YACA,mBAAA,cAAuB,KAAA,EAAA,MAAA,EAEzB,CAAA,EAAC,IAAA,GACH,CAAA,KACL,OAAA,CAAQ,CAAA,EAAG,CAAA;AAAA,KAiFF,OAAA,WACA,oBAAA,YACA,mBAAA,cAAiC,KAAA,IACzC,IAAA,CAAK,CAAA,gCAEL,KAAA,EAAO,QAAA,CAAS,CAAA,EAAG,CAAA,gBAChB,YAAA,CAAa,CAAA;EAChB,KAAA,EAAO,QAAA,CAAS,CAAA,EAAG,CAAA;EACnB,SAAA,IAAa,MAAA,CAAO,QAAA,CAAS,CAAA,EAAG,CAAA;AAAA;EAEhC,MAAA;EACA,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,IACE,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,QAAA,CAAS,CAAA,EAAG,CAAA,cAClB,QAAA,CAAS,CAAA,EAAG,CAAA;EACf,OAAA,EAAS,QAAA,CAAS,CAAA,EAAG,CAAA;AAAA"}

package/dist/mapping.js

@@ -0,0 +1,46 @@
+import { Primitive } from "./primitive.js";
+import { Empty, Shape } from "./_.js";
+
+//#region src/mapping.ts
+const Mapping = (config, base = Empty) => {
+	let [_key, _value] = config;
+	if (config.length === 1) {
+		_key = Primitive(String);
+		_value = config[0];
+	}
+	const { $key, $value } = {
+		$key: _key,
+		$value: _value
+	};
+	class $Mapping extends base {
+		constructor(value) {
+			super();
+			this.value = value;
+		}
+		static $shape = "mapping";
+		serialize() {
+			return $Mapping.$serialize(this.value);
+		}
+		static deserialize(value) {
+			return new this($Mapping.$deserialize(value));
+		}
+		static $deserialize(value) {
+			const transform = Object.entries(value).map(([key, child]) => {
+				return [key, Shape(_value).$deserialize(child)];
+			});
+			return Object.fromEntries(transform);
+		}
+		static $serialize(value) {
+			const transform = Object.entries(value).map(([key, child]) => {
+				return [key, Shape($value).$serialize(child)];
+			});
+			return Object.fromEntries(transform);
+		}
+		static $inline;
+	}
+	return $Mapping;
+};
+
+//#endregion
+export { Mapping };
+//# sourceMappingURL=mapping.js.map

package/dist/mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.js","names":[],"sources":["../src/mapping.ts"],"sourcesContent":["import {\n  Definition,\n  Expand,\n  Shorthand,\n  DefinitionOf,\n  Shape,\n  AbstractConstructor,\n  Empty,\n  Constructor,\n} from \"./_\";\nimport { Primitive } from \"./primitive\";\n\ntype MappingLiteralKey = [\n  [StringConstructor, string],\n  [NumberConstructor, number],\n];\ntype MappingKeyConstructor = MappingLiteralKey[number][0];\ntype MappingKeyRuntimeFromConstructor<S extends MappingKeyConstructor> =\n  S extends StringConstructor ? string : number;\n\nexport type MappingConfiguration =\n  | [MappingKeyConstructor, Definition | Shorthand]\n  | [Definition | Shorthand];\n\ntype MappingOf<C extends MappingConfiguration> = C extends [\n  infer K extends MappingKeyConstructor,\n  infer V extends Definition | Shorthand,\n]\n  ? { key: K; value: DefinitionOf<V> }\n  : C extends [infer V extends Definition | Shorthand]\n    ? { key: StringConstructor; value: DefinitionOf<V> }\n    : never;\n\ntype Internal<\n  C extends MappingConfiguration,\n  B extends AbstractConstructor<{}>,\n> = {\n  Definition: MappingOf<C>[\"value\"];\n  Serialized: Record<\n    MappingKeyRuntimeFromConstructor<MappingOf<C>[\"key\"]>,\n    ReturnType<MappingOf<C>[\"value\"][\"$serialize\"]>\n  >;\n  Deserializing: Record<\n    MappingKeyRuntimeFromConstructor<MappingOf<C>[\"key\"]>,\n    Parameters<MappingOf<C>[\"value\"][\"$deserialize\"]>[0]\n  >;\n  Inline: Record<\n    MappingKeyRuntimeFromConstructor<MappingOf<C>[\"key\"]>,\n    MappingOf<C>[\"value\"][\"$inline\"]\n  >;\n};\n\nexport const Mapping = <\n  C extends MappingConfiguration,\n  B extends AbstractConstructor<{}> = typeof Empty,\n>(\n  config: C,\n  base: B = Empty as any,\n): Mapping<C, B> => {\n  let [_key, _value] = config;\n  if (config.length === 1) {\n    _key = Primitive(String);\n    _value = config[0];\n  }\n\n  const { $key, $value } = { $key: _key, $value: _value };\n\n  type Definition = MappingOf<C>[\"value\"];\n  type K = MappingOf<C>[\"key\"];\n  type Key = MappingKeyRuntimeFromConstructor<K>;\n  type Serialized = Record<Key, ReturnType<Definition[\"$serialize\"]>>;\n  type Inline = Record<Key, Definition[\"$inline\"]>;\n\n  type A = {\n    Inline: Inline;\n    Serialized: Serialized;\n    Definition: Definition;\n    Deserializing: Serialized;\n  };\n\n  abstract class $Mapping extends (base as any as Constructor<{}>) {\n    constructor(public value: Inline) {\n      super();\n    }\n\n    static $shape = \"mapping\" as const;\n\n    serialize(): Expand<Serialized> {\n      return $Mapping.$serialize(this.value) as any;\n    }\n\n    static deserialize<T extends typeof $Mapping>(\n      this: T,\n      value: Expand<Serialized>,\n    ): InstanceType<T> {\n      return new (this as any)(($Mapping as any).$deserialize(value)) as any;\n    }\n\n    static $deserialize<T extends typeof $Mapping>(\n      this: T,\n      value: Serialized,\n    ): Inline {\n      const split = Object.entries(value);\n      const transform = split.map(([key, child]) => {\n        const longhand = Shape(_value) as any;\n        const deserialized = longhand.$deserialize(child as any);\n        return [key, deserialized] as const;\n      });\n      return Object.fromEntries(transform) as any;\n    }\n\n    static $serialize<T extends typeof $Mapping>(\n      this: T,\n      value: Inline,\n    ): Serialized {\n      const split = Object.entries(value);\n      const transform = split.map(([key, child]) => {\n        const longhand = Shape($value) as any;\n        const serialized = longhand.$serialize(child as any);\n        return [key, serialized];\n      });\n      const merge = Object.fromEntries(transform);\n      return merge;\n    }\n\n    static $inline: Inline;\n  }\n\n  type MappingConstructor = abstract new (\n    value: Expand<Inline>,\n  ) => InstanceType<B> & $Mapping;\n\n  type Mapping = Omit<B, \"prototype\"> &\n    Omit<typeof $Mapping, \"prototype\"> &\n    MappingConstructor;\n\n  return $Mapping as any;\n};\n\nexport type Mapping<\n  C extends MappingConfiguration,\n  B extends AbstractConstructor<{}> = typeof Empty,\n> = Omit<B, \"prototype\"> &\n  (abstract new (\n    value: Internal<C, B>[\"Inline\"],\n  ) => InstanceType<B> & {\n    value: Internal<C, B>[\"Inline\"];\n    serialize(): Expand<Internal<C, B>[\"Serialized\"]>;\n  }) & {\n    $shape: \"mapping\";\n    deserialize<T extends Constructor>(\n      this: T,\n      value: Expand<Internal<C, B>[\"Serialized\"]>,\n    ): InstanceType<T>;\n    $deserialize<T>(\n      this: T,\n      value: Internal<C, B>[\"Deserializing\"],\n    ): Internal<C, B>[\"Inline\"];\n    $serialize<T>(\n      this: T,\n      value: Internal<C, B>[\"Inline\"],\n    ): Internal<C, B>[\"Serialized\"];\n    $inline: Internal<C, B>[\"Inline\"];\n  };\n"],"mappings":";;;;AAoDA,MAAa,WAIX,QACA,OAAU,UACQ;CAClB,IAAI,CAAC,MAAM,UAAU;AACrB,KAAI,OAAO,WAAW,GAAG;AACvB,SAAO,UAAU,OAAO;AACxB,WAAS,OAAO;;CAGlB,MAAM,EAAE,MAAM,WAAW;EAAE,MAAM;EAAM,QAAQ;EAAQ;CAevD,MAAe,iBAAkB,KAAgC;EAC/D,YAAY,AAAO,OAAe;AAChC,UAAO;GADU;;EAInB,OAAO,SAAS;EAEhB,YAAgC;AAC9B,UAAO,SAAS,WAAW,KAAK,MAAM;;EAGxC,OAAO,YAEL,OACiB;AACjB,UAAO,IAAK,KAAc,SAAiB,aAAa,MAAM,CAAC;;EAGjE,OAAO,aAEL,OACQ;GAER,MAAM,YADQ,OAAO,QAAQ,MAAM,CACX,KAAK,CAAC,KAAK,WAAW;AAG5C,WAAO,CAAC,KAFS,MAAM,OAAO,CACA,aAAa,MAAa,CAC9B;KAC1B;AACF,UAAO,OAAO,YAAY,UAAU;;EAGtC,OAAO,WAEL,OACY;GAEZ,MAAM,YADQ,OAAO,QAAQ,MAAM,CACX,KAAK,CAAC,KAAK,WAAW;AAG5C,WAAO,CAAC,KAFS,MAAM,OAAO,CACF,WAAW,MAAa,CAC5B;KACxB;AAEF,UADc,OAAO,YAAY,UAAU;;EAI7C,OAAO;;AAWT,QAAO"}

package/dist/multiple.d.ts

@@ -0,0 +1,23 @@
+import { AbstractConstructor, Constructor, Definition, DefinitionOf, Empty, Expand, Shorthand } from "./_.js";
+
+//#region src/multiple.d.ts
+type MultipleConfiguration = Definition | Shorthand;
+type MultipleShorthand = [any] | readonly [any];
+type Internal<S extends MultipleConfiguration> = {
+  Serialized: ReturnType<DefinitionOf<S>["$serialize"]>[];
+  Inline: DefinitionOf<S>["$inline"][];
+};
+declare const Multiple: <const S extends MultipleConfiguration, B extends AbstractConstructor<{}> = typeof Empty>(of: S, base?: B) => IMultiple<S, B>;
+type IMultiple<S extends MultipleConfiguration, B extends AbstractConstructor<{}> = typeof Empty> = Omit<B, "prototype"> & (abstract new (value: Internal<S>["Inline"]) => InstanceType<B> & Pick<Internal<S>["Inline"], "at" | "length" | "concat" | "copyWithin" | "entries" | "every" | "fill" | "filter" | "find" | "findIndex" | "flat" | "flatMap" | "forEach" | "includes" | "indexOf" | "join" | "keys" | "lastIndexOf" | "map" | "pop" | "push" | "reduce" | "reduceRight" | "reverse" | "shift" | "slice" | "some" | "sort" | "splice" | "unshift" | "values" | typeof Symbol.iterator> & {
+  value: Internal<S>["Inline"];
+  serialize(): Expand<Internal<S>["Serialized"]>;
+}) & {
+  $shape: "multiple";
+  deserialize<T extends Constructor>(this: T, value: Expand<Internal<S>["Serialized"]>): InstanceType<T>;
+  $deserialize<T extends Constructor>(this: T, value: Internal<S>["Serialized"]): InstanceType<T>;
+  $serialize(value: Internal<S>["Inline"]): Internal<S>["Serialized"];
+  $inline: Internal<S>["Inline"];
+};
+//#endregion
+export { IMultiple, Multiple, MultipleConfiguration, MultipleShorthand };
+//# sourceMappingURL=multiple.d.ts.map

package/dist/multiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiple.d.ts","names":[],"sources":["../src/multiple.ts"],"mappings":";;;KAWY,qBAAA,GAAwB,UAAA,GAAa,SAAA;AAAA,KACrC,iBAAA;AAAA,KAEP,QAAA,WAAmB,qBAAA;EACtB,UAAA,EAAY,UAAA,CAAW,YAAA,CAAa,CAAA;EACpC,MAAA,EAAQ,YAAA,CAAa,CAAA;AAAA;AAAA,cAGV,QAAA,mBACK,qBAAA,YACN,mBAAA,cAAuB,KAAA,EAAA,EAAA,EAE7B,CAAA,EAAC,IAAA,GACC,CAAA,KACL,SAAA,CAAU,CAAA,EAAG,CAAA;AAAA,KAqJJ,SAAA,WACA,qBAAA,YACA,mBAAA,cAAiC,KAAA,IACzC,IAAA,CAAK,CAAA,gCAEL,KAAA,EAAO,QAAA,CAAS,CAAA,gBACb,YAAA,CAAa,CAAA,IAChB,IAAA,CACE,QAAA,CAAS,CAAA,qWAgCA,MAAA,CAAO,QAAA;EAEhB,KAAA,EAAO,QAAA,CAAS,CAAA;EAChB,SAAA,IAAa,MAAA,CAAO,QAAA,CAAS,CAAA;AAAA;EAE/B,MAAA;EACA,WAAA,WAAsB,WAAA,EACpB,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,MAAA,CAAO,QAAA,CAAS,CAAA,mBACtB,YAAA,CAAa,CAAA;EAChB,YAAA,WAAuB,WAAA,EACrB,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,QAAA,CAAS,CAAA,kBACf,YAAA,CAAa,CAAA;EAChB,UAAA,CAAW,KAAA,EAAO,QAAA,CAAS,CAAA,cAAe,QAAA,CAAS,CAAA;EACnD,OAAA,EAAS,QAAA,CAAS,CAAA;AAAA"}

package/dist/multiple.js

@@ -0,0 +1,120 @@
+import { Empty, Shape } from "./_.js";
+
+//#region src/multiple.ts
+const Multiple = (of, base = Empty) => {
+	const longhand = Shape(of);
+	class $Multiple extends base {
+		constructor(value) {
+			super();
+			this.value = value;
+		}
+		static $shape = "multiple";
+		serialize() {
+			return $Multiple.$serialize(this.value);
+		}
+		static deserialize(value) {
+			return new this($Multiple.$deserialize(value));
+		}
+		static $deserialize(value) {
+			return value.map(longhand.$deserialize);
+		}
+		static $serialize(value) {
+			return value.map(longhand.$serialize);
+		}
+		[Symbol.iterator]() {
+			return this.value[Symbol.iterator]();
+		}
+		get map() {
+			return this.value.map.bind(this.value);
+		}
+		get reduce() {
+			return this.value.reduce.bind(this.value);
+		}
+		get filter() {
+			return this.value.filter.bind(this.value);
+		}
+		get forEach() {
+			return this.value.forEach.bind(this.value);
+		}
+		get some() {
+			return this.value.some.bind(this.value);
+		}
+		get every() {
+			return this.value.every.bind(this.value);
+		}
+		get find() {
+			return this.value.find.bind(this.value);
+		}
+		get findIndex() {
+			return this.value.findIndex.bind(this.value);
+		}
+		get indexOf() {
+			return this.value.indexOf.bind(this.value);
+		}
+		get lastIndexOf() {
+			return this.value.lastIndexOf.bind(this.value);
+		}
+		get includes() {
+			return this.value.includes.bind(this.value);
+		}
+		get keys() {
+			return this.value.keys.bind(this.value);
+		}
+		get values() {
+			return this.value.values.bind(this.value);
+		}
+		get entries() {
+			return this.value.entries.bind(this.value);
+		}
+		get at() {
+			return this.value.at.bind(this.value);
+		}
+		get concat() {
+			return this.value.concat.bind(this.value);
+		}
+		get flat() {
+			return this.value.flat.bind(this.value);
+		}
+		get splice() {
+			return this.value.splice.bind(this.value);
+		}
+		get flatMap() {
+			return this.value.flatMap.bind(this.value);
+		}
+		get push() {
+			return this.value.push.bind(this.value);
+		}
+		get pop() {
+			return this.value.pop.bind(this.value);
+		}
+		get sort() {
+			return this.value.sort.bind(this.value);
+		}
+		get slice() {
+			return this.value.slice.bind(this.value);
+		}
+		get length() {
+			return this.value.length;
+		}
+		get fill() {
+			return this.value.fill.bind(this.value);
+		}
+		get copyWithin() {
+			return this.value.copyWithin.bind(this.value);
+		}
+		get reverse() {
+			return this.value.reverse.bind(this.value);
+		}
+		get shift() {
+			return this.value.shift.bind(this.value);
+		}
+		get unshift() {
+			return this.value.unshift.bind(this.value);
+		}
+	}
+	return $Multiple;
+};
+
+//#endregion
+export { Multiple };
+//# sourceMappingURL=multiple.js.map

package/dist/multiple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiple.js","names":[],"sources":["../src/multiple.ts"],"sourcesContent":["import {\n  Definition,\n  Expand,\n  Shorthand,\n  DefinitionOf,\n  Shape,\n  AbstractConstructor,\n  Empty,\n  Constructor,\n} from \"./_\";\n\nexport type MultipleConfiguration = Definition | Shorthand;\nexport type MultipleShorthand = [any] | readonly [any];\n\ntype Internal<S extends MultipleConfiguration> = {\n  Serialized: ReturnType<DefinitionOf<S>[\"$serialize\"]>[];\n  Inline: DefinitionOf<S>[\"$inline\"][];\n};\n\nexport const Multiple = <\n  const S extends MultipleConfiguration,\n  B extends AbstractConstructor<{}> = typeof Empty,\n>(\n  of: S,\n  base: B = Empty as any,\n): IMultiple<S, B> => {\n  const longhand = Shape(of);\n\n  abstract class $Multiple extends (base as any as Constructor<{}>) {\n    constructor(public value: any[]) {\n      super();\n    }\n    static $shape = \"multiple\" as const;\n\n    serialize() {\n      return $Multiple.$serialize(this.value);\n    }\n\n    static deserialize(value: any) {\n      return new (this as any)(($Multiple as any).$deserialize(value));\n    }\n\n    static $deserialize(value: any) {\n      return (value as any).map(longhand.$deserialize);\n    }\n\n    static $serialize(value: any) {\n      return (value as any).map(longhand.$serialize as any);\n    }\n\n    [Symbol.iterator]() {\n      return this.value[Symbol.iterator]();\n    }\n\n    get map() {\n      return this.value.map.bind(this.value);\n    }\n\n    get reduce() {\n      return this.value.reduce.bind(this.value);\n    }\n\n    get filter() {\n      return this.value.filter.bind(this.value);\n    }\n\n    get forEach() {\n      return this.value.forEach.bind(this.value);\n    }\n\n    get some() {\n      return this.value.some.bind(this.value);\n    }\n\n    get every() {\n      return this.value.every.bind(this.value);\n    }\n\n    get find() {\n      return this.value.find.bind(this.value);\n    }\n\n    get findIndex() {\n      return this.value.findIndex.bind(this.value);\n    }\n\n    get indexOf() {\n      return this.value.indexOf.bind(this.value);\n    }\n\n    get lastIndexOf() {\n      return this.value.lastIndexOf.bind(this.value);\n    }\n\n    get includes() {\n      return this.value.includes.bind(this.value);\n    }\n\n    get keys() {\n      return this.value.keys.bind(this.value);\n    }\n\n    get values() {\n      return this.value.values.bind(this.value);\n    }\n\n    get entries() {\n      return this.value.entries.bind(this.value);\n    }\n\n    get at() {\n      return this.value.at.bind(this.value);\n    }\n\n    get concat() {\n      return this.value.concat.bind(this.value);\n    }\n\n    get flat() {\n      return this.value.flat.bind(this.value);\n    }\n\n    get splice() {\n      return this.value.splice.bind(this.value);\n    }\n\n    get flatMap() {\n      return this.value.flatMap.bind(this.value);\n    }\n\n    get push() {\n      return this.value.push.bind(this.value);\n    }\n\n    get pop() {\n      return this.value.pop.bind(this.value);\n    }\n\n    get sort() {\n      return this.value.sort.bind(this.value);\n    }\n\n    get slice() {\n      return this.value.slice.bind(this.value);\n    }\n\n    get length() {\n      return this.value.length;\n    }\n\n    get fill() {\n      return this.value.fill.bind(this.value);\n    }\n\n    get copyWithin() {\n      return this.value.copyWithin.bind(this.value);\n    }\n\n    get reverse() {\n      return this.value.reverse.bind(this.value);\n    }\n\n    get shift() {\n      return this.value.shift.bind(this.value);\n    }\n\n    get unshift() {\n      return this.value.unshift.bind(this.value);\n    }\n  }\n\n  return $Multiple as any;\n};\n\nexport type IMultiple<\n  S extends MultipleConfiguration,\n  B extends AbstractConstructor<{}> = typeof Empty,\n> = Omit<B, \"prototype\"> &\n  (abstract new (\n    value: Internal<S>[\"Inline\"],\n  ) => InstanceType<B> &\n    Pick<\n      Internal<S>[\"Inline\"],\n      | \"at\"\n      | \"length\"\n      | \"concat\"\n      | \"copyWithin\"\n      | \"entries\"\n      | \"every\"\n      | \"fill\"\n      | \"filter\"\n      | \"find\"\n      | \"findIndex\"\n      | \"flat\"\n      | \"flatMap\"\n      | \"forEach\"\n      | \"includes\"\n      | \"indexOf\"\n      | \"join\"\n      | \"keys\"\n      | \"lastIndexOf\"\n      | \"map\"\n      | \"pop\"\n      | \"push\"\n      | \"reduce\"\n      | \"reduceRight\"\n      | \"reverse\"\n      | \"shift\"\n      | \"slice\"\n      | \"some\"\n      | \"sort\"\n      | \"splice\"\n      | \"unshift\"\n      | \"values\"\n      | typeof Symbol.iterator\n    > & {\n      value: Internal<S>[\"Inline\"];\n      serialize(): Expand<Internal<S>[\"Serialized\"]>;\n    }) & {\n    $shape: \"multiple\";\n    deserialize<T extends Constructor>(\n      this: T,\n      value: Expand<Internal<S>[\"Serialized\"]>,\n    ): InstanceType<T>;\n    $deserialize<T extends Constructor>(\n      this: T,\n      value: Internal<S>[\"Serialized\"],\n    ): InstanceType<T>;\n    $serialize(value: Internal<S>[\"Inline\"]): Internal<S>[\"Serialized\"];\n    $inline: Internal<S>[\"Inline\"];\n  };\n"],"mappings":"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"}

package/dist/nothing.d.ts

@@ -0,0 +1,18 @@
+import { AbstractConstructor, Constructor, Empty } from "./_.js";
+
+//#region src/nothing.d.ts
+type NothingShorthand = undefined;
+declare const Nothing: <B extends AbstractConstructor<{}> = typeof Empty>(config: void, base?: B) => Omit<B, "prototype"> & Omit<(abstract new (...args: any[]) => {
+  serialize(): void;
+}) & {
+  $shape: "nothing";
+  deserialize<T extends Constructor>(this: T, value: void): InstanceType<T>;
+  $deserialize(): void;
+  $serialize(): void;
+  $inline: void;
+}, ""> & (abstract new (value: void) => InstanceType<B> & {
+  serialize(): void;
+});
+//#endregion
+export { Nothing, NothingShorthand };
+//# sourceMappingURL=nothing.d.ts.map

package/dist/nothing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nothing.d.ts","names":[],"sources":["../src/nothing.ts"],"mappings":";;;KAEY,gBAAA;AAAA,cAEC,OAAA,aAAqB,mBAAA,cAAuB,KAAA,EAAA,MAAA,QAC3C,IAAA,GACN,CAAA,KAAC,IAAA,CAAA,CAAA,iBAAA,IAAA,mBAAA,IAAA;;;;wBAMwB,WAAA,EAAW,IAAA,EAChC,CAAA,EAAC,KAAA,SAEN,YAAA,CAAa,CAAA;;;;wCAUb,YAAA,CAAa,CAAA"}

package/dist/nothing.js

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

package/dist/nothing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nothing.js","names":[],"sources":["../src/nothing.ts"],"sourcesContent":["import { AbstractConstructor, Constructor, Definition, Empty } from \"./_\";\n\nexport type NothingShorthand = undefined;\n\nexport const Nothing = <B extends AbstractConstructor<{}> = typeof Empty>(\n  config: void,\n  base: B = Empty as any,\n) => {\n  abstract class $Nothing extends (base as any as Constructor<{}>) {\n    static $shape = \"nothing\" as const;\n\n    serialize() {}\n    static deserialize<T extends Constructor>(\n      this: T,\n      value: void,\n    ): InstanceType<T> {\n      return new (this as any)();\n    }\n    static $deserialize() {}\n    static $serialize() {}\n    static $inline: void;\n  }\n\n  type NothingConstructor = abstract new (\n    value: void,\n  ) => InstanceType<B> & $Nothing;\n\n  type Nothing = Omit<B, \"prototype\"> &\n    Omit<typeof $Nothing, \"\"> &\n    NothingConstructor;\n\n  return $Nothing as Nothing;\n};\n"],"mappings":";;;AAIA,MAAa,WACX,QACA,OAAU,UACP;CACH,MAAe,iBAAkB,KAAgC;EAC/D,OAAO,SAAS;EAEhB,YAAY;EACZ,OAAO,YAEL,OACiB;AACjB,UAAO,IAAK,MAAc;;EAE5B,OAAO,eAAe;EACtB,OAAO,aAAa;EACpB,OAAO;;AAWT,QAAO"}

package/dist/optional.d.ts

@@ -0,0 +1,29 @@
+import { AbstractConstructor, Constructor, Definition, DefinitionOf, Empty, Expand, Shorthand } from "./_.js";
+
+//#region src/optional.d.ts
+type OptionalConfiguration = Definition | Shorthand;
+type Matcher<V> = {
+  some: (value: V) => any;
+  none: () => any;
+};
+type Internal<S extends Definition | Shorthand> = {
+  Serialized: ReturnType<DefinitionOf<S>["$serialize"]> | undefined;
+  Deserializing: Parameters<DefinitionOf<S>["$deserialize"]>[0] | undefined;
+  Inline: Expand<DefinitionOf<S>["$inline"]> | undefined;
+  Required: Expand<DefinitionOf<S>["$inline"]>;
+};
+declare const Optional: <S extends Definition | Shorthand, B extends AbstractConstructor<{}> = typeof Empty>(of: S, base?: B) => IOptional<S, B>;
+type IOptional<S extends Definition | Shorthand, B extends AbstractConstructor<{}> = typeof Object> = Omit<B, "prototype"> & {
+  $shape: "optional";
+  deserialize<T extends Constructor>(this: T, value: Internal<S>["Deserializing"]): InstanceType<T>;
+  $deserialize(value: Internal<S>["Deserializing"]): Definition["$inline"];
+  $serialize<T>(this: T, value: Internal<S>["Inline"]): Internal<S>["Serialized"];
+  $inline: Internal<S>["Inline"];
+} & (abstract new (value: Internal<S>["Inline"]) => InstanceType<B> & {
+  value: Internal<S>["Inline"];
+  serialize(): Expand<Internal<S>["Serialized"]>;
+  match<M extends Matcher<Expand<Internal<S>["Required"]>>>(config: M): ReturnType<M["some"]> | ReturnType<M["none"]>;
+});
+//#endregion
+export { IOptional, Optional, OptionalConfiguration };
+//# sourceMappingURL=optional.d.ts.map

package/dist/optional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional.d.ts","names":[],"sources":["../src/optional.ts"],"mappings":";;;KAWY,qBAAA,GAAwB,UAAA,GAAa,SAAA;AAAA,KAE5C,OAAA;EAAe,IAAA,GAAO,KAAA,EAAO,CAAA;EAAW,IAAA;AAAA;AAAA,KAExC,QAAA,WAAmB,UAAA,GAAa,SAAA;EACnC,UAAA,EAAY,UAAA,CAAW,YAAA,CAAa,CAAA;EACpC,aAAA,EAAe,UAAA,CAAW,YAAA,CAAa,CAAA;EACvC,MAAA,EAAQ,MAAA,CAAO,YAAA,CAAa,CAAA;EAC5B,QAAA,EAAU,MAAA,CAAO,YAAA,CAAa,CAAA;AAAA;AAAA,cAGnB,QAAA,aACD,UAAA,GAAa,SAAA,YACb,mBAAA,cAAuB,KAAA,EAAA,EAAA,EAE7B,CAAA,EAAC,IAAA,GACC,CAAA,KACL,SAAA,CAAU,CAAA,EAAG,CAAA;AAAA,KA6CJ,SAAA,WACA,UAAA,GAAa,SAAA,YACb,mBAAA,cAAiC,MAAA,IACzC,IAAA,CAAK,CAAA;EACP,MAAA;EACA,WAAA,WAAsB,WAAA,EACpB,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,QAAA,CAAS,CAAA,qBACf,YAAA,CAAa,CAAA;EAChB,YAAA,CAAa,KAAA,EAAO,QAAA,CAAS,CAAA,qBAAsB,UAAA;EACnD,UAAA,IACE,IAAA,EAAM,CAAA,EACN,KAAA,EAAO,QAAA,CAAS,CAAA,cACf,QAAA,CAAS,CAAA;EACZ,OAAA,EAAS,QAAA,CAAS,CAAA;AAAA,mBAEhB,KAAA,EAAO,QAAA,CAAS,CAAA,gBACb,YAAA,CAAa,CAAA;EAChB,KAAA,EAAO,QAAA,CAAS,CAAA;EAChB,SAAA,IAAa,MAAA,CAAO,QAAA,CAAS,CAAA;EAC7B,KAAA,WAAgB,OAAA,CAAQ,MAAA,CAAO,QAAA,CAAS,CAAA,iBACtC,MAAA,EAAQ,CAAA,GACP,UAAA,CAAW,CAAA,YAAa,UAAA,CAAW,CAAA;AAAA"}