Add files using upload-large-folder tool

astra_scene_test/X_03/node_modules/@types/d3-array/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

astra_scene_test/X_03/node_modules/@types/d3-array/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/d3-array`
+
+# Summary
+This package contains type definitions for d3-array (https://github.com/d3/d3-array).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-array.
+
+### Additional Details
+ * Last updated: Fri, 12 Sep 2025 20:02:35 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [Tom Wanzek](https://github.com/tomwanzek), [denisname](https://github.com/denisname), [Hugues Stefanski](https://github.com/ledragon), [Nathan Bierema](https://github.com/Methuselah96), and [Fil](https://github.com/Fil).

astra_scene_test/X_03/node_modules/@types/d3-array/index.d.ts

@@ -0,0 +1,1118 @@
+// Last module patch version validated against: 3.2.4
+
+// --------------------------------------------------------------------------
+// Shared Types and Interfaces
+// --------------------------------------------------------------------------
+
+/**
+ * Administrivia: JavaScript primitive types and Date
+ */
+export type Primitive = number | string | boolean | Date;
+
+/**
+ * Administrivia: anything with a valueOf(): number method is comparable, so we allow it in numeric operations
+ */
+export interface Numeric {
+    valueOf(): number;
+}
+
+/**
+ * Administrivia: a matrix of numeric values.
+ * If height is not specified, it is inferred from the given width and data.length.
+ */
+export interface Matrix {
+    data: ArrayLike<number>;
+    width: number;
+    height?: number;
+}
+
+/**
+ * Represents a nested/recursive InternMap type
+ *
+ * The first generic "TObject" refers to the type of the data object that is available in the accessor functions.
+ * The second generic "TReduce" refers to the type of the data available at the deepest level (the result data).
+ * The third generic "TKeys" refers to the type of the keys at each level of the nestes InternMap.
+ */
+export type NestedInternMap<TObject, TReduce, TKeys extends unknown[]> = TKeys extends [infer TFirst, ...infer TRest]
+    ? InternMap<TFirst, NestedInternMap<TObject, TReduce, TRest>>
+    : TReduce;
+
+/**
+ * Represents a nested/recursive Array type
+ *
+ * The first generic "TObject" refers to the type of the data object that is available in the accessor functions.
+ * The second generic "TReduce" refers to the type of the data available at the deepest level (the result data).
+ * The third generic "TKeys" refers to the type of the keys at each level of the nestes Array.
+ */
+export type NestedArray<TObject, TReduce, TKeys extends unknown[]> = TKeys extends [infer TFirst, ...infer TRest]
+    ? Array<[TFirst, NestedArray<TObject, TReduce, TRest>]>
+    : TReduce;
+
+// --------------------------------------------------------------------------------------
+// Statistics
+// --------------------------------------------------------------------------------------
+
+/**
+ * Return the minimum value in the array using natural order.
+ */
+export function min(iterable: Iterable<string>): string | undefined;
+
+/**
+ * Return the minimum value in the array using natural order.
+ */
+export function min<T extends Numeric>(iterable: Iterable<T>): T | undefined;
+/**
+ * Return the minimum value in the array using natural order.
+ */
+export function min<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null,
+): string | undefined;
+/**
+ * Return the minimum value in the array using natural order.
+ */
+export function min<T, U extends Numeric>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null,
+): U | undefined;
+
+/**
+ * Return the index of the minimum value in the array using natural order.
+ */
+export function minIndex(iterable: Iterable<unknown>): number;
+/**
+ * Return the index of the minimum value in the array using natural order and a projection function to map values.
+ */
+export function minIndex<TDatum>(
+    iterable: Iterable<TDatum>,
+    accessor: (datum: TDatum, index: number, array: Iterable<TDatum>) => unknown,
+): number;
+/**
+ * Return the index of the minimum value in the array using natural order.
+ */
+export function minIndex(iterable: Iterable<unknown>): number;
+
+/**
+ * Return the maximum value in the array of strings using natural order.
+ */
+export function max(iterable: Iterable<string>): string | undefined;
+/**
+ * Return the maximum value in the array of numbers using natural order.
+ */
+export function max<T extends Numeric>(iterable: Iterable<T>): T | undefined;
+/**
+ * Return the maximum value in the array using natural order and a projection function to map values to strings.
+ */
+export function max<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null,
+): string | undefined;
+/**
+ * Return the maximum value in the array using natural order and a projection function to map values to easily-sorted values.
+ */
+export function max<T, U extends Numeric>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null,
+): U | undefined;
+
+/**
+ * Return the index of the maximum value in the array using natural order.
+ */
+export function maxIndex(iterable: Iterable<unknown>): number;
+/**
+ * Return the index of the maximum value in the array using natural order and a projection function to map values.
+ */
+export function maxIndex<TDatum>(
+    iterable: Iterable<TDatum>,
+    accessor: (datum: TDatum, index: number, array: Iterable<TDatum>) => unknown,
+): number;
+
+/**
+ * Return the min and max simultaneously.
+ */
+export function extent(iterable: Iterable<string>): [string, string] | [undefined, undefined];
+/**
+ * Return the min and max simultaneously.
+ */
+export function extent<T extends Numeric>(iterable: Iterable<T>): [T, T] | [undefined, undefined];
+/**
+ * Return the min and max simultaneously.
+ */
+export function extent<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null,
+): [string, string] | [undefined, undefined];
+/**
+ * Return the min and max simultaneously.
+ */
+export function extent<T, U extends Numeric>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null,
+): [U, U] | [undefined, undefined];
+
+/**
+ * Returns the mode of the given iterable, i.e. the value which appears the most often.
+ * In case of equality, returns the first of the relevant values.
+ * If the iterable contains no comparable values, returns undefined.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the mode.
+ * This method ignores undefined, null and NaN values; this is useful for ignoring missing data.
+ */
+export function mode(iterable: Iterable<Numeric | undefined | null>): number;
+/**
+ * Returns the mode of the given iterable, i.e. the value which appears the most often.
+ * In case of equality, returns the first of the relevant values.
+ * If the iterable contains no comparable values, returns undefined.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the mode.
+ * This method ignores undefined, null and NaN values; this is useful for ignoring missing data.
+ */
+export function mode<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null,
+): number;
+
+/**
+ * Compute the sum of an array of numbers.
+ */
+export function sum(iterable: Iterable<Numeric | undefined | null>): number;
+/**
+ * Compute the sum of an array, using the given accessor to convert values to numbers.
+ */
+export function sum<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null,
+): number;
+
+/**
+ * Return the mean of an array of numbers
+ */
+export function mean(iterable: Iterable<Numeric | undefined | null>): number | undefined;
+/**
+ * Return the mean of an array of numbers
+ */
+export function mean<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null,
+): number | undefined;
+
+/**
+ * Return the median of an array of numbers
+ */
+export function median(iterable: Iterable<Numeric | undefined | null>): number | undefined;
+/**
+ * Return the median of an array of numbers
+ */
+export function median<T>(
+    iterable: Iterable<T>,
+    accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null,
+): number | undefined;
+
+/**
+ * Like median, but returns the index of the element to the left of the median.
+ */
+export function medianIndex(iterable: Iterable<Numeric | undefined | null>): number;
+/**
+ * Like median, but returns the index of the element to the left of the median.
+ */
+export function medianIndex<T>(
+    iterable: Iterable<T>,
+    accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null,
+): number;
+
+/**
+ * Returns the cumulative sum of the given iterable of numbers, as a Float64Array of the same length.
+ * If the iterable contains no numbers, returns zeros.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the cumulative sum.
+ * This method ignores undefined and NaN values; this is useful for ignoring missing data.
+ */
+export function cumsum(iterable: Iterable<Numeric | undefined | null>): Float64Array;
+/**
+ * Returns the cumulative sum of the given iterable of numbers, as a Float64Array of the same length.
+ * If the iterable contains no numbers, returns zeros.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the cumulative sum.
+ * This method ignores undefined and NaN values; this is useful for ignoring missing data.
+ */
+export function cumsum<T>(
+    iterable: Iterable<T>,
+    accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null,
+): Float64Array;
+
+/**
+ * Returns the p-quantile of the given iterable of numbers, where p is a number in the range [0, 1].
+ *
+ * An optional accessor function may be specified, which is equivalent to calling array.map(accessor) before computing the quantile.
+ */
+export function quantile(iterable: Iterable<Numeric | undefined | null>, p: number): number | undefined;
+/**
+ * Returns the p-quantile of the given iterable of numbers, where p is a number in the range [0, 1].
+ *
+ * An optional accessor function may be specified, which is equivalent to calling array.map(accessor) before computing the quantile.
+ */
+export function quantile<T>(
+    iterable: Iterable<T>,
+    p: number,
+    accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null,
+): number | undefined;
+
+/**
+ * Similar to quantile, but returns the index to the left of p.
+ */
+export function quantileIndex(iterable: Iterable<Numeric | undefined | null>, p: number): number;
+/**
+ * Similar to quantile, but returns the index to the left of p.
+ */
+export function quantileIndex<T>(
+    iterable: Iterable<T>,
+    p: number,
+    accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null,
+): number;
+
+/**
+ * Similar to quantile, but expects the input to be a sorted array of values.
+ * In contrast with quantile, the accessor is only called on the elements needed to compute the quantile.
+ */
+export function quantileSorted(
+    array: Array<Numeric | undefined | null>,
+    p: number,
+): number | undefined;
+/**
+ * Similar to quantile, but expects the input to be a sorted array of values.
+ * In contrast with quantile, the accessor is only called on the elements needed to compute the quantile.
+ */
+export function quantileSorted<T>(
+    array: T[],
+    p: number,
+    accessor: (element: T, i: number, array: T[]) => number | undefined | null,
+): number | undefined;
+
+/**
+ * Returns an array with the rank of each value in the iterable, i.e. the zero-based index of the value when the iterable is sorted.
+ * Nullish values are sorted to the end and ranked NaN.
+ * An optional comparator or accessor function may be specified; the latter is equivalent to calling array.map(accessor) before computing the ranks.
+ * If comparator is not specified, it defaults to ascending.
+ * Ties (equivalent values) all get the same rank, defined as the first time the value is found.
+ */
+export function rank(iterable: Iterable<Numeric | undefined | null>): Float64Array;
+/**
+ * Returns an array with the rank of each value in the iterable, i.e. the zero-based index of the value when the iterable is sorted.
+ * Nullish values are sorted to the end and ranked NaN.
+ * An optional comparator or accessor function may be specified; the latter is equivalent to calling array.map(accessor) before computing the ranks.
+ * If comparator is not specified, it defaults to ascending.
+ * Ties (equivalent values) all get the same rank, defined as the first time the value is found.
+ */
+export function rank<T>(
+    iterable: Iterable<T>,
+    accessorOrComparator:
+        | ((datum: T, index: number, array: Iterable<T>) => number | undefined | null)
+        | ((a: T, b: T) => number | undefined | null),
+): Float64Array;
+
+/**
+ * Returns an unbiased estimator of the population variance of the given iterable of numbers using Welford’s algorithm.
+ * If the iterable has fewer than two numbers, returns undefined.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the variance.
+ * This method ignores undefined and NaN values; this is useful for ignoring missing data.
+ */
+export function variance(iterable: Iterable<Numeric | undefined | null>): number | undefined;
+/**
+ * Returns an unbiased estimator of the population variance of the given iterable of numbers using Welford’s algorithm.
+ * If the iterable has fewer than two numbers, returns undefined.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the variance.
+ * This method ignores undefined and NaN values; this is useful for ignoring missing data.
+ */
+export function variance<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null,
+): number | undefined;
+
+/**
+ * Compute the standard deviation, defined as the square root of the bias-corrected variance, of the given array of numbers.
+ */
+export function deviation(iterable: Iterable<Numeric | undefined | null>): number | undefined;
+/**
+ * Compute the standard deviation, defined as the square root of the bias-corrected variance, of the given array,
+ * using the given accessor to convert values to numbers.
+ */
+export function deviation<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null,
+): number | undefined;
+
+/**
+ * Returns a full precision summation of the given values.
+ * Although slower, d3.fsum can replace d3.sum wherever greater precision is needed. Uses d3.Adder.
+ */
+export function fsum(values: Iterable<Numeric | undefined | null>): number;
+/**
+ * Returns a full precision summation of the given values.
+ * Although slower, d3.fsum can replace d3.sum wherever greater precision is needed. Uses d3.Adder.
+ */
+export function fsum<T>(
+    values: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null,
+): number;
+
+/**
+ * Returns a full precision cumulative sum of the given values.
+ * Although slower, d3.fcumsum can replace d3.cumsum when greater precision is needed. Uses d3.Adder.
+ */
+export function fcumsum(values: Iterable<Numeric | undefined | null>): Float64Array;
+/**
+ * Returns a full precision cumulative sum of the given values.
+ * Although slower, d3.fcumsum can replace d3.cumsum when greater precision is needed. Uses d3.Adder.
+ */
+export function fcumsum<T>(
+    values: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null,
+): Float64Array;
+
+export class Adder {
+    /**
+     * Creates a full precision adder for IEEE 754 floating point numbers, setting its initial value to 0.
+     */
+    constructor();
+
+    /**
+     * Adds the specified number to the adder’s current value and returns the adder.
+     */
+    add(number: number): Adder;
+
+    /**
+     * Returns the IEEE 754 double precision representation of the adder’s current value.
+     * Most useful as the short-hand notation +adder.
+     */
+    valueOf(): number;
+}
+
+// --------------------------------------------------------------------------------------
+// Search
+// --------------------------------------------------------------------------------------
+
+/**
+ * Returns the least element of the specified iterable according to the specified comparator.
+ * If comparator is not specified, it defaults to ascending.
+ */
+export function least<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T | undefined;
+/**
+ * Returns the least element of the specified iterable according to the specified accessor.
+ */
+export function least<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): T | undefined;
+
+/**
+ * Returns the index of the least element of the specified iterable according to the specified comparator.
+ */
+export function leastIndex(iterable: Iterable<unknown>): number | undefined;
+/**
+ * Returns the index of the least element of the specified iterable according to the specified comparator.
+ */
+export function leastIndex<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): number | undefined;
+/**
+ * Returns the index of the least element of the specified iterable according to the specified accessor.
+ */
+// tslint:disable-next-line:unified-signatures
+export function leastIndex<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): number | undefined;
+
+/**
+ * Returns the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable contains no comparable elements (i.e., the comparator returns NaN when comparing each element to itself), returns undefined.
+ * If comparator is not specified, it defaults to ascending.
+ */
+export function greatest<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T | undefined;
+/**
+ * Returns the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable contains no comparable elements (i.e., the comparator returns NaN when comparing each element to itself), returns undefined.
+ * If comparator is not specified, it defaults to ascending.
+ */
+export function greatest<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): T | undefined;
+
+/**
+ * Returns the index of the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable contains no comparable elements (i.e., the comparator returns NaN when comparing each element to itself), returns -1.
+ * If comparator is not specified, it defaults to ascending.
+ */
+export function greatestIndex(iterable: Iterable<unknown>): number | undefined;
+/**
+ * Returns the index of the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable contains no comparable elements (i.e., the comparator returns NaN when comparing each element to itself), returns -1.
+ * If comparator is not specified, it defaults to ascending.
+ */
+export function greatestIndex<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): number | undefined;
+/**
+ * Returns the index of the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable contains no comparable elements (i.e., the comparator returns NaN when comparing each element to itself), returns -1.
+ * If comparator is not specified, it defaults to ascending.
+ */
+// tslint:disable-next-line:unified-signatures
+export function greatestIndex<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): number | undefined;
+
+export function bisectLeft(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+export function bisectLeft(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+export function bisectLeft(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+
+export function bisectRight(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+export function bisectRight(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+export function bisectRight(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+
+export function bisectCenter(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+export function bisectCenter(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+export function bisectCenter(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+
+export const bisect: typeof bisectRight;
+
+export interface Bisector<T, U> {
+    left(array: ArrayLike<T>, x: U, lo?: number, hi?: number): number;
+    right(array: ArrayLike<T>, x: U, lo?: number, hi?: number): number;
+    center(array: ArrayLike<T>, x: U, lo?: number, hi?: number): number;
+}
+
+export function bisector<T, U>(comparator: (a: T, b: U) => number): Bisector<T, U>;
+// tslint:disable-next-line:unified-signatures
+export function bisector<T, U>(accessor: (x: T) => U): Bisector<T, U>;
+
+/**
+ * Rearranges items so that all items in the [left, k] are the smallest. The k-th element will have the (k - left + 1)-th smallest value in [left, right].
+ *
+ * @param array The array to partially sort (in place).
+ * @param k The middle index for partial sorting.
+ * @param left The left index of the range to sort.
+ * @param right The right index.
+ * @param compare The compare function.
+ */
+export function quickselect<T>(
+    array: ArrayLike<T>,
+    k: number,
+    left?: number,
+    right?: number,
+    compare?: (a: Primitive | undefined, b: Primitive | undefined) => number,
+): T[];
+
+// NB. this is limited to primitive values due to D3's use of the <, >, and >= operators. Results get weird for object instances.
+/**
+ * Compares two primitive values for sorting (in ascending order).
+ */
+export function ascending(a: Primitive | undefined, b: Primitive | undefined): number;
+
+// NB. this is limited to primitive values due to D3's use of the <, >, and >= operators. Results get weird for object instances.
+/**
+ * Compares two primitive values for sorting (in descending order).
+ */
+export function descending(a: Primitive | undefined, b: Primitive | undefined): number;
+
+// --------------------------------------------------------------------------------------
+// Transformations
+// --------------------------------------------------------------------------------------
+
+/**
+ * Groups the specified iterable of values into an InternMap from key to array of value.
+ *
+ * @param iterable The iterable to group.
+ * @param keys The key functions.
+ */
+export function group<TObject, TKeys extends unknown[]>(
+    iterable: Iterable<TObject>,
+    ...keys: {
+        [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index];
+    }
+): NestedInternMap<TObject, TObject[], TKeys>;
+
+/**
+ * Equivalent to group, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The iterable to group.
+ * @param keys The key functions.
+ */
+export function groups<TObject, TKeys extends unknown[]>(
+    iterable: Iterable<TObject>,
+    ...keys: {
+        [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index];
+    }
+): NestedArray<TObject, TObject[], TKeys>;
+
+/**
+ * Equivalent to group, but returns a flat array of [key0, key1, …, values] instead of nested maps.
+ *
+ * @param iterable The iterable to group.
+ * @param keys The key functions.
+ */
+export function flatGroup<TObject, TKeys extends unknown[]>(
+    iterable: Iterable<TObject>,
+    ...keys: {
+        [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index];
+    }
+): Array<[...TKeys, TObject[]]>;
+
+/**
+ * Equivalent to group but returns a unique value per compound key instead of an array, throwing if the key is not unique.
+ *
+ * @param iterable The iterable to group.
+ * @param key The key functions.
+ */
+export function index<TObject, TKeys extends unknown[]>(
+    iterable: Iterable<TObject>,
+    ...keys: {
+        [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index];
+    }
+): NestedInternMap<TObject, TObject, TKeys>;
+
+/**
+ * Equivalent to index, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The iterable to group.
+ * @param keys The key functions.
+ */
+export function indexes<TObject, TKeys extends unknown[]>(
+    iterable: Iterable<TObject>,
+    ...keys: {
+        [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index];
+    }
+): NestedArray<TObject, TObject, TKeys>;
+
+/**
+ * Groups and reduces the specified array of values into an InternMap from key to value.
+ *
+ * @param iterable The iterable to group.
+ * @param reduce The reduce function.
+ * @param keys The key functions.
+ */
+export function rollup<TObject, TReduce, TKeys extends unknown[]>(
+    iterable: Iterable<TObject>,
+    reduce: (values: TObject[]) => TReduce,
+    ...keys: {
+        [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index];
+    }
+): NestedInternMap<TObject, TReduce, TKeys>;
+
+/**
+ * Equivalent to rollup, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The iterable to group.
+ * @param reduce The reduce function.
+ * @param keys The key functions.
+ */
+export function rollups<TObject, TReduce, TKeys extends unknown[]>(
+    iterable: Iterable<TObject>,
+    reduce: (values: TObject[]) => TReduce,
+    ...keys: {
+        [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index];
+    }
+): NestedArray<TObject, TReduce, TKeys>;
+
+/**
+ * Equivalent to rollup, but returns a flat array of [key0, key1, …, value] instead of nested maps.
+ *
+ * @param iterable The iterable to group.
+ * @param reduce The reduce function.
+ * @param keys The key functions.
+ */
+export function flatRollup<TObject, TReduce, TKeys extends unknown[]>(
+    iterable: Iterable<TObject>,
+    reduce: (values: TObject[]) => TReduce,
+    ...keys: {
+        [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index];
+    }
+): Array<[...TKeys, TReduce]>;
+
+/**
+ * Groups the specified iterable of elements according to the specified key function, sorts the groups according to the specified comparator, and then returns an array of keys in sorted order.
+ * The comparator will be asked to compare two groups a and b and should return a negative value if a should be before b, a positive value if a should be after b, or zero for a partial ordering.
+ */
+export function groupSort<TObject, TKey>(
+    iterable: Iterable<TObject>,
+    comparator: (a: TObject[], b: TObject[]) => number,
+    key: (value: TObject) => TKey,
+): TKey[];
+/**
+ * Groups the specified iterable of elements according to the specified key function, sorts the groups according to the specified accessor, and then returns an array of keys in sorted order.
+ */
+export function groupSort<TObject, TKey>(
+    iterable: Iterable<TObject>,
+    // tslint:disable-next-line:unified-signatures
+    accessor: (value: TObject[]) => unknown,
+    key: (value: TObject) => TKey,
+): TKey[];
+
+/**
+ * Returns the number of valid number values (i.e., not null, NaN, or undefined) in the specified iterable; accepts an accessor.
+ *
+ * @param iterable Input array.
+ */
+export function count(iterable: Iterable<unknown>): number;
+/**
+ * Returns the number of valid number values (i.e., not null, NaN, or undefined) in the specified iterable; accepts an accessor.
+ *
+ * @param iterable Input array.
+ * @param accessor Accessor method.
+ */
+export function count<TObject>(
+    iterable: Iterable<TObject>,
+    accessor: (a: TObject, b: TObject) => number | null | undefined,
+): number;
+
+/**
+ * Computes the Cartesian product of any number of iterables.
+ *
+ * When called **without** a reducer, the result is an array of tuples,
+ * where each tuple contains one element from each input iterable.
+ *
+ * @typeParam T - A tuple type describing the element type of each iterable argument.
+ *                For example, passing `[number[], string[]]` infers `T` as `[number, string]`.
+ *
+ * @param iterables - Two or more iterables to combine into a Cartesian product.
+ * @returns An array of tuples containing one value from each iterable.
+ *
+ * @example
+ * ```ts
+ * const nums = [1, 2];
+ * const chars = ['a', 'b'];
+ * const out = cross(nums, chars);
+ * //    ^? type: [number, string][]
+ * // Example value: [[1,'a'], [1,'b'], [2,'a'], [2,'b']]
+ * ```
+ */
+export function cross<T extends unknown[]>(
+    ...iterables: { [K in keyof T]: Iterable<T[K]> }
+): T[];
+
+/**
+ * Computes the Cartesian product of any number of iterables and then applies
+ * a reducer to each tuple, returning the reduced values.
+ *
+ * The final argument **must** be the reducer function; all prior arguments are iterables.
+ *
+ * @typeParam T - A tuple type describing the element type of each iterable argument.
+ * @typeParam U - The result type produced by the reducer.
+ *
+ * @param args - The iterables to combine, followed by a reducer function.
+ * @param args.reducer - A function invoked with one element from each iterable
+ *                       (spread as individual parameters) that returns a reduced value.
+ * @returns An array of reduced values returned by the reducer.
+ *
+ * @example
+ * ```ts
+ * const nums = [1, 2];
+ * const chars = ['a', 'b'];
+ * const out = cross(nums, chars, (n, c) => `${n}${c}`);
+ * //    ^? type: string[]
+ * // Example value: ['1a', '1b', '2a', '2b']
+ * ```
+ */
+export function cross<T extends unknown[], U>(
+    ...args: [...iterables: { [K in keyof T]: Iterable<T[K]> }, reducer: (...values: T) => U]
+): U[];
+
+/**
+ * Merges the specified arrays into a single array.
+ */
+export function merge<T>(iterables: Iterable<Iterable<T>>): T[];
+
+/**
+ * For each adjacent pair of elements in the specified array, returns a new array of tuples of elements i and i - 1.
+ * Returns the empty array if the input array has fewer than two elements.
+ *
+ * @param iterable Array of input elements
+ */
+export function pairs<T>(iterable: Iterable<T>): Array<[T, T]>;
+/**
+ * For each adjacent pair of elements in the specified array, in order, invokes the specified reducer function passing the element i and element i - 1.
+ * Returns the resulting array of pair-wise reduced elements.
+ * Returns the empty array if the input array has fewer than two elements.
+ *
+ * @param iterable Array of input elements
+ * @param reducer A reducer function taking as input to adjacent elements of the input array and returning a reduced value.
+ */
+export function pairs<T, U>(iterable: Iterable<T>, reducer: (a: T, b: T) => U): U[];
+
+/**
+ * Returns a permutation of the specified source object (or array) using the specified iterable of keys.
+ * The returned array contains the corresponding property of the source object for each key in keys, in order.
+ * For example, `permute(["a", "b", "c"], [1, 2, 0]) // ["b", "c", "a"]`
+ *
+ * It is acceptable to have more keys than source elements, and for keys to be duplicated or omitted.
+ */
+export function permute<T>(source: { [key: number]: T }, keys: Iterable<number>): T[];
+/**
+ * Extract the values from an object into an array with a stable order. For example:
+ * `var object = {yield: 27, year: 1931, site: "University Farm"};`
+ * `d3.permute(object, ["site", "yield"]); // ["University Farm", 27]`
+ */
+export function permute<T, K extends keyof T>(source: T, keys: Iterable<K>): Array<T[K]>;
+
+/**
+ * Randomizes the order of the specified array using the Fisher–Yates shuffle.
+ */
+export function shuffle<T>(array: T[], lo?: number, hi?: number): T[];
+export function shuffle(array: Int8Array, lo?: number, hi?: number): Int8Array;
+export function shuffle(array: Uint8Array, lo?: number, hi?: number): Uint8Array;
+export function shuffle(array: Uint8ClampedArray, lo?: number, hi?: number): Uint8ClampedArray;
+export function shuffle(array: Int16Array, lo?: number, hi?: number): Int16Array;
+export function shuffle(array: Uint16Array, lo?: number, hi?: number): Uint16Array;
+export function shuffle(array: Int32Array, lo?: number, hi?: number): Int32Array;
+export function shuffle(array: Uint32Array, lo?: number, hi?: number): Uint32Array;
+export function shuffle(array: Float32Array, lo?: number, hi?: number): Float32Array;
+export function shuffle(array: Float64Array, lo?: number, hi?: number): Float64Array;
+
+/**
+ * Returns a shuffle function given the specified random source.
+ */
+export function shuffler(random: () => number): typeof shuffle;
+
+/**
+ * Generate an array of approximately count + 1 uniformly-spaced, nicely-rounded values between start and stop (inclusive).
+ * Each value is a power of ten multiplied by 1, 2 or 5. See also d3.tickIncrement, d3.tickStep and linear.ticks.
+ *
+ * Ticks are inclusive in the sense that they may include the specified start and stop values if (and only if) they are exact,
+ * nicely-rounded values consistent with the inferred step. More formally, each returned tick t satisfies start ≤ t and t ≤ stop.
+ *
+ * @param start Start value for ticks
+ * @param stop Stop value for ticks
+ * @param count count + 1 is the approximate number of ticks to be returned by d3.ticks.
+ */
+export function ticks(start: number, stop: number, count: number): number[];
+
+/**
+ * Returns the difference between adjacent tick values if the same arguments were passed to d3.ticks:
+ * a nicely-rounded value that is a power of ten multiplied by 1, 2 or 5.
+ *
+ * Like d3.tickStep, except requires that start is always less than or equal to stop, and if the tick step for the given start,
+ * stop and count would be less than one, returns the negative inverse tick step instead.
+ *
+ * This method is always guaranteed to return an integer, and is used by d3.ticks to avoid guarantee that the returned tick values
+ * are represented as precisely as possible in IEEE 754 floating point.
+ *
+ * @param start Start value for ticks
+ * @param stop Stop value for ticks
+ * @param count count + 1 is the approximate number of ticks to be returned by d3.ticks.
+ */
+export function tickIncrement(start: number, stop: number, count: number): number;
+
+/**
+ * Returns the difference between adjacent tick values if the same arguments were passed to d3.ticks:
+ * a nicely-rounded value that is a power of ten multiplied by 1, 2 or 5.
+ *
+ * Note that due to the limited precision of IEEE 754 floating point, the returned value may not be exact decimals;
+ * use d3-format to format numbers for human consumption.
+ *
+ * @param start Start value for ticks
+ * @param stop Stop value for ticks
+ * @param count count + 1 is the approximate number of ticks to be returned by d3.ticks.
+ */
+export function tickStep(start: number, stop: number, count: number): number;
+
+/**
+ * Returns a new interval [niceStart, niceStop] covering the given interval [start, stop] and where niceStart and niceStop are guaranteed to align with the corresponding tick step.
+ * Like d3.tickIncrement, this requires that start is less than or equal to stop.
+ *
+ * @param start Start value for ticks
+ * @param stop Stop value for ticks
+ * @param count count + 1 is the approximate number of ticks to be returned by d3.ticks.
+ */
+export function nice(start: number, stop: number, count: number): [number, number];
+
+/**
+ * Generates a 0-based numeric sequence. The output range does not include 'stop'.
+ */
+export function range(stop: number): number[];
+/**
+ * Generates a numeric sequence starting from the given start and stop values. 'step' defaults to 1. The output range does not include 'stop'.
+ */
+// tslint:disable-next-line:unified-signatures
+export function range(start: number, stop: number, step?: number): number[];
+
+/**
+ * Transpose a matrix provided in Array of Arrays format.
+ */
+export function transpose<T>(matrix: ArrayLike<ArrayLike<T>>): T[][];
+
+/**
+ * Returns an array of arrays, where the ith array contains the ith element from each of the argument arrays.
+ * The returned array is truncated in length to the shortest array in arrays. If arrays contains only a single array, the returned array
+ * contains one-element arrays. With no arguments, the returned array is empty.
+ */
+export function zip<T>(...arrays: Array<ArrayLike<T>>): T[][];
+
+// --------------------------------------------------------------------------------------
+// Blur
+// --------------------------------------------------------------------------------------
+
+/**
+ * Blurs an array of data in-place by applying three iterations of a moving average transform (box filter)
+ * for a fast approximation of a Gaussian kernel of the given radius, a non-negative number.
+ * Returns the given data.
+ */
+export function blur(data: ArrayLike<number>, radius: number): ArrayLike<number>;
+
+/**
+ * Blurs a matrix of the given width and height in-place by applying a horizontal blur of radius rx
+ * and a vertical blur of radius ry (which defaults to rx).
+ * The matrix values data are stored in a flat (one-dimensional) array.
+ * If height is not specified, it is inferred from the given width and data.length.
+ * Returns the blurred matrix {data, width, height}.
+ */
+export function blur2(data: Matrix, rx: number, ry?: number): Matrix;
+
+/**
+ * Blurs the given ImageData in-place, blurring each of the RGBA layers independently by applying an horizontal blur of radius rx
+ * and a vertical blur of radius ry (which defaults to rx).
+ * Returns the blurred ImageData.
+ */
+export function blurImage(imageData: ImageData, rx: number, ry?: number): ImageData;
+
+// --------------------------------------------------------------------------------------
+// Iterables
+// --------------------------------------------------------------------------------------
+
+/**
+ * Returns true if the given test function returns true for every value in the given iterable.
+ * This method returns as soon as test returns a non-truthy value or all values are iterated over.
+ * Equivalent to array.every.
+ */
+export function every<T>(
+    iterable: Iterable<T>,
+    test: (value: T, index: number, iterable: Iterable<T>) => unknown,
+): boolean;
+
+/**
+ * Returns true if the given test function returns true for any value in the given iterable.
+ * This method returns as soon as test returns a truthy value or all values are iterated over.
+ * Equivalent to array.some.
+ */
+export function some<T>(
+    iterable: Iterable<T>,
+    test: (value: T, index: number, iterable: Iterable<T>) => unknown,
+): boolean;
+
+/**
+ * Returns a new array containing the values from iterable, in order, for which the given test function returns true.
+ * Equivalent to array.filter.
+ */
+export function filter<T>(
+    iterable: Iterable<T>,
+    test: (value: T, index: number, iterable: Iterable<T>) => unknown,
+): T[];
+
+/**
+ * Returns a new array containing the mapped values from iterable, in order, as defined by given mapper function.
+ * Equivalent to array.map and Array.from.
+ */
+export function map<T, U>(iterable: Iterable<T>, mapper: (value: T, index: number, iterable: Iterable<T>) => U): U[];
+
+/**
+ * Returns the reduced value defined by given reducer function, which is repeatedly invoked for each value in iterable, being passed the current reduced value and the next value.
+ * Equivalent to array.reduce.
+ */
+export function reduce<T>(
+    iterable: Iterable<T>,
+    reducer: (previousValue: T, currentValue: T, currentIndex: number, iterable: Iterable<T>) => T,
+    initialValue?: T,
+): T;
+/**
+ * Returns the reduced value defined by given reducer function, which is repeatedly invoked for each value in iterable, being passed the current reduced value and the next value.
+ * Equivalent to array.reduce.
+ */
+export function reduce<T, U>(
+    iterable: Iterable<T>,
+    reducer: (previousValue: U, currentValue: T, currentIndex: number, iterable: Iterable<T>) => U,
+    initialValue: U,
+): U;
+
+/**
+ * Returns an array containing the values in the given iterable in reverse order.
+ * Equivalent to array.reverse, except that it does not mutate the given iterable.
+ */
+export function reverse<T>(iterable: Iterable<T>): T[];
+
+/**
+ * Returns an array containing the values in the given iterable in the sorted order defined by the given comparator function.
+ * If comparator is not specified, it defaults to d3.ascending.
+ * Equivalent to array.sort, except that it does not mutate the given iterable, and the comparator defaults to natural order instead of lexicographic order.
+ */
+export function sort<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T[];
+/**
+ * Returns an array containing the values in the given iterable in the sorted order defined by the given accessor function.
+ * This is equivalent to a comparator using natural order.
+ * The accessor is only invoked once per element, and thus may be nondeterministic.
+ * Multiple accessors may be specified to break ties.
+ */
+export function sort<T>(iterable: Iterable<T>, ...accessors: Array<(a: T) => unknown>): T[];
+
+// --------------------------------------------------------------------------------------
+// Sets
+// --------------------------------------------------------------------------------------
+
+/**
+ * Returns a new InternSet containing every value in iterable that is not in any of the others iterables.
+ */
+export function difference<T>(iterable: Iterable<T>, ...others: Array<Iterable<T>>): InternSet<T>;
+
+/**
+ * Returns a new InternSet containing every (distinct) value that appears in any of the given iterables.
+ * The order of values in the returned set is based on their first occurrence in the given iterables.
+ */
+export function union<T>(...iterables: Array<Iterable<T>>): InternSet<T>;
+
+/**
+ * Returns a new InternSet containing every (distinct) value that appears in all of the given iterables.
+ * The order of values in the returned set is based on their first occurrence in the given iterables.
+ */
+export function intersection<T>(...iterables: Array<Iterable<T>>): InternSet<T>;
+
+/**
+ * Returns true if a is a superset of b: if every value in the given iterable b is also in the given iterable a.
+ */
+export function superset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+
+/**
+ * Returns true if a is a subset of b: if every value in the given iterable a is also in the given iterable b.
+ */
+export function subset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+
+/**
+ * Returns true if a and b are disjoint: if a and b contain no shared value.
+ */
+export function disjoint<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+
+// --------------------------------------------------------------------------------------
+// Bins
+// --------------------------------------------------------------------------------------
+
+export interface Bin<Datum, Value extends number | Date | undefined> extends Array<Datum> {
+    x0: Value | undefined;
+    x1: Value | undefined;
+}
+
+/**
+ * Type definition for threshold generator which returns the count of recommended thresholds
+ */
+export type ThresholdCountGenerator<Value extends number | undefined = number | undefined> = (
+    values: ArrayLike<Value>,
+    min: number,
+    max: number,
+) => number;
+
+/**
+ * Type definition for threshold generator which returns an array of recommended numbers thresholds
+ */
+export type ThresholdNumberArrayGenerator<Value extends number | undefined> = (
+    values: ArrayLike<Value>,
+    min: number,
+    max: number,
+) => Value[];
+
+/**
+ * Type definition for threshold generator which returns an array of recommended dates thresholds
+ */
+export type ThresholdDateArrayGenerator<Value extends Date | undefined> = (
+    values: ArrayLike<Value>,
+    min: Date,
+    max: Date,
+) => Value[];
+
+export interface HistogramCommon<Datum, Value extends number | Date | undefined> {
+    (data: ArrayLike<Datum>): Array<Bin<Datum, Value>>;
+
+    value(): (d: Datum, i: number, data: ArrayLike<Datum>) => Value;
+    value(valueAccessor: (d: Datum, i: number, data: ArrayLike<Datum>) => Value): this;
+}
+
+export interface HistogramGeneratorDate<Datum, Value extends Date | undefined> extends HistogramCommon<Datum, Date> {
+    domain(): (values: ArrayLike<Value>) => [Date, Date];
+    domain(domain: [Date, Date] | ((values: ArrayLike<Value>) => [Date, Date])): this;
+
+    thresholds(): ThresholdDateArrayGenerator<Value>;
+    /**
+     * Set the array of values to be used as thresholds in determining the bins.
+     *
+     * Any threshold values outside the domain are ignored. The first bin.x0 is always equal to the minimum domain value,
+     * and the last bin.x1 is always equal to the maximum domain value.
+     *
+     * @param thresholds Either an array of threshold values used for binning. The elements must
+     * be of the same type as the materialized values of the histogram.
+     * Or a function which accepts as arguments the array of materialized values, and
+     * optionally the domain minimum and maximum. The function calculates and returns the array of values to be used as
+     * thresholds in determining the bins.
+     */
+    thresholds(thresholds: ArrayLike<Value> | ThresholdDateArrayGenerator<Value>): this;
+}
+
+export interface HistogramGeneratorNumber<Datum, Value extends number | undefined>
+    extends HistogramCommon<Datum, Value>
+{
+    domain(): (values: Iterable<Value>) => [number, number] | [undefined, undefined];
+    domain(domain: [number, number] | ((values: Iterable<Value>) => [number, number] | [undefined, undefined])): this;
+
+    thresholds(): ThresholdCountGenerator<Value> | ThresholdNumberArrayGenerator<Value>;
+    /**
+     * Divide the domain uniformly into approximately count bins. IMPORTANT: This threshold
+     * setting approach only works, when the materialized values are numbers!
+     *
+     * Any threshold values outside the domain are ignored. The first bin.x0 is always equal to the minimum domain value,
+     * and the last bin.x1 is always equal to the maximum domain value.
+     *
+     * @param count Either the desired number of uniform bins or a function which accepts as arguments the array of
+     * materialized values, and optionally the domain minimum and maximum. The function calculates and returns the
+     * suggested number of bins.
+     */
+    thresholds(count: number | ThresholdCountGenerator<Value>): this;
+    /**
+     * Set the array of values to be used as thresholds in determining the bins.
+     *
+     * Any threshold values outside the domain are ignored. The first bin.x0 is always equal to the minimum domain value,
+     * and the last bin.x1 is always equal to the maximum domain value.
+     *
+     * @param thresholds Either an array of threshold values used for binning. The elements must
+     * be of the same type as the materialized values of the histogram.
+     * Or a function which accepts as arguments the array of materialized values, and
+     * optionally the domain minimum and maximum. The function calculates and returns the array of values to be used as
+     * thresholds in determining the bins.
+     */
+    // tslint:disable-next-line:unified-signatures
+    thresholds(thresholds: ArrayLike<Value> | ThresholdNumberArrayGenerator<Value>): this;
+}
+
+/**
+ * @deprecated Use bin instead.
+ */
+export function histogram(): HistogramGeneratorNumber<number, number>;
+
+/**
+ * @deprecated Use bin instead.
+ */
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+export function histogram<Datum, Value extends number | undefined>(): HistogramGeneratorNumber<Datum, Value>;
+
+/**
+ * @deprecated Use bin instead.
+ */
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+export function histogram<Datum, Value extends Date | undefined>(): HistogramGeneratorDate<Datum, Value>;
+
+export function bin(): HistogramGeneratorNumber<number, number>;
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+export function bin<Datum, Value extends number | undefined>(): HistogramGeneratorNumber<Datum, Value>;
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+export function bin<Datum, Value extends Date | undefined>(): HistogramGeneratorDate<Datum, Value>;
+
+// --------------------------------------------------------------------------------------
+// Histogram Thresholds
+// --------------------------------------------------------------------------------------
+
+export function thresholdFreedmanDiaconis(values: ArrayLike<number | undefined>, min: number, max: number): number; // of type ThresholdCountGenerator
+
+export function thresholdScott(values: ArrayLike<number | undefined>, min: number, max: number): number; // of type ThresholdCountGenerator
+
+export function thresholdSturges(values: ArrayLike<number | undefined>): number; // of type ThresholdCountGenerator
+
+// --------------------------------------------------------------------------------------
+// Interning
+// --------------------------------------------------------------------------------------
+
+/**
+ * The InternMap class extends the native JavaScript Map class, allowing Dates and other non-primitive keys by bypassing the SameValueZero algorithm when determining key equality.
+ */
+export class InternMap<K = any, V = any> extends Map<K, V> {
+}
+
+/**
+ * The InternSet class extends the native JavaScript Set class, allowing Dates and other non-primitive keys by bypassing the SameValueZero algorithm when determining key equality.
+ */
+export class InternSet<T = any> extends Set<T> {
+}

