ts-data-forge 2.0.2 → 2.1.0

package/dist/entry-point.d.mts

@@ -0,0 +1,27 @@
+import 'ts-type-forge';
+export * from './index.mjs';
+declare global {
+    type SmallPositiveInt = WithSmallInt<PositiveInt>;
+    /**
+     * Represents the type of keys that can be used in a standard JavaScript Map.
+     */
+    type MapSetKeyType = Primitive;
+    namespace SizeType {
+        type Arr = Uint32;
+        type TypedArray = SafeUint;
+        type Str = SafeUint;
+        type ArrSearchResult = Arr | -1;
+        type TypedArraySearchResult = TypedArray | -1;
+        type StrSearchResult = Str | -1;
+        type ArgArr = WithSmallInt<Arr>;
+        type ArgTypedArray = WithSmallInt<TypedArray>;
+        type ArgStr = WithSmallInt<Str>;
+        type ArgArrWithNegative = WithSmallInt<NormalizeBrandUnion<NegativeInt32 | Arr>>;
+        type ArgTypedArrayWithNegative = WithSmallInt<SafeInt>;
+        type ArgStrWithNegative = WithSmallInt<SafeInt>;
+        type ArgArrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Arr>>;
+        type ArgTypedArrayPositive = WithSmallInt<IntersectBrand<PositiveNumber, TypedArray>>;
+        type ArgStrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Str>>;
+    }
+}
+//# sourceMappingURL=entry-point.d.mts.map

package/dist/entry-point.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.d.mts","sourceRoot":"","sources":["../src/entry-point.mts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC;AAEvB,cAAc,aAAa,CAAC;AAE5B,OAAO,CAAC,MAAM,CAAC;IACb,KAAK,gBAAgB,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;IAElD;;OAEG;IACH,KAAK,aAAa,GAAG,SAAS,CAAC;IAO/B,UAAU,QAAQ,CAAC;QACjB,KAAK,GAAG,GAAG,MAAM,CAAC;QAClB,KAAK,UAAU,GAAG,QAAQ,CAAC;QAC3B,KAAK,GAAG,GAAG,QAAQ,CAAC;QAEpB,KAAK,eAAe,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC;QAChC,KAAK,sBAAsB,GAAG,UAAU,GAAG,CAAC,CAAC,CAAC;QAC9C,KAAK,eAAe,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC;QAEhC,KAAK,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;QAChC,KAAK,aAAa,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC;QAC9C,KAAK,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;QAEhC,KAAK,kBAAkB,GAAG,YAAY,CACpC,mBAAmB,CAAC,aAAa,GAAG,GAAG,CAAC,CACzC,CAAC;QACF,KAAK,yBAAyB,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QACvD,KAAK,kBAAkB,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QAEhD,KAAK,cAAc,GAAG,YAAY,CAAC,cAAc,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC;QACxE,KAAK,qBAAqB,GAAG,YAAY,CACvC,cAAc,CAAC,cAAc,EAAE,UAAU,CAAC,CAC3C,CAAC;QACF,KAAK,cAAc,GAAG,YAAY,CAAC,cAAc,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC;KACzE;CACF"}

package/dist/entry-point.mjs

