@atproto/lex-schema 0.0.20 → 0.1.0-next.0

package/dist/schema/typed-object.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypedObjectSchema = void 0;
-exports.typedObject = typedObject;
-const lex_data_1 = require("@atproto/lex-data");
-const core_js_1 = require("../core.js");
-const lazy_property_js_1 = require("../util/lazy-property.js");
+import { isPlainObject } from '@atproto/lex-data';
+import { $type, $typed, Schema, } from '../core.js';
+import { lazyProperty } from '../util/lazy-property.js';
 /**
  * Schema for typed objects in Lexicon unions.
  *
@@ -23,17 +19,15 @@ const lazy_property_js_1 = require("../util/lazy-property.js");
  * )
  * ```
  */
-class TypedObjectSchema extends core_js_1.Schema {
-    $type;
-    schema;
-    type = 'typedObject';
+export class TypedObjectSchema extends Schema {
     constructor($type, schema) {
         super();
         this.$type = $type;
         this.schema = schema;
+        this.type = 'typedObject';
     }
     validateInContext(input, ctx) {
-        if (!(0, lex_data_1.isPlainObject)(input)) {
+        if (!isPlainObject(input)) {
             return ctx.issueUnexpectedType(input, 'object');
         }
         if ('$type' in input &&
@@ -44,7 +38,7 @@ class TypedObjectSchema extends core_js_1.Schema {
         return ctx.validate(input, this.schema);
     }
     build(input) {
-        return (0, core_js_1.$typed)(input, this.$type);
+        return $typed(input, this.$type);
     }
     isTypeOf(value) {
         return value.$type === undefined || value.$type === this.$type;
@@ -54,19 +48,18 @@ class TypedObjectSchema extends core_js_1.Schema {
      * @see {@link build}
      */
     get $build() {
-        return (0, lazy_property_js_1.lazyProperty)(this, '$build', this.build.bind(this));
+        return lazyProperty(this, '$build', this.build.bind(this));
     }
     /**
      * Bound alias for {@link isTypeOf} for compatibility with generated utilities.
      * @see {@link isTypeOf}
      */
     get $isTypeOf() {
-        return (0, lazy_property_js_1.lazyProperty)(this, '$isTypeOf', this.isTypeOf.bind(this));
+        return lazyProperty(this, '$isTypeOf', this.isTypeOf.bind(this));
     }
 }
-exports.TypedObjectSchema = TypedObjectSchema;
 /*@__NO_SIDE_EFFECTS__*/
-function typedObject(nsid, hash, validator) {
-    return new TypedObjectSchema((0, core_js_1.$type)(nsid, hash), validator);
+export function typedObject(nsid, hash, validator) {
+    return new TypedObjectSchema($type(nsid, hash), validator);
 }
 //# sourceMappingURL=typed-object.js.map

package/dist/schema/typed-object.js.map

@@ -1 +1 @@
-{"version":3,"file":"typed-object.js","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":";;;AA8KA,kCAMC;AApLD,gDAAyD;AACzD,wCAcmB;AACnB,+DAAuD;AASvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,iBAGX,SAAQ,gBAGT;IAIY;IACA;IAJF,IAAI,GAAG,aAAsB,CAAA;IAEtC,YACW,KAAY,EACZ,MAAc;QAEvB,KAAK,EAAE,CAAA;QAHE,UAAK,GAAL,KAAK,CAAO;QACZ,WAAM,GAAN,MAAM,CAAQ;IAGzB,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,IACE,OAAO,IAAI,KAAK;YAChB,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAC1B,CAAC;YACD,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACpE,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;IAQD,KAAK,CAAC,KAA8B;QAClC,OAAO,IAAA,gBAAM,EAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAA;IAClC,CAAC;IAED,QAAQ,CACN,KAAa;QAEb,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAA;IAChE,CAAC;IAED;;;OAGG;IACH,IAAI,MAAM;QACR,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAC5D,CAAC;IAED;;;OAGG;IACH,IAAI,SAAS;QACX,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAClE,CAAC;CACF;AA/DD,8CA+DC;AAmED,wBAAwB;AACxB,SAAgB,WAAW,CAIzB,IAAO,EAAE,IAAO,EAAE,SAAY;IAC9B,OAAO,IAAI,iBAAiB,CAAiB,IAAA,eAAK,EAAC,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,CAAA;AAC5E,CAAC","sourcesContent":["import { LexMap, isPlainObject } from '@atproto/lex-data'\nimport {\n  $Type,\n  $TypeOf,\n  $Typed,\n  $TypedMaybe,\n  $type,\n  $typed,\n  InferInput,\n  InferOutput,\n  NsidString,\n  Schema,\n  Unknown$TypedObject,\n  ValidationContext,\n  Validator,\n} from '../core.js'\nimport { lazyProperty } from '../util/lazy-property.js'\n\nexport type MaybeTypedObject<\n  TType extends $Type,\n  TValue extends { $type?: unknown } = { $type?: unknown },\n> = TValue extends { $type?: TType }\n  ? TValue\n  : $TypedMaybe<Exclude<TValue, Unknown$TypedObject>, TType>\n\n/**\n * Schema for typed objects in Lexicon unions.\n *\n * Typed objects have a `$type` field that identifies which variant they are\n * in a union. The `$type` can be omitted in input (it's implicit), but if\n * present, it must match the expected value.\n *\n * @template TType - The $type string literal type\n * @template TShape - The validator type for the object's shape\n *\n * @example\n * ```ts\n * const schema = new TypedObjectSchema(\n *   'app.bsky.embed.images#view',\n *   l.object({ images: l.array(imageSchema) })\n * )\n * ```\n */\nexport class TypedObjectSchema<\n  const TType extends $Type = $Type,\n  const TShape extends Validator<LexMap> = Validator<LexMap>,\n> extends Schema<\n  $TypedMaybe<InferInput<TShape>, TType>,\n  $TypedMaybe<InferOutput<TShape>, TType>\n> {\n  readonly type = 'typedObject' as const\n\n  constructor(\n    readonly $type: TType,\n    readonly schema: TShape,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    if (\n      '$type' in input &&\n      input.$type !== undefined &&\n      input.$type !== this.$type\n    ) {\n      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])\n    }\n\n    return ctx.validate(input, this.schema)\n  }\n\n  build(\n    input: Omit<InferOutput<TShape>, '$type'>,\n  ): $Typed<InferOutput<TShape>, TType>\n  build(\n    input: Omit<InferInput<TShape>, '$type'>,\n  ): $Typed<InferInput<TShape>, TType>\n  build(input: Record<string, unknown>) {\n    return $typed(input, this.$type)\n  }\n\n  isTypeOf<TValue extends Record<string, unknown>>(\n    value: TValue,\n  ): value is MaybeTypedObject<TType, TValue> {\n    return value.$type === undefined || value.$type === this.$type\n  }\n\n  /**\n   * Bound alias for {@link build} for compatibility with generated utilities.\n   * @see {@link build}\n   */\n  get $build(): typeof this.build {\n    return lazyProperty(this, '$build', this.build.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link isTypeOf} for compatibility with generated utilities.\n   * @see {@link isTypeOf}\n   */\n  get $isTypeOf(): typeof this.isTypeOf {\n    return lazyProperty(this, '$isTypeOf', this.isTypeOf.bind(this))\n  }\n}\n\n/**\n * Creates a typed object schema for use in Lexicon unions.\n *\n * Typed objects are identified by their `$type` field, which combines an NSID\n * and a hash (e.g., 'app.bsky.embed.images#view'). Used for union variants.\n *\n * This function offers two overloads:\n * - One that infers the type from arguments (no circular reference support)\n * - One with explicit interface for codegen with circular references\n *\n * @param nsid - The NSID part of the type (e.g., 'app.bsky.embed.images')\n * @param hash - The hash part of the type (e.g., 'view'), defaults to 'main'\n * @param validator - Schema for validating the object properties\n * @returns A new {@link TypedObjectSchema} instance\n *\n * @example\n * ```ts\n * // Image embed view\n * const imageViewSchema = l.typedObject(\n *   'app.bsky.embed.images',\n *   'view',\n *   l.object({\n *     images: l.array(l.object({\n *       thumb: l.string(),\n *       fullsize: l.string(),\n *       alt: l.string(),\n *     })),\n *   })\n * )\n *\n * // Main type (hash defaults to 'main')\n * const postViewSchema = l.typedObject(\n *   'app.bsky.feed.defs',\n *   'postView',\n *   l.object({ uri: l.string(), cid: l.string(), author: authorSchema })\n * )\n *\n * // Use $isTypeOf to narrow union types\n * if (imageViewSchema.$isTypeOf(embed)) {\n *   // embed is narrowed to image view type\n * }\n *\n * // Use $build to construct typed objects\n * const view = imageViewSchema.$build({ images: [...] })\n * // view.$type === 'app.bsky.embed.images#view'\n * ```\n */\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<LexMap>,\n>(nsid: N, hash: H, validator: S): TypedObjectSchema<$Type<N, H>, S>\nexport function typedObject<V extends { $type?: $Type }>(\n  nsid: V extends { $type?: infer T extends string }\n    ? T extends `${infer N}#${string}`\n      ? N\n      : T // (T is a \"main\" type, so already an NSID)\n    : never,\n  hash: V extends { $type?: infer T extends string }\n    ? T extends `${string}#${infer H}`\n      ? H\n      : 'main'\n    : never,\n  validator: Validator<Omit<V, '$type'>>,\n): TypedObjectSchema<$TypeOf<V>, Validator<V>>\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<LexMap>,\n>(nsid: N, hash: H, validator: S) {\n  return new TypedObjectSchema<$Type<N, H>, S>($type(nsid, hash), validator)\n}\n"]}
+{"version":3,"file":"typed-object.js","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACzD,OAAO,EAKL,KAAK,EACL,MAAM,EAIN,MAAM,GAIP,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AASvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,iBAGX,SAAQ,MAGT;IAGC,YACW,KAAY,EACZ,MAAc;QAEvB,KAAK,EAAE,CAAA;QAHE,UAAK,GAAL,KAAK,CAAO;QACZ,WAAM,GAAN,MAAM,CAAQ;QAJhB,SAAI,GAAG,aAAsB,CAAA;IAOtC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,IACE,OAAO,IAAI,KAAK;YAChB,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAC1B,CAAC;YACD,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACpE,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;IAQD,KAAK,CAAC,KAA8B;QAClC,OAAO,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAA;IAClC,CAAC;IAED,QAAQ,CACN,KAAa;QAEb,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAA;IAChE,CAAC;IAED;;;OAGG;IACH,IAAI,MAAM;QACR,OAAO,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAC5D,CAAC;IAED;;;OAGG;IACH,IAAI,SAAS;QACX,OAAO,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAClE,CAAC;CACF;AAmED,wBAAwB;AACxB,MAAM,UAAU,WAAW,CAIzB,IAAO,EAAE,IAAO,EAAE,SAAY;IAC9B,OAAO,IAAI,iBAAiB,CAAiB,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,CAAA;AAC5E,CAAC","sourcesContent":["import { LexMap, isPlainObject } from '@atproto/lex-data'\nimport {\n  $Type,\n  $TypeOf,\n  $Typed,\n  $TypedMaybe,\n  $type,\n  $typed,\n  InferInput,\n  InferOutput,\n  NsidString,\n  Schema,\n  Unknown$TypedObject,\n  ValidationContext,\n  Validator,\n} from '../core.js'\nimport { lazyProperty } from '../util/lazy-property.js'\n\nexport type MaybeTypedObject<\n  TType extends $Type,\n  TValue extends { $type?: unknown } = { $type?: unknown },\n> = TValue extends { $type?: TType }\n  ? TValue\n  : $TypedMaybe<Exclude<TValue, Unknown$TypedObject>, TType>\n\n/**\n * Schema for typed objects in Lexicon unions.\n *\n * Typed objects have a `$type` field that identifies which variant they are\n * in a union. The `$type` can be omitted in input (it's implicit), but if\n * present, it must match the expected value.\n *\n * @template TType - The $type string literal type\n * @template TShape - The validator type for the object's shape\n *\n * @example\n * ```ts\n * const schema = new TypedObjectSchema(\n *   'app.bsky.embed.images#view',\n *   l.object({ images: l.array(imageSchema) })\n * )\n * ```\n */\nexport class TypedObjectSchema<\n  const TType extends $Type = $Type,\n  const TShape extends Validator<LexMap> = Validator<LexMap>,\n> extends Schema<\n  $TypedMaybe<InferInput<TShape>, TType>,\n  $TypedMaybe<InferOutput<TShape>, TType>\n> {\n  readonly type = 'typedObject' as const\n\n  constructor(\n    readonly $type: TType,\n    readonly schema: TShape,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    if (\n      '$type' in input &&\n      input.$type !== undefined &&\n      input.$type !== this.$type\n    ) {\n      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])\n    }\n\n    return ctx.validate(input, this.schema)\n  }\n\n  build(\n    input: Omit<InferOutput<TShape>, '$type'>,\n  ): $Typed<InferOutput<TShape>, TType>\n  build(\n    input: Omit<InferInput<TShape>, '$type'>,\n  ): $Typed<InferInput<TShape>, TType>\n  build(input: Record<string, unknown>) {\n    return $typed(input, this.$type)\n  }\n\n  isTypeOf<TValue extends Record<string, unknown>>(\n    value: TValue,\n  ): value is MaybeTypedObject<TType, TValue> {\n    return value.$type === undefined || value.$type === this.$type\n  }\n\n  /**\n   * Bound alias for {@link build} for compatibility with generated utilities.\n   * @see {@link build}\n   */\n  get $build(): typeof this.build {\n    return lazyProperty(this, '$build', this.build.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link isTypeOf} for compatibility with generated utilities.\n   * @see {@link isTypeOf}\n   */\n  get $isTypeOf(): typeof this.isTypeOf {\n    return lazyProperty(this, '$isTypeOf', this.isTypeOf.bind(this))\n  }\n}\n\n/**\n * Creates a typed object schema for use in Lexicon unions.\n *\n * Typed objects are identified by their `$type` field, which combines an NSID\n * and a hash (e.g., 'app.bsky.embed.images#view'). Used for union variants.\n *\n * This function offers two overloads:\n * - One that infers the type from arguments (no circular reference support)\n * - One with explicit interface for codegen with circular references\n *\n * @param nsid - The NSID part of the type (e.g., 'app.bsky.embed.images')\n * @param hash - The hash part of the type (e.g., 'view'), defaults to 'main'\n * @param validator - Schema for validating the object properties\n * @returns A new {@link TypedObjectSchema} instance\n *\n * @example\n * ```ts\n * // Image embed view\n * const imageViewSchema = l.typedObject(\n *   'app.bsky.embed.images',\n *   'view',\n *   l.object({\n *     images: l.array(l.object({\n *       thumb: l.string(),\n *       fullsize: l.string(),\n *       alt: l.string(),\n *     })),\n *   })\n * )\n *\n * // Main type (hash defaults to 'main')\n * const postViewSchema = l.typedObject(\n *   'app.bsky.feed.defs',\n *   'postView',\n *   l.object({ uri: l.string(), cid: l.string(), author: authorSchema })\n * )\n *\n * // Use $isTypeOf to narrow union types\n * if (imageViewSchema.$isTypeOf(embed)) {\n *   // embed is narrowed to image view type\n * }\n *\n * // Use $build to construct typed objects\n * const view = imageViewSchema.$build({ images: [...] })\n * // view.$type === 'app.bsky.embed.images#view'\n * ```\n */\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<LexMap>,\n>(nsid: N, hash: H, validator: S): TypedObjectSchema<$Type<N, H>, S>\nexport function typedObject<V extends { $type?: $Type }>(\n  nsid: V extends { $type?: infer T extends string }\n    ? T extends `${infer N}#${string}`\n      ? N\n      : T // (T is a \"main\" type, so already an NSID)\n    : never,\n  hash: V extends { $type?: infer T extends string }\n    ? T extends `${string}#${infer H}`\n      ? H\n      : 'main'\n    : never,\n  validator: Validator<Omit<V, '$type'>>,\n): TypedObjectSchema<$TypeOf<V>, Validator<V>>\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<LexMap>,\n>(nsid: N, hash: H, validator: S) {\n  return new TypedObjectSchema<$Type<N, H>, S>($type(nsid, hash), validator)\n}\n"]}

package/dist/schema/typed-ref.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypedRefSchema = void 0;
-exports.typedRef = typedRef;
-const core_js_1 = require("../core.js");
+import { Schema, } from '../core.js';
 /**
  * Schema for referencing typed objects with lazy resolution.
  *
@@ -18,13 +14,13 @@ const core_js_1 = require("../core.js");
  * // ref.$type === 'app.bsky.embed.images#view'
  * ```
  */
-class TypedRefSchema extends core_js_1.Schema {
-    type = 'typedRef';
+export class TypedRefSchema extends Schema {
     #getter;
     constructor(getter) {
         // @NOTE In order to avoid circular dependency issues, we don't resolve
         // the schema here. Instead, we resolve it lazily when first accessed.
         super();
+        this.type = 'typedRef';
         this.#getter = getter;
     }
     get validator() {
@@ -43,8 +39,7 @@ class TypedRefSchema extends core_js_1.Schema {
         return result;
     }
 }
-exports.TypedRefSchema = TypedRefSchema;
-function typedRef(get) {
+export function typedRef(get) {
     return new TypedRefSchema(get);
 }
 //# sourceMappingURL=typed-ref.js.map

package/dist/schema/typed-ref.js.map

@@ -1 +1 @@
-{"version":3,"file":"typed-ref.js","sourceRoot":"","sources":["../../src/schema/typed-ref.ts"],"names":[],"mappings":";;;AAyHA,4BAIC;AA7HD,wCAOmB;AAyBnB;;;;;;;;;;;;;;GAcG;AACH,MAAa,cAEX,SAAQ,gBAGT;IACU,IAAI,GAAG,UAAmB,CAAA;IAEnC,OAAO,CAA4B;IAEnC,YAAY,MAAkC;QAC5C,uEAAuE;QACvE,sEAAsE;QAEtE,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;IACvB,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAA;IAC7B,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QAClD,IAAI,CAAC,MAAM,CAAC,OAAO;YAAE,OAAO,MAAM,CAAA;QAElC,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACtC,OAAO,GAAG,CAAC,yBAAyB,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QAC3E,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AArCD,wCAqCC;AAqCD,SAAgB,QAAQ,CACtB,GAA+B;IAE/B,OAAO,IAAI,cAAc,CAAa,GAAG,CAAC,CAAA;AAC5C,CAAC","sourcesContent":["import {\n  $Typed,\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\n/**\n * Interface for validators that have a $type property.\n *\n * Used by typed objects and records to identify their type in unions.\n *\n * @template TInput - The input type (with optional $type)\n * @template TOutput - The output type (with non-optional $type)\n */\nexport interface TypedObjectValidator<\n  TInput extends { $type?: string } = { $type?: string },\n  TOutput extends TInput = TInput,\n> extends Validator<TInput, TOutput> {\n  $type: NonNullable<TOutput['$type']>\n}\n\n/**\n * Function type that returns a typed object validator, used for lazy resolution.\n *\n * @template TValidator - The typed object validator type\n */\nexport type TypedRefGetter<out TValidator extends TypedObjectValidator> =\n  () => TValidator\n\n/**\n * Schema for referencing typed objects with lazy resolution.\n *\n * Used in typed unions to reference typed object schemas. Requires the\n * `$type` field to be present and match the referenced schema's type.\n * The referenced schema is resolved lazily to support circular references.\n *\n * @template TValidator - The referenced typed object validator type\n *\n * @example\n * ```ts\n * const ref = new TypedRefSchema(() => imageViewSchema)\n * // ref.$type === 'app.bsky.embed.images#view'\n * ```\n */\nexport class TypedRefSchema<\n  const TValidator extends TypedObjectValidator = TypedObjectValidator,\n> extends Schema<\n  $Typed<InferInput<TValidator>>,\n  $Typed<InferOutput<TValidator>>\n> {\n  readonly type = 'typedRef' as const\n\n  #getter: TypedRefGetter<TValidator>\n\n  constructor(getter: TypedRefGetter<TValidator>) {\n    // @NOTE In order to avoid circular dependency issues, we don't resolve\n    // the schema here. Instead, we resolve it lazily when first accessed.\n\n    super()\n\n    this.#getter = getter\n  }\n\n  get validator(): TValidator {\n    return this.#getter.call(null)\n  }\n\n  get $type(): TValidator['$type'] {\n    return this.validator.$type\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const result = ctx.validate(input, this.validator)\n    if (!result.success) return result\n\n    if (result.value.$type !== this.$type) {\n      return ctx.issueInvalidPropertyValue(result.value, '$type', [this.$type])\n    }\n\n    return result\n  }\n}\n\n/**\n * Creates a reference to a typed object schema for use in typed unions.\n *\n * Unlike regular `ref()`, this requires the referenced schema to have a\n * `$type` property, and validates that the input's `$type` matches.\n *\n * @param get - Function that returns the typed object validator\n * @returns A new {@link TypedRefSchema} instance\n *\n * @example\n * ```ts\n * // Reference to image embed view\n * const imageRef = l.typedRef(() => imageViewSchema)\n *\n * // Use in a typed union\n * const embedUnion = l.typedUnion([\n *   l.typedRef(() => imageViewSchema),\n *   l.typedRef(() => videoViewSchema),\n *   l.typedRef(() => externalViewSchema),\n * ], true) // closed union\n *\n * // The $type is accessible on the ref\n * console.log(imageRef.$type) // 'app.bsky.embed.images#view'\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedRef<const TValidator extends TypedObjectValidator>(\n  get: TypedRefGetter<TValidator>,\n): TypedRefSchema<TValidator>\nexport function typedRef<\n  TInput extends { $type?: string },\n  TOutput extends TInput = TInput,\n>(\n  get: TypedRefGetter<TypedObjectValidator<TInput, TOutput>>,\n): TypedRefSchema<TypedObjectValidator<TInput, TOutput>>\nexport function typedRef<const TValidator extends TypedObjectValidator>(\n  get: TypedRefGetter<TValidator>,\n): TypedRefSchema<TValidator> {\n  return new TypedRefSchema<TValidator>(get)\n}\n"]}
+{"version":3,"file":"typed-ref.js","sourceRoot":"","sources":["../../src/schema/typed-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,MAAM,GAGP,MAAM,YAAY,CAAA;AAyBnB;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,cAEX,SAAQ,MAGT;IAGC,OAAO,CAA4B;IAEnC,YAAY,MAAkC;QAC5C,uEAAuE;QACvE,sEAAsE;QAEtE,KAAK,EAAE,CAAA;QARA,SAAI,GAAG,UAAmB,CAAA;QAUjC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;IACvB,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAA;IAC7B,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QAClD,IAAI,CAAC,MAAM,CAAC,OAAO;YAAE,OAAO,MAAM,CAAA;QAElC,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACtC,OAAO,GAAG,CAAC,yBAAyB,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QAC3E,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAqCD,MAAM,UAAU,QAAQ,CACtB,GAA+B;IAE/B,OAAO,IAAI,cAAc,CAAa,GAAG,CAAC,CAAA;AAC5C,CAAC","sourcesContent":["import {\n  $Typed,\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\n/**\n * Interface for validators that have a $type property.\n *\n * Used by typed objects and records to identify their type in unions.\n *\n * @template TInput - The input type (with optional $type)\n * @template TOutput - The output type (with non-optional $type)\n */\nexport interface TypedObjectValidator<\n  TInput extends { $type?: string } = { $type?: string },\n  TOutput extends TInput = TInput,\n> extends Validator<TInput, TOutput> {\n  $type: NonNullable<TOutput['$type']>\n}\n\n/**\n * Function type that returns a typed object validator, used for lazy resolution.\n *\n * @template TValidator - The typed object validator type\n */\nexport type TypedRefGetter<out TValidator extends TypedObjectValidator> =\n  () => TValidator\n\n/**\n * Schema for referencing typed objects with lazy resolution.\n *\n * Used in typed unions to reference typed object schemas. Requires the\n * `$type` field to be present and match the referenced schema's type.\n * The referenced schema is resolved lazily to support circular references.\n *\n * @template TValidator - The referenced typed object validator type\n *\n * @example\n * ```ts\n * const ref = new TypedRefSchema(() => imageViewSchema)\n * // ref.$type === 'app.bsky.embed.images#view'\n * ```\n */\nexport class TypedRefSchema<\n  const TValidator extends TypedObjectValidator = TypedObjectValidator,\n> extends Schema<\n  $Typed<InferInput<TValidator>>,\n  $Typed<InferOutput<TValidator>>\n> {\n  readonly type = 'typedRef' as const\n\n  #getter: TypedRefGetter<TValidator>\n\n  constructor(getter: TypedRefGetter<TValidator>) {\n    // @NOTE In order to avoid circular dependency issues, we don't resolve\n    // the schema here. Instead, we resolve it lazily when first accessed.\n\n    super()\n\n    this.#getter = getter\n  }\n\n  get validator(): TValidator {\n    return this.#getter.call(null)\n  }\n\n  get $type(): TValidator['$type'] {\n    return this.validator.$type\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const result = ctx.validate(input, this.validator)\n    if (!result.success) return result\n\n    if (result.value.$type !== this.$type) {\n      return ctx.issueInvalidPropertyValue(result.value, '$type', [this.$type])\n    }\n\n    return result\n  }\n}\n\n/**\n * Creates a reference to a typed object schema for use in typed unions.\n *\n * Unlike regular `ref()`, this requires the referenced schema to have a\n * `$type` property, and validates that the input's `$type` matches.\n *\n * @param get - Function that returns the typed object validator\n * @returns A new {@link TypedRefSchema} instance\n *\n * @example\n * ```ts\n * // Reference to image embed view\n * const imageRef = l.typedRef(() => imageViewSchema)\n *\n * // Use in a typed union\n * const embedUnion = l.typedUnion([\n *   l.typedRef(() => imageViewSchema),\n *   l.typedRef(() => videoViewSchema),\n *   l.typedRef(() => externalViewSchema),\n * ], true) // closed union\n *\n * // The $type is accessible on the ref\n * console.log(imageRef.$type) // 'app.bsky.embed.images#view'\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedRef<const TValidator extends TypedObjectValidator>(\n  get: TypedRefGetter<TValidator>,\n): TypedRefSchema<TValidator>\nexport function typedRef<\n  TInput extends { $type?: string },\n  TOutput extends TInput = TInput,\n>(\n  get: TypedRefGetter<TypedObjectValidator<TInput, TOutput>>,\n): TypedRefSchema<TypedObjectValidator<TInput, TOutput>>\nexport function typedRef<const TValidator extends TypedObjectValidator>(\n  get: TypedRefGetter<TValidator>,\n): TypedRefSchema<TValidator> {\n  return new TypedRefSchema<TValidator>(get)\n}\n"]}

package/dist/schema/typed-union.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypedUnionSchema = void 0;
-exports.typedUnion = typedUnion;
-const lex_data_1 = require("@atproto/lex-data");
-const core_js_1 = require("../core.js");
-const lazy_property_js_1 = require("../util/lazy-property.js");
+import { isPlainObject } from '@atproto/lex-data';
+import { Schema, } from '../core.js';
+import { lazyProperty } from '../util/lazy-property.js';
 /**
  * Schema for Lexicon typed unions (unions discriminated by $type).
  *
@@ -23,10 +19,7 @@ const lazy_property_js_1 = require("../util/lazy-property.js");
  * ], true) // closed - only accepts images and videos
  * ```
  */
-class TypedUnionSchema extends core_js_1.Schema {
-    validators;
-    closed;
-    type = 'typedUnion';
+export class TypedUnionSchema extends Schema {
     constructor(validators, closed) {
         // @NOTE In order to avoid circular dependency issues, we don't access the
         // refs's schema (or $type) here. Instead, we access them lazily when first
@@ -35,18 +28,19 @@ class TypedUnionSchema extends core_js_1.Schema {
         super();
         this.validators = validators;
         this.closed = closed;
+        this.type = 'typedUnion';
     }
     get validatorsMap() {
         const map = new Map();
         for (const ref of this.validators)
             map.set(ref.$type, ref);
-        return (0, lazy_property_js_1.lazyProperty)(this, 'validatorsMap', map);
+        return lazyProperty(this, 'validatorsMap', map);
     }
     get $types() {
         return Array.from(this.validatorsMap.keys());
     }
     validateInContext(input, ctx) {
-        if (!(0, lex_data_1.isPlainObject)(input) || !('$type' in input)) {
+        if (!isPlainObject(input) || !('$type' in input)) {
             return ctx.issueUnexpectedType(input, '$typed');
         }
         const { $type } = input;
@@ -63,7 +57,6 @@ class TypedUnionSchema extends core_js_1.Schema {
         return ctx.success(input);
     }
 }
-exports.TypedUnionSchema = TypedUnionSchema;
 /**
  * Creates a typed union schema for Lexicon unions.
  *
@@ -95,7 +88,7 @@ exports.TypedUnionSchema = TypedUnionSchema;
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function typedUnion(refs, closed) {
+export function typedUnion(refs, closed) {
     return new TypedUnionSchema(refs, closed);
 }
 //# sourceMappingURL=typed-union.js.map

package/dist/schema/typed-union.js.map

@@ -1 +1 @@
-{"version":3,"file":"typed-union.js","sourceRoot":"","sources":["../../src/schema/typed-union.ts"],"names":[],"mappings":";;;AA4HA,gCAKC;AAjID,gDAAiD;AACjD,wCAMmB;AACnB,+DAAuD;AAIvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,gBAMX,SAAQ,gBAOT;IAIsB;IACH;IAJT,IAAI,GAAG,YAAqB,CAAA;IAErC,YACqB,UAAuB,EAC1B,MAAe;QAE/B,0EAA0E;QAC1E,2EAA2E;QAC3E,sEAAsE;QACtE,+DAA+D;QAE/D,KAAK,EAAE,CAAA;QARY,eAAU,GAAV,UAAU,CAAa;QAC1B,WAAM,GAAN,MAAM,CAAS;IAQjC,CAAC;IAED,IAAI,aAAa;QACf,MAAM,GAAG,GAAG,IAAI,GAAG,EAAgC,CAAA;QACnD,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,UAAU;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;QAE1D,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,CAAA;IACjD,CAAC;IAED,IAAI,MAAM;QACR,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,CAAA;IAC9C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,IAAI,KAAK,CAAC,EAAE,CAAC;YACjD,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAA;QAEvB,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAC/C,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;QACvC,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QACnE,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,GAAG,CAAC,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAA;QAC/D,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AA7DD,4CA6DC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAwB;AACxB,SAAgB,UAAU,CAGxB,IAAO,EAAE,MAAS;IAClB,OAAO,IAAI,gBAAgB,CAAO,IAAI,EAAE,MAAM,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  Unknown$TypedObject,\n  ValidationContext,\n} from '../core.js'\nimport { lazyProperty } from '../util/lazy-property.js'\nimport { TypedObjectSchema } from './typed-object.js'\nimport { TypedRefSchema } from './typed-ref.js'\n\n/**\n * Schema for Lexicon typed unions (unions discriminated by $type).\n *\n * Typed unions are collections of typed objects identified by their `$type`\n * field. Can be \"open\" (accept unknown types) or \"closed\" (only accept\n * known types).\n *\n * @template TValidators - Tuple of {@link TypedRefSchema} or {@link TypedObjectSchema} instances\n * @template TClosed - Whether the union is closed (rejects unknown $types)\n *\n * @example\n * ```ts\n * const embedUnion = new TypedUnionSchema([\n *   l.typedRef(() => imageSchema),\n *   l.typedRef(() => videoSchema),\n * ], true) // closed - only accepts images and videos\n * ```\n */\nexport class TypedUnionSchema<\n  const TValidators extends readonly (\n    | TypedRefSchema\n    | TypedObjectSchema\n  )[] = [],\n  const TClosed extends boolean = boolean,\n> extends Schema<\n  TClosed extends true\n    ? InferInput<TValidators[number]>\n    : InferInput<TValidators[number]> | Unknown$TypedObject,\n  TClosed extends true\n    ? InferOutput<TValidators[number]>\n    : InferOutput<TValidators[number]> | Unknown$TypedObject\n> {\n  readonly type = 'typedUnion' as const\n\n  constructor(\n    protected readonly validators: TValidators,\n    public readonly closed: TClosed,\n  ) {\n    // @NOTE In order to avoid circular dependency issues, we don't access the\n    // refs's schema (or $type) here. Instead, we access them lazily when first\n    // needed. The biggest issue with this strategy is that we can't throw\n    // early if the refs contain multiple refs with the same $type.\n\n    super()\n  }\n\n  get validatorsMap(): Map<unknown, TValidators[number]> {\n    const map = new Map<unknown, TValidators[number]>()\n    for (const ref of this.validators) map.set(ref.$type, ref)\n\n    return lazyProperty(this, 'validatorsMap', map)\n  }\n\n  get $types() {\n    return Array.from(this.validatorsMap.keys())\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input) || !('$type' in input)) {\n      return ctx.issueUnexpectedType(input, '$typed')\n    }\n\n    const { $type } = input\n\n    const validator = this.validatorsMap.get($type)\n    if (validator) {\n      return ctx.validate(input, validator)\n    }\n\n    if (this.closed) {\n      return ctx.issueInvalidPropertyValue(input, '$type', this.$types)\n    }\n\n    if (typeof $type !== 'string') {\n      return ctx.issueInvalidPropertyType(input, '$type', 'string')\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a typed union schema for Lexicon unions.\n *\n * Typed unions discriminate variants by their `$type` field. Can be open\n * (accepts unknown types, useful for extensibility) or closed (strict).\n *\n * @param refs - Array of typed refs for the union variants\n * @param closed - Whether to reject unknown $type values\n * @returns A new {@link TypedUnionSchema} instance\n *\n * @example\n * ```ts\n * // Closed union - only accepts known types\n * const embedSchema = l.typedUnion([\n *   l.typedRef(() => imageViewSchema),\n *   l.typedRef(() => videoViewSchema),\n *   l.typedRef(() => externalViewSchema),\n * ], true)\n *\n * // Open union - accepts unknown types for forward compatibility\n * const feedItemSchema = l.typedUnion([\n *   l.typedRef(() => postSchema),\n *   l.typedRef(() => repostSchema),\n * ], false) // unknown types pass through\n *\n * // Get all known $types\n * console.log(embedSchema.$types)\n * // ['app.bsky.embed.images#view', 'app.bsky.embed.video#view', ...]\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedUnion<\n  const R extends readonly TypedRefSchema[],\n  const C extends boolean,\n>(refs: R, closed: C) {\n  return new TypedUnionSchema<R, C>(refs, closed)\n}\n"]}
+{"version":3,"file":"typed-union.js","sourceRoot":"","sources":["../../src/schema/typed-union.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAGL,MAAM,GAGP,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAIvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,gBAMX,SAAQ,MAOT;IAGC,YACqB,UAAuB,EAC1B,MAAe;QAE/B,0EAA0E;QAC1E,2EAA2E;QAC3E,sEAAsE;QACtE,+DAA+D;QAE/D,KAAK,EAAE,CAAA;QARY,eAAU,GAAV,UAAU,CAAa;QAC1B,WAAM,GAAN,MAAM,CAAS;QAJxB,SAAI,GAAG,YAAqB,CAAA;IAYrC,CAAC;IAED,IAAI,aAAa;QACf,MAAM,GAAG,GAAG,IAAI,GAAG,EAAgC,CAAA;QACnD,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,UAAU;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;QAE1D,OAAO,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,CAAA;IACjD,CAAC;IAED,IAAI,MAAM;QACR,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,CAAA;IAC9C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,IAAI,KAAK,CAAC,EAAE,CAAC;YACjD,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAA;QAEvB,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAC/C,IAAI,SAAS,EAAE,CAAC;YACd,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;QACvC,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QACnE,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,GAAG,CAAC,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAA;QAC/D,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAwB;AACxB,MAAM,UAAU,UAAU,CAGxB,IAAO,EAAE,MAAS;IAClB,OAAO,IAAI,gBAAgB,CAAO,IAAI,EAAE,MAAM,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  Unknown$TypedObject,\n  ValidationContext,\n} from '../core.js'\nimport { lazyProperty } from '../util/lazy-property.js'\nimport { TypedObjectSchema } from './typed-object.js'\nimport { TypedRefSchema } from './typed-ref.js'\n\n/**\n * Schema for Lexicon typed unions (unions discriminated by $type).\n *\n * Typed unions are collections of typed objects identified by their `$type`\n * field. Can be \"open\" (accept unknown types) or \"closed\" (only accept\n * known types).\n *\n * @template TValidators - Tuple of {@link TypedRefSchema} or {@link TypedObjectSchema} instances\n * @template TClosed - Whether the union is closed (rejects unknown $types)\n *\n * @example\n * ```ts\n * const embedUnion = new TypedUnionSchema([\n *   l.typedRef(() => imageSchema),\n *   l.typedRef(() => videoSchema),\n * ], true) // closed - only accepts images and videos\n * ```\n */\nexport class TypedUnionSchema<\n  const TValidators extends readonly (\n    | TypedRefSchema\n    | TypedObjectSchema\n  )[] = [],\n  const TClosed extends boolean = boolean,\n> extends Schema<\n  TClosed extends true\n    ? InferInput<TValidators[number]>\n    : InferInput<TValidators[number]> | Unknown$TypedObject,\n  TClosed extends true\n    ? InferOutput<TValidators[number]>\n    : InferOutput<TValidators[number]> | Unknown$TypedObject\n> {\n  readonly type = 'typedUnion' as const\n\n  constructor(\n    protected readonly validators: TValidators,\n    public readonly closed: TClosed,\n  ) {\n    // @NOTE In order to avoid circular dependency issues, we don't access the\n    // refs's schema (or $type) here. Instead, we access them lazily when first\n    // needed. The biggest issue with this strategy is that we can't throw\n    // early if the refs contain multiple refs with the same $type.\n\n    super()\n  }\n\n  get validatorsMap(): Map<unknown, TValidators[number]> {\n    const map = new Map<unknown, TValidators[number]>()\n    for (const ref of this.validators) map.set(ref.$type, ref)\n\n    return lazyProperty(this, 'validatorsMap', map)\n  }\n\n  get $types() {\n    return Array.from(this.validatorsMap.keys())\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input) || !('$type' in input)) {\n      return ctx.issueUnexpectedType(input, '$typed')\n    }\n\n    const { $type } = input\n\n    const validator = this.validatorsMap.get($type)\n    if (validator) {\n      return ctx.validate(input, validator)\n    }\n\n    if (this.closed) {\n      return ctx.issueInvalidPropertyValue(input, '$type', this.$types)\n    }\n\n    if (typeof $type !== 'string') {\n      return ctx.issueInvalidPropertyType(input, '$type', 'string')\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a typed union schema for Lexicon unions.\n *\n * Typed unions discriminate variants by their `$type` field. Can be open\n * (accepts unknown types, useful for extensibility) or closed (strict).\n *\n * @param refs - Array of typed refs for the union variants\n * @param closed - Whether to reject unknown $type values\n * @returns A new {@link TypedUnionSchema} instance\n *\n * @example\n * ```ts\n * // Closed union - only accepts known types\n * const embedSchema = l.typedUnion([\n *   l.typedRef(() => imageViewSchema),\n *   l.typedRef(() => videoViewSchema),\n *   l.typedRef(() => externalViewSchema),\n * ], true)\n *\n * // Open union - accepts unknown types for forward compatibility\n * const feedItemSchema = l.typedUnion([\n *   l.typedRef(() => postSchema),\n *   l.typedRef(() => repostSchema),\n * ], false) // unknown types pass through\n *\n * // Get all known $types\n * console.log(embedSchema.$types)\n * // ['app.bsky.embed.images#view', 'app.bsky.embed.video#view', ...]\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedUnion<\n  const R extends readonly TypedRefSchema[],\n  const C extends boolean,\n>(refs: R, closed: C) {\n  return new TypedUnionSchema<R, C>(refs, closed)\n}\n"]}

package/dist/schema/union.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnionSchema = void 0;
-exports.union = union;
-const core_js_1 = require("../core.js");
+import { LexValidationError, Schema, } from '../core.js';
 /**
  * Schema for validating values that match one of several possible schemas.
  *
@@ -19,12 +15,11 @@ const core_js_1 = require("../core.js");
  * schema.validate(true)    // fails
  * ```
  */
-class UnionSchema extends core_js_1.Schema {
-    validators;
-    type = 'union';
+export class UnionSchema extends Schema {
     constructor(validators) {
         super();
         this.validators = validators;
+        this.type = 'union';
     }
     validateInContext(input, ctx) {
         const failures = [];
@@ -34,10 +29,9 @@ class UnionSchema extends core_js_1.Schema {
                 return result;
             failures.push(result);
         }
-        return ctx.failure(core_js_1.LexValidationError.fromFailures(failures));
+        return ctx.failure(LexValidationError.fromFailures(failures));
     }
 }
-exports.UnionSchema = UnionSchema;
 /**
  * Creates a union schema that accepts values matching any of the provided schemas.
  *
@@ -63,7 +57,7 @@ exports.UnionSchema = UnionSchema;
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function union(validators) {
+export function union(validators) {
     return new UnionSchema(validators);
 }
 //# sourceMappingURL=union.js.map

package/dist/schema/union.js.map

@@ -1 +1 @@
-{"version":3,"file":"union.js","sourceRoot":"","sources":["../../src/schema/union.ts"],"names":[],"mappings":";;;AAoFA,sBAIC;AAxFD,wCAQmB;AASnB;;;;;;;;;;;;;;;GAeG;AACH,MAAa,WAEX,SAAQ,gBAGT;IAGgC;IAFtB,IAAI,GAAG,OAAgB,CAAA;IAEhC,YAA+B,UAAuB;QACpD,KAAK,EAAE,CAAA;QADsB,eAAU,GAAV,UAAU,CAAa;IAEtD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,QAAQ,GAAwB,EAAE,CAAA;QAExC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;YAC7C,IAAI,MAAM,CAAC,OAAO;gBAAE,OAAO,MAAM,CAAA;YAEjC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACvB,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,4BAAkB,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAA;IAC/D,CAAC;CACF;AAxBD,kCAwBC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAwB;AACxB,SAAgB,KAAK,CACnB,UAAuB;IAEvB,OAAO,IAAI,WAAW,CAAc,UAAU,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  LexValidationError,\n  Schema,\n  ValidationContext,\n  ValidationFailure,\n  Validator,\n} from '../core.js'\n\n/**\n * Type representing a non-empty tuple of validators for union schemas.\n *\n * Requires at least one validator in the tuple.\n */\nexport type UnionSchemaValidators = readonly [Validator, ...Validator[]]\n\n/**\n * Schema for validating values that match one of several possible schemas.\n *\n * Tries each validator in order until one succeeds. If all validators fail,\n * returns a combined error from all attempts.\n *\n * @template TValidators - Tuple type of the validators in the union\n *\n * @example\n * ```ts\n * const schema = new UnionSchema([l.string(), l.integer()])\n * schema.validate('hello') // success\n * schema.validate(42)      // success\n * schema.validate(true)    // fails\n * ```\n */\nexport class UnionSchema<\n  const TValidators extends UnionSchemaValidators = any,\n> extends Schema<\n  InferInput<TValidators[number]>,\n  InferOutput<TValidators[number]>\n> {\n  readonly type = 'union' as const\n\n  constructor(protected readonly validators: TValidators) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const failures: ValidationFailure[] = []\n\n    for (const validator of this.validators) {\n      const result = ctx.validate(input, validator)\n      if (result.success) return result\n\n      failures.push(result)\n    }\n\n    return ctx.failure(LexValidationError.fromFailures(failures))\n  }\n}\n\n/**\n * Creates a union schema that accepts values matching any of the provided schemas.\n *\n * Validators are tried in order. Use `discriminatedUnion()` for better\n * performance when discriminating on a known property.\n *\n * @param validators - Non-empty array of validators to try\n * @returns A new {@link UnionSchema} instance\n *\n * @example\n * ```ts\n * // String or number\n * const stringOrNumber = l.union([l.string(), l.integer()])\n *\n * // Nullable value\n * const nullableString = l.union([l.string(), l.null()])\n *\n * // Multiple object types\n * const mediaSchema = l.union([\n *   l.object({ type: l.literal('image'), url: l.string() }),\n *   l.object({ type: l.literal('video'), url: l.string(), duration: l.integer() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function union<const TValidators extends UnionSchemaValidators>(\n  validators: TValidators,\n) {\n  return new UnionSchema<TValidators>(validators)\n}\n"]}
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../../src/schema/union.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,kBAAkB,EAClB,MAAM,GAIP,MAAM,YAAY,CAAA;AASnB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,WAEX,SAAQ,MAGT;IAGC,YAA+B,UAAuB;QACpD,KAAK,EAAE,CAAA;QADsB,eAAU,GAAV,UAAU,CAAa;QAF7C,SAAI,GAAG,OAAgB,CAAA;IAIhC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,QAAQ,GAAwB,EAAE,CAAA;QAExC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;YAC7C,IAAI,MAAM,CAAC,OAAO;gBAAE,OAAO,MAAM,CAAA;YAEjC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACvB,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,kBAAkB,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAA;IAC/D,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAwB;AACxB,MAAM,UAAU,KAAK,CACnB,UAAuB;IAEvB,OAAO,IAAI,WAAW,CAAc,UAAU,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  LexValidationError,\n  Schema,\n  ValidationContext,\n  ValidationFailure,\n  Validator,\n} from '../core.js'\n\n/**\n * Type representing a non-empty tuple of validators for union schemas.\n *\n * Requires at least one validator in the tuple.\n */\nexport type UnionSchemaValidators = readonly [Validator, ...Validator[]]\n\n/**\n * Schema for validating values that match one of several possible schemas.\n *\n * Tries each validator in order until one succeeds. If all validators fail,\n * returns a combined error from all attempts.\n *\n * @template TValidators - Tuple type of the validators in the union\n *\n * @example\n * ```ts\n * const schema = new UnionSchema([l.string(), l.integer()])\n * schema.validate('hello') // success\n * schema.validate(42)      // success\n * schema.validate(true)    // fails\n * ```\n */\nexport class UnionSchema<\n  const TValidators extends UnionSchemaValidators = any,\n> extends Schema<\n  InferInput<TValidators[number]>,\n  InferOutput<TValidators[number]>\n> {\n  readonly type = 'union' as const\n\n  constructor(protected readonly validators: TValidators) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const failures: ValidationFailure[] = []\n\n    for (const validator of this.validators) {\n      const result = ctx.validate(input, validator)\n      if (result.success) return result\n\n      failures.push(result)\n    }\n\n    return ctx.failure(LexValidationError.fromFailures(failures))\n  }\n}\n\n/**\n * Creates a union schema that accepts values matching any of the provided schemas.\n *\n * Validators are tried in order. Use `discriminatedUnion()` for better\n * performance when discriminating on a known property.\n *\n * @param validators - Non-empty array of validators to try\n * @returns A new {@link UnionSchema} instance\n *\n * @example\n * ```ts\n * // String or number\n * const stringOrNumber = l.union([l.string(), l.integer()])\n *\n * // Nullable value\n * const nullableString = l.union([l.string(), l.null()])\n *\n * // Multiple object types\n * const mediaSchema = l.union([\n *   l.object({ type: l.literal('image'), url: l.string() }),\n *   l.object({ type: l.literal('video'), url: l.string(), duration: l.integer() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function union<const TValidators extends UnionSchemaValidators>(\n  validators: TValidators,\n) {\n  return new UnionSchema<TValidators>(validators)\n}\n"]}

package/dist/schema/unknown.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unknown = exports.UnknownSchema = void 0;
-const core_js_1 = require("../core.js");
-const memoize_js_1 = require("../util/memoize.js");
+import { Schema } from '../core.js';
+import { memoizedOptions } from '../util/memoize.js';
 /**
  * Schema that accepts any value without validation.
  *
@@ -16,13 +13,15 @@ const memoize_js_1 = require("../util/memoize.js");
  * schema.validate(anything) // always succeeds
  * ```
  */
-class UnknownSchema extends core_js_1.Schema {
-    type = 'unknown';
+export class UnknownSchema extends Schema {
+    constructor() {
+        super(...arguments);
+        this.type = 'unknown';
+    }
     validateInContext(input, ctx) {
         return ctx.success(input);
     }
 }
-exports.UnknownSchema = UnknownSchema;
 /**
  * Creates an unknown schema that accepts any value.
  *
@@ -43,7 +42,7 @@ exports.UnknownSchema = UnknownSchema;
  * })
  * ```
  */
-exports.unknown = (0, memoize_js_1.memoizedOptions)(function () {
+export const unknown = /*#__PURE__*/ memoizedOptions(function () {
     return new UnknownSchema();
 });
 //# sourceMappingURL=unknown.js.map

package/dist/schema/unknown.js.map

@@ -1 +1 @@
-{"version":3,"file":"unknown.js","sourceRoot":"","sources":["../../src/schema/unknown.ts"],"names":[],"mappings":";;;AAAA,wCAAsD;AACtD,mDAAoD;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAa,aAAc,SAAQ,gBAAe;IACvC,IAAI,GAAG,SAAkB,CAAA;IAElC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAND,sCAMC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACU,QAAA,OAAO,GAAiB,IAAA,4BAAe,EAAC;IACnD,OAAO,IAAI,aAAa,EAAE,CAAA;AAC5B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema that accepts any value without validation.\n *\n * Passes through any input unchanged. Use sparingly as it bypasses\n * type safety. Useful for dynamic data or when the schema is not\n * known at compile time.\n *\n * @example\n * ```ts\n * const schema = new UnknownSchema()\n * schema.validate(anything) // always succeeds\n * ```\n */\nexport class UnknownSchema extends Schema<unknown> {\n  readonly type = 'unknown' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates an unknown schema that accepts any value.\n *\n * The value passes through without any validation or transformation.\n * Use this when you need to accept arbitrary data.\n *\n * @returns A new {@link UnknownSchema} instance\n *\n * @example\n * ```ts\n * // Accept any value\n * const anyDataSchema = l.unknown()\n *\n * // In an object with a dynamic field\n * const flexibleSchema = l.object({\n *   type: l.string(),\n *   data: l.unknown(),\n * })\n * ```\n */\nexport const unknown = /*#__PURE__*/ memoizedOptions(function () {\n  return new UnknownSchema()\n})\n"]}
+{"version":3,"file":"unknown.js","sourceRoot":"","sources":["../../src/schema/unknown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,aAAc,SAAQ,MAAe;IAAlD;;QACW,SAAI,GAAG,SAAkB,CAAA;IAKpC,CAAC;IAHC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC,eAAe,CAAC;IACnD,OAAO,IAAI,aAAa,EAAE,CAAA;AAC5B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema that accepts any value without validation.\n *\n * Passes through any input unchanged. Use sparingly as it bypasses\n * type safety. Useful for dynamic data or when the schema is not\n * known at compile time.\n *\n * @example\n * ```ts\n * const schema = new UnknownSchema()\n * schema.validate(anything) // always succeeds\n * ```\n */\nexport class UnknownSchema extends Schema<unknown> {\n  readonly type = 'unknown' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates an unknown schema that accepts any value.\n *\n * The value passes through without any validation or transformation.\n * Use this when you need to accept arbitrary data.\n *\n * @returns A new {@link UnknownSchema} instance\n *\n * @example\n * ```ts\n * // Accept any value\n * const anyDataSchema = l.unknown()\n *\n * // In an object with a dynamic field\n * const flexibleSchema = l.object({\n *   type: l.string(),\n *   data: l.unknown(),\n * })\n * ```\n */\nexport const unknown = /*#__PURE__*/ memoizedOptions(function () {\n  return new UnknownSchema()\n})\n"]}

package/dist/schema/with-default.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WithDefaultSchema = void 0;
-exports.withDefault = withDefault;
-const core_js_1 = require("../core.js");
+import { Schema, } from '../core.js';
 /**
  * Schema wrapper that provides a default value when the input is undefined.
  *
@@ -19,14 +15,12 @@ const core_js_1 = require("../core.js");
  * schema.parse(42)        // 42
  * ```
  */
-class WithDefaultSchema extends core_js_1.Schema {
-    validator;
-    defaultValue;
-    type = 'withDefault';
+export class WithDefaultSchema extends Schema {
     constructor(validator, defaultValue) {
         super();
         this.validator = validator;
         this.defaultValue = defaultValue;
+        this.type = 'withDefault';
     }
     validateInContext(input, ctx) {
         // When in a validation context, the output should not be altered,
@@ -37,7 +31,6 @@ class WithDefaultSchema extends core_js_1.Schema {
         return ctx.validate(input, this.validator);
     }
 }
-exports.WithDefaultSchema = WithDefaultSchema;
 /**
  * Creates a schema that applies a default value when the input is undefined.
  *
@@ -66,7 +59,7 @@ exports.WithDefaultSchema = WithDefaultSchema;
  * const enabledSchema = l.withDefault(l.boolean(), false)
  * ```
  */
-function withDefault(validator, defaultValue) {
+export function withDefault(validator, defaultValue) {
     return new WithDefaultSchema(validator, defaultValue);
 }
 //# sourceMappingURL=with-default.js.map

package/dist/schema/with-default.js.map

@@ -1 +1 @@
-{"version":3,"file":"with-default.js","sourceRoot":"","sources":["../../src/schema/with-default.ts"],"names":[],"mappings":";;;AA2EA,kCAKC;AAhFD,wCAMmB;AAEnB;;;;;;;;;;;;;;;GAeG;AACH,MAAa,iBAEX,SAAQ,gBAAuD;IAIpD;IACA;IAJF,IAAI,GAAG,aAAsB,CAAA;IAEtC,YACW,SAAqB,EACrB,YAAoC;QAE7C,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAY;QACrB,iBAAY,GAAZ,YAAY,CAAwB;IAG/C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,kEAAkE;QAClE,iCAAiC;QACjC,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC3D,OAAO,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QACxD,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC5C,CAAC;CACF;AArBD,8CAqBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,WAAW,CACzB,SAAqB,EACrB,YAAoC;IAEpC,OAAO,IAAI,iBAAiB,CAAa,SAAS,EAAE,YAAY,CAAC,CAAA;AACnE,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\n/**\n * Schema wrapper that provides a default value when the input is undefined.\n *\n * In parse mode, when the input is `undefined`, the default value is used\n * instead. In validate mode, undefined values pass through unchanged (the\n * default is not applied).\n *\n * @template TValidator - The wrapped validator type\n *\n * @example\n * ```ts\n * const schema = new WithDefaultSchema(l.integer(), 0)\n * schema.parse(undefined) // 0\n * schema.parse(42)        // 42\n * ```\n */\nexport class WithDefaultSchema<\n  const TValidator extends Validator,\n> extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {\n  readonly type = 'withDefault' as const\n\n  constructor(\n    readonly validator: TValidator,\n    readonly defaultValue: InferInput<TValidator>,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // When in a validation context, the output should not be altered,\n    // so we don't apply the default.\n    if (input === undefined && ctx.options.mode !== 'validate') {\n      return ctx.validate(this.defaultValue, this.validator)\n    }\n\n    return ctx.validate(input, this.validator)\n  }\n}\n\n/**\n * Creates a schema that applies a default value when the input is undefined.\n *\n * Commonly used with `optional()` to provide fallback values for missing\n * properties. The default value is validated against the schema.\n *\n * @param validator - The validator for the value\n * @param defaultValue - The default value to use when input is undefined\n * @returns A new {@link WithDefaultSchema} instance\n *\n * @example\n * ```ts\n * // Integer with default\n * const countSchema = l.withDefault(l.integer(), 0)\n * countSchema.parse(undefined) // 0\n * countSchema.parse(5)         // 5\n *\n * // Commonly combined with optional in objects\n * const settingsSchema = l.object({\n *   theme: l.optional(l.withDefault(l.string(), 'light')),\n *   pageSize: l.optional(l.withDefault(l.integer(), 25)),\n * })\n * settingsSchema.parse({}) // { theme: 'light', pageSize: 25 }\n *\n * // Boolean with default\n * const enabledSchema = l.withDefault(l.boolean(), false)\n * ```\n */\nexport function withDefault<const TValidator extends Validator>(\n  validator: TValidator,\n  defaultValue: InferInput<TValidator>,\n) {\n  return new WithDefaultSchema<TValidator>(validator, defaultValue)\n}\n"]}
+{"version":3,"file":"with-default.js","sourceRoot":"","sources":["../../src/schema/with-default.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,GAGP,MAAM,YAAY,CAAA;AAEnB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,iBAEX,SAAQ,MAAuD;IAG/D,YACW,SAAqB,EACrB,YAAoC;QAE7C,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAY;QACrB,iBAAY,GAAZ,YAAY,CAAwB;QAJtC,SAAI,GAAG,aAAsB,CAAA;IAOtC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,kEAAkE;QAClE,iCAAiC;QACjC,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC3D,OAAO,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QACxD,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC5C,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,WAAW,CACzB,SAAqB,EACrB,YAAoC;IAEpC,OAAO,IAAI,iBAAiB,CAAa,SAAS,EAAE,YAAY,CAAC,CAAA;AACnE,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\n/**\n * Schema wrapper that provides a default value when the input is undefined.\n *\n * In parse mode, when the input is `undefined`, the default value is used\n * instead. In validate mode, undefined values pass through unchanged (the\n * default is not applied).\n *\n * @template TValidator - The wrapped validator type\n *\n * @example\n * ```ts\n * const schema = new WithDefaultSchema(l.integer(), 0)\n * schema.parse(undefined) // 0\n * schema.parse(42)        // 42\n * ```\n */\nexport class WithDefaultSchema<\n  const TValidator extends Validator,\n> extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {\n  readonly type = 'withDefault' as const\n\n  constructor(\n    readonly validator: TValidator,\n    readonly defaultValue: InferInput<TValidator>,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // When in a validation context, the output should not be altered,\n    // so we don't apply the default.\n    if (input === undefined && ctx.options.mode !== 'validate') {\n      return ctx.validate(this.defaultValue, this.validator)\n    }\n\n    return ctx.validate(input, this.validator)\n  }\n}\n\n/**\n * Creates a schema that applies a default value when the input is undefined.\n *\n * Commonly used with `optional()` to provide fallback values for missing\n * properties. The default value is validated against the schema.\n *\n * @param validator - The validator for the value\n * @param defaultValue - The default value to use when input is undefined\n * @returns A new {@link WithDefaultSchema} instance\n *\n * @example\n * ```ts\n * // Integer with default\n * const countSchema = l.withDefault(l.integer(), 0)\n * countSchema.parse(undefined) // 0\n * countSchema.parse(5)         // 5\n *\n * // Commonly combined with optional in objects\n * const settingsSchema = l.object({\n *   theme: l.optional(l.withDefault(l.string(), 'light')),\n *   pageSize: l.optional(l.withDefault(l.integer(), 25)),\n * })\n * settingsSchema.parse({}) // { theme: 'light', pageSize: 25 }\n *\n * // Boolean with default\n * const enabledSchema = l.withDefault(l.boolean(), false)\n * ```\n */\nexport function withDefault<const TValidator extends Validator>(\n  validator: TValidator,\n  defaultValue: InferInput<TValidator>,\n) {\n  return new WithDefaultSchema<TValidator>(validator, defaultValue)\n}\n"]}

package/dist/schema.js

@@ -1,45 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
 // Concrete Types
-tslib_1.__exportStar(require("./schema/array.js"), exports);
-tslib_1.__exportStar(require("./schema/blob.js"), exports);
-tslib_1.__exportStar(require("./schema/boolean.js"), exports);
-tslib_1.__exportStar(require("./schema/bytes.js"), exports);
-tslib_1.__exportStar(require("./schema/cid.js"), exports);
-tslib_1.__exportStar(require("./schema/dict.js"), exports);
-tslib_1.__exportStar(require("./schema/enum.js"), exports);
-tslib_1.__exportStar(require("./schema/integer.js"), exports);
-tslib_1.__exportStar(require("./schema/lex-map.js"), exports);
-tslib_1.__exportStar(require("./schema/lex-value.js"), exports);
-tslib_1.__exportStar(require("./schema/literal.js"), exports);
-tslib_1.__exportStar(require("./schema/never.js"), exports);
-tslib_1.__exportStar(require("./schema/null.js"), exports);
-tslib_1.__exportStar(require("./schema/object.js"), exports);
-tslib_1.__exportStar(require("./schema/regexp.js"), exports);
-tslib_1.__exportStar(require("./schema/string.js"), exports);
-tslib_1.__exportStar(require("./schema/unknown.js"), exports);
+export * from './schema/array.js';
+export * from './schema/blob.js';
+export * from './schema/boolean.js';
+export * from './schema/bytes.js';
+export * from './schema/cid.js';
+export * from './schema/dict.js';
+export * from './schema/enum.js';
+export * from './schema/integer.js';
+export * from './schema/lex-map.js';
+export * from './schema/lex-value.js';
+export * from './schema/literal.js';
+export * from './schema/never.js';
+export * from './schema/null.js';
+export * from './schema/object.js';
+export * from './schema/regexp.js';
+export * from './schema/string.js';
+export * from './schema/unknown.js';
 // Composite Types
-tslib_1.__exportStar(require("./schema/custom.js"), exports);
-tslib_1.__exportStar(require("./schema/discriminated-union.js"), exports);
-tslib_1.__exportStar(require("./schema/intersection.js"), exports);
-tslib_1.__exportStar(require("./schema/nullable.js"), exports);
-tslib_1.__exportStar(require("./schema/optional.js"), exports);
-tslib_1.__exportStar(require("./schema/ref.js"), exports);
-tslib_1.__exportStar(require("./schema/refine.js"), exports);
-tslib_1.__exportStar(require("./schema/union.js"), exports);
-tslib_1.__exportStar(require("./schema/with-default.js"), exports);
+export * from './schema/custom.js';
+export * from './schema/discriminated-union.js';
+export * from './schema/intersection.js';
+export * from './schema/nullable.js';
+export * from './schema/optional.js';
+export * from './schema/ref.js';
+export * from './schema/refine.js';
+export * from './schema/union.js';
+export * from './schema/with-default.js';
 // Lexicon specific Types
-tslib_1.__exportStar(require("./schema/params.js"), exports);
-tslib_1.__exportStar(require("./schema/payload.js"), exports);
-tslib_1.__exportStar(require("./schema/permission-set.js"), exports);
-tslib_1.__exportStar(require("./schema/permission.js"), exports);
-tslib_1.__exportStar(require("./schema/procedure.js"), exports);
-tslib_1.__exportStar(require("./schema/query.js"), exports);
-tslib_1.__exportStar(require("./schema/record.js"), exports);
-tslib_1.__exportStar(require("./schema/subscription.js"), exports);
-tslib_1.__exportStar(require("./schema/token.js"), exports);
-tslib_1.__exportStar(require("./schema/typed-object.js"), exports);
-tslib_1.__exportStar(require("./schema/typed-ref.js"), exports);
-tslib_1.__exportStar(require("./schema/typed-union.js"), exports);
+export * from './schema/params.js';
+export * from './schema/payload.js';
+export * from './schema/permission-set.js';
+export * from './schema/permission.js';
+export * from './schema/procedure.js';
+export * from './schema/query.js';
+export * from './schema/record.js';
+export * from './schema/subscription.js';
+export * from './schema/token.js';
+export * from './schema/typed-object.js';
+export * from './schema/typed-ref.js';
+export * from './schema/typed-union.js';
 //# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":";;;AAAA,iBAAiB;AACjB,4DAAiC;AACjC,2DAAgC;AAChC,8DAAmC;AACnC,4DAAiC;AACjC,0DAA+B;AAC/B,2DAAgC;AAChC,2DAAgC;AAChC,8DAAmC;AACnC,8DAAmC;AACnC,gEAAqC;AACrC,8DAAmC;AACnC,4DAAiC;AACjC,2DAAgC;AAChC,6DAAkC;AAClC,6DAAkC;AAClC,6DAAkC;AAClC,8DAAmC;AAEnC,kBAAkB;AAClB,6DAAkC;AAClC,0EAA+C;AAC/C,mEAAwC;AACxC,+DAAoC;AACpC,+DAAoC;AACpC,0DAA+B;AAC/B,6DAAkC;AAClC,4DAAiC;AACjC,mEAAwC;AAExC,yBAAyB;AACzB,6DAAkC;AAClC,8DAAmC;AACnC,qEAA0C;AAC1C,iEAAsC;AACtC,gEAAqC;AACrC,4DAAiC;AACjC,6DAAkC;AAClC,mEAAwC;AACxC,4DAAiC;AACjC,mEAAwC;AACxC,gEAAqC;AACrC,kEAAuC","sourcesContent":["// Concrete Types\nexport * from './schema/array.js'\nexport * from './schema/blob.js'\nexport * from './schema/boolean.js'\nexport * from './schema/bytes.js'\nexport * from './schema/cid.js'\nexport * from './schema/dict.js'\nexport * from './schema/enum.js'\nexport * from './schema/integer.js'\nexport * from './schema/lex-map.js'\nexport * from './schema/lex-value.js'\nexport * from './schema/literal.js'\nexport * from './schema/never.js'\nexport * from './schema/null.js'\nexport * from './schema/object.js'\nexport * from './schema/regexp.js'\nexport * from './schema/string.js'\nexport * from './schema/unknown.js'\n\n// Composite Types\nexport * from './schema/custom.js'\nexport * from './schema/discriminated-union.js'\nexport * from './schema/intersection.js'\nexport * from './schema/nullable.js'\nexport * from './schema/optional.js'\nexport * from './schema/ref.js'\nexport * from './schema/refine.js'\nexport * from './schema/union.js'\nexport * from './schema/with-default.js'\n\n// Lexicon specific Types\nexport * from './schema/params.js'\nexport * from './schema/payload.js'\nexport * from './schema/permission-set.js'\nexport * from './schema/permission.js'\nexport * from './schema/procedure.js'\nexport * from './schema/query.js'\nexport * from './schema/record.js'\nexport * from './schema/subscription.js'\nexport * from './schema/token.js'\nexport * from './schema/typed-object.js'\nexport * from './schema/typed-ref.js'\nexport * from './schema/typed-union.js'\n"]}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,iBAAiB;AACjB,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AAEnC,kBAAkB;AAClB,cAAc,oBAAoB,CAAA;AAClC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AAExC,yBAAyB;AACzB,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA","sourcesContent":["// Concrete Types\nexport * from './schema/array.js'\nexport * from './schema/blob.js'\nexport * from './schema/boolean.js'\nexport * from './schema/bytes.js'\nexport * from './schema/cid.js'\nexport * from './schema/dict.js'\nexport * from './schema/enum.js'\nexport * from './schema/integer.js'\nexport * from './schema/lex-map.js'\nexport * from './schema/lex-value.js'\nexport * from './schema/literal.js'\nexport * from './schema/never.js'\nexport * from './schema/null.js'\nexport * from './schema/object.js'\nexport * from './schema/regexp.js'\nexport * from './schema/string.js'\nexport * from './schema/unknown.js'\n\n// Composite Types\nexport * from './schema/custom.js'\nexport * from './schema/discriminated-union.js'\nexport * from './schema/intersection.js'\nexport * from './schema/nullable.js'\nexport * from './schema/optional.js'\nexport * from './schema/ref.js'\nexport * from './schema/refine.js'\nexport * from './schema/union.js'\nexport * from './schema/with-default.js'\n\n// Lexicon specific Types\nexport * from './schema/params.js'\nexport * from './schema/payload.js'\nexport * from './schema/permission-set.js'\nexport * from './schema/permission.js'\nexport * from './schema/procedure.js'\nexport * from './schema/query.js'\nexport * from './schema/record.js'\nexport * from './schema/subscription.js'\nexport * from './schema/token.js'\nexport * from './schema/typed-object.js'\nexport * from './schema/typed-ref.js'\nexport * from './schema/typed-union.js'\n"]}

package/dist/util/array-agg.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayAgg = arrayAgg;
 /**
  * Aggregates items in an array based on a comparison function and an aggregation function.
  *
@@ -20,7 +17,7 @@ exports.arrayAgg = arrayAgg;
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-function arrayAgg(arr, cmp, agg) {
+export function arrayAgg(arr, cmp, agg) {
     if (arr.length === 0)
         return [];
     const groups = [[arr[0]]];

package/dist/util/array-agg.js.map

@@ -1 +1 @@
-{"version":3,"file":"array-agg.js","sourceRoot":"","sources":["../../src/util/array-agg.ts"],"names":[],"mappings":";;AAmBA,4BAwBC;AA3CD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAwB;AACxB,SAAgB,QAAQ,CACtB,GAAiB,EACjB,GAA4B,EAC5B,GAA8B;IAE9B,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAE/B,MAAM,MAAM,GAAkB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACxC,MAAM,OAAO,GAAG,KAAK,CAAsB,GAAG,CAAC,MAAM,CAAC,CAAA;IAEtD,KAAK,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,IAAI,OAAO,CAAC,CAAC,CAAC;YAAE,SAAQ;QACxB,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAA;QACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC5B,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBACpB,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;gBACjB,SAAS,KAAK,CAAA;YAChB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;IACrB,CAAC;IAED,OAAO,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AACxB,CAAC","sourcesContent":["/**\n * Aggregates items in an array based on a comparison function and an aggregation function.\n *\n * @param arr - The input array to aggregate.\n * @param cmp - A comparison function that determines if two items belong to the same group.\n * @param agg - An aggregation function that combines items in a group into a single item.\n * @returns An array of aggregated items.\n * @example\n * ```ts\n * const input = [1, 1, 2, 2, 3, 3, 3]\n * const result = arrayAgg(\n *   input,\n *   (a, b) => a === b,\n *   (items) => { value: items[0], sum: items.reduce((sum, item) => sum + item, 0) },\n * )\n * // result is [{ value: 1, sum: 2 }, { value: 2, sum: 4 }, { value: 3, sum: 6 }]\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function arrayAgg<T, O>(\n  arr: readonly T[],\n  cmp: (a: T, b: T) => boolean,\n  agg: (items: [T, ...T[]]) => O,\n): O[] {\n  if (arr.length === 0) return []\n\n  const groups: [T, ...T[]][] = [[arr[0]]]\n  const skipped = Array<undefined | boolean>(arr.length)\n\n  outer: for (let i = 1; i < arr.length; i++) {\n    if (skipped[i]) continue\n    const item = arr[i]\n    for (let j = 0; j < groups.length; j++) {\n      if (cmp(item, groups[j][0])) {\n        groups[j].push(item)\n        skipped[i] = true\n        continue outer\n      }\n    }\n    groups.push([item])\n  }\n\n  return groups.map(agg)\n}\n"]}
+{"version":3,"file":"array-agg.js","sourceRoot":"","sources":["../../src/util/array-agg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAwB;AACxB,MAAM,UAAU,QAAQ,CACtB,GAAiB,EACjB,GAA4B,EAC5B,GAA8B;IAE9B,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAE/B,MAAM,MAAM,GAAkB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACxC,MAAM,OAAO,GAAG,KAAK,CAAsB,GAAG,CAAC,MAAM,CAAC,CAAA;IAEtD,KAAK,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,IAAI,OAAO,CAAC,CAAC,CAAC;YAAE,SAAQ;QACxB,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAA;QACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC5B,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBACpB,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;gBACjB,SAAS,KAAK,CAAA;YAChB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;IACrB,CAAC;IAED,OAAO,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AACxB,CAAC","sourcesContent":["/**\n * Aggregates items in an array based on a comparison function and an aggregation function.\n *\n * @param arr - The input array to aggregate.\n * @param cmp - A comparison function that determines if two items belong to the same group.\n * @param agg - An aggregation function that combines items in a group into a single item.\n * @returns An array of aggregated items.\n * @example\n * ```ts\n * const input = [1, 1, 2, 2, 3, 3, 3]\n * const result = arrayAgg(\n *   input,\n *   (a, b) => a === b,\n *   (items) => { value: items[0], sum: items.reduce((sum, item) => sum + item, 0) },\n * )\n * // result is [{ value: 1, sum: 2 }, { value: 2, sum: 4 }, { value: 3, sum: 6 }]\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function arrayAgg<T, O>(\n  arr: readonly T[],\n  cmp: (a: T, b: T) => boolean,\n  agg: (items: [T, ...T[]]) => O,\n): O[] {\n  if (arr.length === 0) return []\n\n  const groups: [T, ...T[]][] = [[arr[0]]]\n  const skipped = Array<undefined | boolean>(arr.length)\n\n  outer: for (let i = 1; i < arr.length; i++) {\n    if (skipped[i]) continue\n    const item = arr[i]\n    for (let j = 0; j < groups.length; j++) {\n      if (cmp(item, groups[j][0])) {\n        groups[j].push(item)\n        skipped[i] = true\n        continue outer\n      }\n    }\n    groups.push([item])\n  }\n\n  return groups.map(agg)\n}\n"]}

package/dist/util/assertion-util.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=assertion-util.js.map

package/dist/util/if-any.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=if-any.js.map

package/dist/util/lazy-property.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lazyProperty = lazyProperty;
 /*@__NO_SIDE_EFFECTS__*/
-function lazyProperty(obj, key, value) {
+export function lazyProperty(obj, key, value) {
     Object.defineProperty(obj, key, {
         value,
         writable: false,

package/dist/util/lazy-property.js.map

@@ -1 +1 @@
-{"version":3,"file":"lazy-property.js","sourceRoot":"","sources":["../../src/util/lazy-property.ts"],"names":[],"mappings":";;AACA,oCAYC;AAbD,wBAAwB;AACxB,SAAgB,YAAY,CAI1B,GAAM,EAAE,GAAM,EAAE,KAAQ;IACxB,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE;QAC9B,KAAK;QACL,QAAQ,EAAE,KAAK;QACf,UAAU,EAAE,KAAK;QACjB,YAAY,EAAE,IAAI;KACnB,CAAC,CAAA;IACF,OAAO,KAAK,CAAA;AACd,CAAC","sourcesContent":["/*@__NO_SIDE_EFFECTS__*/\nexport function lazyProperty<\n  O extends object,\n  const K extends keyof O,\n  const V extends O[K],\n>(obj: O, key: K, value: V): V {\n  Object.defineProperty(obj, key, {\n    value,\n    writable: false,\n    enumerable: false,\n    configurable: true,\n  })\n  return value\n}\n"]}
+{"version":3,"file":"lazy-property.js","sourceRoot":"","sources":["../../src/util/lazy-property.ts"],"names":[],"mappings":"AAAA,wBAAwB;AACxB,MAAM,UAAU,YAAY,CAI1B,GAAM,EAAE,GAAM,EAAE,KAAQ;IACxB,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE;QAC9B,KAAK;QACL,QAAQ,EAAE,KAAK;QACf,UAAU,EAAE,KAAK;QACjB,YAAY,EAAE,IAAI;KACnB,CAAC,CAAA;IACF,OAAO,KAAK,CAAA;AACd,CAAC","sourcesContent":["/*@__NO_SIDE_EFFECTS__*/\nexport function lazyProperty<\n  O extends object,\n  const K extends keyof O,\n  const V extends O[K],\n>(obj: O, key: K, value: V): V {\n  Object.defineProperty(obj, key, {\n    value,\n    writable: false,\n    enumerable: false,\n    configurable: true,\n  })\n  return value\n}\n"]}