astra_scene_test/X_03/node_modules/@types/d3-array/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@types/d3-array",
+    "version": "3.2.2",
+    "description": "TypeScript definitions for d3-array",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-array",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Alex Ford",
+            "githubUsername": "gustavderdrache",
+            "url": "https://github.com/gustavderdrache"
+        },
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "denisname",
+            "githubUsername": "denisname",
+            "url": "https://github.com/denisname"
+        },
+        {
+            "name": "Hugues Stefanski",
+            "githubUsername": "ledragon",
+            "url": "https://github.com/ledragon"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        },
+        {
+            "name": "Fil",
+            "githubUsername": "Fil",
+            "url": "https://github.com/Fil"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-array"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "peerDependencies": {},
+    "typesPublisherContentHash": "d8ff015b14e99aec79f6ac45682bd8237145131c804b94de0ed1e6bc003d5190",
+    "typeScriptVersion": "5.2"
+}

astra_scene_test/X_03/node_modules/@types/d3-color/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

astra_scene_test/X_03/node_modules/@types/d3-color/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/d3-color`
+
+# Summary
+This package contains type definitions for d3-color (https://github.com/d3/d3-color/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-color.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 15:11:36 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), [Hugues Stefanski](https://github.com/ledragon), [Nathan Bierema](https://github.com/Methuselah96), and [Fil](https://github.com/Fil).

astra_scene_test/X_03/node_modules/@types/d3-color/index.d.ts

@@ -0,0 +1,669 @@
+// Last module patch version validated against: 3.1.0
+
+// ---------------------------------------------------------------------------
+// Shared Type Definitions and Interfaces
+// ---------------------------------------------------------------------------
+
+/**
+ * Type allowing for color objects from a specified color space
+ */
+export type ColorSpaceObject = RGBColor | HSLColor | LabColor | HCLColor | CubehelixColor;
+
+/**
+ * A helper interface of methods common to color objects (including colors defined outside the d3-color standard module,
+ * e.g. in d3-hsv). This interface
+ */
+export interface ColorCommonInstance {
+    /**
+     * Returns true if and only if the color is displayable on standard hardware.
+     * For example, this returns false for an RGB color if any channel value is less than zero or greater than 255, or if the opacity is not in the range [0, 1].
+     */
+    displayable(): boolean;
+    /**
+     * Returns a string representing this color according to the CSS Object Model specification,
+     * such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    toString(): string;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1. The behavior of this method is dependent on the implementing color space.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1. The behavior of this method is dependent on the implementing color space.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB equivalent of this color. For RGB colors, that’s "this".
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a hexadecimal string representing this color.
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    hex(): string;
+}
+
+/**
+ * A Color object which serves as a base class for
+ * colorspace-specific sub-class implementations.
+ */
+export interface Color {
+    /**
+     * Returns true if and only if the color is displayable on standard hardware.
+     * For example, this returns false for an RGB color if any channel value is less than zero or greater than 255, or if the opacity is not in the range [0, 1].
+     */
+    displayable(): boolean; // Note: While this method is used in prototyping for colors of specific colorspaces, it should not be called directly, as 'this.rgb' would not be implemented on Color
+    /**
+     * Returns a string representing this color according to the CSS Object Model specification,
+     * such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    toString(): string; // Note: While this method is used in prototyping for colors of specific colorspaces, it should not be called directly, as 'this.rgb' would not be implemented on Color
+    /**
+     * Returns a hexadecimal string representing this color in RGB space, such as #f7eaba.
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    formatHex(): string;
+    /**
+     * Returns a hexadecimal string representing this color in RGBA space, such as #f7eaba90.
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    formatHex8(): string;
+    /**
+     * Returns a string representing this color according to the CSS Color Module Level 3 specification, such as hsl(257, 50%, 80%) or hsla(257, 50%, 80%, 0.2).
+     * If this color is not displayable, a suitable displayable color is returned instead by clamping S and L channel values to the interval [0, 100].
+     */
+    formatHsl(): string;
+    /**
+     * Returns a string representing this color according to the CSS Object Model specification, such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
+     * If this color is not displayable, a suitable displayable color is returned instead by clamping RGB channel values to the interval [0, 255].
+     */
+    formatRgb(): string;
+    /**
+     * @deprecated Use color.formatHex.
+     */
+    hex(): string;
+}
+
+/**
+ * A Color factory object, which may also be used with instanceof to test if an object is a color instance.
+ */
+export interface ColorFactory extends Function {
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an RGB or HSL color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): RGBColor | HSLColor | null;
+    /**
+     * Converts the provided color instance and returns an RGB or HSL color.
+     *
+     * @param color A permissible color space instance.
+     */
+    (color: ColorSpaceObject | ColorCommonInstance): RGBColor | HSLColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: Color;
+}
+
+/**
+ * An RGB color object.
+ */
+export interface RGBColor extends Color {
+    /**
+     * Value of red channel
+     */
+    r: number;
+    /**
+     * Value of green channel
+     */
+    g: number;
+    /**
+     * Value of blue channel
+     */
+    b: number;
+    /**
+     * Opacity value
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB equivalent of this color.
+     */
+    rgb(): this;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(
+        values?: {
+            r?: number | undefined;
+            g?: number | undefined;
+            b?: number | undefined;
+            opacity?: number | undefined;
+        },
+    ): this;
+    /**
+     * Returns a new RGB color where the r, g, and b channels are clamped to the range [0, 255] and rounded to the nearest integer value,
+     * and the opacity is clamped to the range [0, 1].
+     */
+    clamp(): this;
+}
+
+/**
+ * An RGB color factory object, which may also be used with instanceof to test if an object
+ * is an RGB color instance.
+ */
+export interface RGBColorFactory extends Function {
+    /**
+     * Constructs a new RGB color based on the specified channel values and opacity.
+     *
+     * @param r Red channel value.
+     * @param g Green channel value.
+     * @param b Blue channel value.
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (r: number, g: number, b: number, opacity?: number): RGBColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an RGB color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): RGBColor;
+    /**
+     * Converts the provided color instance and returns an RGB color. The color instance is converted to the RGB color space using color.rgb.
+     * Note that unlike color.rgb this method always returns a new instance, even if color is already an RGB color.
+     *
+     * @param color A permissible color space instance.
+     */
+    // tslint:disable-next-line:unified-signatures
+    (color: ColorSpaceObject | ColorCommonInstance): RGBColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: RGBColor;
+}
+
+/**
+ * An HSL color object.
+ */
+export interface HSLColor extends Color {
+    /**
+     * Hue channel value.
+     */
+    h: number;
+    /**
+     * Saturation channel value.
+     */
+    s: number;
+    /**
+     * Lightness channel value.
+     */
+    l: number;
+    /**
+     * Opacity value.
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB color equivalent of this color.
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(
+        values?: {
+            h?: number | undefined;
+            s?: number | undefined;
+            l?: number | undefined;
+            opacity?: number | undefined;
+        },
+    ): this;
+    /**
+     * Returns a new HSL color where the h channel is clamped to the range [0, 360), and the s, l, and opacity channels are clamped to the range [0, 1].
+     */
+    clamp(): this;
+}
+
+/**
+ * An HSL color factory object, which may also be used with instanceof to test if an object
+ * is an HSL color instance.
+ */
+export interface HSLColorFactory extends Function {
+    /**
+     * Constructs a new HSL color based on the specified channel values and opacity.
+     *
+     * @param h Hue channel value.
+     * @param s Saturation channel value.
+     * @param l Lightness channel value.
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (h: number, s: number, l: number, opacity?: number): HSLColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an HSL color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): HSLColor;
+    /**
+     * Converts the provided color instance and returns an HSL color.
+     * The color instance is converted to the RGB color space using color.rgb and then converted to HSL.
+     * (Colors already in the HSL color space skip the conversion to RGB.)
+     *
+     * @param color A permissible color space instance.
+     */
+    // tslint:disable-next-line:unified-signatures
+    (color: ColorSpaceObject | ColorCommonInstance): HSLColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: HSLColor;
+}
+
+/**
+ * A Lab (CIELAB) color object.
+ */
+export interface LabColor extends Color {
+    /**
+     * Lightness typically in the range [0, 100].
+     */
+    l: number;
+    /**
+     * Position between red/magenta and green typically in [-160, +160].
+     */
+    a: number;
+    /**
+     * Position between yellow and blue typically in [-160, +160].
+     */
+    b: number;
+    /**
+     * Opacity value
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB color equivalent of this color.
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(
+        values?: {
+            l?: number | undefined;
+            a?: number | undefined;
+            b?: number | undefined;
+            opacity?: number | undefined;
+        },
+    ): this;
+}
+
+/**
+ * A Lab (CIELAB) color factory object, which may also be used with instanceof to test if an object
+ * is a Lab color instance.
+ */
+export interface LabColorFactory extends Function {
+    /**
+     * Constructs a new CIELAB color based on the specified channel values and opacity.
+     *
+     * @param l Lightness typically in the range [0, 100].
+     * @param a Position between red/magenta and green typically in [-160, +160].
+     * @param b Position between yellow and blue typically in [-160, +160].
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (l: number, a: number, b: number, opacity?: number): LabColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning a Lab color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): LabColor;
+    /**
+     * Converts the provided color instance and returns a Lab color.
+     * The color instance is converted to the RGB color space using color.rgb and then converted to CIELAB.
+     * (Colors already in the Lab color space skip the conversion to RGB,
+     * and colors in the HCL color space are converted directly to CIELAB.)
+     *
+     * @param color A permissible color space instance.
+     */
+    // tslint:disable-next-line:unified-signatures
+    (color: ColorSpaceObject | ColorCommonInstance): LabColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: LabColor;
+}
+
+/**
+ * A gray color factory for Lab (CIELAB) colors.
+ */
+export type GrayColorFactory =
+    /**
+     * Constructs a new CIELAB color with the specified l value and a = b = 0.
+     *
+     * @param l Lightness typically in the range [0, 100].
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (l: number, opacity?: number) => LabColor;
+
+/**
+ * An HCL (CIELCH) color object.
+ */
+export interface HCLColor extends Color {
+    /**
+     * Hue channel value typically in [0, 360).
+     */
+    h: number;
+    /**
+     * Chroma channel value typically in [0, 230].
+     */
+    c: number;
+    /**
+     * Luminance channel value typically in the range [0, 100].
+     */
+    l: number;
+    /**
+     * Opacity value
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB color equivalent of this color.
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(
+        values?: {
+            h?: number | undefined;
+            c?: number | undefined;
+            l?: number | undefined;
+            opacity?: number | undefined;
+        },
+    ): this;
+}
+
+/**
+ * An HCL (CIELCH) color factory object, which may also be used with instanceof to test if an object
+ * is an HCL color instance.
+ */
+export interface HCLColorFactory extends Function {
+    /**
+     * Constructs a new HCL color based on the specified channel values and opacity.
+     *
+     * @param h Hue channel value typically in [0, 360).
+     * @param c Chroma channel value typically in [0, 230].
+     * @param l Luminance channel value typically in the range [0, 100].
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (h: number, c: number, l: number, opacity?: number): HCLColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an HCL color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): HCLColor;
+    /**
+     * Converts the provided color instance and returns an HCL color.
+     * The color instance is converted to the RGB color space using color.rgb and then converted to HCL.
+     * (Colors already in the HCL color space skip the conversion to RGB,
+     * and colors in the Lab color space are converted directly to HCL.)
+     *
+     * @param color A permissible color space instance.
+     */
+    // tslint:disable-next-line:unified-signatures
+    (color: ColorSpaceObject | ColorCommonInstance): HCLColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: HCLColor;
+}
+
+/**
+ * An LCH (CIELCH) color factory function to create an HCL color object.
+ */
+export interface LCHColorFactory {
+    /**
+     * Constructs a new HCL color based on the specified channel values and opacity.
+     *
+     * @param l Luminance channel value typically in the range [0, 100].
+     * @param c Chroma channel value typically in [0, 230].
+     * @param h Hue channel value typically in [0, 360).
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (l: number, c: number, h: number, opacity?: number): HCLColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an HCL color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): HCLColor;
+    /**
+     * Converts the provided color instance and returns an HCL color.
+     * The color instance is converted to the RGB color space using color.rgb and then converted to HCL.
+     * (Colors already in the HCL color space skip the conversion to RGB,
+     * and colors in the Lab color space are converted directly to HCL.)
+     *
+     * @param color A permissible color space instance.
+     */
+    // tslint:disable-next-line:unified-signatures
+    (color: ColorSpaceObject | ColorCommonInstance): HCLColor;
+}
+
+/**
+ * Dave Green’s Cubehelix color object.
+ */
+export interface CubehelixColor extends Color {
+    /**
+     * Hue channel value.
+     */
+    h: number;
+    /**
+     * Saturation channel value.
+     */
+    s: number;
+    /**
+     * Lightness channel value.
+     */
+    l: number;
+    /**
+     * Opacity value.
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB color equivalent of this color.
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(
+        values?: {
+            h?: number | undefined;
+            s?: number | undefined;
+            l?: number | undefined;
+            opacity?: number | undefined;
+        },
+    ): this;
+}
+
+/**
+ * A color factory object for Dave Green's Cubehelix colors, which may also be used with instanceof to test if an object
+ * is a Cubehelix color instance.
+ */
+export interface CubehelixColorFactory extends Function {
+    /**
+     * Constructs a new Cubehelix color based on the specified channel values and opacity.
+     *
+     * @param h Hue channel value.
+     * @param s Saturation channel value.
+     * @param l Lightness channel value.
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (h: number, s: number, l: number, opacity?: number): CubehelixColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an Cubehelix color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): CubehelixColor;
+    /**
+     * Converts the provided color instance and returns a Cubehelix color.
+     * The color instance is specified, it is converted to the RGB color space using color.rgb and then converted to Cubehelix.
+     * (Colors already in the Cubehelix color space skip the conversion to RGB.)
+     *
+     * @param color A permissible color space instance.
+     */
+    // tslint:disable-next-line:unified-signatures
+    (color: ColorSpaceObject | ColorCommonInstance): CubehelixColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: CubehelixColor;
+}
+
+// --------------------------------------------------------------------------
+// Color object factories
+// --------------------------------------------------------------------------
+
+/**
+ * A Color factory object, which may also be used with instanceof to test if an object is a color instance.
+ */
+export const color: ColorFactory;
+
+/**
+ * An RGB color factory object, which may also be used with instanceof to test if an object
+ * is an RGB color instance.
+ */
+export const rgb: RGBColorFactory;
+
+/**
+ * An HSL color factory object, which may also be used with instanceof to test if an object
+ * is an HSL color instance.
+ */
+export const hsl: HSLColorFactory;
+
+/**
+ * A Lab (CIELAB) color factory object, which may also be used with instanceof to test if an object
+ * is a Lab color instance.
+ */
+export const lab: LabColorFactory;
+
+/**
+ * A gray color factory for Lab (CIELAB) colors.
+ */
+export const gray: GrayColorFactory;
+
+/**
+ * An HCL (CIELCH) color factory object, which may also be used with instanceof to test if an object
+ * is an HCL color instance.
+ */
+export const hcl: HCLColorFactory;
+
+/**
+ * An LCH (CIELCH) color factory function to create an HCL color object.
+ */
+export const lch: LCHColorFactory;
+
+/**
+ * A color factory object for Dave Green's Cubehelix colors, which may also be used with instanceof to test if an object
+ * is a Cubehelix color instance.
+ */
+export const cubehelix: CubehelixColorFactory;

astra_scene_test/X_03/node_modules/@types/d3-color/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "@types/d3-color",
+    "version": "3.1.3",
+    "description": "TypeScript definitions for d3-color",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-color",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "Alex Ford",
+            "githubUsername": "gustavderdrache",
+            "url": "https://github.com/gustavderdrache"
+        },
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "denisname",
+            "githubUsername": "denisname",
+            "url": "https://github.com/denisname"
+        },
+        {
+            "name": "Hugues Stefanski",
+            "githubUsername": "ledragon",
+            "url": "https://github.com/ledragon"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        },
+        {
+            "name": "Fil",
+            "githubUsername": "Fil",
+            "url": "https://github.com/Fil"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-color"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "89cf9357324cddaa31cfb539b1c33d118648ed55319f2a0d26f24b004975a947",
+    "typeScriptVersion": "4.5"
+}

astra_scene_test/X_03/node_modules/@types/d3-interpolate/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

astra_scene_test/X_03/node_modules/@types/d3-interpolate/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/d3-interpolate`
+
+# Summary
+This package contains type definitions for d3-interpolate (https://github.com/d3/d3-interpolate/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-interpolate.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 15:11:37 GMT
+ * Dependencies: [@types/d3-color](https://npmjs.com/package/@types/d3-color)
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

astra_scene_test/X_03/node_modules/@types/d3-interpolate/index.d.ts

@@ -0,0 +1,387 @@
+// Last module patch version validated against: 3.0.1
+
+import { ColorCommonInstance } from "d3-color";
+
+// ---------------------------------------------------------------------------
+// Shared Type Definitions and Interfaces
+// ---------------------------------------------------------------------------
+
+export interface ZoomInterpolator extends Function {
+    (t: number): ZoomView;
+    /**
+     * Recommended duration of zoom transition in milliseconds.
+     */
+    duration: number;
+
+    /**
+     * Given a zoom interpolator, returns a new zoom interpolator using the specified curvature rho.
+     * When rho is close to 0, the interpolator is almost linear.
+     * The default curvature is sqrt(2).
+     * @param rho
+     */
+    rho(rho: number): this;
+}
+
+export interface ColorGammaInterpolationFactory extends Function {
+    (a: string | ColorCommonInstance, b: string | ColorCommonInstance): (t: number) => string;
+    /**
+     * Returns a new interpolator factory of the same type using the specified *gamma*.
+     * For example, to interpolate from purple to orange with a gamma of 2.2 in RGB space: `d3.interpolateRgb.gamma(2.2)("purple", "orange")`.
+     * See Eric Brasseur’s article, [Gamma error in picture scaling](https://web.archive.org/web/20160112115812/http://www.4p8.com/eric.brasseur/gamma.html), for more on gamma correction.
+     */
+    gamma(g: number): ColorGammaInterpolationFactory;
+}
+
+/**
+ * Type zoomView is used to represent a numeric array with three elements.
+ * In order of appearance the elements correspond to:
+ * - cx: *x*-coordinate of the center of the viewport
+ * - cy: *y*-coordinate of the center of the viewport
+ * - width: size of the viewport
+ */
+export type ZoomView = [number, number, number];
+
+export type TypedArray =
+    | Int8Array
+    | Uint8Array
+    | Int16Array
+    | Uint16Array
+    | Int32Array
+    | Uint32Array
+    | Uint8ClampedArray
+    | Float32Array
+    | Float64Array;
+
+export type NumberArray = TypedArray | DataView;
+
+// ---------------------------------------------------------------------------
+// Interpolation Function Factories
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns an `null` constant interpolator.
+ */
+export function interpolate(a: any, b: null): (t: number) => null;
+/**
+ * Returns an boolean constant interpolator of value `b`.
+ */
+export function interpolate(a: any, b: boolean): (t: number) => boolean;
+/**
+ * Returns a `interpolateRgb` interpolator.
+ */
+export function interpolate(a: string | ColorCommonInstance, b: ColorCommonInstance): (t: number) => string;
+/**
+ * Returns a `interpolateDate` interpolator.
+ */
+export function interpolate(a: Date, b: Date): (t: number) => Date;
+/**
+ * Returns a `interpolateNumber` interpolator.
+ */
+export function interpolate(
+    a: number | { valueOf(): number },
+    b: number | { valueOf(): number },
+): (t: number) => number;
+/**
+ * Returns a `interpolateNumberArray` interpolator.
+ */
+export function interpolate<T extends NumberArray>(a: NumberArray | number[], b: T): (t: number) => T;
+/**
+ * Returns a `interpolateString` interpolator. If `b` is a string coercible to a color use use `interpolateRgb`.
+ */
+export function interpolate(a: string | { toString(): string }, b: string): (t: number) => string;
+/**
+ * Returns a `interpolateArray` interpolator.
+ */
+export function interpolate<U extends any[]>(a: any[], b: U): (t: number) => U;
+/**
+ * Returns a `interpolateObject` interpolator.
+ */
+export function interpolate<U extends object>(a: any, b: U): (t: number) => U;
+
+/**
+ * Returns an interpolator between the two numbers `a` and `b`.
+ * The returned interpolator is equivalent to: `(t) => a * (1 - t) + b * t`.
+ */
+export function interpolateNumber(
+    a: number | { valueOf(): number },
+    b: number | { valueOf(): number },
+): (t: number) => number;
+
+/**
+ * Returns an interpolator between the two numbers `a` and `b`; the interpolator is similar to `interpolateNumber`,
+ * except it will round the resulting value to the nearest integer.
+ */
+export function interpolateRound(
+    a: number | { valueOf(): number },
+    b: number | { valueOf(): number },
+): (t: number) => number;
+
+/**
+ * Returns an interpolator between the two strings `a` and `b`.
+ * The string interpolator finds numbers embedded in `a` and `b`, where each number is of the form understood by JavaScript.
+ * A few examples of numbers that will be detected within a string: `-1`, `42`, `3.14159`, and `6.0221413e+23`.
+ *
+ * For each number embedded in `b`, the interpolator will attempt to find a corresponding number in `a`.
+ * If a corresponding number is found, a numeric interpolator is created using `interpolateNumber`.
+ * The remaining parts of the string `b` are used as a template.
+ *
+ * For example, if `a` is `"300 12px sans-serif"`, and `b` is `"500 36px Comic-Sans"`, two embedded numbers are found.
+ * The remaining static parts (of string `b`) are a space between the two numbers (`" "`), and the suffix (`"px Comic-Sans"`).
+ * The result of the interpolator at `t` = 0.5 is `"400 24px Comic-Sans"`.
+ */
+export function interpolateString(
+    a: string | { toString(): string },
+    b: string | { toString(): string },
+): (t: number) => string;
+
+/**
+ * Returns an interpolator between the two dates `a` and `b`.
+ *
+ * Note: *no defensive copy* of the returned date is created; the same Date instance is returned for every evaluation of the interpolator.
+ * No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
+ */
+export function interpolateDate(a: Date, b: Date): (t: number) => Date;
+
+export type ArrayInterpolator<A extends any[]> = (t: number) => A;
+
+/**
+ * Returns an interpolator between the two arrays `a` and `b`. Internally, an array template is created that is the same length in `b`.
+ * For each element in `b`, if there exists a corresponding element in `a`, a generic interpolator is created for the two elements using `interpolate`.
+ * If there is no such element, the static value from `b` is used in the template.
+ * Then, for the given parameter `t`, the template’s embedded interpolators are evaluated. The updated array template is then returned.
+ *
+ * For example, if `a` is the array `[0, 1]` and `b` is the array `[1, 10, 100]`, then the result of the interpolator for `t = 0.5` is the array `[0.5, 5.5, 100]`.
+ *
+ * Note: *no defensive copy* of the template array is created; modifications of the returned array may adversely affect subsequent evaluation of the interpolator.
+ * No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
+ */
+export function interpolateArray<A extends any[]>(a: any[], b: A): ArrayInterpolator<A>;
+/**
+ * interpolateNumberArray is called
+ */
+export function interpolateArray<T extends NumberArray>(a: NumberArray | number[], b: T): (t: number) => T;
+
+/**
+ * Returns an interpolator between the two arrays of numbers a and b.
+ * Internally, an array template is created that is the same type and length as b.
+ * For each element in b, if there exists a corresponding element in a, the values are directly interpolated in the array template.
+ * If there is no such element, the static value from b is copied.
+ * The updated array template is then returned.
+ *
+ * Note: For performance reasons, no defensive copy is made of the template array and the arguments a and b; modifications of these arrays may affect subsequent evaluation of the interpolator.
+ */
+export function interpolateNumberArray<T extends NumberArray | number[]>(
+    a: NumberArray | number[],
+    b: T,
+): (t: number) => T;
+
+/**
+ * Returns an interpolator between the two objects `a` and `b`. Internally, an object template is created that has the same properties as `b`.
+ * For each property in `b`, if there exists a corresponding property in `a`, a generic interpolator is created for the two elements using `interpolate`.
+ * If there is no such property, the static value from `b` is used in the template.
+ * Then, for the given parameter `t`, the template's embedded interpolators are evaluated and the updated object template is then returned.
+ *
+ * For example, if `a` is the object `{x: 0, y: 1}` and `b` is the object `{x: 1, y: 10, z: 100}`, the result of the interpolator for `t = 0.5` is the object `{x: 0.5, y: 5.5, z: 100}`.
+ *
+ * Note: *no defensive copy* of the template object is created; modifications of the returned object may adversely affect subsequent evaluation of the interpolator.
+ * No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
+ */
+export function interpolateObject<U extends object>(a: any, b: U): (t: number) => U;
+
+/**
+ * Returns an interpolator between the two 2D CSS transforms represented by `a` and `b`.
+ * Each transform is decomposed to a standard representation of translate, rotate, *x*-skew and scale; these component transformations are then interpolated.
+ * This behavior is standardized by CSS: see [matrix decomposition for animation](http://www.w3.org/TR/css3-2d-transforms/#matrix-decomposition).
+ */
+export function interpolateTransformCss(a: string, b: string): (t: number) => string;
+
+/**
+ * Returns an interpolator between the two 2D SVG transforms represented by `a` and `b`.
+ * Each transform is decomposed to a standard representation of translate, rotate, *x*-skew and scale; these component transformations are then interpolated.
+ * This behavior is standardized by CSS: see [matrix decomposition for animation](http://www.w3.org/TR/css3-2d-transforms/#matrix-decomposition).
+ */
+export function interpolateTransformSvg(a: string, b: string): (t: number) => string;
+
+/**
+ * Returns an interpolator between the two views `a` and `b` of a two-dimensional plane,
+ * based on [“Smooth and efficient zooming and panning”](http://www.win.tue.nl/~vanwijk/zoompan.pdf).
+ * Each view is defined as an array of three numbers: *cx*, *cy* and *width*.
+ * The first two coordinates *cx*, *cy* represent the center of the viewport; the last coordinate *width* represents the size of the viewport.
+ *
+ * The returned interpolator exposes a *duration* property which encodes the recommended transition duration in milliseconds.
+ * This duration is based on the path length of the curved trajectory through *x,y* space.
+ * If you want to a slower or faster transition, multiply this by an arbitrary scale factor (*V* as described in the original paper).
+ */
+export function interpolateZoom(a: ZoomView, b: ZoomView): ZoomInterpolator;
+
+/**
+ * Returns a discrete interpolator for the given array of values. The returned interpolator maps `t` in `[0, 1 / n)` to values[0],
+ * `t` in `[1 / n, 2 / n)` to `values[1]`, and so on, where `n = values.length`. In effect, this is a lightweight quantize scale with a fixed domain of [0, 1].
+ */
+export function interpolateDiscrete<T>(values: T[]): (t: number) => T;
+
+// Sampling ------------------------------------------------------------------
+
+/**
+ * Returns `n` uniformly-spaced samples from the specified `interpolator`, where `n` is an integer greater than one.
+ * The first sample is always at `t = 0`, and the last sample is always at `t = 1`.
+ * This can be useful in generating a fixed number of samples from a given interpolator,
+ * such as to derive the range of a [quantize scale](https://github.com/d3/d3-scale#quantize-scales) from a [continuous interpolator](https://github.com/d3/d3-scale#interpolateWarm).
+ *
+ * Caution: this method will not work with interpolators that do not return defensive copies of their output,
+ * such as `d3.interpolateArray`, `d3.interpolateDate` and `d3.interpolateObject`. For those interpolators, you must wrap the interpolator and create a copy for each returned value.
+ */
+export function quantize<T>(interpolator: (t: number) => T, n: number): T[];
+
+// Color Spaces
+
+/**
+ * Returns an RGB color space interpolator between the two colors `a` and `b` with a configurable gamma. If the gamma is not specified, it defaults to 1.0.
+ * The colors `a` and `b` need not be in RGB; they will be converted to RGB using [`d3.rgb`](https://github.com/d3/d3-color#rgb). The return value of the interpolator is an RGB string.
+ */
+export const interpolateRgb: ColorGammaInterpolationFactory;
+
+/**
+ * Returns a uniform nonrational B-spline interpolator through the specified array of *colors*, which are converted to RGB color space.
+ * Implicit control points are generated such that the interpolator returns `colors[0]` at `t = 0` and `colors[colors.length - 1]` at `t = 1`.
+ * Opacity interpolation is not currently supported. See also `d3.interpolateBasis`, and see [d3-scale-chromatic](https://github.com/d3/d3-scale-chromatic) for examples.
+ */
+export function interpolateRgbBasis(colors: Array<string | ColorCommonInstance>): (t: number) => string;
+
+/**
+ * Returns a uniform nonrational B-spline interpolator through the specified array of colors, which are converted to RGB color space.
+ * The control points are implicitly repeated such that the resulting spline has cyclical C² continuity when repeated around `t` in [0,1];
+ * this is useful, for example, to create cyclical color scales. Opacity interpolation is not currently supported.
+ * See also `d3.interpolateBasisClosed, and see [d3-scale-chromatic](https://github.com/d3/d3-scale-chromatic) for examples.
+ */
+export function interpolateRgbBasisClosed(colors: Array<string | ColorCommonInstance>): (t: number) => string;
+
+/**
+ * Returns an HSL color space interpolator between the two colors *a* and *b*. The colors *a* and *b* need not be in HSL;
+ * they will be converted to HSL using `d3.hsl`. If either color’s hue or saturation is NaN, the opposing color’s channel value is used.
+ * The shortest path between hues is used. The return value of the interpolator is an RGB string.
+ */
+export function interpolateHsl(a: string | ColorCommonInstance, b: string | ColorCommonInstance): (t: number) => string;
+
+/**
+ * Like `interpolateHsl`, but does not use the shortest path between hues.
+ */
+export function interpolateHslLong(
+    a: string | ColorCommonInstance,
+    b: string | ColorCommonInstance,
+): (t: number) => string;
+
+/**
+ * Returns a Lab color space interpolator between the two colors *a* and *b*. The colors *a* and *b* need not be in Lab;
+ * they will be converted to Lab using `d3.lab`. The return value of the interpolator is an RGB string.
+ */
+export function interpolateLab(a: string | ColorCommonInstance, b: string | ColorCommonInstance): (t: number) => string;
+
+/**
+ * Returns an HCL color space interpolator between the two colors `a` and `b`. The colors `a` and `b` need not be in HCL;
+ * they will be converted to HCL using `d3.hcl`. If either color’s hue or chroma is NaN, the opposing color’s channel value is used.
+ * The shortest path between hues is used. The return value of the interpolator is an RGB string.
+ */
+export function interpolateHcl(a: string | ColorCommonInstance, b: string | ColorCommonInstance): (t: number) => string;
+
+/**
+ * Like `interpolateHcl`, but does not use the shortest path between hues.
+ */
+export function interpolateHclLong(
+    a: string | ColorCommonInstance,
+    b: string | ColorCommonInstance,
+): (t: number) => string;
+
+/**
+ * Returns a Cubehelix color space interpolator between the two colors `a` and `b` using a configurable `gamma`.
+ * If the gamma is not specified, it defaults to 1.0. The colors `a` and `b` need not be in Cubehelix;
+ * they will be converted to Cubehelix using [`d3.cubehelix`](https://github.com/d3/d3-color#cubehelix).
+ * If either color’s hue or saturation is NaN, the opposing color’s channel value is used. The shortest path between hues is used. The return value of the interpolator is an RGB string.
+ */
+export const interpolateCubehelix: ColorGammaInterpolationFactory;
+
+/**
+ * Like `interpolateCubehelix`, but does not use the shortest path between hues.
+ */
+export const interpolateCubehelixLong: ColorGammaInterpolationFactory;
+
+/**
+ * Returns an interpolator between the two hue angles `a` and `b`. If either hue is NaN, the opposing value is used.
+ * The shortest path between hues is used. The return value of the interpolator is a number in `[0, 360)`.
+ */
+export function interpolateHue(a: number, b: number): (t: number) => number;
+
+// Splines -------------------------------------------------------------------
+
+/**
+ * Returns a uniform nonrational B-spline interpolator through the specified array of `values`, which must be numbers.
+ * Implicit control points are generated such that the interpolator returns `values[0]` at `t` = 0 and `values[values.length - 1]` at `t` = 1.
+ * See also [`d3.curveBasis`](https://github.com/d3/d3-shape#curveBasis).
+ */
+export function interpolateBasis(splineNodes: number[]): (t: number) => number;
+
+/**
+ * Returns a uniform nonrational B-spline interpolator through the specified array of `values`, which must be numbers.
+ * The control points are implicitly repeated such that the resulting one-dimensional spline has cyclical C² continuity when repeated around `t` in [0,1].
+ * See also [`d3.curveBasisClosed`](https://github.com/d3/d3-shape#curveBasisClosed).
+ */
+export function interpolateBasisClosed(splineNodes: number[]): (t: number) => number;
+
+// Piecewise -----------------------------------------------------------------
+
+/**
+ * Returns a piecewise zoom interpolator, composing zoom interpolators for each adjacent pair of zoom view.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through three different zoom views: `d3.piecewise(d3.interpolateZoom, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
+ *
+ * interpolate defaults to d3.interpolate.
+ */
+export function piecewise(values: ZoomView[]): ZoomInterpolator;
+/**
+ * Returns a piecewise zoom interpolator, composing zoom interpolators for each adjacent pair of zoom view.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through three different zoom views: `d3.piecewise(d3.interpolateZoom, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
+ */
+export function piecewise(
+    interpolate: (a: ZoomView, b: ZoomView) => ZoomInterpolator,
+    values: ZoomView[],
+): ZoomInterpolator;
+
+/**
+ * Returns a piecewise array interpolator, composing array interpolators for each adjacent pair of arrays.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through three different arrays: `d3.piecewise(d3.interpolateArray, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
+ *
+ * interpolate defaults to d3.interpolate.
+ */
+export function piecewise<A extends any[]>(values: A[]): ArrayInterpolator<A>;
+/**
+ * Returns a piecewise array interpolator, composing array interpolators for each adjacent pair of arrays.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through three different arrays: `d3.piecewise(d3.interpolateArray, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
+ */
+export function piecewise<A extends any[]>(
+    interpolate: (a: any[], b: A) => ArrayInterpolator<A>,
+    values: A[],
+): ArrayInterpolator<A>;
+
+/**
+ * Returns a piecewise interpolator, composing interpolators for each adjacent pair of values.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through red, green and blue: `d3.piecewise(d3.interpolateRgb.gamma(2.2), ["red", "green", "blue"])`.
+ *
+ * interpolate defaults to d3.interpolate.
+ */
+export function piecewise(values: unknown[]): (t: number) => any;
+/**
+ * Returns a piecewise interpolator, composing interpolators for each adjacent pair of values.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through red, green and blue: `d3.piecewise(d3.interpolateRgb.gamma(2.2), ["red", "green", "blue"])`.
+ */
+export function piecewise<TData>(interpolate: (a: TData, b: TData) => unknown, values: TData[]): (t: number) => any;

astra_scene_test/X_03/node_modules/@types/d3-interpolate/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@types/d3-interpolate",
+    "version": "3.0.4",
+    "description": "TypeScript definitions for d3-interpolate",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-interpolate",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "Alex Ford",
+            "githubUsername": "gustavderdrache",
+            "url": "https://github.com/gustavderdrache"
+        },
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "denisname",
+            "githubUsername": "denisname",
+            "url": "https://github.com/denisname"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-interpolate"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/d3-color": "*"
+    },
+    "typesPublisherContentHash": "d315fc677144695b44f1447ef7429c9ff248886716c2e9f742d031abcb319115",
+    "typeScriptVersion": "4.5"
+}