@@ -0,0 +1,62 @@
+import 'ts-type-forge';
+export { Arr } from './array/array-utils.mjs';
+export { IMapMapped } from './collections/imap-mapped.mjs';
+export { IMap } from './collections/imap.mjs';
+export { ISetMapped } from './collections/iset-mapped.mjs';
+export { ISet } from './collections/iset.mjs';
+export { createQueue } from './collections/queue.mjs';
+export { createStack } from './collections/stack.mjs';
+export { expectType } from './expect-type.mjs';
+export { match } from './functional/match.mjs';
+export { Optional } from './functional/optional.mjs';
+export { pipe } from './functional/pipe.mjs';
+export { Result } from './functional/result.mjs';
+export { hasKey } from './guard/has-key.mjs';
+export { isNonEmptyString } from './guard/is-non-empty-string.mjs';
+export { isNonNullObject } from './guard/is-non-null-object.mjs';
+export { isPrimitive } from './guard/is-primitive.mjs';
+export { isRecord } from './guard/is-record.mjs';
+export { isBigint, isBoolean, isNonNullish, isNotBigint, isNotBoolean, isNotNull, isNotNumber, isNotString, isNotSymbol, isNotUndefined, isNull, isNullish, isNumber, isString, isSymbol, isUndefined } from './guard/is-type.mjs';
+export { keyIsIn } from './guard/key-is-in.mjs';
+export { range } from './iterator/range.mjs';
+export { Json } from './json/json.mjs';
+export { FiniteNumber, asFiniteNumber, isFiniteNumber } from './number/branded-types/finite-number.mjs';
+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 { 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 { 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';
+export { NonZeroInt32, asNonZeroInt32, isNonZeroInt32 } from './number/branded-types/non-zero-int32.mjs';
+export { NonZeroSafeInt, asNonZeroSafeInt, isNonZeroSafeInt } from './number/branded-types/non-zero-safe-int.mjs';
+export { NonZeroUint16, asNonZeroUint16, isNonZeroUint16 } from './number/branded-types/non-zero-uint16.mjs';
+export { NonZeroUint32, asNonZeroUint32, isNonZeroUint32 } from './number/branded-types/non-zero-uint32.mjs';
+export { PositiveFiniteNumber, asPositiveFiniteNumber, isPositiveFiniteNumber } from './number/branded-types/positive-finite-number.mjs';
+export { PositiveInt, asPositiveInt, isPositiveInt } from './number/branded-types/positive-int.mjs';
+export { PositiveInt16, asPositiveInt16, isPositiveInt16 } from './number/branded-types/positive-int16.mjs';
+export { PositiveInt32, asPositiveInt32, isPositiveInt32 } from './number/branded-types/positive-int32.mjs';
+export { PositiveSafeInt, asPositiveSafeInt, isPositiveSafeInt } from './number/branded-types/positive-safe-int.mjs';
+export { PositiveUint16, asPositiveUint16, isPositiveUint16 } from './number/branded-types/positive-uint16.mjs';
+export { PositiveUint32, asPositiveUint32, isPositiveUint32 } from './number/branded-types/positive-uint32.mjs';
+export { SafeInt, asSafeInt, isSafeInt } from './number/branded-types/safe-int.mjs';
+export { SafeUint, asSafeUint, isSafeUint } from './number/branded-types/safe-uint.mjs';
+export { Uint, asUint, isUint } from './number/branded-types/uint.mjs';
+export { Uint16, asUint16, isUint16 } from './number/branded-types/uint16.mjs';
+export { Uint32, asUint32, isUint32 } from './number/branded-types/uint32.mjs';
+export { Int8, asInt8, isInt8 } from './number/enum/int8.mjs';
+export { Uint8, asUint8, isUint8 } from './number/enum/uint8.mjs';
+export { Num } from './number/num.mjs';
+export { TsDataForgeInternals } from './number/refined-number-utils.mjs';
+export { Obj } from './object/object.mjs';
+export { castDeepMutable, castMutable } from './others/cast-mutable.mjs';
+export { castDeepReadonly, castReadonly } from './others/cast-readonly.mjs';
+export { ifThen } from './others/if-then.mjs';
+export { mapNullable } from './others/map-nullable.mjs';
+export { memoizeFunction } from './others/memoize-function.mjs';
+export { tp } from './others/tuple.mjs';
+export { unknownToString } from './others/unknown-to-string.mjs';
+export { createPromise } from './promise/promise.mjs';
+//# sourceMappingURL=entry-point.mjs.map

package/dist/entry-point.mjs.map

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

package/dist/iterator/range.d.mts

@@ -88,6 +88,9 @@
  * }
  * ```
  */
-export declare function range(start: SafeUintWithSmallInt, end: SafeUintWithSmallInt, step?: PositiveSafeIntWithSmallInt): Generator<SafeUint, void, unknown>;
-export declare function range(start: SafeIntWithSmallInt, end: SafeIntWithSmallInt, step?: NonZeroSafeIntWithSmallInt): Generator<SafeInt, void, unknown>;
+export declare function range(end: WithSmallInt<SafeUint, MaxInt>): Generator<SafeUint, void, unknown>;
+export declare function range(start: WithSmallInt<SafeUint, MaxInt>, end: WithSmallInt<SafeUint, MaxInt>, step?: WithSmallInt<PositiveSafeInt, MaxInt>): Generator<SafeUint, void, unknown>;
+export declare function range(start: WithSmallInt<SafeInt, MaxInt>, end: WithSmallInt<SafeInt, MaxInt>, step?: WithSmallInt<NonZeroSafeInt, MaxInt>): Generator<SafeInt, void, unknown>;
+type MaxInt = 512;
+export {};
 //# sourceMappingURL=range.d.mts.map

package/dist/iterator/range.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"range.d.mts","sourceRoot":"","sources":["../../src/iterator/range.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,oBAAoB,EAC3B,GAAG,EAAE,oBAAoB,EACzB,IAAI,CAAC,EAAE,2BAA2B,GACjC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CACnB,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,mBAAmB,EACxB,IAAI,CAAC,EAAE,0BAA0B,GAChC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC"}
+{"version":3,"file":"range.d.mts","sourceRoot":"","sources":["../../src/iterator/range.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH,wBAAgB,KAAK,CACnB,GAAG,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,GAClC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CACnB,KAAK,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EACrC,GAAG,EAAE,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,EAEnC,IAAI,CAAC,EAAE,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,GAC3C,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAEtC,wBAAgB,KAAK,CACnB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,EACpC,GAAG,EAAE,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,EAClC,IAAI,CAAC,EAAE,YAAY,CAAC,cAAc,EAAE,MAAM,CAAC,GAC1C,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;AAkCrC,KAAK,MAAM,GAAG,GAAG,CAAC"}

package/dist/iterator/range.mjs

@@ -29,9 +29,22 @@ import '../number/enum/uint8.mjs';
 import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
 
-function* range(start, end, step = 1) {
-    for (let mut_i = asSafeInt(start); step > 0 ? mut_i < end : mut_i > end; mut_i = SafeInt.add(mut_i, step)) {
-        yield mut_i;
+function* range(...args) {
+    switch (args.length) {
+        case 1: {
+            const [end] = args;
+            for (const i of range(0, end, 1)) {
+                yield i;
+            }
+            break;
+        }
+        case 2:
+        case 3: {
+            const [start, end, step = 1] = args;
+            for (let mut_i = asSafeInt(start); step > 0 ? mut_i < end : mut_i > end; mut_i = SafeInt.add(mut_i, asSafeInt(step))) {
+                yield mut_i;
+            }
+        }
     }
 }
 

package/dist/iterator/range.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"range.mjs","sources":["../../src/iterator/range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGM,UAAW,KAAK,CACpB,KAA0B,EAC1B,GAAwB,EACxB,IAAA,GAAmC,CAAC,EAAA;AAEpC,IAAA,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,IAAI,CAAC,EAChC;AACA,QAAA,MAAM,KAAK;IACb;AACF;;;;"}
+{"version":3,"file":"range.mjs","sources":["../../src/iterator/range.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA6GiB,KAAK,CACpB,GAAG,IAME,EAAA;AAEL,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI;AAClB,YAAA,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE;AAChC,gBAAA,MAAM,CAAC;YACT;YACA;QACF;AAEA,QAAA,KAAK,CAAC;QACN,KAAK,CAAC,EAAE;YACN,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI;AACnC,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -21,13 +21,13 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./dist/entry-point.d.mts",
+        "default": "./dist/entry-point.mjs"
       }
     }
   },
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "module": "./dist/entry-point.js",
+  "types": "./dist/entry-point.d.ts",
   "files": [
     "src",
     "dist",
@@ -69,7 +69,7 @@
   "devDependencies": {
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.1",
-    "@eslint/js": "^9.30.0",
+    "@eslint/js": "^9.31.0",
     "@mui/material": "^7.2.0",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-strip": "^3.0.4",
@@ -81,7 +81,7 @@
     "@semantic-release/github": "^11.0.3",
     "@semantic-release/npm": "^12.0.2",
     "@semantic-release/release-notes-generator": "^14.0.3",
-    "@types/node": "^20.19.4",
+    "@types/node": "^20.19.7",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.0.0",
@@ -93,14 +93,14 @@
     "prettier": "^3.5.3",
     "prettier-plugin-organize-imports": "^4.1.0",
     "prettier-plugin-packagejson": "^2.5.18",
-    "rollup": "^4.44.2",
-    "semantic-release": "^24.2.6",
-    "ts-repo-utils": "^3.0.1",
+    "rollup": "^4.45.0",
+    "semantic-release": "^24.2.7",
+    "ts-repo-utils": "^3.1.1",
     "tsx": "^4.20.3",
     "typedoc": "^0.28.7",
     "typedoc-plugin-markdown": "^4.7.0",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.35.1",
+    "typescript-eslint": "^8.36.0",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {

package/src/entry-point.mts

@@ -0,0 +1,43 @@
+import 'ts-type-forge';
+
+export * from './index.mjs';
+
+declare global {
+  type SmallPositiveInt = WithSmallInt<PositiveInt>;
+
+  /**
+   * Represents the type of keys that can be used in a standard JavaScript Map.
+   */
+  type MapSetKeyType = Primitive;
+
+  // https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/length
+  // https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/String/length
+  // Max array length : 2^32 - 1
+  // Max string length : 2^53 - 1
+
+  namespace SizeType {
+    type Arr = Uint32;
+    type TypedArray = SafeUint;
+    type Str = SafeUint;
+
+    type ArrSearchResult = Arr | -1;
+    type TypedArraySearchResult = TypedArray | -1;
+    type StrSearchResult = Str | -1;
+
+    type ArgArr = WithSmallInt<Arr>;
+    type ArgTypedArray = WithSmallInt<TypedArray>;
+    type ArgStr = WithSmallInt<Str>;
+
+    type ArgArrWithNegative = WithSmallInt<
+      NormalizeBrandUnion<NegativeInt32 | Arr>
+    >;
+    type ArgTypedArrayWithNegative = WithSmallInt<SafeInt>;
+    type ArgStrWithNegative = WithSmallInt<SafeInt>;
+
+    type ArgArrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Arr>>;
+    type ArgTypedArrayPositive = WithSmallInt<
+      IntersectBrand<PositiveNumber, TypedArray>
+    >;
+    type ArgStrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Str>>;
+  }
+}

package/src/iterator/range.mts

@@ -91,27 +91,52 @@ import { SafeInt, asSafeInt } from '../number/index.mjs';
  * ```
  */
 export function range(
-  start: SafeUintWithSmallInt,
-  end: SafeUintWithSmallInt,
-  step?: PositiveSafeIntWithSmallInt,
+  end: WithSmallInt<SafeUint, MaxInt>,
 ): Generator<SafeUint, void, unknown>;
 
 export function range(
-  start: SafeIntWithSmallInt,
-  end: SafeIntWithSmallInt,
-  step?: NonZeroSafeIntWithSmallInt,
+  start: WithSmallInt<SafeUint, MaxInt>,
+  end: WithSmallInt<SafeUint, MaxInt>,
+  // eslint-disable-next-line @typescript-eslint/unified-signatures
+  step?: WithSmallInt<PositiveSafeInt, MaxInt>,
+): Generator<SafeUint, void, unknown>;
+
+export function range(
+  start: WithSmallInt<SafeInt, MaxInt>,
+  end: WithSmallInt<SafeInt, MaxInt>,
+  step?: WithSmallInt<NonZeroSafeInt, MaxInt>,
 ): Generator<SafeInt, void, unknown>;
 
 export function* range(
-  start: SafeIntWithSmallInt,
-  end: SafeIntWithSmallInt,
-  step: NonZeroSafeIntWithSmallInt = 1,
+  ...args:
+    | readonly [end: WithSmallInt<SafeInt, MaxInt>]
+    | readonly [
+        start: WithSmallInt<SafeInt, MaxInt>,
+        end: WithSmallInt<SafeInt, MaxInt>,
+        step?: WithSmallInt<NonZeroSafeInt, MaxInt>,
+      ]
 ): Generator<SafeInt, void, unknown> {
-  for (
-    let mut_i: SafeInt = asSafeInt(start);
-    step > 0 ? mut_i < end : mut_i > end;
-    mut_i = SafeInt.add(mut_i, step)
-  ) {
-    yield mut_i;
+  switch (args.length) {
+    case 1: {
+      const [end] = args;
+      for (const i of range(0, end, 1)) {
+        yield i;
+      }
+      break;
+    }
+
+    case 2:
+    case 3: {
+      const [start, end, step = 1] = args;
+      for (
+        let mut_i: SafeInt = asSafeInt(start);
+        step > 0 ? mut_i < end : mut_i > end;
+        mut_i = SafeInt.add(mut_i, asSafeInt(step))
+      ) {
+        yield mut_i;
+      }
+    }
   }
 }
+
+type MaxInt = 512;

package/src/iterator/range.test.mts

@@ -7,6 +7,19 @@ describe('range', () => {
     ]);
   });
 
