ts-data-forge 6.13.0 → 7.0.0

package/dist/functional/pipe.d.mts

@@ -1,4 +1,3 @@
-import { type MergeIntersection } from 'ts-type-forge';
 import { Optional, type UnknownOptional } from './optional/index.mjs';
 /**
  * Creates a new pipe object that allows for chaining operations on a value.
@@ -18,15 +17,8 @@ import { Optional, type UnknownOptional } from './optional/index.mjs';
  * @param a The initial value to wrap in a pipe.
  * @returns A pipe object with chaining methods appropriate for the value type.
  */
-export declare function pipe<const A extends UnknownOptional>(a: A): PipeWithMapOptional<A>;
-export declare function pipe<const A>(a: A): PipeBase<A>;
-type Pipe<A> = A extends UnknownOptional ? PipeWithMapOptional<A> : PipeBase<A>;
-/**
- * @template A The type of the current value in the pipe.
- * @internal
- * Base pipe interface providing core functionality.
- * All pipe types extend this interface.
- */
+export declare const pipe: <const A>(a: A) => Pipe<A>;
+export type Pipe<A> = PipeBase<A> & PipeMapNullable<A> & ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown);
 type PipeBase<A> = Readonly<{
     /** The current value being piped. */
     value: A;
@@ -48,6 +40,8 @@ type PipeBase<A> = Readonly<{
      * @returns A new pipe containing the transformed value.
      */
     map: <B>(fn: (a: A) => B) => Pipe<B>;
+}>;
+type PipeMapNullable<A> = Readonly<{
     /**
      * Maps the current value only if it's not null or undefined. If the current
      * value is null/undefined, the transformation is skipped and undefined is
@@ -75,13 +69,7 @@ type PipeBase<A> = Readonly<{
      */
     mapNullable: <B>(fn: (a: NonNullable<A>) => B) => Pipe<B | undefined>;
 }>;
-/**
- * @template A The Optional type currently in the pipe.
- * @internal
- * Pipe interface for Optional values, providing Optional-aware mapping.
- * Extends PipeBase with mapOptional functionality for monadic operations.
- */
-type PipeWithMapOptional<A extends UnknownOptional> = MergeIntersection<PipeBase<A> & Readonly<{
+type PipeMapOptional<A extends UnknownOptional> = Readonly<{
     /**
      * Maps the value inside an Optional using Optional.map semantics. If the
      * Optional is None, the transformation is skipped and None is propagated.
@@ -109,6 +97,6 @@ type PipeWithMapOptional<A extends UnknownOptional> = MergeIntersection<PipeBase
      * @returns A new pipe containing an Optional with the transformed value.
      */
     mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => Pipe<Optional<B>>;
-}>>;
+}>;
 export {};
 //# sourceMappingURL=pipe.d.mts.map

package/dist/functional/pipe.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,eAAe,EAClD,CAAC,EAAE,CAAC,GACH,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE1B,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAkBjD,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,eAAe,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEhF;;;;;GAKG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH;;;;;GAKG;AACH,KAAK,mBAAmB,CAAC,CAAC,SAAS,eAAe,IAAI,iBAAiB,CACrE,QAAQ,CAAC,CAAC,CAAC,GACT,QAAQ,CAAC;IACP;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CACL,CAAC"}
+{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,EAAG,GAAG,CAAC,KAAG,IAAI,CAAC,CAAC,CAYI,CAAC;AAmBjD,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAC/B,eAAe,CAAC,CAAC,CAAC,GAClB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;AAgCjE,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;CACtC,CAAC,CAAC;AAEH,KAAK,eAAe,CAAC,CAAC,IAAI,QAAQ,CAAC;IACjC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH,KAAK,eAAe,CAAC,CAAC,SAAS,eAAe,IAAI,QAAQ,CAAC;IACzD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CAAC"}

package/dist/functional/pipe.mjs

@@ -1,22 +1,42 @@
 import { isOptional } from './optional/impl/optional-is-optional.mjs';
 import { map } from './optional/impl/optional-map.mjs';
 
-function pipe(a) {
-    if (isOptional(a)) {
-        return {
-            value: a,
-            map: (fn) => pipe(fn(a)),
+/**
+ * Creates a new pipe object that allows for chaining operations on a value.
+ *
+ * This function provides a fluent interface for applying transformations to
+ * values, with intelligent method selection based on the input type:
+ *
+ * - For `Optional` values: Provides `mapOptional` for safe Optional
+ *   transformations
+ * - For other values: Provides `mapNullable` for null-safe transformations
+ * - All types get the basic `map` method for general transformations
+ *
+ * The pipe maintains type safety throughout the chain, automatically selecting
+ * the appropriate overload based on the current value type.
+ *
+ * @template A The type of the initial value to wrap in a pipe.
+ * @param a The initial value to wrap in a pipe.
+ * @returns A pipe object with chaining methods appropriate for the value type.
+ */
+const pipe = (a) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+({
+    value: a,
+    map: (fn) => pipe(fn(a)),
+    mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),
+    ...(isOptional(a)
+        ? {
             mapOptional: (fn) => pipe(map(a, fn)),
-        };
-    }
-    else {
-        return {
-            value: a,
-            map: (fn) => pipe(fn(a)),
-            mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),
-        };
-    }
-}
+        }
+        : {}),
+});
+// NOTE: 以下では 'typing when used with generics' test で型エラーが出る。
+// 詳細は documents/reports/pipe-typing.md の 「mapNullable を条件付きで含めるのがうまくいかない理由」を参照。
+// export type Pipe<A> = PipeBase<A> &
+//   ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown) &
+//   ([undefined] extends [A] ? PipeMapNullable<A> : unknown) &
+//   ([null] extends [A] ? PipeMapNullable<A> : unknown);
 
 export { pipe };
 //# sourceMappingURL=pipe.mjs.map