astra_scene_test/X_03/node_modules/@types/d3-scale/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

astra_scene_test/X_03/node_modules/@types/d3-scale/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/d3-scale`
+
+# Summary
+This package contains type definitions for d3-scale (https://github.com/d3/d3-scale/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-scale.
+
+### Additional Details
+ * Last updated: Wed, 05 Feb 2025 00:46:59 GMT
+ * Dependencies: [@types/d3-time](https://npmjs.com/package/@types/d3-time)
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), [rulonder](https://github.com/rulonder), and [Nathan Bierema](https://github.com/Methuselah96).

astra_scene_test/X_03/node_modules/@types/d3-scale/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "@types/d3-scale",
+    "version": "4.0.9",
+    "description": "TypeScript definitions for d3-scale",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-scale",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "Alex Ford",
+            "githubUsername": "gustavderdrache",
+            "url": "https://github.com/gustavderdrache"
+        },
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "denisname",
+            "githubUsername": "denisname",
+            "url": "https://github.com/denisname"
+        },
+        {
+            "name": "rulonder",
+            "githubUsername": "rulonder",
+            "url": "https://github.com/rulonder"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-scale"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/d3-time": "*"
+    },
+    "peerDependencies": {},
+    "typesPublisherContentHash": "c7eb4d63d0dfb659f0f8e359a4de33ed1f690bdea8051641bffa941f06a92f4d",
+    "typeScriptVersion": "5.0"
+}

astra_scene_test/X_03/node_modules/@types/d3-shape/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

astra_scene_test/X_03/node_modules/@types/d3-shape/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/d3-shape`
+
+# Summary
+This package contains type definitions for d3-shape (https://github.com/d3/d3-shape/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-shape.
+
+### Additional Details
+ * Last updated: Fri, 21 Aug 2026 21:38:06 GMT
+ * Dependencies: [@types/d3-path](https://npmjs.com/package/@types/d3-path)
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), [Nathan Bierema](https://github.com/Methuselah96), and [Fil](https://github.com/Fil).

astra_scene_test/X_03/node_modules/@types/d3-shape/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "@types/d3-shape",
+    "version": "3.2.0",
+    "description": "TypeScript definitions for d3-shape",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-shape",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "Alex Ford",
+            "githubUsername": "gustavderdrache",
+            "url": "https://github.com/gustavderdrache"
+        },
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "denisname",
+            "githubUsername": "denisname",
+            "url": "https://github.com/denisname"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        },
+        {
+            "name": "Fil",
+            "githubUsername": "Fil",
+            "url": "https://github.com/Fil"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-shape"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/d3-path": "*"
+    },
+    "peerDependencies": {},
+    "typesPublisherContentHash": "4d33e16c0579135ebe257c1dfb53b603cbf36eb29b15a4748ff9b6cbf1f979b2",
+    "typeScriptVersion": "5.6"
+}