+  test('range(10)', () => {
+    expect(Array.from(range(10))).toStrictEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  });
+
+  test('range(0)', () => {
+    expect(Array.from(range(0))).toStrictEqual([]);
+  });
+
+  test('range(0)', () => {
+    // @ts-expect-error negative end is not allowed
+    expect(Array.from(range(-1))).toStrictEqual([]);
+  });
+
   test('range(10, 0, -1)', () => {
     expect(Array.from(range(10, 0, -1))).toStrictEqual([
       10, 9, 8, 7, 6, 5, 4, 3, 2, 1,

package/dist/globals.d.mts

@@ -1,39 +0,0 @@
-/// <reference types="ts-type-forge" />
-
-type SmallPositiveInt = WithSmallInt<PositiveInt>;
-
-/**
- * Represents the type of keys that can be used in a standard JavaScript Map.
- */
-type MapSetKeyType = Primitive;
-
-// https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/length
-// https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/String/length
-// Max array length : 2^32 - 1
-// Max string length : 2^53 - 1
-
-declare namespace SizeType {
-  type Arr = Uint32;
-  type TypedArray = SafeUint;
-  type Str = SafeUint;
-
-  type ArrSearchResult = Arr | -1;
-  type TypedArraySearchResult = TypedArray | -1;
-  type StrSearchResult = Str | -1;
-
-  type ArgArr = WithSmallInt<Arr>;
-  type ArgTypedArray = WithSmallInt<TypedArray>;
-  type ArgStr = WithSmallInt<Str>;
-
-  type ArgArrWithNegative = WithSmallInt<
-    NormalizeBrandUnion<NegativeInt32 | Arr>
-  >;
-  type ArgTypedArrayWithNegative = WithSmallInt<SafeInt>;
-  type ArgStrWithNegative = WithSmallInt<SafeInt>;
-
-  type ArgArrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Arr>>;
-  type ArgTypedArrayPositive = WithSmallInt<
-    IntersectBrand<PositiveNumber, TypedArray>
-  >;
-  type ArgStrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Str>>;
-}

package/src/globals.d.mts

@@ -1,39 +0,0 @@
-/// <reference types="ts-type-forge" />
-
-type SmallPositiveInt = WithSmallInt<PositiveInt>;
-
-/**
- * Represents the type of keys that can be used in a standard JavaScript Map.
- */
-type MapSetKeyType = Primitive;
-
-// https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/length
-// https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/String/length
-// Max array length : 2^32 - 1
-// Max string length : 2^53 - 1
-
-declare namespace SizeType {
-  type Arr = Uint32;
-  type TypedArray = SafeUint;
-  type Str = SafeUint;
-
-  type ArrSearchResult = Arr | -1;
-  type TypedArraySearchResult = TypedArray | -1;
-  type StrSearchResult = Str | -1;
-
-  type ArgArr = WithSmallInt<Arr>;
-  type ArgTypedArray = WithSmallInt<TypedArray>;
-  type ArgStr = WithSmallInt<Str>;
-
-  type ArgArrWithNegative = WithSmallInt<
-    NormalizeBrandUnion<NegativeInt32 | Arr>
-  >;
-  type ArgTypedArrayWithNegative = WithSmallInt<SafeInt>;
-  type ArgStrWithNegative = WithSmallInt<SafeInt>;
-
-  type ArgArrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Arr>>;
-  type ArgTypedArrayPositive = WithSmallInt<
-    IntersectBrand<PositiveNumber, TypedArray>
-  >;
-  type ArgStrPositive = WithSmallInt<IntersectBrand<PositiveNumber, Str>>;
-}