package/dist/functional/pipe.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":["Optional.isOptional","Optional.map"],"mappings":";;;AA2BM,SAAU,IAAI,CAAU,CAAI,EAAA;AAChC,IAAA,IAAIA,UAAmB,CAAC,CAAC,CAAC,EAAE;QAC1B,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACxB,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAACC,GAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC/C;IACH;SAAO;QACL,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;SACzD;IACH;AACF;;;;"}
+{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":["Optional.isOptional","Optional.map"],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,IAAI,GAAG,CAAW,CAAI;AACjC;AACA,CAAC;AACC,IAAA,KAAK,EAAE,CAAC;AACR,IAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAExD,IAAA,IAAIA,UAAmB,CAAC,CAAC;AACvB,UAAE;AACE,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAACC,GAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC/C;UACD,EAAE,CAAC;AACR,CAAA;AAuBH;AACA;AACA;AACA;AACA;AACA;;;;"}

package/dist/index.mjs

@@ -18,9 +18,15 @@ export { FiniteNumber, asFiniteNumber, isFiniteNumber } from './number/branded-t
 export { Int, asInt, isInt } from './number/branded-types/int.mjs';
 export { Int16, asInt16, isInt16 } from './number/branded-types/int16.mjs';
 export { Int32, asInt32, isInt32 } from './number/branded-types/int32.mjs';
+export { NegativeFiniteNumber, asNegativeFiniteNumber, isNegativeFiniteNumber } from './number/branded-types/negative-finite-number.mjs';
+export { NegativeInt, asNegativeInt, isNegativeInt } from './number/branded-types/negative-int.mjs';
+export { NegativeSafeInt, asNegativeSafeInt, isNegativeSafeInt } from './number/branded-types/negative-safe-int.mjs';
 export { NonNegativeFiniteNumber, asNonNegativeFiniteNumber, isNonNegativeFiniteNumber } from './number/branded-types/non-negative-finite-number.mjs';
 export { NonNegativeInt16, asNonNegativeInt16, isNonNegativeInt16 } from './number/branded-types/non-negative-int16.mjs';
 export { NonNegativeInt32, asNonNegativeInt32, isNonNegativeInt32 } from './number/branded-types/non-negative-int32.mjs';
