@synnaxlabs/x 0.26.7 → 0.28.0

package/dist/telem.js

@@ -1,4 +1,4 @@
-import { d as s, D as i, M as t, R as r, S, e as m, c as p, b as T, T as d, a as y, g as l, i as n, f as D, t as o } from "./series-CaeAWaDJ.js";
+import { d as s, D as i, M as t, R as r, S, e as m, c as p, b as T, T as d, a as y, g as l, i as n, f as D, t as o } from "./series-DIZdmPCa.js";
 export {
   s as DataType,
   i as Density,

package/dist/types-BpAJW2TM.js

@@ -0,0 +1,11 @@
+import { z as t } from "zod";
+const e = t.object({
+  key: t.string(),
+  value: t.string()
+}), r = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  stringPairZ: e
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  r as t
+};

package/dist/types-zRwnQ1hc.cjs

@@ -0,0 +1 @@
+"use strict";const e=require("zod"),t=e.z.object({key:e.z.string(),value:e.z.string()}),r=Object.freeze(Object.defineProperty({__proto__:null,stringPairZ:t},Symbol.toStringTag,{value:"Module"}));exports.types=r;

package/dist/zodutil.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./path-Coj1BKMh.cjs"),c=e=>o.transformPath(e,(t,r,n)=>{const u=r===n.length-1,i=!isNaN(parseInt(t)),l=!isNaN(parseInt(n[r+1]));return i&&(t="element"),u||l?t:[t,"shape"]}),s=(e,t)=>{if(e==null)return null;const r=e[t];return r==null&&typeof e=="object"&&"sourceType"in e?e.sourceType()[t]:r},a=(e,t,r)=>o.get(s(e,"shape"),c(t),{...r,getter:s}),p=Object.freeze(Object.defineProperty({__proto__:null,getFieldSchema:a,getFieldSchemaPath:c},Symbol.toStringTag,{value:"Module"}));exports.zodutil=p;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./path-577Fmn5N.cjs"),c=e=>o.transformPath(e,(t,r,n)=>{const u=r===n.length-1,i=!isNaN(parseInt(t)),l=!isNaN(parseInt(n[r+1]));return i&&(t="element"),u||l?t:[t,"shape"]}),s=(e,t)=>{if(e==null)return null;const r=e[t];return r==null&&typeof e=="object"&&"sourceType"in e?e.sourceType()[t]:r},a=(e,t,r)=>o.get(s(e,"shape"),c(t),{...r,getter:s}),p=Object.freeze(Object.defineProperty({__proto__:null,getFieldSchema:a,getFieldSchemaPath:c},Symbol.toStringTag,{value:"Module"}));exports.zodutil=p;

package/dist/zodutil.js

@@ -1,4 +1,4 @@
-import { t as l, g as a } from "./path-DH9iaDDf.js";
+import { t as l, g as a } from "./path-B-1-i3qC.js";
 const o = (e) => l(e, (t, r, n) => {
   const c = r === n.length - 1, u = !isNaN(parseInt(t)), i = !isNaN(parseInt(n[r + 1]));
   return u && (t = "element"), c || i ? t : [t, "shape"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/x",
-  "version": "0.26.7",
+  "version": "0.28.0",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/go",
@@ -24,8 +24,8 @@
     "vite": "5.3.3",
     "vitest": "^1.6.0",
     "@synnaxlabs/tsconfig": "0.0.2",
-    "eslint-config-synnaxlabs": "0.0.1",
-    "@synnaxlabs/vite-plugin": "0.0.1"
+    "@synnaxlabs/vite-plugin": "0.0.1",
+    "eslint-config-synnaxlabs": "0.0.1"
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

package/src/caseconv/caseconv.spec.ts

@@ -1,3 +1,12 @@
+// Copyright 2024 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
 import { describe, expect, it } from "vitest";
 
 import { caseconv } from "@/caseconv";

package/src/compare/compare.ts

@@ -115,12 +115,18 @@ export const LESS_THAN = -1;
 /** The greater than return value of a compare function. */
 export const GREATER_THAN = 1;
 
+/** @returns true if the result of the comparison is less than 0. */
 export const isLessThan = (n: number): boolean => n < EQUAL;
 
+/** @returns true if the result of the comparison is greater than 0. */
 export const isGreaterThan = (n: number): boolean => n > EQUAL;
 
+/** @returns true if the result of the comparison is equal to 0. */
 export const isGreaterThanEqual = (n: number): boolean => n >= EQUAL;
 
+/** @returns true if the result of the comparison is equal to 0. */
+export const isEqualTo = (n: number): boolean => n === EQUAL;
+
 export const stringsWithNumbers = (a: string, b: string): number => {
   const alphaNumericRegex = /([a-zA-Z]+)|(\d+)/g;
 

package/src/control/index.ts

@@ -1 +1,10 @@
+// Copyright 2024 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
 export * as control from "@/control/control";

package/src/deep/path.spec.ts

@@ -144,4 +144,33 @@ describe("path", () => {
       expect(deep.pathsMatch("a.b.c", "")).toEqual(true);
     });
   });
+  describe("delete", () => {
+    const a: TestRecord = {
+      a: 1,
+      b: {
+        c: 2,
+      },
+      c: [1, 2, 3],
+    };
+    it("should delete a key", () => {
+      const cpy = deep.copy(a);
+      deep.remove(a, "b.c");
+      expect(a).toEqual({ ...cpy, b: {} });
+    });
+    it("should delete an array index", () => {
+      const cpy = deep.copy(a);
+      deep.remove(a, "c.1");
+      expect(a).toEqual({ ...cpy, c: [1, 3] });
+    });
+    it("should not throw an error when the index is out of bounds", () => {
+      const cpy = deep.copy(a);
+      deep.remove(a, "c.100");
+      expect(a).toEqual(cpy);
+    });
+    it("should not throw an error when the key exists", () => {
+      const cpy = deep.copy(a);
+      deep.remove(a, "b.d");
+      expect(a).toEqual(cpy);
+    });
+  });
 });

