ts-data-forge 6.13.1 → 7.0.0

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"}

package/dist/number/branded-types/negative-finite-number.mjs

@@ -0,0 +1,156 @@
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { PositiveFiniteNumber } from './positive-finite-number.mjs';
+
+const typeNameInMessage = 'a negative finite number';
+const { MAX_VALUE, add, castType, clamp, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
+    nonZero: true,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: -Number.MIN_VALUE,
+    typeNameInMessage,
+});
+/**
+ * Returns the absolute value of a negative finite number.
+ *
+ * The absolute value of a negative finite number is always a positive finite
+ * number, so the result is typed as a {@link PositiveFiniteNumber}.
+ *
+ * @param x - The negative finite number.
+ * @returns `|x|` as a PositiveFiniteNumber.
+ */
+const abs = (x) => PositiveFiniteNumber.clamp(Math.abs(x));
+const floor = (x) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+Math.floor(x);
+const ceil = (x) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+Math.ceil(x);
+const round = (x) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+Math.round(x);
+/**
+ * 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.
+ */
+const isNegativeFiniteNumber = is;
+/**
+ * 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.
+ */
+const asNegativeFiniteNumber = castType;
+/**
+ * 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.
+ */
+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.
+     */
+    is,
+    /**
+     * The maximum value for a negative finite number.
+     *
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the absolute value of a negative finite number.
+     *
+     * @param a The negative finite number.
+     * @returns The absolute value as a PositiveFiniteNumber.
+     */
+    abs,
+    /**
+     * Returns the smaller of two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns The minimum value as a NegativeFiniteNumber.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns The maximum value as a NegativeFiniteNumber.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the negative finite range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `(-∞, 0)` as a NegativeFiniteNumber.
+     */
+    clamp,
+    /**
+     * Rounds down a NegativeFiniteNumber to the nearest integer.
+     *
+     * @param x The NegativeFiniteNumber to round down.
+     * @returns The floor value as a NegativeInt (always `<= -1`).
+     */
+    floor,
+    /**
+     * 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).
+     */
+    ceil,
+    /**
+     * 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).
+     */
+    round,
+    /**
+     * Generates a random NegativeFiniteNumber value.
+     *
+     * @returns A random negative finite number.
+     */
+    random,
+    /**
+     * 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.
+     */
+    pow,
+    /**
+     * Adds two NegativeFiniteNumber values.
+     *
+     * @param a The first NegativeFiniteNumber.
+     * @param b The second NegativeFiniteNumber.
+     * @returns `a + b` as a NegativeFiniteNumber.
+     */
+    add,
+    /**
+     * 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.
+     */
+    sub,
+};
+
+export { NegativeFiniteNumber, asNegativeFiniteNumber, isNegativeFiniteNumber };
+//# sourceMappingURL=negative-finite-number.mjs.map

package/dist/number/branded-types/negative-finite-number.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative-finite-number.mjs","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;AAC5B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;AAQG;AACH,MAAM,GAAG,GAAG,CAAC,CAAc,KACzB,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAEzC,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAId;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAEV;AAEH,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAEH;;;;;AAKG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;AAMG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;;;AAQG;AACI,MAAM,oBAAoB,GAAG;AAClC;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;;;;;"}

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

@@ -0,0 +1,120 @@
+import { type NegativeInt as TtfImported_NegativeInt, type WithSmallInt } from 'ts-type-forge';
+import { PositiveInt } from './positive-int.mjs';
+export type NegativeInt = TtfImported_NegativeInt;
+type ElementType = NegativeInt;
+/**
+ * Checks if a number is a NegativeInt (a negative integer `<= -1`).
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a NegativeInt, `false` otherwise.
+ */
+export declare const isNegativeInt: (a: number) => a is TtfImported_NegativeInt;
+/**
+ * Casts a number to a NegativeInt type.
+ *
+ * @param value The value to cast.
+ * @returns The value as a NegativeInt type.
+ * @throws {TypeError} If the value is not a negative integer.
+ */
+export declare const asNegativeInt: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: 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 integers.
+ *
+ * NegativeInt represents integers that are strictly less than zero (`<= -1`).
+ * Operations that stay within the negative integers (such as `add`) 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 NegativeInt: {
+    /**
+     * Type guard to check if a value is a NegativeInt.
+     *
+     * @param value The value to check.
+     * @returns `true` if the value is a negative integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is TtfImported_NegativeInt;
+    /**
+     * The maximum value for a negative integer.
+     *
+     * @readonly
+     */
+    readonly MAX_VALUE: -1;
+    /**
+     * Returns the absolute value of a negative integer.
+     *
+     * @param a The negative integer.
+     * @returns The absolute value as a PositiveInt.
+     */
+    readonly abs: (x: WithSmallInt<ElementType>) => PositiveInt;
+    /**
+     * Returns the smaller of two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns The minimum value as a NegativeInt.
+     */
+    readonly min: (...values: readonly WithSmallInt<TtfImported_NegativeInt>[]) => TtfImported_NegativeInt;
+    /**
+     * Returns the larger of two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns The maximum value as a NegativeInt.
+     */
+    readonly max: (...values: readonly WithSmallInt<TtfImported_NegativeInt>[]) => TtfImported_NegativeInt;
+    /**
+     * Clamps a number to the negative integer range.
+     *
+     * @param value The number to clamp.
+     * @returns The value clamped to `[-∞, -1]` as a NegativeInt.
+     */
+    readonly clamp: (x: number) => TtfImported_NegativeInt;
+    /**
+     * Generates a random NegativeInt value within the valid range.
+     *
+     * @returns A random negative integer.
+     */
+    readonly random: (min?: WithSmallInt<TtfImported_NegativeInt> | undefined, max?: WithSmallInt<TtfImported_NegativeInt> | undefined) => TtfImported_NegativeInt;
+    /**
+     * Raises a negative integer to the power of another negative integer.
+     *
+     * @param a The base negative integer.
+     * @param b The exponent negative integer.
+     * @returns `a ** b` clamped to the negative integer range.
+     */
+    readonly pow: (x: WithSmallInt<TtfImported_NegativeInt>, y: WithSmallInt<TtfImported_NegativeInt>) => TtfImported_NegativeInt;
+    /**
+     * Adds two negative integers.
+     *
+     * @param a The first negative integer.
+     * @param b The second negative integer.
+     * @returns `a + b` as a NegativeInt.
+     */
+    readonly add: (x: WithSmallInt<TtfImported_NegativeInt>, y: WithSmallInt<TtfImported_NegativeInt>) => TtfImported_NegativeInt;
+    /**
+     * Subtracts one negative integer from another.
+     *
+     * The mathematical result can be positive, so it is clamped to the negative
+     * integer range (maximum `-1`).
+     *
+     * @param a The minuend negative integer.
+     * @param b The subtrahend negative integer.
+     * @returns `a - b` clamped to the negative integer range.
+     */
+    readonly sub: (x: WithSmallInt<TtfImported_NegativeInt>, y: WithSmallInt<TtfImported_NegativeInt>) => TtfImported_NegativeInt;
+};
+export {};
+//# sourceMappingURL=negative-int.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"negative-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,IAAI,uBAAuB,EAC3C,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAElD,KAAK,WAAW,GAAG,WAAW,CAAC;AAuC/B;;;;;GAKG;AACH,eAAO,MAAM,aAAa,6CAAK,CAAC;AAEhC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;sBAjDW,YAAY,CAAC,WAAW,CAAC,KAAG,WAAW;IAoDrD;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;CAEK,CAAC"}