+export { NonPositiveFiniteNumber, asNonPositiveFiniteNumber, isNonPositiveFiniteNumber } from './number/branded-types/non-positive-finite-number.mjs';
+export { NonPositiveInt, asNonPositiveInt, isNonPositiveInt } from './number/branded-types/non-positive-int.mjs';
+export { NonPositiveSafeInt, asNonPositiveSafeInt, isNonPositiveSafeInt } from './number/branded-types/non-positive-safe-int.mjs';
 export { NonZeroFiniteNumber, asNonZeroFiniteNumber, isNonZeroFiniteNumber } from './number/branded-types/non-zero-finite-number.mjs';
 export { NonZeroInt, asNonZeroInt, isNonZeroInt } from './number/branded-types/non-zero-int.mjs';
 export { NonZeroInt16, asNonZeroInt16, isNonZeroInt16 } from './number/branded-types/non-zero-int16.mjs';

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/iterator/range.mjs

@@ -2,9 +2,15 @@ import '../number/branded-types/finite-number.mjs';
 import '../number/branded-types/int.mjs';
 import '../number/branded-types/int16.mjs';
 import '../number/branded-types/int32.mjs';
+import '../number/branded-types/negative-finite-number.mjs';
+import '../number/branded-types/negative-int.mjs';
+import '../number/branded-types/negative-safe-int.mjs';
 import '../number/branded-types/non-negative-finite-number.mjs';
 import '../number/branded-types/non-negative-int16.mjs';
 import '../number/branded-types/non-negative-int32.mjs';
+import '../number/branded-types/non-positive-finite-number.mjs';
+import '../number/branded-types/non-positive-int.mjs';
+import '../number/branded-types/non-positive-safe-int.mjs';
 import '../number/branded-types/non-zero-finite-number.mjs';
 import '../number/branded-types/non-zero-int.mjs';
 import '../number/branded-types/non-zero-int16.mjs';

package/dist/iterator/range.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"range.mjs","sources":["../../src/iterator/range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAsFiB,KAAK,CACpB,GAAG,IAME,EAAA;AAEL,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI;AAElB,YAAA,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE;AAChC,gBAAA,MAAM,CAAC;YACT;YAEA;QACF;AAEA,QAAA,KAAK,CAAC;;QAGN,KAAK,CAAC,EAAE;YACN,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI;AAEnC,YAAA,KACE,IAAI,KAAK,GAAY,SAAS,CAAC,KAAK,CAAC,EACrC,IAAI,GAAG,CAAC,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,EACpC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAC3C;AACA,gBAAA,MAAM,KAAK;YACb;QACF;;AAEJ;;;;"}
+{"version":3,"file":"range.mjs","sources":["../../src/iterator/range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAsFiB,KAAK,CACpB,GAAG,IAME,EAAA;AAEL,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI;AAElB,YAAA,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE;AAChC,gBAAA,MAAM,CAAC;YACT;YAEA;QACF;AAEA,QAAA,KAAK,CAAC;;QAGN,KAAK,CAAC,EAAE;YACN,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI;AAEnC,YAAA,KACE,IAAI,KAAK,GAAY,SAAS,CAAC,KAAK,CAAC,EACrC,IAAI,GAAG,CAAC,GAAG,KAAK,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,EACpC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAC3C;AACA,gBAAA,MAAM,KAAK;YACb;QACF;;AAEJ;;;;"}

package/dist/json/json.mjs

@@ -2,9 +2,15 @@ import '../number/branded-types/finite-number.mjs';
 import '../number/branded-types/int.mjs';
 import '../number/branded-types/int16.mjs';
 import '../number/branded-types/int32.mjs';
+import '../number/branded-types/negative-finite-number.mjs';
+import '../number/branded-types/negative-int.mjs';
+import '../number/branded-types/negative-safe-int.mjs';
 import '../number/branded-types/non-negative-finite-number.mjs';
 import '../number/branded-types/non-negative-int16.mjs';
 import '../number/branded-types/non-negative-int32.mjs';
+import '../number/branded-types/non-positive-finite-number.mjs';
+import '../number/branded-types/non-positive-int.mjs';
+import '../number/branded-types/non-positive-safe-int.mjs';
 import '../number/branded-types/non-zero-finite-number.mjs';
 import '../number/branded-types/non-zero-int.mjs';
 import '../number/branded-types/non-zero-int16.mjs';

package/dist/json/json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"json.mjs","sources":["../../src/json/json.mts"],"sourcesContent":[null],"names":["Result.ok","Result.err","Arr.uniq"],"mappings":"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"}
+{"version":3,"file":"json.mjs","sources":["../../src/json/json.mts"],"sourcesContent":[null],"names":["Result.ok","Result.err","Arr.uniq"],"mappings":"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"}