astra_scene_test/X_03/node_modules/@types/d3-time/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

astra_scene_test/X_03/node_modules/@types/d3-time/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/d3-time`
+
+# Summary
+This package contains type definitions for d3-time (https://github.com/d3/d3-time/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-time.
+
+### Additional Details
+ * Last updated: Mon, 25 Nov 2024 10:02:27 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

astra_scene_test/X_03/node_modules/@types/d3-time/index.d.ts

@@ -0,0 +1,697 @@
+// Last module patch version validated against: 3.0.0
+
+// ---------------------------------------------------------------
+// Interfaces
+// ---------------------------------------------------------------
+
+/**
+ * A D3 Time Interval
+ */
+export interface TimeInterval {
+    /**
+     * Returns a new date representing the latest interval boundary date before or equal to date.
+     * Equivalent to interval.floor, except it date is not specified, it defaults to the current time.
+     * For example, d3.timeYear(date) and d3.timeYear.floor(date) are equivalent.
+     *
+     * For example, timeDay(date) typically returns 12:00 AM local time on the given date.
+     *
+     * This function is idempotent: if the specified date is already floored to the current interval,
+     * a new date with an identical time is returned.
+     * Furthermore, the returned date is the minimum expressible value of the associated interval,
+     * such that interval.floor(interval.floor(date) - 1) returns the preceding interval boundary date.
+     *
+     * Note that the == and === operators do not compare by value with Date objects,
+     * and thus you cannot use them to tell whether the specified date has already been floored.
+     * Instead, coerce to a number and then compare.
+     *
+     * This is more reliable than testing whether the time is 12:00 AM, as in some time zones midnight may not exist due to daylight saving.
+     *
+     * @param date A date object.
+     */
+    (date?: Date): Date;
+
+    /**
+     * Returns a new date representing the latest interval boundary date before or equal to date.
+     *
+     * For example, timeDay.floor(date) typically returns 12:00 AM local time on the given date.
+     *
+     * This method is idempotent: if the specified date is already floored to the current interval,
+     * a new date with an identical time is returned.
+     * Furthermore, the returned date is the minimum expressible value of the associated interval,
+     * such that interval.floor(interval.floor(date) - 1) returns the preceding interval boundary date.
+     *
+     * Note that the == and === operators do not compare by value with Date objects,
+     * and thus you cannot use them to tell whether the specified date has already been floored.
+     * Instead, coerce to a number and then compare.
+     *
+     * This is more reliable than testing whether the time is 12:00 AM, as in some time zones midnight may not exist due to daylight saving.
+     *
+     * @param date A date object.
+     */
+    floor(date: Date): Date;
+
+    /**
+     * Returns a new date representing the closest interval boundary date to date.
+     *
+     * For example, timeDay.round(date) typically returns 12:00 AM local time on the given date if it is on or before noon,
+     * and 12:00 AM of the following day if it is after noon.
+     *
+     * This method is idempotent: if the specified date is already rounded to the current interval, a new date with an identical time is returned.
+     *
+     * @param date A date object.
+     */
+    round(date: Date): Date;
+
+    /**
+     * Returns a new date representing the earliest interval boundary date after or equal to date.
+     *
+     * For example, timeDay.ceil(date) typically returns 12:00 AM local time on the date following the given date.
+     *
+     * This method is idempotent: if the specified date is already ceilinged to the current interval,
+     * a new date with an identical time is returned. Furthermore,
+     * the returned date is the maximum expressible value of the associated interval,
+     * such that interval.ceil(interval.ceil(date) + 1) returns the following interval boundary date.
+     *
+     * @param date A date object.
+     */
+    ceil(date: Date): Date;
+
+    /**
+     * Returns a new date equal to date plus step intervals.
+     *
+     * If step is not specified it defaults to 1.
+     *
+     * This method does not round the specified date to the interval. For example, if date is today at 5:34 PM,
+     * then timeDay.offset(date, 1) returns 5:34 PM tomorrow (even if daylight saving changes!).
+     *
+     * @param date A date object.
+     * @param step An optional number of steps to apply when calculating the offset date.
+     * If step is negative, then the returned date will be before the specified date;
+     * if step is zero, then a copy of the specified date is returned; if step is not an integer, it is floored.
+     */
+    offset(date: Date, step?: number): Date;
+
+    /**
+     * Returns an array of dates representing every interval boundary after or equal to start (inclusive) and before stop (exclusive).
+     *
+     * If step is specified, then every step-th boundary will be returned; for example,
+     * for the timeDay interval a step of 2 will return every other day.
+     * If step is not an integer, it is floored.
+     *
+     * The first date in the returned array is the earliest boundary after or equal to start;
+     * subsequent dates are offset by step intervals and floored.
+     * Thus, two overlapping ranges may be inconsistent.
+     *
+     * To make ranges consistent when a step is specified, use CountableInterval.every instead.
+     *
+     * @param start A start date object for the range.
+     * @param stop A stop date object for the range.
+     * @param step An optional number of steps to apply when calculating the dates in the range.
+     */
+    range(start: Date, stop: Date, step?: number): Date[];
+
+    /**
+     * Returns a new interval that is a filtered subset of this interval using the specified test function.
+     *
+     * @param test A test function which is passed a date and should return true if and only if
+     * the specified date should be considered part of the interval.
+     */
+    filter(test: (date: Date) => boolean): TimeInterval;
+}
+
+/**
+ * A D3 Countable Time Interval
+ */
+export interface CountableTimeInterval extends TimeInterval {
+    /**
+     * Returns the number of interval boundaries after start (exclusive) and before or equal to end (inclusive).
+     *
+     * Note that this behavior is slightly different than interval.range,
+     * because its purpose is to return the zero-based number of the specified end date relative to the specified start date.
+     *
+     * @param start A start date object.
+     * @param end An end date object.
+     */
+    count(start: Date, end: Date): number;
+    /**
+     * Returns a filtered view of this interval representing every stepth date.
+     *
+     * The meaning of step is dependent on this interval’s parent interval as defined by the field function.
+     *
+     * For example, timeMinute.every(15) returns an interval representing every fifteen minutes,
+     * starting on the hour: :00, :15, :30, :45, etc. Note that for some intervals,
+     * the resulting dates may not be uniformly-spaced;
+     * timeDay’s parent interval is timeMonth, and thus the interval number resets at the start of each month.
+     *
+     * If step is not valid, returns null. If step is one, returns this interval.
+     *
+     * This method can be used in conjunction with interval.range to ensure that two overlapping ranges are consistent.
+     *
+     * The returned filtered interval does not support interval.count. See also interval.filter.
+     *
+     * @param step Number of steps.
+     */
+    every(step: number): TimeInterval | null;
+}
+
+// ---------------------------------------------------------------
+// Custom (Countable)Interval Factories
+// ---------------------------------------------------------------
+
+/**
+ * Constructs a new custom interval given the specified floor and offset functions.
+ *
+ * The returned custom interval is not countable, i.e. does not expose the methods "count(..)" and "every(...)".
+ *
+ * @param floor A floor function which takes a single date as an argument and rounds it down to the nearest interval boundary.
+ * @param offset An offset function which takes a date and an integer step as arguments and advances
+ * the specified date by the specified number of boundaries; the step may be positive, negative or zero.
+ */
+export function timeInterval(
+    floor: (date: Date) => void,
+    offset: (date: Date, step: number) => void,
+): TimeInterval;
+/**
+ * Constructs a new custom interval given the specified floor, offset and count functions.
+ *
+ * The returned custom interval is countable and exposes the methods "count(..)" and "every(...)".
+ *
+ * Note: due to an internal optimization, the specified count function must not invoke interval.count on other time intervals.
+ *
+ * @param floor A floor function which takes a single date as an argument and rounds it down to the nearest interval boundary.
+ * @param offset An offset function which takes a date and an integer step as arguments and advances
+ * the specified date by the specified number of boundaries; the step may be positive, negative or zero.
+ * @param count A count function which takes a start date and an end date, already floored to the current interval,
+ * and returns the number of boundaries between the start (exclusive) and end (inclusive).
+ * Note: due to an internal optimization, the specified count function must not invoke interval.count on other time intervals.
+ * @param field An optional field function which takes a date, already floored to the current interval,
+ * and returns the field value of the specified date,
+ * corresponding to the number of boundaries between this date (exclusive) and the latest previous parent boundary.
+ * For example, for the timeDay interval, this returns the number of days since the start of the month.
+ * If a field function is not specified, it defaults to counting the number of interval boundaries since
+ * the UNIX epoch of January 1, 1970 UTC. The field function defines the behavior of interval.every.
+ */
+export function timeInterval(
+    floor: (date: Date) => void,
+    offset: (date: Date, step: number) => void,
+    count: (start: Date, end: Date) => number,
+    field?: (date: Date) => number,
+): CountableTimeInterval;
+
+// ---------------------------------------------------------------
+// Built-In Factories and Date Array Creators
+// ---------------------------------------------------------------
+
+// local time ----------------------------------------------------------
+
+/**
+ * Milliseconds Interval in Local Time; the shortest available time unit.
+ */
+export const timeMillisecond: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeMillisecond.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeMilliseconds(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Seconds Interval in Local Time; seconds (e.g., 01:23:45.0000 AM); 1,000 milliseconds.
+ */
+export const timeSecond: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeSecond.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeSeconds(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Minutes Interval in Local Time; minutes (e.g., 01:02:00 AM); 60 seconds. Note that ECMAScript ignores leap seconds.
+ */
+export const timeMinute: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeMinute.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeMinutes(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Hours Interval in Local Time; Hours (e.g., 01:00 AM); 60 minutes.
+ *
+ * Note that advancing time by one hour in local time can return the same hour or skip an hour due to daylight saving.
+ */
+export const timeHour: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeHour.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeHours(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Days Interval in Local Time; days (e.g., February 7, 2012 at 12:00 AM); typically 24 hours.
+ * Days in local time may range from 23 to 25 hours due to daylight saving.
+ */
+export const timeDay: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeDay.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeDays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval in Local Time. Alias for sunday; 7 days and typically 168 hours.
+ *
+ * Weeks in local time may range from 167 to 169 hours due on daylight saving.
+ */
+export const timeWeek: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeWeek.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeWeeks(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Sunday-based weeks in Local Time (e.g., February 5, 2012 at 12:00 AM).
+ * 7 days and typically 168 hours.
+ *
+ * Weeks in local time may range from 167 to 169 hours due on daylight saving.
+ */
+export const timeSunday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeSunday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeSundays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Monday-based weeks in Local Time (e.g., February 6, 2012 at 12:00 AM).
+ * 7 days and typically 168 hours.
+ *
+ * Weeks in local time may range from 167 to 169 hours due on daylight saving.
+ */
+export const timeMonday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeMonday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeMondays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Tuesday-based weeks in Local Time (e.g., February 7, 2012 at 12:00 AM).
+ * 7 days and typically 168 hours.
+ *
+ * Weeks in local time may range from 167 to 169 hours due on daylight saving.
+ */
+export const timeTuesday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeTuesday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeTuesdays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Wednesday-based weeks in Local Time (e.g., February 8, 2012 at 12:00 AM).
+ * 7 days and typically 168 hours.
+ *
+ * Weeks in local time may range from 167 to 169 hours due on daylight saving.
+ */
+export const timeWednesday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeWednesday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeWednesdays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Thursday-based weeks in Local Time (e.g., February 9, 2012 at 12:00 AM).
+ * 7 days and typically 168 hours.
+ *
+ * Weeks in local time may range from 167 to 169 hours due on daylight saving.
+ */
+export const timeThursday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeThursday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeThursdays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Friday-based weeks in Local Time (e.g., February 10, 2012 at 12:00 AM).
+ * 7 days and typically 168 hours.
+ *
+ * Weeks in local time may range from 167 to 169 hours due on daylight saving.
+ */
+export const timeFriday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeFriday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeFridays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Saturday-based weeks in Local Time (e.g., February 11, 2012 at 12:00 AM).
+ * 7 days and typically 168 hours.
+ *
+ * Weeks in local time may range from 167 to 169 hours due on daylight saving.
+ */
+export const timeSaturday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeSaturday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeSaturdays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Month Interval in Local Time; months (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to 31 days.
+ */
+export const timeMonth: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeMonth.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeMonths(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Year Interval in Local Time; years (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to 366 days.
+ */
+export const timeYear: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for timeYear.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function timeYears(start: Date, stop: Date, step?: number): Date[];
+
+// utc Coordinated Universal Time ----------------------------------------------------------
+
+/**
+ * Milliseconds Interval in Coordinated Universal Time (UTC); the shortest available time unit.
+ */
+export const utcMillisecond: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcMillisecond.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcMilliseconds(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Seconds Interval in Coordinated Universal Time (UTC); seconds (e.g., 01:23:45.0000 AM); 1,000 milliseconds.
+ */
+export const utcSecond: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcSecond.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcSeconds(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Minutes Interval in Coordinated Universal Time (UTC); minutes (e.g., 01:02:00 AM); 60 seconds.
+ * Note that ECMAScript ignores leap seconds.
+ */
+export const utcMinute: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcMinute.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcMinutes(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Hours Interval in Coordinated Universal Time (UTC); Hours (e.g., 01:00 AM); 60 minutes.
+ */
+export const utcHour: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcHour.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcHours(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Days Interval in Coordinated Universal Time (UTC); days (e.g., February 7, 2012 at 12:00 AM); 24 hours.
+ */
+export const utcDay: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcDay.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcDays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval in Local Time. Alias for sunday; 7 days and 168 hours.
+ */
+export const utcWeek: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcWeek.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcWeeks(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Sunday-based weeks in Coordinated Universal Time (UTC) (e.g., February 5, 2012 at 12:00 AM).
+ * 7 days and 168 hours.
+ */
+export const utcSunday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcSunday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcSundays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Monday-based weeks in Coordinated Universal Time (UTC) (e.g., February 6, 2012 at 12:00 AM).
+ * 7 days and 168 hours.
+ */
+export const utcMonday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcMonday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcMondays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Tuesday-based weeks in Coordinated Universal Time (UTC) (e.g., February 7, 2012 at 12:00 AM).
+ * 7 days and 168 hours.
+ */
+export const utcTuesday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcTuesday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcTuesdays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Wednesday-based weeks in Coordinated Universal Time (UTC) (e.g., February 8, 2012 at 12:00 AM).
+ * 7 days and 168 hours.
+ */
+export const utcWednesday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcWednesday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcWednesdays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Thursday-based weeks in Coordinated Universal Time (UTC) (e.g., February 9, 2012 at 12:00 AM).
+ * 7 days and 168 hours.
+ */
+export const utcThursday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcThursday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcThursdays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Friday-based weeks in Coordinated Universal Time (UTC) (e.g., February 10, 2012 at 12:00 AM).
+ * 7 days and 168 hours.
+ */
+export const utcFriday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcFriday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcFridays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Week Interval for Saturday-based weeks in Coordinated Universal Time (UTC) (e.g., February 11, 2012 at 12:00 AM).
+ * 7 days and 168 hours.
+ */
+export const utcSaturday: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcSaturday.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcSaturdays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Month Interval in Coordinated Universal Time (UTC); months (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to 31 days.
+ */
+export const utcMonth: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcMonth.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcMonths(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Year Interval in Coordinated Universal Time (UTC); years (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to 366 days.
+ */
+export const utcYear: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for utcYear.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function utcYears(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Like d3.utcDay, except it counts days since the UNIX epoch (January 1, 1970) such that interval.every returns uniformly-spaced dates rather than varying based on day-of-month.
+ */
+export const unixDay: CountableTimeInterval;
+
+/**
+ * This is a convenience alias for unixDay.range(...).
+ *
+ * @param start A start date object for the range.
+ * @param stop A stop date object for the range.
+ * @param step An optional number of steps to apply when calculating the dates in the range.
+ */
+export function unixDays(start: Date, stop: Date, step?: number): Date[];
+
+/**
+ * Equivalent to d3.utcTicks, but in local time.
+ */
+export function timeTicks(start: Date, stop: Date, count: number): Date[];
+
+/**
+ * Returns the time interval that would be used by d3.timeTicks given the same arguments.
+ */
+export function timeTickInterval(start: Date, stop: Date, count: number): TimeInterval | null;
+
+/**
+ * Returns an array of approximately count dates at regular intervals between start and stop (inclusive).
+ * If stop is before start, dates are returned in reverse chronological order; otherwise dates are returned in chronological order.
+ */
+export function utcTicks(start: Date, stop: Date, count: number): Date[];
+
+/**
+ * Returns the time interval that would be used by d3.utcTicks given the same arguments.
+ * If there is no associated interval, such as when start or stop is invalid, returns null.
+ */
+export function utcTickInterval(start: Date, stop: Date, count: number): TimeInterval | null;

astra_scene_test/X_03/node_modules/@types/d3-time/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@types/d3-time",
+    "version": "3.0.4",
+    "description": "TypeScript definitions for d3-time",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-time",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "Alex Ford",
+            "githubUsername": "gustavderdrache",
+            "url": "https://github.com/gustavderdrache"
+        },
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "denisname",
+            "githubUsername": "denisname",
+            "url": "https://github.com/denisname"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-time"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "peerDependencies": {},
+    "typesPublisherContentHash": "995c6a7a1f21328f5dceb32804c5f3d92ab20a98694246d9c8f213f4eef298ed",
+    "typeScriptVersion": "4.9"
+}

astra_scene_test/X_03/node_modules/@types/d3-timer/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

astra_scene_test/X_03/node_modules/@types/d3-timer/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/d3-timer`
+
+# Summary
+This package contains type definitions for d3-timer (https://github.com/d3/d3-timer/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-timer.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 15:11:37 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

astra_scene_test/X_03/node_modules/@types/d3-timer/index.d.ts

@@ -0,0 +1,68 @@
+// Last module patch version validated against: 3.0.1
+
+/**
+ * Returns the current time as defined by performance.now if available, and Date.now if not.
+ * The current time is updated at the start of a frame; it is thus consistent during the frame, and any timers scheduled during the same frame will be synchronized.
+ * If this method is called outside of a frame, such as in response to a user event, the current time is calculated and then fixed until the next frame,
+ * again ensuring consistent timing during event handling.
+ */
+export function now(): number;
+
+export interface Timer {
+    /**
+     * Restart a timer with the specified callback and optional delay and time.
+     * This is equivalent to stopping this timer and creating a new timer with the specified arguments,
+     * although this timer retains the original invocation priority.
+     *
+     * @param callback A callback function to be invoked and passed in the apparent
+     * elapsed time since the timer became active in milliseconds.
+     * @param delay An optional numeric delay in milliseconds (default = 0) relative to time.
+     * @param time An optional time in milliseconds relative to which the delay is calculated (default = now).
+     */
+    restart(callbackFn: (elapsed: number) => void, delay?: number, time?: number): void;
+
+    /**
+     * Stop the timer.
+     */
+    stop(): void;
+}
+
+/**
+ * Schedules and returns a new timer, invoking the specified callback repeatedly until the timer is stopped.
+ * The callback is passed the (apparent) elapsed time since the timer became active.
+ *
+ * @param callback A callback function to be invoked and passed in the apparent
+ * elapsed time since the timer became active in milliseconds.
+ * @param delay An optional numeric delay in milliseconds (default = 0) relative to time.
+ * @param time An optional time in milliseconds relative to which the delay is calculated (default = now).
+ */
+export function timer(callback: (elapsed: number) => void, delay?: number, time?: number): Timer;
+
+/**
+ * Immediately invoke any eligible timer callbacks.
+ */
+export function timerFlush(): void;
+
+/**
+ * Schedules and returns a new timer, invoking the specified callback. The timer is stopped automatically
+ * on its first callback. The callback is passed the (apparent) elapsed time since the timer became active.
+ *
+ * @param callback A callback function to be invoked and passed in the apparent
+ * elapsed time since the timer became active in milliseconds.
+ * @param delay An optional numeric delay in milliseconds (default = 0) relative to time.
+ * @param time An optional time in milliseconds relative to which the delay is calculated (default = now).
+ */
+export function timeout(callback: (elapsed: number) => void, delay?: number, time?: number): Timer;
+
+/**
+ * Schedules and returns a new timer, invoking the specified callback repeatedly every 'delay' milliseconds
+ * until the timer is stopped.
+ * The callback is passed the (apparent) elapsed time since the timer became active.
+ *
+ * @param callback A callback function to be invoked and passed in the apparent
+ * elapsed time since the timer became active in milliseconds.
+ * @param delay An optional numeric delay in milliseconds between repeat invocations of the callback.
+ * If not specified, the interval timer behaves like the regular timer.
+ * @param time An optional time in milliseconds relative to which the initial delay is calculated (default = now).
+ */
+export function interval(callback: (elapsed: number) => void, delay?: number, time?: number): Timer;

astra_scene_test/X_03/node_modules/@types/d3-timer/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@types/d3-timer",
+    "version": "3.0.2",
+    "description": "TypeScript definitions for d3-timer",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-timer",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "Alex Ford",
+            "githubUsername": "gustavderdrache",
+            "url": "https://github.com/gustavderdrache"
+        },
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "denisname",
+            "githubUsername": "denisname",
+            "url": "https://github.com/denisname"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-timer"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "a51fc6981e6d12715fd052f7e598dd291c354465025cbb33ece1895bdab4109c",
+    "typeScriptVersion": "4.5"
+}