package/src/deep/path.ts

@@ -36,6 +36,10 @@ type Prev = [
   ...Array<0>,
 ];
 
+/**
+ * A type that represents a deep key in an object.
+ * @example type Key<T, 3> = "a" | "a.b" | "a.b.c"
+ */
 export type Key<T, D extends number = 5> = [D] extends [never]
   ? never
   : T extends object
@@ -46,11 +50,24 @@ export type Key<T, D extends number = 5> = [D] extends [never]
       }[keyof T]
     : "";
 
+/** Options for the get function. */
 export interface GetOptions<O extends boolean | undefined = boolean | undefined> {
   optional: O;
   getter?: (obj: UnknownRecord, key: string) => unknown;
+  separator?: string;
 }
 
+/**
+ * A function that gets the value at the given path on the object. If the path does not exist
+ * and the optional flag is set to true, null will be returned. If the path does not exist and
+ * the optional flag is set to false, an error will be thrown.
+ * @param obj the object to get the value from.
+ * @param path the path to get the value at.
+ * @param options the options for getting the value.
+ * @param options.optional whether the path is optional.
+ * @param options.getter a custom getter function to use on each part of the path.
+ * @returns the value at the given path on the object.
+ */
 export interface Get {
   <V = unknown, T = UnknownRecord>(
     obj: T,
@@ -64,11 +81,20 @@ export interface Get {
   ): V | null;
 }
 
+/** A strongly typed version of the @see Get function. */
 export interface TypedGet<V = unknown, T = UnknownRecord> {
   (obj: T, path: string, options?: GetOptions<false>): V;
   (obj: T, path: string, options?: GetOptions<boolean | undefined>): V | null;
 }
 
+/**
+ * Executes the given replacer function on each part of the path.
+ * @param path the path to transform
+ * @param replacer the function to execute on each part of the path. If multiple
+ * parts are returned, they will be joined with a period. If null/undefined is returned,
+ * the part will be removed from the path.
+ * @returns the transformed path.
+ */
 export const transformPath = (
   path: string,
   replacer: (
@@ -76,26 +102,39 @@ export const transformPath = (
     index: number,
     parts: string[],
   ) => string | string[] | undefined,
+  separator = ".",
 ): string => {
-  const parts = path.split(".");
+  const parts = path.split(separator);
   const result = parts
     .map((part, index) => {
       const r = replacer(part, index, parts);
       if (r == null) return null;
       if (typeof r === "string") return r;
-      return r.join(".");
+      return r.join(separator);
     })
     .filter((part) => part != null) as string[];
-  return result.join(".");
+  return result.join(separator);
 };
 
+/**
+ * Gets the value at the given path on the object. If the path does not exist
+ * and the optional flag is set to true, null will be returned. If the path does
+ * not exist and the optional flag is set to false, an error will be thrown.
+ * @param obj the object to get the value from.
+ * @param path the path to get the value at.
+ * @param opts the options for getting the value.
+ * @param opts.optional whether the path is optional.
+ * @param opts.getter a custom getter function to use on each part of the path.
+ * @returns the value at the given path on the object.
+ */
 export const get = (<V = unknown, T = UnknownRecord>(
   obj: T,
   path: string,
-  opts: GetOptions = { optional: false },
+  opts: GetOptions = { optional: false, separator: "." },
 ): V | null => {
+  opts.separator ??= ".";
   const { optional, getter = (obj, key) => (obj as UnknownRecord)[key] } = opts;
-  const parts = path.split(".");
+  const parts = path.split(opts.separator);
   if (parts.length === 1 && parts[0] === "") return obj as unknown as V;
   let result: UnknownRecord = obj as UnknownRecord;
   for (const part of parts) {
@@ -109,27 +148,66 @@ export const get = (<V = unknown, T = UnknownRecord>(
   return result as V;
 }) as unknown as Get;
 
+/**
+ * Sets the value at the given path on the object. If the parents of the deep path
+ * do not exist, new objects will be created.
+ * @param obj the object to set the value on.
+ * @param path the path to set the value at.
+ * @param value the value to set.
+ */
 export const set = <V>(obj: V, path: string, value: unknown): void => {
   const parts = path.split(".");
   let result: UnknownRecord = obj as UnknownRecord;
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i];
-    if (result[part] == null) {
-      throw new Error(`Path ${path} does not exist`);
-    }
+    if (result[part] == null) result[part] = {};
     result = result[part] as UnknownRecord;
   }
   result[parts[parts.length - 1]] = value;
 };
 
+/**
+ * Removes the value at the given path, modifying the object in place.
+ * @param obj the object to remove the value from.
+ * @param path the path to remove the value from.
+ * @returns the object with the value removed.
+ */
+export const remove = <V>(obj: V, path: string): void => {
+  const parts = path.split(".");
+  let result: UnknownRecord = obj as UnknownRecord;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (result[part] == null) return;
+    result = result[part] as UnknownRecord;
+  }
+  // if its an array, we need to splice it
+  if (Array.isArray(result)) {
+    const index = parseInt(parts[parts.length - 1], 10);
+    if (isNaN(index)) return;
+    result.splice(index, 1);
+    return;
+  }
+  delete result[parts[parts.length - 1]];
+};
+
+/**
+ * Returns the element at the given index in the path.
+ * @param path the path to get the element from
+ * @param index the index of the element to get
+ * @returns the element at the given index in the path
+ */
 export const element = (path: string, index: number): string => {
   const parts = path.split(".");
   if (index < 0) return parts[parts.length + index];
   return parts[index];
 };
 
-export const join = (path: string[]): string => path.join(".");
-
+/**
+ * Checks if the path exists in the object.
+ * @param obj the object to check
+ * @param path the path to check
+ * @returns whether the path exists in the object
+ */
 export const has = <V = unknown, T = UnknownRecord>(obj: T, path: string): boolean => {
   try {
     get<V, T>(obj, path);
@@ -139,6 +217,20 @@ export const has = <V = unknown, T = UnknownRecord>(obj: T, path: string): boole
   }
 };
 
+/**
+ * Checks if the path matches the given pattern.
+ *
+ * @param path The path to check.
+ * @param pattern The pattern to match against. Only "*" is supported as a wildcard.
+ * @returns Whether the path matches the pattern.
+ *
+ *  * @example
+ * pathsMatch("a.b.c", "a.b.c") // true
+ * pathsMatch("a.b.c", "a.b") // true
+ * pathsMatch("a.b", "a.b.c") // false
+ * pathsMatch("a.b.c", "a.*") // true
+ * pathsMatch("a.b.c", "a.*.c") // true
+ */
 export const pathsMatch = (path: string, pattern: string): boolean => {
   if (pattern.length === 0) return true;
   const parts = path.split(".");

package/src/errors/errors.ts

@@ -1,3 +1,12 @@
+// Copyright 2024 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
 class Canceled extends Error {
   static readonly MESSAGE = "canceled";
   constructor() {

package/src/errors/index.ts

@@ -1 +1,10 @@
+// Copyright 2024 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
 export * as errors from "@/errors/errors";

package/src/kv/types.ts

@@ -7,6 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { z } from "zod";
+
 export interface KV<K = string, V = string, WK = K, WV = V, D = K>
   extends Reader<K, V>,
     Writer<WK, WV>,
@@ -50,3 +52,14 @@ export interface AsyncDeleter<K = string> {
   /** Deletes a key-value pair from the store. */
   delete: (key: K) => Promise<void>;
 }
+
+export const stringPairZ = z.object({
+  key: z.string(),
+  value: z.string(),
+});
+
+/** A general purpose key-value pair. */
+export interface Pair<K = string, V = string> {
+  key: K;
+  value: V;
+}

package/src/migrate/migrate.spec.ts

@@ -61,6 +61,84 @@ describe("compareSemVer", () => {
     expect(migrate.compareSemVer("1.0.0", "0.0.0")).toBeGreaterThan(0);
     expect(migrate.semVerNewer("3.0.0", "0.3.0")).toBeTruthy();
   });
+  describe("only check major", () => {
+    it("should return equal when the major versions are equal but the minor and patch are different", () => {
+      expect(
+        migrate.compareSemVer("1.0.0", "1.1.0", {
+          checkMinor: false,
+          checkPatch: false,
+        }),
+      ).toBe(0);
+    });
+    it("should return greater than when the major version is higher", () => {
+      expect(
+        migrate.compareSemVer("2.0.0", "1.1.0", {
+          checkMinor: false,
+          checkPatch: false,
+        }),
+      ).toBeGreaterThan(0);
+    });
+    it("should return less than when the major version is lower", () => {
+      expect(
+        migrate.compareSemVer("1.0.0", "2.1.0", {
+          checkMinor: false,
+          checkPatch: false,
+        }),
+      ).toBeLessThan(0);
+    });
+  });
+  describe("only check minor", () => {
+    it("should return equal when the minor versions are equal but the major and patch are different", () => {
+      expect(
+        migrate.compareSemVer("1.0.0", "2.0.0", {
+          checkMajor: false,
+          checkPatch: false,
+        }),
+      ).toBe(0);
+    });
+    it("should return greater than when the minor version is higher", () => {
+      expect(
+        migrate.compareSemVer("1.2.0", "1.1.0", {
+          checkMajor: false,
+          checkPatch: false,
+        }),
+      ).toBeGreaterThan(0);
+    });
+    it("should return less than when the minor version is lower", () => {
+      expect(
+        migrate.compareSemVer("1.0.0", "1.1.0", {
+          checkMajor: false,
+          checkPatch: false,
+        }),
+      ).toBeLessThan(0);
+    });
+  });
+  describe("only check patch", () => {
+    it("should return equal when the patch versions are equal but the major and minor are different", () => {
+      expect(
+        migrate.compareSemVer("2.1.1", "2.2.1", {
+          checkMajor: false,
+          checkMinor: false,
+        }),
+      ).toBe(0);
+    });
+    it("should return greater than when the patch version is higher", () => {
+      expect(
+        migrate.compareSemVer("1.4.2", "1.9.1", {
+          checkMajor: false,
+          checkMinor: false,
+        }),
+      ).toBeGreaterThan(0);
+    });
+    it("should return less than when the patch version is lower", () => {
+      expect(
+        migrate.compareSemVer("10000.2.0", "95.6.1", {
+          checkMajor: false,
+          checkMinor: false,
+        }),
+      ).toBeLessThan(0);
+    });
+  });
 });
 
 describe("migrator", () => {

package/src/migrate/migrate.ts

@@ -15,40 +15,100 @@ export const semVerZ = z.string().regex(/^\d+\.\d+\.\d+$/);
 
 export type SemVer = z.infer<typeof semVerZ>;
 
+export interface CompareSemVerOptions {
+  /**
+   * Whether to validate that major versions are equal.
+   * @default true
+   */
+  checkMajor?: boolean;
+  /**
+   * Whether to validate that minor versions are equal.
+   * @default true
+   */
+  checkMinor?: boolean;
+  /**
+   * Whether to validate that patch versions are equal.
+   * @default true
+   */
+  checkPatch?: boolean;
+}
+
 /**
  * Compares the two semantic versions.
  *
  * @param a  The first semantic version.
  * @param b  The second semantic version.
+ * @param opts - Optional object to disable checking specific version parts
+ * (major, minor, patch).
  * @returns a number, where the the number is compare.LESS_THAN (negative) if a is OLDER
  * than B, compare.EQUAL (0) if a is the same as b, and compare.GREATER_THAN (positive)
  * if a is NEWER than b.
  */
-export const compareSemVer: compare.CompareF<string> = (a, b) => {
+export const compareSemVer = ((
+  a: SemVer,
+  b: SemVer,
+  opts: CompareSemVerOptions = {},
+) => {
+  opts.checkMajor ??= true;
+  opts.checkMinor ??= true;
+  opts.checkPatch ??= true;
   const semA = semVerZ.parse(a);
   const semB = semVerZ.parse(b);
   const [aMajor, aMinor, aPatch] = semA.split(".").map(Number);
   const [bMajor, bMinor, bPatch] = semB.split(".").map(Number);
-  if (aMajor !== bMajor) return aMajor - bMajor;
-  if (aMinor !== bMinor) return aMinor - bMinor;
-  return aPatch - bPatch;
-};
+  if (opts.checkMajor) {
+    if (aMajor < bMajor) return compare.LESS_THAN;
+    if (aMajor > bMajor) return compare.GREATER_THAN;
+  }
+  if (opts.checkMinor) {
+    if (aMinor < bMinor) return compare.LESS_THAN;
+    if (aMinor > bMinor) return compare.GREATER_THAN;
+  }
+  if (opts.checkPatch) {
+    if (aPatch < bPatch) return compare.LESS_THAN;
+    if (aPatch > bPatch) return compare.GREATER_THAN;
+  }
+  return compare.EQUAL;
+}) satisfies compare.CompareF<SemVer>;
+
+/**
+ * @returns true if the two semantic versions are equal.
+ * @param a - The first semantic version.
+ * @param b - The second semantic version.
+ * @param opts - Optional object to disable checking specific version parts
+ * (major, minor, patch).
+ */
+export const versionsEqual = (
+  a: SemVer,
+  b: SemVer,
+  opts: CompareSemVerOptions = {},
+): boolean => compare.isEqualTo(compareSemVer(a, b, opts));
 
 /**
  * @returns true if the first semantic version is newer than the second.
  * @param a The first semantic version.
  * @param b The second semantic version.
+ * @param opts - Optional object to disable checking specific version parts
+ * (major, minor, patch).
  */
-export const semVerNewer = (a: SemVer, b: SemVer): boolean =>
-  compare.isGreaterThan(compareSemVer(a, b));
+export const semVerNewer = (
+  a: SemVer,
+  b: SemVer,
+  opts: CompareSemVerOptions = {},
+): boolean => compare.isGreaterThan(compareSemVer(a, b, opts));
 
 /**
  * @returns true if the first semantic version is older than the second.
  * @param a The first semantic version.
  * @param b The second semantic version.
+ * @param opts - Optional object to disable checking specific version parts
+ * (major, minor, patch).
  */
-export const semVerOlder = (a: SemVer, b: SemVer): boolean =>
-  compare.isLessThan(compareSemVer(a, b));
+export const semVerOlder = (
+  a: SemVer,
+  b: SemVer,
+  opts: CompareSemVerOptions = {},
+): boolean => compare.isLessThan(compareSemVer(a, b, opts));
 
 export type Migratable<V extends string = string> = { version: V };
 

package/src/mock/MockGLBufferController.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type Mock,vi } from "vitest";
+import { type Mock, vi } from "vitest";
 
 import { type GLBufferController } from "@/telem/gl";
 
@@ -20,14 +20,14 @@ export class MockGLBufferController implements GLBufferController {
   counter: number = 0;
   buffers: Record<number, ArrayBuffer> = {};
 
-  createBufferMock: Mock<[], WebGLBuffer | null> = vi.fn();
-  bufferDataMock: Mock<[number, ArrayBufferLike | number, number]> = vi.fn();
-  bufferSubDataMock: Mock<[number, number, ArrayBufferLike]> = vi.fn();
-  bindBufferMock: Mock<[number, WebGLBuffer | null]> = vi.fn();
-  deleteBufferMock: Mock<[WebGLBuffer | null]> = vi.fn();
+  createBufferMock: Mock<() => WebGLBuffer | null> = vi.fn();
+  bufferDataMock: Mock<(a: number, b: ArrayBufferLike | number, c: number) => void> =
+    vi.fn();
+  bufferSubDataMock: Mock<(a: number, b: number, c: ArrayBufferLike) => void> = vi.fn();
+  bindBufferMock: Mock<(a: number, b: WebGLBuffer | null) => void> = vi.fn();
+  deleteBufferMock: Mock<(a: WebGLBuffer | null) => void> = vi.fn();
 
   deleteBuffer(buffer: WebGLBuffer | null): void {
-     
     if (buffer != null) delete this.buffers[buffer as number];
     this.deleteBufferMock(buffer);
   }

package/src/numeric/index.ts

@@ -1 +1,10 @@
+// Copyright 2024 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
 export * as numeric from "@/numeric/numeric";

package/src/numeric/numeric.ts

@@ -1,3 +1,12 @@
+// Copyright 2024 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
 export type Value = number | bigint;
 export type ValueGuard<T> = [T] extends [number]
   ? number