@limitlesspc/std 0.20.2

package/dist/math/index.d.ts

@@ -0,0 +1,463 @@
+import { int, uint } from '../types.js';
+import { a as Vec } from '../vec3-D7Wuy2AZ.js';
+export { R as ReadonlyVec3Like, V as Vec3, b as Vec3Like, v as vec3 } from '../vec3-D7Wuy2AZ.js';
+
+/**
+ * Determines if a value is a number other than `NaN`
+ * @param x
+ */
+declare function isNumber(x: unknown): x is number;
+/**
+ * Determines if a value is a finite number other than `NaN`
+ * @param x
+ */
+declare function isReal(x: unknown): x is number;
+/**
+ * Determines if a value is an integer
+ * @param x
+ */
+declare function isInteger(x: unknown): x is int;
+/**
+ * Rounds `x` to the nearest multiple of `n`
+ * @param x the number to round
+ * @param n the multiple to round to
+ */
+declare function roundToMultiple(x: number, n: number): number;
+/**
+ * Rounds `x` to the nearest even number
+ * @param x
+ */
+declare function roundToEven(x: number): number;
+declare function norm(x: number, min: number, max: number): number;
+declare function lerp(min: number, max: number, norm: number): number;
+declare function map(x: number, fromMin: number, fromMax: number, toMin: number, toMax: number): number;
+declare function step(x: number, edge?: number): number;
+declare function smoothstep(x: number, min: number, max: number): number;
+declare function smootherstep(x: number, min: number, max: number): number;
+declare function clamp(n: number, min: number, max: number): number;
+declare function overlap(min1: number, max1: number, min2: number, max2: number): number;
+/** Returns which number (a or b) is closer to x */
+declare function closer(x: number, a: [number, number], b: [number, number]): number;
+declare function round(n: number, precision?: int): number;
+declare function floor(n: number, precision?: int): number;
+declare function ceil(n: number, precision?: int): number;
+declare function trunc(n: number, precision?: int): number;
+declare function fract(x: number): number;
+declare function closeTo(n: number, target: number, precision?: int): boolean;
+declare function factorial(n: uint): number;
+declare function log(base: number, x: number): number;
+declare const ln: (x: number) => number;
+/**
+ * Calculates the greatest common factor between the numbers
+ * a and b using the [Euclidean algorithm](https://www.wikiwand.com/en/Euclidean_algorithm)
+ * @param a a number
+ * @param b a number
+ */
+declare function gcd(a: uint, b: uint): number;
+declare function fibonacci(n: uint): number;
+/** Convert farhenheit to celsius */
+declare const celsius: (fahrenheit: number) => number;
+/** Convert celsius to farhenheit */
+declare const fahrenheit: (celsius: number) => number;
+/**
+ * @param points a list of (x,y) points
+ * @returns the line of best fit in terms of m and b in the form y = mx + b
+ */
+declare function lineOfBestFit(points: Array<{
+    x: number;
+    y: number;
+}>): [m: number, b: number];
+/**
+ * Calculates the number of ways to choose `k` items from `n` items without repeating and with ordering
+ * @param n the number of items
+ * @param k the number of choices being made
+ */
+declare function permutations(n: uint, k: uint): number;
+/**
+ * Calculates the number of ways to choose `k` items from `n` items without repeating or ordering
+ * @param n the number of items
+ * @param k the number of choices being made
+ */
+declare function combinations(n: uint, k: uint): number;
+declare function dot(a: Iterable<number>, b: Iterable<number>): number;
+
+/** @unstable */
+declare class Mat extends Float32Array {
+    rows: uint;
+    constructor(rows: uint, cols: uint);
+    constructor(mat: number[][]);
+    get cols(): number;
+    toString(): string;
+    copy(): Mat;
+    static random(rows: uint, cols: uint): Mat;
+    eq(m: Mat, precision?: uint): boolean;
+    add(m: Mat): this;
+    static add(m1: Mat, m2: Mat): Mat;
+    sub(m: Mat): this;
+    static sub(m1: Mat, m2: Mat): Mat;
+    mul(m: Mat | number): this;
+    static mul(m1: Mat, m2: Mat | number): Mat;
+    div(m: number): this;
+    static transpose(m: Mat): Mat;
+}
+declare function mat(rows: uint, cols: uint): Mat;
+declare function mat(mat: number[][]): Mat;
+
+type Mat2Like = [m00: number, m01: number, m10: number, m11: number] | Float32Array;
+type ReadonlyMat2Like = Readonly<Mat2Like>;
+declare class Mat2 extends Float32Array {
+    static readonly BYTE_LENGTH: number;
+    constructor(matrix?: ReadonlyMat2Like);
+    toString(): string;
+    copy(): Mat2;
+    identity(): Mat2;
+    eq(m: ReadonlyMat2Like, precision?: int): boolean;
+    add(m: ReadonlyMat2Like): this;
+    static add(m1: Mat2, m2: ReadonlyMat2Like): Mat2;
+    sub(m: ReadonlyMat2Like): this;
+    static sub(m1: Mat2, m2: ReadonlyMat2Like): Mat2;
+    mul(m: number | ReadonlyMat2Like): this;
+    static mul(m1: ReadonlyMat2Like, m2: number | ReadonlyMat2Like): Mat2;
+    div(m: number): this;
+    transpose(): this;
+    det(): number;
+    adj(): Mat2;
+    inv(): Mat2;
+}
+declare function mat2(matrix?: ReadonlyMat2Like): Mat2;
+
+type Mat3Like = [
+    m00: number,
+    m01: number,
+    m02: number,
+    m10: number,
+    m11: number,
+    m12: number,
+    m20: number,
+    m21: number,
+    m22: number
+] | Float32Array;
+type ReadonlyMat3Like = Readonly<Mat3Like>;
+declare class Mat3 extends Float32Array {
+    static readonly BYTE_LENGTH: number;
+    constructor(matrix?: ReadonlyMat3Like);
+    toString(): string;
+    copy(): Mat3;
+    identity(): this;
+    eq(m: ReadonlyMat3Like, precision?: int): boolean;
+    add(m: ReadonlyMat3Like): this;
+    static add(m1: Mat3, m2: ReadonlyMat3Like): Mat3;
+    sub(m: ReadonlyMat3Like): this;
+    static sub(m1: Mat3, m2: ReadonlyMat3Like): Mat3;
+    mul(m: number | ReadonlyMat3Like): this;
+    static mul(m1: ReadonlyMat3Like, m2: number | ReadonlyMat3Like): Mat3;
+    div(m: number): this;
+    transpose(): this;
+    det(): number;
+    adj(): Mat3;
+    inv(): Mat3;
+}
+declare function mat3(matrix?: ReadonlyMat3Like): Mat3;
+
+type Mat4Like = [
+    m00: number,
+    m01: number,
+    m02: number,
+    m03: number,
+    m10: number,
+    m11: number,
+    m12: number,
+    m13: number,
+    m20: number,
+    m21: number,
+    m22: number,
+    m23: number,
+    m30: number,
+    m31: number,
+    m32: number,
+    m33: number
+] | Float32Array;
+type ReadonlyMat4Like = Readonly<Mat4Like>;
+declare class Mat4 extends Float32Array {
+    constructor(matrix?: ReadonlyMat4Like);
+    toString(): string;
+    copy(): Mat4;
+    eq(m: ReadonlyMat4Like, precision?: int): boolean;
+    add(m: ReadonlyMat4Like): this;
+    static add(m1: Mat4, m2: ReadonlyMat4Like): Mat4;
+    sub(m: ReadonlyMat4Like): this;
+    static sub(m1: Mat4, m2: ReadonlyMat4Like): Mat4;
+    mul(m: number | ReadonlyMat4Like): this;
+    static mul(m1: ReadonlyMat4Like, m2: number | ReadonlyMat4Like): Mat4;
+    div(m: number): this;
+    transpose(): this;
+    det(): number;
+    adj(): Mat4;
+    inv(): Mat4;
+}
+declare function mat4(matrix?: ReadonlyMat4Like): Mat4;
+
+/**
+ * @module
+ * Functions for working with numbers
+ */
+/**
+ * Returns the minimum value in an iterable of numbers
+ * @param iter The iterable of numbers
+ * @returns The minimum value
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const minValue = min(numbers);
+ * console.log(minValue); // 1
+ * ```
+ */
+declare function min(iter: Iterable<number>): number;
+/**
+ * Returns the maximum value in an iterable of numbers
+ * @param iter The iterable of numbers
+ * @returns The maximum value
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const maxValue = max(numbers);
+ * console.log(maxValue); // 5
+ * ```
+ */
+declare function max(iter: Iterable<number>): number;
+/**
+ * Returns the minimum and maximum values in an iterable of numbers
+ * @param iter The iterable of numbers
+ * @returns A tuple containing the minimum and maximum values
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const [min, max] = minmax(numbers);
+ * console.log(min); // 1
+ * console.log(max); // 5
+ * ```
+ */
+declare function minmax(iter: Iterable<number>): [min: number, max: number];
+/**
+ * Returns the sum of an iterable of numbers
+ * @param iter The iterable of numbers
+ * @returns The sum
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const total = sum(numbers);
+ * console.log(total); // 15
+ * ```
+ */
+declare function sum(iter: Iterable<number>): number;
+/**
+ * Returns each number in an iterable multiplied together. If the iterable is empty, returns 1.
+ * @param iter The iterable of numbers
+ * @returns The product
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const product = product(numbers);
+ * console.log(product); // 120
+ * ```
+ */
+declare function product(iter: Iterable<number>): number;
+/**
+ * Returns the average of an iterable of numbers
+ * @param iter The iterable of numbers
+ * @returns The average
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const average = avg(numbers);
+ * console.log(average); // 3
+ * ```
+ */
+declare function avg(iter: Iterable<number>): number;
+/**
+ * Returns the median, or middle, of an array of numbers, or 0 if the array is empty.
+ * @param array The array of numbers
+ * @returns The median
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const median = median(numbers);
+ * console.log(median); // 3
+ *
+ * const numbers2 = [1, 2, 3, 4, 5, 6];
+ * const median2 = median(numbers2);
+ * console.log(median2); // 3.5
+ * ```
+ */
+declare function median(array: number[]): number;
+/**
+ * Returns the mode, or most common, elements of an iterable
+ * @param iter The iterable of numbers
+ * @returns The mode
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 3, 4, 5, 5, 5];
+ * const mode = mode(numbers);
+ * console.log(mode); // [5]
+ *
+ * const numbers2 = [1, 2, 3, 3, 4, 5, 5];
+ * const mode2 = mode(numbers2);
+ * console.log(mode2); // [3, 5]
+ * ```
+ */
+declare function mode<T>(iter: Iterable<T>): T[];
+/**
+ * Returns the variance of an iterable of numbers
+ * @param iter The iterable of numbers
+ * @returns The variance
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const variance = variance(numbers);
+ * console.log(variance); // 2.5
+ * ```
+ */
+declare function variance(iter: Iterable<number>): number;
+/**
+ * Returns the standard deviation of an iterable of numbers
+ * @param iter The iterable of numbers
+ * @returns The standard deviation
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const stddev = stddev(numbers);
+ * console.log(stddev); // 1.5811388300841898
+ * ```
+ */
+declare function stddev(iter: Iterable<number>): number;
+/**
+ * Returns the mean absolute deviation of an iterable of numbers
+ * @param iter The iterable of numbers
+ * @returns The mean absolute deviation
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5];
+ * const mad = meanAbsDev(numbers);
+ * console.log(mad); // 1.2
+ * ```
+ */
+declare function meanAbsDev(iter: Iterable<number>): number;
+
+/** The ratio to convert degrees to radians */
+declare const DEG2RAD: number;
+/** Converts radians to degrees */
+declare const degrees: (radians: number) => number;
+/** Converts degrees to radians */
+declare const radians: (degrees: number) => number;
+
+type Vec2Like = [x: number, y: number] | Float32Array;
+type ReadonlyVec2Like = Readonly<Vec2Like>;
+type First$1 = ReadonlyVec2Like | number;
+declare class Vec2 extends Float32Array implements Vec {
+    static readonly BYTE_LENGTH: number;
+    constructor(x?: First$1, y?: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    toString(): string;
+    copy(): Vec2;
+    static random(mag?: number): Vec2;
+    eq(x: First$1, y?: number): boolean;
+    add(x: First$1, y?: number): this;
+    static add(v1: Vec2, x: First$1, y?: number): Vec2;
+    sub(x: First$1, y?: number): this;
+    static sub(v1: Vec2, x: First$1, y?: number): Vec2;
+    mul(x: First$1, y?: number): this;
+    static mul(v1: Vec2, x: First$1, y?: number): Vec2;
+    div(x: First$1, y?: number): this;
+    static div(v1: Vec2, x: First$1, y?: number): Vec2;
+    static fma(a: ReadonlyVec2Like, b: ReadonlyVec2Like, c: ReadonlyVec2Like): Vec2;
+    lt(x: ReadonlyVec2Like): Vec2;
+    lte(x: ReadonlyVec2Like): Vec2;
+    gt(x: ReadonlyVec2Like): Vec2;
+    gte(x: ReadonlyVec2Like): Vec2;
+    mag(): number;
+    setMag(n: number): this;
+    magSq(): number;
+    limit(max: number): this;
+    normalize(): this;
+    static normalize(v: Vec2): Vec2;
+    dist(v: Vec2): number;
+    distSq(v: Vec2): number;
+    dot(v: ReadonlyVec2Like): number;
+    cross(v: ReadonlyVec2Like): number;
+    lerp(v: ReadonlyVec2Like, norm: number): this;
+    static lerp(v1: Vec2, v2: ReadonlyVec2Like, norm: number): Vec2;
+    clamp(min: ReadonlyVec2Like, max: ReadonlyVec2Like): this;
+    static clamp(v: Vec2, min: ReadonlyVec2Like, max: ReadonlyVec2Like): Vec2;
+    perp(): Vec2;
+    angle(): number;
+    setAngle(a: number): this;
+    static fromAngle(a: number, mag?: number): Vec2;
+    rotate(angle: number): this;
+    static rotate(v: Vec2, angle: number): Vec2;
+    rotateAbout(angle: number, center: Vec2): this;
+    reflect(normal: Vec2): this;
+    refract(normal: Vec2, eta: number): this;
+}
+declare function vec2(x?: First$1, y?: number): Vec2;
+
+type Vec4Like = [x: number, y: number, z: number, w: number] | Float32Array;
+type ReadonlyVec4Like = Readonly<Vec4Like>;
+type First = ReadonlyVec4Like | number;
+declare class Vec4 extends Float32Array implements Vec {
+    static readonly BYTE_LENGTH: number;
+    constructor(x?: First, y?: number, z?: number, w?: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get w(): number;
+    set w(value: number);
+    get r(): number;
+    set r(value: number);
+    get g(): number;
+    set g(value: number);
+    get b(): number;
+    set b(value: number);
+    get a(): number;
+    set a(value: number);
+    toString(): string;
+    copy(): Vec4;
+    eq(x: First, y?: number, z?: number, w?: number): boolean;
+    add(x: First, y?: number, z?: number, w?: number): this;
+    static add(v1: Vec4, x: First, y?: number, z?: number, w?: number): Vec4;
+    sub(x: First, y?: number, z?: number, w?: number): this;
+    static sub(v1: Vec4, x: First, y?: number, z?: number, w?: number): Vec4;
+    mul(x: First, y?: number, z?: number, w?: number): this;
+    static mul(v1: Vec4, x: First, y?: number, z?: number, w?: number): Vec4;
+    div(x: First, y?: number, z?: number, w?: number): this;
+    static div(v1: Vec4, x: First, y?: number, z?: number, w?: number): Vec4;
+    static fma(a: ReadonlyVec4Like, b: ReadonlyVec4Like, c: ReadonlyVec4Like): Vec4;
+    lt(x: ReadonlyVec4Like): Vec4;
+    lte(x: ReadonlyVec4Like): Vec4;
+    gt(x: ReadonlyVec4Like): Vec4;
+    gte(x: ReadonlyVec4Like): Vec4;
+    limit(max: number): this;
+    normalize(): this;
+    static normalize(v: Vec4): Vec4;
+    mag(): number;
+    setMag(n: number): this;
+    magSq(): number;
+    dist(v: Vec4): number;
+    distSq(v: Vec4): number;
+    dot(v: ReadonlyVec4Like): number;
+    lerp(v: ReadonlyVec4Like, norm: number): this;
+    static lerp(v1: Vec4, v2: ReadonlyVec4Like, norm: number): Vec4;
+    clamp(min: ReadonlyVec4Like, max: ReadonlyVec4Like): this;
+    static clamp(v: Vec4, min: ReadonlyVec4Like, max: ReadonlyVec4Like): Vec4;
+    reflect(normal: Vec4): Vec4;
+    static reflect(v: Vec4, normal: Vec4): Vec4;
+    refract(normal: Vec4, eta: number): this;
+}
+declare function vec4(x?: First, y?: number, z?: number, w?: number): Vec4;
+
+export { DEG2RAD, Mat, Mat2, type Mat2Like, Mat3, type Mat3Like, Mat4, type Mat4Like, type ReadonlyMat2Like, type ReadonlyMat3Like, type ReadonlyMat4Like, type ReadonlyVec2Like, type ReadonlyVec4Like, Vec, Vec2, type Vec2Like, Vec4, type Vec4Like, avg, ceil, celsius, clamp, closeTo, closer, combinations, degrees, dot, factorial, fahrenheit, fibonacci, floor, fract, gcd, isInteger, isNumber, isReal, lerp, lineOfBestFit, ln, log, map, mat, mat2, mat3, mat4, max, meanAbsDev, median, min, minmax, mode, norm, overlap, permutations, product, radians, round, roundToEven, roundToMultiple, smootherstep, smoothstep, stddev, step, sum, trunc, variance, vec2, vec4 };

package/dist/math/index.js

@@ -0,0 +1,129 @@
+import {
+  DEG2RAD,
+  Mat,
+  Mat2,
+  Mat3,
+  Mat4,
+  Vec2,
+  Vec3,
+  Vec4,
+  avg,
+  ceil,
+  celsius,
+  clamp,
+  closeTo,
+  closer,
+  combinations,
+  degrees,
+  dot,
+  factorial,
+  fahrenheit,
+  fibonacci,
+  floor,
+  fract,
+  gcd,
+  isInteger,
+  isNumber,
+  isReal,
+  lerp,
+  lineOfBestFit,
+  ln,
+  log,
+  map,
+  mat,
+  mat2,
+  mat3,
+  mat4,
+  max,
+  meanAbsDev,
+  median,
+  min,
+  minmax,
+  mode,
+  norm,
+  overlap,
+  permutations,
+  product,
+  radians,
+  round,
+  roundToEven,
+  roundToMultiple,
+  smootherstep,
+  smoothstep,
+  stddev,
+  step,
+  sum,
+  trunc,
+  variance,
+  vec2,
+  vec3,
+  vec4
+} from "../chunk-C2DS6YRJ.js";
+import "../chunk-EWSJTMH2.js";
+import "../chunk-ILLWUQPY.js";
+import "../chunk-WBSY6KRH.js";
+import "../chunk-MG5VQSTV.js";
+import "../chunk-6F4PWJZI.js";
+import "../chunk-TMLWLR46.js";
+import "../chunk-LJSF3QBT.js";
+export {
+  DEG2RAD,
+  Mat,
+  Mat2,
+  Mat3,
+  Mat4,
+  Vec2,
+  Vec3,
+  Vec4,
+  avg,
+  ceil,
+  celsius,
+  clamp,
+  closeTo,
+  closer,
+  combinations,
+  degrees,
+  dot,
+  factorial,
+  fahrenheit,
+  fibonacci,
+  floor,
+  fract,
+  gcd,
+  isInteger,
+  isNumber,
+  isReal,
+  lerp,
+  lineOfBestFit,
+  ln,
+  log,
+  map,
+  mat,
+  mat2,
+  mat3,
+  mat4,
+  max,
+  meanAbsDev,
+  median,
+  min,
+  minmax,
+  mode,
+  norm,
+  overlap,
+  permutations,
+  product,
+  radians,
+  round,
+  roundToEven,
+  roundToMultiple,
+  smootherstep,
+  smoothstep,
+  stddev,
+  step,
+  sum,
+  trunc,
+  variance,
+  vec2,
+  vec3,
+  vec4
+};

package/dist/object.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @module
+ * Functions for working with objects
+ */
+/**
+ * Determines if an object has a property. This is simply a type-safe wrapper around `Object.prototype.hasOwnProperty`
+ * @param obj The object
+ * @param key The property key
+ * @returns true if the object has the property
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: 2 };
+ * console.log(hasOwn(obj, "a")); // true
+ * console.log(hasOwn(obj, "c")); // false
+ * ```
+ */
+declare const hasOwn: <T, K extends PropertyKey>(obj: T, key: K) => obj is T & { [key in K]: unknown; };
+/**
+ * Determines if two objects are shallowly equal, that is,
+ * if they have the same properties and the properties have the same values.
+ * @param a The first object
+ * @param b The second object
+ * @returns true if the objects are shallowly equal
+ * @example
+ * ```ts
+ * console.log(shallowEquals({ a: 1, b: 2 }, { a: 1, b: 2 })); // true
+ * console.log(shallowEquals({ a: 1, b: 2 }, { a: 1, b: 3 })); // false
+ * ```
+ */
+declare function shallowEquals<A, B>(a: A, b: B): boolean;
+/**
+ * Determines if two objects are deeply equal, that is,
+ * if they have the same properties and the properties have the same values.
+ * @param a The first object
+ * @param b The second object
+ * @returns true if the objects are deeply equal
+ * @example
+ * ```ts
+ * console.log(deepEquals({ a: 1, b: 2 }, { a: 1, b: 2 })); // true
+ * console.log(deepEquals({ a: 1, b: 2 }, { a: 1, b: 3 })); // false
+ * console.log(deepEquals({ a: { b: 1 } }, { a: { b: 1 } })); // true
+ * console.log(deepEquals({ a: { b: 1 } }, { a: { b: 2 } })); // false
+ * ```
+ */
+declare function deepEquals<A, B>(a: A, b: B): boolean;
+declare const objectKeys: <T>(obj: T) => Array<keyof T>;
+type Entry<T> = [key: keyof T, value: T[keyof T]];
+type Entries<T> = Array<Entry<T>>;
+declare const objectEntries: <T>(obj: T) => Entries<T>;
+type ReadonlyEntry<T> = [key: keyof T, value: T[keyof T]];
+declare const objectFromEntries: <T>(entries: Iterable<ReadonlyEntry<T>>) => T;
+declare function value2Keys<K extends string, T extends string>(obj: Record<K, Iterable<T>>): Record<T, K[]>;
+/**
+ * Maps the values of an object to a new object
+ * @param obj The object
+ * @param fn The mapping function
+ * @returns A new object with the mapped values
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: 2 };
+ * const result = objectMap(obj, ([key, value]) => [key, value * 2]);
+ * console.log(result); // { a: 2, b: 4 }
+ * ```
+ */
+declare function objectMap<T, U>(obj: T, fn: (value: Entry<T>) => U): {
+    [K in keyof T]: U;
+};
+declare function deepCopy<T>(object: T): T;
+declare function pickByKeys<T, K extends keyof T>(object: T, key: K): T[K];
+declare function pickByKeys<T, K extends keyof T>(object: T, keys: Iterable<K>): Pick<T, K>;
+
+export { deepCopy, deepEquals, hasOwn, objectEntries, objectFromEntries, objectKeys, objectMap, pickByKeys, shallowEquals, value2Keys };

package/dist/object.js

@@ -0,0 +1,24 @@
+import {
+  deepCopy,
+  deepEquals,
+  hasOwn,
+  objectEntries,
+  objectFromEntries,
+  objectKeys,
+  objectMap,
+  pickByKeys,
+  shallowEquals,
+  value2Keys
+} from "./chunk-LJSF3QBT.js";
+export {
+  deepCopy,
+  deepEquals,
+  hasOwn,
+  objectEntries,
+  objectFromEntries,
+  objectKeys,
+  objectMap,
+  pickByKeys,
+  shallowEquals,
+  value2Keys
+};