astra_scene_test/X_03/node_modules/@types/three/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

astra_scene_test/X_03/node_modules/@types/three/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/three`
+
+# Summary
+This package contains type definitions for three (https://threejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
+
+### Additional Details
+ * Last updated: Wed, 03 Sep 2025 18:38:35 GMT
+ * Dependencies: [@dimforge/rapier3d-compat](https://npmjs.com/package/@dimforge/rapier3d-compat), [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
+
+# Credits
+These definitions were written by [Josh Ellis](https://github.com/joshuaellis), and [Nathan Bierema](https://github.com/Methuselah96).

astra_scene_test/X_03/node_modules/@types/three/build/three.core.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.Core.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.core.min.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.Core.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.d.cts

@@ -0,0 +1 @@
+export * from "../src/Three.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.module.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.module.min.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.tsl.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.TSL.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.tsl.min.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.TSL.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.webgpu.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.WebGPU.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.webgpu.min.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.WebGPU.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.webgpu.nodes.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.WebGPU.Nodes.js";

astra_scene_test/X_03/node_modules/@types/three/build/three.webgpu.nodes.min.d.ts

@@ -0,0 +1 @@
+export * from "../src/Three.WebGPU.Nodes.js";

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/Addons.d.ts

@@ -0,0 +1,285 @@
+export * from "./animation/AnimationClipCreator.js";
+export * from "./animation/CCDIKSolver.js";
+
+export { default as WebGL } from "./capabilities/WebGL.js";
+
+export * from "./controls/ArcballControls.js";
+export * from "./controls/DragControls.js";
+export * from "./controls/FirstPersonControls.js";
+export * from "./controls/FlyControls.js";
+export * from "./controls/MapControls.js";
+export * from "./controls/OrbitControls.js";
+export * from "./controls/PointerLockControls.js";
+export * from "./controls/TrackballControls.js";
+export * from "./controls/TransformControls.js";
+
+export * from "./csm/CSM.js";
+export * from "./csm/CSMFrustum.js";
+export * from "./csm/CSMHelper.js";
+export * from "./csm/CSMShader.js";
+
+export * as Curves from "./curves/CurveExtras.js";
+export * from "./curves/NURBSCurve.js";
+export * from "./curves/NURBSSurface.js";
+export * as NURBSUtils from "./curves/NURBSUtils.js";
+export * from "./curves/NURBSVolume.js";
+
+export * from "./effects/AnaglyphEffect.js";
+export * from "./effects/AsciiEffect.js";
+export * from "./effects/OutlineEffect.js";
+export * from "./effects/ParallaxBarrierEffect.js";
+export * from "./effects/StereoEffect.js";
+
+export * from "./environments/DebugEnvironment.js";
+export * from "./environments/RoomEnvironment.js";
+
+export * from "./exporters/DRACOExporter.js";
+export * from "./exporters/EXRExporter.js";
+export * from "./exporters/GLTFExporter.js";
+export * from "./exporters/KTX2Exporter.js";
+export * from "./exporters/OBJExporter.js";
+export * from "./exporters/PLYExporter.js";
+export * from "./exporters/STLExporter.js";
+export * from "./exporters/USDZExporter.js";
+
+export * from "./geometries/BoxLineGeometry.js";
+export * from "./geometries/ConvexGeometry.js";
+export * from "./geometries/DecalGeometry.js";
+export * from "./geometries/ParametricFunctions.js";
+export * from "./geometries/ParametricGeometry.js";
+export * from "./geometries/RoundedBoxGeometry.js";
+export * from "./geometries/TeapotGeometry.js";
+export * from "./geometries/TextGeometry.js";
+
+export * from "./helpers/LightProbeHelper.js";
+export * from "./helpers/OctreeHelper.js";
+export * from "./helpers/PositionalAudioHelper.js";
+export * from "./helpers/RectAreaLightHelper.js";
+export * from "./helpers/TextureHelper.js";
+export * from "./helpers/VertexNormalsHelper.js";
+export * from "./helpers/VertexTangentsHelper.js";
+export * from "./helpers/ViewHelper.js";
+
+export * from "./interactive/HTMLMesh.js";
+export * from "./interactive/InteractiveGroup.js";
+export * from "./interactive/SelectionBox.js";
+export * from "./interactive/SelectionHelper.js";
+
+export * from "./lights/LightProbeGenerator.js";
+export * from "./lights/RectAreaLightUniformsLib.js";
+
+export * from "./lines/Line2.js";
+export * from "./lines/LineGeometry.js";
+export * from "./lines/LineMaterial.js";
+export * from "./lines/LineSegments2.js";
+export * from "./lines/LineSegmentsGeometry.js";
+export * from "./lines/Wireframe.js";
+export * from "./lines/WireframeGeometry2.js";
+
+export * from "./loaders/3DMLoader.js";
+export * from "./loaders/3MFLoader.js";
+export * from "./loaders/AMFLoader.js";
+export * from "./loaders/BVHLoader.js";
+export * from "./loaders/ColladaLoader.js";
+export * from "./loaders/DDSLoader.js";
+export * from "./loaders/DRACOLoader.js";
+export * from "./loaders/EXRLoader.js";
+export * from "./loaders/FBXLoader.js";
+export * from "./loaders/FontLoader.js";
+export * from "./loaders/GCodeLoader.js";
+export * from "./loaders/GLTFLoader.js";
+export * from "./loaders/HDRCubeTextureLoader.js";
+export * from "./loaders/HDRLoader.js";
+export * from "./loaders/IESLoader.js";
+export * from "./loaders/KMZLoader.js";
+export * from "./loaders/KTX2Loader.js";
+export * from "./loaders/KTXLoader.js";
+export * from "./loaders/LDrawLoader.js";
+export * from "./loaders/LottieLoader.js";
+export * from "./loaders/LUT3dlLoader.js";
+export * from "./loaders/LUTCubeLoader.js";
+export * from "./loaders/LWOLoader.js";
+export * from "./loaders/MD2Loader.js";
+export * from "./loaders/MDDLoader.js";
+export * from "./loaders/MTLLoader.js";
+export * from "./loaders/NRRDLoader.js";
+export * from "./loaders/OBJLoader.js";
+export * from "./loaders/PCDLoader.js";
+export * from "./loaders/PDBLoader.js";
+export * from "./loaders/PLYLoader.js";
+export * from "./loaders/PVRLoader.js";
+export * from "./loaders/RGBELoader.js";
+export * from "./loaders/STLLoader.js";
+export * from "./loaders/SVGLoader.js";
+export * from "./loaders/TDSLoader.js";
+export * from "./loaders/TGALoader.js";
+export * from "./loaders/TIFFLoader.js";
+export * from "./loaders/TTFLoader.js";
+export * from "./loaders/UltraHDRLoader.js";
+export * from "./loaders/USDLoader.js";
+export * from "./loaders/VOXLoader.js";
+export * from "./loaders/VRMLLoader.js";
+export * from "./loaders/VTKLoader.js";
+export * from "./loaders/XYZLoader.js";
+
+export * from "./materials/LDrawConditionalLineMaterial.js";
+export * from "./materials/MeshGouraudMaterial.js";
+export * from "./materials/MeshPostProcessingMaterial.js";
+
+export * from "./math/Capsule.js";
+export * from "./math/ColorConverter.js";
+export * from "./math/ConvexHull.js";
+export * from "./math/ImprovedNoise.js";
+export * from "./math/Lut.js";
+export * from "./math/MeshSurfaceSampler.js";
+export * from "./math/OBB.js";
+export * from "./math/Octree.js";
+export * from "./math/SimplexNoise.js";
+
+export * from "./misc/ConvexObjectBreaker.js";
+export * from "./misc/GPUComputationRenderer.js";
+export * from "./misc/Gyroscope.js";
+export * from "./misc/MD2Character.js";
+export * from "./misc/MD2CharacterComplex.js";
+export * from "./misc/MorphAnimMesh.js";
+export * from "./misc/MorphBlendMesh.js";
+export * from "./misc/ProgressiveLightMap.js";
+export * from "./misc/RollerCoaster.js";
+export * from "./misc/TubePainter.js";
+export * from "./misc/Volume.js";
+export * from "./misc/VolumeSlice.js";
+
+export * from "./modifiers/CurveModifier.js";
+export * from "./modifiers/EdgeSplitModifier.js";
+export * from "./modifiers/SimplifyModifier.js";
+export * from "./modifiers/TessellateModifier.js";
+
+export * from "./objects/GroundedSkybox.js";
+export * from "./objects/Lensflare.js";
+export * from "./objects/MarchingCubes.js";
+export * from "./objects/Reflector.js";
+export * from "./objects/ReflectorForSSRPass.js";
+export * from "./objects/Refractor.js";
+export * from "./objects/ShadowMesh.js";
+export * from "./objects/Sky.js";
+export * from "./objects/Water.js";
+export { Water as Water2 } from "./objects/Water2.js";
+export type { WaterOptions as Water2Options } from "./objects/Water2.js";
+
+export * from "./physics/AmmoPhysics.js";
+export * from "./physics/RapierPhysics.js";
+
+export * from "./postprocessing/AfterimagePass.js";
+export * from "./postprocessing/BloomPass.js";
+export * from "./postprocessing/BokehPass.js";
+export * from "./postprocessing/ClearPass.js";
+export * from "./postprocessing/CubeTexturePass.js";
+export * from "./postprocessing/DotScreenPass.js";
+export * from "./postprocessing/EffectComposer.js";
+export * from "./postprocessing/FilmPass.js";
+export * from "./postprocessing/GlitchPass.js";
+export * from "./postprocessing/GTAOPass.js";
+export * from "./postprocessing/HalftonePass.js";
+export * from "./postprocessing/LUTPass.js";
+export * from "./postprocessing/MaskPass.js";
+export * from "./postprocessing/OutlinePass.js";
+export * from "./postprocessing/OutputPass.js";
+export * from "./postprocessing/Pass.js";
+export * from "./postprocessing/RenderPass.js";
+export * from "./postprocessing/RenderPixelatedPass.js";
+export * from "./postprocessing/SAOPass.js";
+export * from "./postprocessing/SavePass.js";
+export * from "./postprocessing/ShaderPass.js";
+export * from "./postprocessing/SMAAPass.js";
+export * from "./postprocessing/SSAARenderPass.js";
+export * from "./postprocessing/SSAOPass.js";
+export * from "./postprocessing/SSRPass.js";
+export * from "./postprocessing/TAARenderPass.js";
+export * from "./postprocessing/TexturePass.js";
+export * from "./postprocessing/UnrealBloomPass.js";
+
+export * from "./renderers/CSS2DRenderer.js";
+export * from "./renderers/CSS3DRenderer.js";
+export * from "./renderers/Projector.js";
+export * from "./renderers/SVGRenderer.js";
+
+export * from "./shaders/ACESFilmicToneMappingShader.js";
+export * from "./shaders/AfterimageShader.js";
+export * from "./shaders/BasicShader.js";
+export * from "./shaders/BleachBypassShader.js";
+export * from "./shaders/BlendShader.js";
+export * from "./shaders/BokehShader.js";
+export { BokehShader as BokehShader2 } from "./shaders/BokehShader2.js";
+export * from "./shaders/BrightnessContrastShader.js";
+export * from "./shaders/ColorCorrectionShader.js";
+export * from "./shaders/ColorifyShader.js";
+export * from "./shaders/ConvolutionShader.js";
+export * from "./shaders/CopyShader.js";
+export * from "./shaders/DepthLimitedBlurShader.js";
+export * from "./shaders/DigitalGlitch.js";
+export * from "./shaders/DOFMipMapShader.js";
+export * from "./shaders/DotScreenShader.js";
+export * from "./shaders/ExposureShader.js";
+export * from "./shaders/FilmShader.js";
+export * from "./shaders/FocusShader.js";
+export * from "./shaders/FreiChenShader.js";
+export * from "./shaders/FXAAShader.js";
+export * from "./shaders/GammaCorrectionShader.js";
+export * from "./shaders/GodRaysShader.js";
+export * from "./shaders/GTAOShader.js";
+export * from "./shaders/HalftoneShader.js";
+export * from "./shaders/HorizontalBlurShader.js";
+export * from "./shaders/HorizontalTiltShiftShader.js";
+export * from "./shaders/HueSaturationShader.js";
+export * from "./shaders/KaleidoShader.js";
+export * from "./shaders/LuminosityHighPassShader.js";
+export * from "./shaders/LuminosityShader.js";
+export * from "./shaders/MirrorShader.js";
+export * from "./shaders/NormalMapShader.js";
+export * from "./shaders/OutputShader.js";
+export * from "./shaders/RGBShiftShader.js";
+export * from "./shaders/SAOShader.js";
+export * from "./shaders/SepiaShader.js";
+export * from "./shaders/SMAAShader.js";
+export * from "./shaders/SobelOperatorShader.js";
+export * from "./shaders/SSAOShader.js";
+export * from "./shaders/SSRShader.js";
+export * from "./shaders/SubsurfaceScatteringShader.js";
+export * from "./shaders/TechnicolorShader.js";
+export * from "./shaders/ToonShader.js";
+export * from "./shaders/TriangleBlurShader.js";
+export * from "./shaders/UnpackDepthRGBAShader.js";
+export * from "./shaders/VelocityShader.js";
+export * from "./shaders/VerticalBlurShader.js";
+export * from "./shaders/VerticalTiltShiftShader.js";
+export * from "./shaders/VignetteShader.js";
+export * from "./shaders/VolumeShader.js";
+export * from "./shaders/WaterRefractionShader.js";
+
+export * from "./textures/FlakesTexture.js";
+
+export * as BufferGeometryUtils from "./utils/BufferGeometryUtils.js";
+export * as CameraUtils from "./utils/CameraUtils.js";
+export * as GeometryCompressionUtils from "./utils/GeometryCompressionUtils.js";
+export * as GeometryUtils from "./utils/GeometryUtils.js";
+export * from "./utils/LDrawUtils.js";
+export * as SceneUtils from "./utils/SceneUtils.js";
+export * from "./utils/ShadowMapViewer.js";
+export * as SkeletonUtils from "./utils/SkeletonUtils.js";
+export * as SortUtils from "./utils/SortUtils.js";
+export * from "./utils/UVsDebug.js";
+export * from "./utils/WebGLTextureUtils.js";
+export * from "./utils/WorkerPool.js";
+
+export * from "./webxr/ARButton.js";
+export * from "./webxr/OculusHandModel.js";
+export * from "./webxr/OculusHandPointerModel.js";
+export * from "./webxr/Text2D.js";
+export * from "./webxr/VRButton.js";
+export * from "./webxr/XRButton.js";
+export * from "./webxr/XRControllerModelFactory.js";
+export * from "./webxr/XREstimatedLight.js";
+export * from "./webxr/XRHandMeshModel.js";
+export * from "./webxr/XRHandModelFactory.js";
+export * from "./webxr/XRHandPrimitiveModel.js";
+export * from "./webxr/XRPlanes.js";

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/animation/AnimationClipCreator.d.ts

@@ -0,0 +1,12 @@
+import { AnimationClip, Vector3 } from "three";
+
+export interface AnimationClipCreator {
+    CreateRotationAnimation(period: number, axis: string): AnimationClip;
+    CreateScaleAxisAnimation(period: number, axis: string): AnimationClip;
+    CreateShakeAnimation(duration: number, shakeScale: Vector3): AnimationClip;
+    CreatePulsationAnimation(duration: number, pulseScale: number): AnimationClip;
+    CreateVisibilityAnimation(duration: number): AnimationClip;
+    CreateMaterialColorAnimation(duration: number, colors: number[]): AnimationClip;
+}
+
+export const AnimationClipCreator: AnimationClipCreator;

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/animation/CCDIKSolver.d.ts

@@ -0,0 +1,44 @@
+import { LineBasicMaterial, MeshBasicMaterial, Object3D, SkinnedMesh, SphereGeometry, Vector3 } from "three";
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export interface IK {
+    effector: number;
+    iteration?: number | undefined;
+    links: Array<{
+        enabled?: boolean | undefined;
+        index: number;
+        limitation?: Vector3 | undefined;
+        rotationMin?: Vector3 | undefined;
+        rotationMax?: Vector3 | undefined;
+    }>;
+    minAngle?: number | undefined;
+    maxAngle?: number | undefined;
+    target: number;
+    blendFactor?: number | undefined;
+}
+
+export class CCDIKSolver {
+    mesh: SkinnedMesh;
+    iks: IK[];
+
+    constructor(mesh: SkinnedMesh, iks?: IK[]);
+
+    update(globalBlendFactor?: number): this;
+    updateOne(ik: IK, overrideBlend?: number): this;
+    createHelper(sphereSize?: number): CCDIKHelper;
+}
+
+export class CCDIKHelper extends Object3D {
+    root: SkinnedMesh;
+    iks: IK[];
+
+    sphereGeometry: SphereGeometry;
+    targetSphereMaterial: MeshBasicMaterial;
+    effectorSphereMaterial: MeshBasicMaterial;
+    linkSphereMaterial: MeshBasicMaterial;
+    lineMaterial: LineBasicMaterial;
+
+    constructor(mesh: SkinnedMesh, iks?: IK[], sphereSize?: number);
+
+    dispose(): void;
+}

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/capabilities/WebGL.d.ts

@@ -0,0 +1,6 @@
+export default class WebGL {
+    static isWebGL2Available(): boolean;
+    static isColorSpaceAvailable(colorSpace: PredefinedColorSpace): boolean;
+    static getWebGL2ErrorMessage(): HTMLElement;
+    static getErrorMessage(version: number): HTMLElement;
+}

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/capabilities/WebGPU.d.ts

@@ -0,0 +1,7 @@
+// tslint:disable-next-line:no-unnecessary-class
+
+export default class WebGPU {
+    static isAvailable(): boolean;
+    static getStaticAdapter(): unknown;
+    static getErrorMessage(): HTMLElement;
+}

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/controls/ArcballControls.d.ts

@@ -0,0 +1,208 @@
+import { Camera, Controls, Raycaster, Scene } from "three";
+
+export type ArcballControlsMouseActionOperation = "PAN" | "ROTATE" | "ZOOM" | "FOV";
+
+export type ArcballControlsMouseActionMouse = 0 | 1 | 2 | "WHEEL";
+
+export type ArcballControlsMouseActionKey = "SHIFT" | "CTRL";
+
+export interface ArcballControlsEventMap {
+    /**
+     * Fires when the camera has been transformed by the controls.
+     */
+    change: {};
+
+    /**
+     * Fires when an interaction was initiated.
+     */
+    start: {};
+
+    /**
+     * Fires when an interaction has finished.
+     */
+    end: {};
+}
+
+/**
+ * Arcball controls allow the camera to be controlled by a virtual trackball with full touch support and advanced
+ * navigation functionality.
+ */
+declare class ArcballControls extends Controls<ArcballControlsEventMap> {
+    /**
+     * The scene rendered by the camera.
+     */
+    scene: Scene | null;
+
+    /**
+     * The size of the gizmo relative to the screen width and height. Default is 0.67.
+     */
+    radiusFactor: number;
+
+    /**
+     * Duration time of focus animation.
+     */
+    focusAnimationTime: number;
+
+    /**
+     * If true, camera's near and far values will be adjusted every time zoom is performed trying to maintain the same
+     * visible portion given by initial near and far values ( {@link PerspectiveCamera} only ). Default is false.
+     */
+    adjustNearFar: boolean;
+
+    /**
+     * The scaling factor used when performing zoom operation.
+     */
+    scaleFactor: number;
+
+    /**
+     * The damping inertia used if [page:.enableAnimations] is set to true.
+     */
+    dampingFactor: number;
+
+    /**
+     * Maximum angular velocity allowed on rotation animation start.
+     */
+    wMax: number;
+
+    /**
+     * Set to true to enable animations for rotation (damping) and focus operation. Default is true.
+     */
+    enableAnimations: boolean;
+
+    /**
+     * Enable or disable camera focusing on double-tap (or click) operations. Default is true.
+     */
+    enableFocus: boolean;
+
+    /**
+     * When set to true, a grid will appear when panning operation is being performed (desktop interaction only). Default is false.
+     */
+    enableGrid: boolean;
+
+    /**
+     * Set to true to make zoom become cursor centered.
+     */
+    cursorZoom: boolean;
+
+    /**
+     * Speed of rotation. Default is 1.
+     */
+    rotateSpeed: number;
+
+    /**
+     * Enable or disable camera panning. Default is true.
+     */
+    enablePan: boolean;
+
+    /**
+     * Enable or disable camera rotation. Default is true.
+     */
+    enableRotate: boolean;
+
+    /**
+     * Enable or disable zooming of the camera.
+     */
+    enableZoom: boolean;
+
+    /**
+     * How far you can dolly in ( {@link PerspectiveCamera} only ). Default is 0.
+     */
+    minDistance: number;
+
+    /**
+     * How far you can dolly out ( {@link PerspectiveCamera} only ). Default is Infinity.
+     */
+    maxDistance: number;
+
+    /**
+     * How far you can zoom in ( {@link OrthographicCamera} only ). Default is 0.
+     */
+    minZoom: number;
+
+    /**
+     * How far you can zoom out ( {@link OrthographicCamera} only ). Default is Infinity.
+     */
+    maxZoom: number;
+
+    /**
+     * @param camera The camera to be controlled. The camera must not be a child of another object, unless that object
+     * is the scene itself.
+     * @param domElement The HTML element used for event listeners. (optional)
+     * @param scene The scene rendered by the camera. If not given, gizmos cannot be shown. (optional)
+     */
+    constructor(camera: Camera, domElement?: HTMLElement | null, scene?: Scene | null);
+
+    /**
+     * Set a new mouse action by specifying the operation to be performed and a mouse/key combination. In case of
+     * conflict, replaces the existing one.
+     * @param operation Operations can be specified as 'ROTATE', 'PAN', 'FOV' or 'ZOOM'.
+     * @param mouse Mouse inputs can be specified as mouse buttons 0, 1 and 2 or 'WHEEL' for wheel notches.
+     * @param key Keyboard modifiers can be specified as 'CTRL', 'SHIFT' or null if not needed.
+     */
+    setMouseAction(
+        operation: ArcballControlsMouseActionOperation,
+        mouse: ArcballControlsMouseActionMouse,
+        key?: ArcballControlsMouseActionKey | null,
+    ): boolean;
+
+    /**
+     * Removes a mouse action by specifying its mouse/key combination.
+     * @param mouse Mouse inputs can be specified as mouse buttons 0, 1 and 2 or 'WHEEL' for wheel notches.
+     * @param key Keyboard modifiers can be specified as 'CTRL', 'SHIFT' or null if not needed.
+     */
+    unsetMouseAction(mouse: ArcballControlsMouseActionMouse, key?: ArcballControlsMouseActionKey | null): boolean;
+
+    /**
+     * Make gizmos more or less visible.
+     */
+    activateGizmos(isActive: boolean): void;
+
+    /**
+     * Set the camera to be controlled. Must be called in order to set a new camera to be controlled.
+     */
+    setCamera(camera: Camera): void;
+
+    /**
+     * Set the visible property of gizmos.
+     */
+    setGizmosVisible(value: boolean): void;
+
+    /**
+     * Update the `radiusFactor` value, redraw the gizmo and send a `changeEvent` to visualize the changes.
+     */
+    setTbRadius(value: number): void;
+
+    /**
+     * Reset the controls to their state from either the last time the {@link .saveState} was called, or the initial
+     * state.
+     */
+    reset(): void;
+
+    /**
+     * Copy the current state to clipboard (as a readable JSON text).
+     */
+    copyState(): void;
+
+    /**
+     * Set the controls state from the clipboard, assumes that the clipboard stores a JSON text as saved from
+     * {@link .copyState}.
+     */
+    pasteState(): void;
+
+    /**
+     * Save the current state of the controls. This can later be recovered with {@link .reset}.
+     */
+    saveState(): void;
+
+    /**
+     * Returns the {@link Raycaster} object that is used for user interaction. This object is shared between all
+     * instances of ArcballControls. If you set the [.layers]{@link Object3D.layers} property of the
+     * {@link ArcballControls}, you will also want to set the [.layers]{@link Raycaster.layers} property on the
+     * {@link Raycaster} with a matching value, or else the {@link ArcballControls} won't work as expected.
+     */
+    getRaycaster(): Raycaster;
+
+    update(): void;
+}
+
+export { ArcballControls };

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/controls/DragControls.d.ts

@@ -0,0 +1,81 @@
+import { Camera, Controls, MOUSE, Object3D, Raycaster, TOUCH } from "three";
+
+export interface DragControlsEventMap {
+    /**
+     * Fires when the pointer is moved onto a 3D object, or onto one of its children.
+     */
+    hoveron: { object: Object3D };
+
+    /**
+     * Fires when the pointer is moved out of a 3D object.
+     */
+    hoveroff: { object: Object3D };
+
+    /**
+     * Fires when the user starts to drag a 3D object.
+     */
+    dragstart: { object: Object3D };
+
+    /**
+     * Fires when the user drags a 3D object.
+     */
+    drag: { object: Object3D };
+
+    /**
+     * Fires when the user has finished dragging a 3D object.
+     */
+    dragend: { object: Object3D };
+}
+
+declare class DragControls extends Controls<DragControlsEventMap> {
+    /**
+     * An array of draggable 3D objects.
+     */
+    objects: Object3D[];
+
+    /**
+     * Whether children of draggable objects can be dragged independently from their parent. Default is `true`.
+     */
+    recursive: boolean;
+
+    /**
+     * This option only works if the {@link .objects} array contains a single draggable group object. If set to `true`,
+     * {@link DragControls} does not transform individual objects but the entire group. Default is `false`.
+     */
+    transformGroup: boolean;
+
+    /**
+     * The speed at which the object will rotate when dragged in `rotate` mode. The higher the number the faster the
+     * rotation. Default is `1`.
+     */
+    rotateSpeed: number;
+
+    /**
+     * The internal raycaster used for detecting 3D objects.
+     */
+    raycaster: Raycaster;
+
+    /**
+     * This object defines what type of actions are assigned to the available mouse buttons.
+     */
+    mouseButtons: {
+        LEFT?: MOUSE | null | undefined;
+        MIDDLE?: MOUSE | null | undefined;
+        RIGHT?: MOUSE | null | undefined;
+    };
+
+    /**
+     * This object defines what type of actions are assigned to what kind of touch interaction.
+     */
+    touches: { ONE?: TOUCH | null | undefined };
+
+    /**
+     * Creates a new instance of DragControls.
+     * @param objects An array of draggable 3D objects.
+     * @param camera The camera of the rendered scene.
+     * @param domElement The HTML element used for event listeners. (optional)
+     */
+    constructor(objects: Object3D[], camera: Camera, domElement?: HTMLElement | null);
+}
+
+export { DragControls };

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/controls/FirstPersonControls.d.ts

@@ -0,0 +1,101 @@
+import { Camera, Controls, Vector3 } from "three";
+
+/**
+ * This class is an alternative implementation of {@link FlyControls}.
+ */
+declare class FirstPersonControls extends Controls<{}> {
+    /**
+     * The movement speed. Default is *1*.
+     */
+    movementSpeed: number;
+
+    /**
+     * The look around speed. Default is `0.005`.
+     */
+    lookSpeed: number;
+
+    /**
+     * Whether or not it's possible to vertically look around. Default is `true`.
+     */
+    lookVertical: boolean;
+
+    /**
+     * Whether or not the camera is automatically moved forward. Default is `false`.
+     */
+    autoForward: boolean;
+
+    /**
+     * Whether or not it's possible to look around. Default is `true`.
+     */
+    activeLook: boolean;
+
+    /**
+     * Whether or not the camera's height influences the forward movement speed. Default is `false`.
+     * Use the properties {@link .heightCoef}, {@link .heightMin} and {@link .heightMax} for configuration
+     */
+    heightSpeed: boolean;
+
+    /**
+     * Determines how much faster the camera moves when it's y-component is near {@link .heightMax}. Default is *1*.
+     */
+    heightCoef: number;
+
+    /**
+     * Lower camera height limit used for movement speed adjustment. Default is *0*.
+     */
+    heightMin: number;
+
+    /**
+     * Upper camera height limit used for movement speed adjustment. Default is *1*.
+     */
+    heightMax: number;
+
+    /**
+     * Whether or not looking around is vertically constrained by [{@link .verticalMin}, {@link .verticalMax}]. Default
+     * is `false`.
+     */
+    constrainVertical: boolean;
+
+    /**
+     * How far you can vertically look around, lower limit. Range is 0 to Math.PI radians. Default is *0*.
+     */
+    verticalMin: number;
+
+    /**
+     * How far you can vertically look around, upper limit. Range is 0 to Math.PI radians. Default is `Math.PI`.
+     */
+    verticalMax: number;
+
+    /**
+     * Whether or not the mouse is pressed down. Read-only property.
+     */
+    mouseDragOn: boolean;
+
+    /**
+     * Creates a new instance of {@link FirstPersonControls}.
+     * @param object The camera to be controlled.
+     * @param domElement The HTML element used for event listeners. (optional)
+     */
+    constructor(object: Camera, domElement?: HTMLElement);
+
+    /**
+     * Should be called if the application window is resized.
+     */
+    handleResize(): void;
+
+    /**
+     * Ensures the controls orient the camera towards the defined target position.
+     * @param vector A vector representing the target position.
+     */
+    lookAt(vector: Vector3): this;
+
+    /**
+     * Ensures the controls orient the camera towards the defined target position.
+     * @param x The x component of the world space position.
+     * @param y The y component of the world space position.
+     * @param z The z component of the world space position.
+     */
+    lookAt(x: number, y: number, z: number): this;
+}
+
+export { FirstPersonControls };

astra_scene_test/X_03/node_modules/@types/three/examples/jsm/controls/FlyControls.d.ts

@@ -0,0 +1,44 @@
+import { Camera, Controls } from "three";
+
+export interface FlyControlsEventMap {
+    /**
+     * Fires when the camera has been transformed by the controls.
+     */
+    change: {};
+}
+
+/**
+ * {@link FlyControls} enables a navigation similar to fly modes in DCC tools like Blender. You can arbitrarily
+ * transform the camera in 3D space without any limitations (e.g. focus on a specific target).
+ */
+declare class FlyControls extends Controls<FlyControlsEventMap> {
+    /**
+     * The movement speed. Default is `1`.
+     */
+    movementSpeed: number;
+
+    /**
+     * The rotation speed. Default is `0.005`.
+     */
+    rollSpeed: number;
+
+    /**
+     * If set to `true`, you can only look around by performing a drag interaction. Default is `false`.
+     */
+    dragToLook: boolean;
+
+    /**
+     * If set to `true`, the camera automatically moves forward (and does not stop) when initially translated. Default
+     * is `false`.
+     */
+    autoForward: boolean;
+
+    /**
+     * Creates a new instance of {@link FlyControls}.
+     * @param object The camera to be controlled.
+     * @param domElement The HTML element used for event listeners. (optional)
+     */
+    constructor(object: Camera, domElement?: HTMLElement | null);
+}
+
+export { FlyControls };