package/dist/number/branded-types/finite-number.d.mts

@@ -58,7 +58,7 @@ export declare const FiniteNumber: {
      * @param x - The finite number to get the absolute value of
      * @returns The absolute value as a FiniteNumber
      */
-    readonly abs: (x: TtfImported_FiniteNumber) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_FiniteNumber>;
+    readonly abs: (x: TtfImported_FiniteNumber) => import("ts-type-forge").IntersectBrand<TtfImported_FiniteNumber, import("ts-type-forge").NonNegativeNumber>;
     /**
      * Returns the minimum value from a list of finite numbers.
      *

package/dist/number/branded-types/index.d.mts

@@ -2,9 +2,15 @@ export * from './finite-number.mjs';
 export * from './int.mjs';
 export * from './int16.mjs';
 export * from './int32.mjs';
+export * from './negative-finite-number.mjs';
+export * from './negative-int.mjs';
+export * from './negative-safe-int.mjs';
 export * from './non-negative-finite-number.mjs';
 export * from './non-negative-int16.mjs';
 export * from './non-negative-int32.mjs';
+export * from './non-positive-finite-number.mjs';
+export * from './non-positive-int.mjs';
+export * from './non-positive-safe-int.mjs';
 export * from './non-zero-finite-number.mjs';
 export * from './non-zero-int.mjs';
 export * from './non-zero-int16.mjs';

package/dist/number/branded-types/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/index.mts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/index.mts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}

package/dist/number/branded-types/index.mjs

@@ -2,9 +2,15 @@ export { FiniteNumber, asFiniteNumber, isFiniteNumber } from './finite-number.mj
 export { Int, asInt, isInt } from './int.mjs';
 export { Int16, asInt16, isInt16 } from './int16.mjs';
 export { Int32, asInt32, isInt32 } from './int32.mjs';
+export { NegativeFiniteNumber, asNegativeFiniteNumber, isNegativeFiniteNumber } from './negative-finite-number.mjs';
+export { NegativeInt, asNegativeInt, isNegativeInt } from './negative-int.mjs';
+export { NegativeSafeInt, asNegativeSafeInt, isNegativeSafeInt } from './negative-safe-int.mjs';
 export { NonNegativeFiniteNumber, asNonNegativeFiniteNumber, isNonNegativeFiniteNumber } from './non-negative-finite-number.mjs';
 export { NonNegativeInt16, asNonNegativeInt16, isNonNegativeInt16 } from './non-negative-int16.mjs';
 export { NonNegativeInt32, asNonNegativeInt32, isNonNegativeInt32 } from './non-negative-int32.mjs';
+export { NonPositiveFiniteNumber, asNonPositiveFiniteNumber, isNonPositiveFiniteNumber } from './non-positive-finite-number.mjs';
+export { NonPositiveInt, asNonPositiveInt, isNonPositiveInt } from './non-positive-int.mjs';
+export { NonPositiveSafeInt, asNonPositiveSafeInt, isNonPositiveSafeInt } from './non-positive-safe-int.mjs';
 export { NonZeroFiniteNumber, asNonZeroFiniteNumber, isNonZeroFiniteNumber } from './non-zero-finite-number.mjs';
 export { NonZeroInt, asNonZeroInt, isNonZeroInt } from './non-zero-int.mjs';
 export { NonZeroInt16, asNonZeroInt16, isNonZeroInt16 } from './non-zero-int16.mjs';

package/dist/number/branded-types/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/number/branded-types/int.d.mts

@@ -1,5 +1,4 @@
 import { type Int as TtfImported_Int } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type Int = TtfImported_Int;
 /**
  * Type guard that checks if a value is an integer.
@@ -102,7 +101,7 @@ export declare const Int: {
      * @param a - The integer value
      * @returns The absolute value as a non-negative Int
      */
-    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_Int>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int>) => import("ts-type-forge").IntersectBrand<TtfImported_Int, import("ts-type-forge").NonNegativeNumber>;
     /**
      * Returns the minimum value from a list of integers.
      *

package/dist/number/branded-types/int.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,IAAI,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,GAAG,GAAG,eAAe,CAAC;AA6BlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,qCAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,IAAI,eAAe,EAAE,MAAM,eAAe,CAAC;AAI5D,MAAM,MAAM,GAAG,GAAG,eAAe,CAAC;AA6BlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,qCAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/int16.d.mts

@@ -1,5 +1,4 @@
 import { type Int16 as TtfImported_Int16 } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type Int16 = TtfImported_Int16;
 /**
  * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15,
@@ -66,7 +65,7 @@ export declare const Int16: {
      * @param a The Int16 value.
      * @returns The absolute value as an Int16, clamped to valid range.
      */
-    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_Int16>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int16>) => import("ts-type-forge").IntersectBrand<TtfImported_Int16, import("ts-type-forge").NonNegativeNumber>;
     /**
      * Returns the smaller of two Int16 values.
      *
@@ -139,11 +138,11 @@ export declare const Int16: {
         readonly NaNValue: false;
         readonly Finite: true;
         readonly Int: true;
-        readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
         readonly ">= -2^15": true;
         readonly ">= -2^31": true;
+        readonly "!=0": true;
         readonly "< 2^15": true;
         readonly "< 2^16": true;
         readonly "< 2^31": true;

package/dist/number/branded-types/int16.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIhE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/int32.d.mts

@@ -1,5 +1,4 @@
 import { type Int32 as TtfImported_Int32 } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type Int32 = TtfImported_Int32;
 /**
  * Checks if a number is an Int32 (32-bit signed integer in the range [-2^31,
@@ -62,7 +61,7 @@ export declare const Int32: {
      * @param a The Int32 value.
      * @returns The absolute value as an Int32, clamped to valid range.
      */
-    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<TtfImported_Int32>;
+    readonly abs: (x: import("ts-type-forge").WithSmallInt<TtfImported_Int32>) => import("ts-type-forge").IntersectBrand<TtfImported_Int32, import("ts-type-forge").NonNegativeNumber>;
     /**
      * Returns the smaller of two Int32 values.
      *
@@ -135,9 +134,9 @@ export declare const Int32: {
         readonly NaNValue: false;
         readonly Finite: true;
         readonly Int: true;
-        readonly "!=0": true;
         readonly "> -2^32": true;
         readonly ">= -2^31": true;
+        readonly "!=0": true;
         readonly "< 2^31": true;
         readonly "< 2^32": true;
         readonly SafeInt: true;

package/dist/number/branded-types/int32.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIhE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/negative-finite-number.d.mts

@@ -0,0 +1,143 @@
+import { type NegativeFiniteNumber as TtfImported_NegativeFiniteNumber } from 'ts-type-forge';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { PositiveFiniteNumber } from './positive-finite-number.mjs';
+export type NegativeFiniteNumber = TtfImported_NegativeFiniteNumber;
+type ElementType = NegativeFiniteNumber;
+/**
+ * Checks if a number is a NegativeFiniteNumber (a finite number `< 0`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeFiniteNumber, `false` otherwise.
+ */
+export declare const isNegativeFiniteNumber: (a: number) => a is TtfImported_NegativeFiniteNumber;
+/**
+ * Casts a number to a NegativeFiniteNumber type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeFiniteNumber type.
+ * @throws {TypeError} If the value is not a negative finite number.
+ */
+export declare const asNegativeFiniteNumber: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly Finite: true;
+    readonly ">=0": false;
+    readonly "!=0": true;
+    readonly "<=0": true;
+    readonly "< 2^15": true;
+    readonly "< 2^16": true;
+    readonly "< 2^31": true;
+    readonly "< 2^32": true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for negative finite
+ * numbers.
+ *
+ * All operations keep results finite (excluding NaN and Infinity). Operations
+ * that stay within the negative finite numbers clamp their results to the valid
+ * range, while operations whose result leaves the set (`mul`, `div`, `abs`) are
+ * typed to reflect the actual sign of the result.
+ */
+export declare const NegativeFiniteNumber: {
+    /**
+     * Type guard to check if a value is a NegativeFiniteNumber.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative finite number, `false`
+     *   otherwise.
+     */
+    readonly is: (a: number) => a is TtfImported_NegativeFiniteNumber;
+    /**
+     * The maximum value for a negative finite number.
+     *
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the absolute value of a negative finite number.
+     *
+     * @param a The negative finite number.
+     * @returns The absolute value as a PositiveFiniteNumber.
+     */
+    readonly abs: (x: ElementType) => PositiveFiniteNumber;
+    /**
+     * Returns the smaller of two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns The minimum value as a NegativeFiniteNumber.
+     */
+    readonly min: (...values: readonly TtfImported_NegativeFiniteNumber[]) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Returns the larger of two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns The maximum value as a NegativeFiniteNumber.
+     */
+    readonly max: (...values: readonly TtfImported_NegativeFiniteNumber[]) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Clamps a number to the negative finite range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    readonly clamp: (x: number) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Rounds down a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round down.
+     * @returns The floor value as a NegativeInt (always `<= -1`).
+     */
+    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
+    /**
+     * Rounds up a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round up.
+     * @returns The ceiling value as a NonPositiveInt (can be 0).
+     */
+    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    /**
+     * Rounds a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round.
+     * @returns The rounded value as a NonPositiveInt (can be 0 if x > -0.5).
+     */
+    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
+    /**
+     * Generates a random NegativeFiniteNumber value.
+     *
+     * @returns A random negative finite number.
+     */
+    readonly random: (min?: TtfImported_NegativeFiniteNumber | undefined, max?: TtfImported_NegativeFiniteNumber | undefined) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Raises a NegativeFiniteNumber to the power of another NegativeFiniteNumber.
+     *
+     * @param a The base NegativeFiniteNumber.
+     * @param b The exponent NegativeFiniteNumber.
+     * @returns `a ** b` clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    readonly pow: (x: TtfImported_NegativeFiniteNumber, y: TtfImported_NegativeFiniteNumber) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Adds two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns `a + b` as a NegativeFiniteNumber.
+     */
+    readonly add: (x: TtfImported_NegativeFiniteNumber, y: TtfImported_NegativeFiniteNumber) => TtfImported_NegativeFiniteNumber;
+    /**
+     * Subtracts one NegativeFiniteNumber from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the negative
+     * finite range (maximum `-Number.MIN_VALUE`).
+     *
+     * @param a The minuend NegativeFiniteNumber.
+     * @param b The subtrahend NegativeFiniteNumber.
+     * @returns `a - b` clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    readonly sub: (x: TtfImported_NegativeFiniteNumber, y: TtfImported_NegativeFiniteNumber) => TtfImported_NegativeFiniteNumber;
+};
+export {};
+//# sourceMappingURL=negative-finite-number.d.mts.map

package/dist/number/branded-types/negative-finite-number.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,IAAI,gCAAgC,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAkExC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;sBA/EW,WAAW,KAAG,oBAAoB;IAkFhD;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBA7GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA+G3D;;;;;OAKG;uBA/GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA+GC;;;;;OAKG;wBA7GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA6GC;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;CAEK,CAAC"}