@ohos-ports/nodejs-polars 0.23.4-beta.0

package/bin/functions.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repeat = repeat;
+exports.concat = concat;
+const dataframe_1 = require("./dataframe");
+const construction_1 = require("./internals/construction");
+const polars_internal_1 = __importDefault(require("./internals/polars_internal"));
+const dataframe_2 = require("./lazy/dataframe");
+const series_1 = require("./series");
+const utils_1 = require("./utils");
+/**
+ * _Repeat a single value n times and collect into a Series._
+ * @param value - Value to repeat.
+ * @param n - Number of repeats
+ * @param name - Optional name of the Series
+ * @example
+ *
+ * ```
+ *
+ * >  const s = pl.repeat("a", 5)
+ * >  s.toArray()
+ * ["a", "a", "a", "a", "a"]
+ *
+ * ```
+ */
+function repeat(value, n, name = "") {
+    const dtype = (0, construction_1.jsTypeToPolarsType)(value);
+    const s = polars_internal_1.default.JsSeries.repeat(name, value, n, dtype);
+    return (0, series_1._Series)(s);
+}
+/**
+ * Aggregate all the Dataframes/Series in a List of DataFrames/Series to a single DataFrame/Series.
+ * @param items DataFrames/Series/LazyFrames to concatenate.
+ * @param options.rechunk Make sure that the result data is in contiguous memory.
+ * @param options.how Only used if the items are DataFrames. *Defaults to 'vertical'*
+ *     - vertical: Applies multiple `vstack` operations.
+ *     - verticalRelaxed: Same as `vertical`, but additionally coerces columns to their common supertype *if* they are mismatched (eg: Int32 → Int64).
+ *     - horizontal: Stacks Series horizontally and fills with nulls if the lengths don't match.
+ *     - diagonal: Finds a union between the column schemas and fills missing column values with ``null``.
+ *     - diagonalRelaxed: Same as `diagonal`, but additionally coerces columns to their common supertype *if* they are mismatched (eg: Int32 → Int64).
+ *     - align, alignFull, alignLeft, alignRight: Combines frames horizontally,
+ *       auto-determining the common key columns and aligning rows using the same
+ *       logic as `alignFrames` (note that "align" is an alias for "alignFull").
+ *       The "align" strategy determines the type of join used to align the frames,
+ *       equivalent to the "how" parameter on `alignFrames`. Note that the common join columns are automatically coalesced, but other column collisions
+ *       will raise an error (if you need more control over this you should use a suitable `join` method directly).
+ * @param options.parallel - Only relevant for LazyFrames. This determines if the concatenated lazy computations may be executed in parallel.
+ * @example
+ * > const df1 = pl.DataFrame({"a": [1], "b": [3]});
+ * > const df2 = pl.DataFrame({"a": [2], "b": [4]});
+ * > pl.concat([df1, df2]);
+ * shape: (2, 2)
+ * ┌─────┬─────┐
+ * │ a   ┆ b   │
+ * │ --- ┆ --- │
+ * │ i64 ┆ i64 │
+ * ╞═════╪═════╡
+ * │ 1   ┆ 3   │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┤
+ * │ 2   ┆ 4   │
+ * └─────┴─────┘
+ *
+ * > const a = pl.DataFrame({ a: ["a", "b"], b: [1, 2] });
+ * > const b = pl.DataFrame({ c: [5, 6], d: [7, 8], e: [9, 10]});
+ * > pl.concat([a, b], { how: "horizontal" });
+ *
+ * shape: (2, 5)
+ * ┌─────┬─────┬─────┬─────┬──────┐
+ * │ a   ┆ b   ┆ c   ┆ d   ┆ e    │
+ * │ --- ┆ --- ┆ --- ┆ --- ┆ ---  │
+ * │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64  │
+ * ╞═════╪═════╪═════╪═════╪══════╡
+ * │ a   ┆ 1.0 ┆ 5.0 ┆ 7.0 ┆ 9.0  │
+ * │ b   ┆ 2.0 ┆ 6.0 ┆ 8.0 ┆ 10.0 │
+ * └─────┴─────┴─────┴─────┴──────┘
+ *
+ * > const df_d1 = pl.DataFrame({"a": [1], "b": [3]});
+ * > const df_d2 = pl.DataFrame({"a": [2], "c": [4]});
+ * > pl.concat([df_d1, df_d2], { how: "diagonal" });
+ *
+ * shape: (2, 3)
+ * ┌─────┬──────┬──────┐
+ * │ a   ┆ b    ┆ c    │
+ * │ --- ┆ ---  ┆ ---  │
+ * │ i64 ┆ i64  ┆ i64  │
+ * ╞═════╪══════╪══════╡
+ * │ 1   ┆ 3    ┆ null │
+ * │ 2   ┆ null ┆ 4    │
+ * └─────┴──────┴──────┘
+ *
+ *  The "align" strategies require at least one common column to align on:
+
+  >>> const df1 = pl.DataFrame({"id": [1, 2], "x": [3, 4]});
+  >>> const df2 = pl.DataFrame({"id": [2, 3], "y": [5, 6]});
+  >>> const df3 = pl.DataFrame({"id": [1, 3], "z": [7, 8]});
+  >>> pl.concat([df1, df2, df3], how="align"); // equivalent to "alignFull"
+  shape: (3, 4)
+  ┌─────┬──────┬──────┬──────┐
+  │ id  ┆ x    ┆ y    ┆ z    │
+  │ --- ┆ ---  ┆ ---  ┆ ---  │
+  │ i64 ┆ i64  ┆ i64  ┆ i64  │
+  ╞═════╪══════╪══════╪══════╡
+  │ 1   ┆ 3    ┆ null ┆ 7    │
+  │ 2   ┆ 4    ┆ 5    ┆ null │
+  │ 3   ┆ null ┆ 6    ┆ 8    │
+  └─────┴──────┴──────┴──────┘
+  >>> pl.concat([df1, df2, df3], how="alignLeft");
+  shape: (2, 4)
+  ┌─────┬─────┬──────┬──────┐
+  │ id  ┆ x   ┆ y    ┆ z    │
+  │ --- ┆ --- ┆ ---  ┆ ---  │
+  │ i64 ┆ i64 ┆ i64  ┆ i64  │
+  ╞═════╪═════╪══════╪══════╡
+  │ 1   ┆ 3   ┆ null ┆ 7    │
+  │ 2   ┆ 4   ┆ 5    ┆ null │
+  └─────┴─────┴──────┴──────┘
+  >>> pl.concat([df1, df2, df3], how="alignRight");
+  shape: (2, 4)
+  ┌─────┬──────┬──────┬─────┐
+  │ id  ┆ x    ┆ y    ┆ z   │
+  │ --- ┆ ---  ┆ ---  ┆ --- │
+  │ i64 ┆ i64  ┆ i64  ┆ i64 │
+  ╞═════╪══════╪══════╪═════╡
+  │ 1   ┆ null ┆ null ┆ 7   │
+  │ 3   ┆ null ┆ 6    ┆ 8   │
+  └─────┴──────┴──────┴─────┘
+  >>> pl.concat([df1, df2, df3], how="alignInner");
+  shape: (0, 4)
+  ┌─────┬─────┬─────┬─────┐
+  │ id  ┆ x   ┆ y   ┆ z   │
+  │ --- ┆ --- ┆ --- ┆ --- │
+  │ i64 ┆ i64 ┆ i64 ┆ i64 │
+  ╞═════╪═════╪═════╪═════╡
+  └─────┴─────┴─────┴─────┘
+ */
+const computeAlignParams = (items, how) => {
+    const commonCols = (0, utils_1.commonValue)(...items.map((c) => c.columns));
+    const uniqueCols = [...new Set(items.flatMap((c) => c.columns))].sort();
+    // Join methods allowed: "full" | "left" | "inner" | "semi" | "anti" | undefined
+    const joinMethod = how === "align"
+        ? "full"
+        : how.replace("align", "").toLocaleLowerCase();
+    return { commonCols, uniqueCols, joinMethod };
+};
+function concat(items, options = { rechunk: true, parallel: true, how: "vertical" }) {
+    const { rechunk, how, parallel } = options;
+    if (!items.length) {
+        throw new RangeError("cannot concat empty list");
+    }
+    // short-circuit common single-item cases early for all types
+    if (items.length === 1)
+        return items[0];
+    if ((0, utils_1.isDataFrameArray)(items)) {
+        let df;
+        switch (how) {
+            case "align":
+            case "alignFull":
+            case "alignInner":
+            case "alignLeft":
+            case "alignRight": {
+                const { commonCols, uniqueCols, joinMethod } = computeAlignParams(items, how);
+                df = (0, dataframe_1._DataFrame)(items.reduce((acc, curr) => acc.join(curr, { on: commonCols, how: joinMethod, coalesce: true })))
+                    ._df.sort(commonCols)
+                    .select(uniqueCols);
+                break;
+            }
+            case "vertical":
+                df = items.reduce((acc, curr) => acc.vstack(curr));
+                break;
+            case "verticalRelaxed":
+            case "diagonalRelaxed":
+                df = (0, dataframe_2._LazyDataFrame)(polars_internal_1.default.concatLf(items.map((i) => i.inner().lazy()), how, rechunk ?? false, parallel ?? true, true, // to_supertypes
+                true)).collectSync();
+                break;
+            case "horizontal":
+                df = (0, dataframe_1._DataFrame)(polars_internal_1.default.horizontalConcat(items.map((i) => i.inner())));
+                break;
+            case "diagonal":
+                df = (0, dataframe_1._DataFrame)(polars_internal_1.default.diagonalConcat(items.map((i) => i.inner())));
+                break;
+            default:
+                throw new TypeError("unknown concat how option");
+        }
+        return rechunk ? df.rechunk() : df;
+    }
+    if ((0, utils_1.isLazyDataFrameArray)(items)) {
+        let df;
+        if (how?.startsWith("align")) {
+            const { commonCols, uniqueCols, joinMethod } = computeAlignParams(items, how);
+            df = (0, dataframe_2._LazyDataFrame)(items.reduce((acc, curr) => acc.join(curr, { on: commonCols, how: joinMethod, coalesce: true })))
+                ._ldf.sort(commonCols)
+                .select(uniqueCols);
+        }
+        else {
+            df = (0, dataframe_2._LazyDataFrame)(polars_internal_1.default.concatLf(items.map((i) => i.inner()), how, rechunk ?? false, parallel ?? true, true, // to_supertypes
+            true));
+        }
+        return df;
+    }
+    if ((0, utils_1.isSeriesArray)(items)) {
+        const s = items.reduce((acc, curr) => acc.concat(curr));
+        return rechunk ? s.rechunk() : s;
+    }
+    throw new TypeError("can only concat series and dataframes");
+}

package/bin/groupby.d.ts

@@ -0,0 +1,212 @@
+import { type DataFrame } from "./dataframe";
+import type { Expr } from "./lazy/expr";
+import type { ColumnsOrExpr, StartBy } from "./utils";
+declare const inspect: unique symbol;
+/**
+ * Starts a new GroupBy operation.
+ */
+export interface GroupBy {
+    [inspect](): string;
+    /**
+     * Aggregate the groups into Series.
+     * @deprecated
+     */
+    aggList(): DataFrame;
+    /**
+     * Compute aggregations for each group of a group by operation.
+     * ___
+     * @param columns - Aggregations to compute for each group of the group by operation, specified as positional arguments.
+     * @example
+     * ```
+     * const df = pl.DataFrame({
+        foo: [1, 2, 2, 3, 3],
+        ham: [6.0, 6, 7, 8.0, 8.0],
+        bar: ["a", "b", "c", "c", "c"],
+        spam: ["a", "b", "c", "c", "c"],
+      });
+     * // use lazy api rest parameter style
+     * > df.groupBy('foo', 'bar').agg(pl.count('ham'), pl.col('spam')).sort(["foo", "bar"]);
+     * shape: (4, 4)
+      ┌─────┬─────┬─────┬────────────┐
+      │ foo ┆ bar ┆ ham ┆ spam       │
+      │ --- ┆ --- ┆ --- ┆ ---        │
+      │ f64 ┆ str ┆ u32 ┆ list[str]  │
+      ╞═════╪═════╪═════╪════════════╡
+      │ 1.0 ┆ a   ┆ 1   ┆ ["a"]      │
+      │ 2.0 ┆ b   ┆ 1   ┆ ["b"]      │
+      │ 2.0 ┆ c   ┆ 1   ┆ ["c"]      │
+      │ 3.0 ┆ c   ┆ 2   ┆ ["c", "c"] │
+      └─────┴─────┴─────┴────────────┘
+     *
+     * > df.groupBy("bar").agg(pl.col("foo"), pl.col("ham"), pl.col("spam") ).sort("bar");
+     * shape: (3, 4)
+      ┌─────┬─────────────────┬─────────────────┬─────────────────┐
+      │ bar ┆ foo             ┆ ham             ┆ spam            │
+      │ --- ┆ ---             ┆ ---             ┆ ---             │
+      │ str ┆ list[f64]       ┆ list[f64]       ┆ list[str]       │
+      ╞═════╪═════════════════╪═════════════════╪═════════════════╡
+      │ a   ┆ [1.0]           ┆ [6.0]           ┆ ["a"]           │
+      │ b   ┆ [2.0]           ┆ [6.0]           ┆ ["b"]           │
+      │ c   ┆ [2.0, 3.0, 3.0] ┆ [7.0, 8.0, 8.0] ┆ ["c", "c", "c"] │
+      └─────┴─────────────────┴─────────────────┴─────────────────┘
+     * > const h = pl.col("ham");
+     * > df.groupBy("bar").agg(h.sum().as("sum_ham"), h.min().as("min_ham"), h.max().as("max_ham"));
+     * shape: (3, 4)
+      ┌─────┬─────────┬─────────┬─────────┐
+      │ bar ┆ sum_ham ┆ min_ham ┆ max_ham │
+      │ --- ┆ ---     ┆ ---     ┆ ---     │
+      │ str ┆ f64     ┆ f64     ┆ f64     │
+      ╞═════╪═════════╪═════════╪═════════╡
+      │ a   ┆ 6.0     ┆ 6.0     ┆ 6.0     │
+      │ b   ┆ 6.0     ┆ 6.0     ┆ 6.0     │
+      │ c   ┆ 23.0    ┆ 7.0     ┆ 8.0     │
+      └─────┴─────────┴─────────┴─────────┘
+     * ```
+     */
+    agg(...columns: Expr[]): DataFrame;
+    agg(columns: Record<string, keyof Expr | (keyof Expr)[]>): DataFrame;
+    /**
+     * Return the number of rows in each group.
+     * @example
+     * > df = pl.DataFrame({a: ["Apple", "Apple", "Orange"], b: [1, None, 2]});
+       > df.groupBy("a").len()
+      shape: (2, 2)
+      ┌────────┬─────┐
+      │ a      ┆ len │
+      │ ---    ┆ --- │
+      │ str    ┆ u32 │
+      ╞════════╪═════╡
+      │ Apple  ┆ 2   │
+      │ Orange ┆ 1   │
+      └────────┴─────┘
+     */
+    len(): DataFrame;
+    /**
+     * Aggregate the first values in the group.
+     */
+    first(): DataFrame;
+    /**
+     * Return a `DataFrame` with:
+     *   - the groupby keys
+     *   - the group indexes aggregated as lists
+     */
+    groups(): DataFrame;
+    /**
+     * Return first n rows of each group.
+     * @param n -Number of values of the group to select
+     * @example
+     * ```
+     * > df = pl.DataFrame({
+     * >   "letters": ["c", "c", "a", "c", "a", "b"],
+     * >   "nrs": [1, 2, 3, 4, 5, 6]
+     * > })
+     * > df
+     * shape: (6, 2)
+     * ╭─────────┬─────╮
+     * │ letters ┆ nrs │
+     * │ ---     ┆ --- │
+     * │ str     ┆ i64 │
+     * ╞═════════╪═════╡
+     * │ "c"     ┆ 1   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "c"     ┆ 2   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "a"     ┆ 3   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "c"     ┆ 4   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "a"     ┆ 5   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "b"     ┆ 6   │
+     * ╰─────────┴─────╯
+     * > df.groupby("letters")
+     * >   .head(2)
+     * >   .sort("letters");
+     * > >>
+     * shape: (5, 2)
+     * ╭─────────┬─────╮
+     * │ letters ┆ nrs │
+     * │ ---     ┆ --- │
+     * │ str     ┆ i64 │
+     * ╞═════════╪═════╡
+     * │ "a"     ┆ 3   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "a"     ┆ 5   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "b"     ┆ 6   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "c"     ┆ 1   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "c"     ┆ 2   │
+     * ╰─────────┴─────╯
+     * ```
+     */
+    head(n?: number): DataFrame;
+    /**
+     * Aggregate the last values in the group.
+     */
+    last(): DataFrame;
+    /**
+     * Reduce the groups to the maximal value.
+     */
+    max(): DataFrame;
+    /**
+     * Reduce the groups to the mean values.
+     */
+    mean(): DataFrame;
+    /**
+     * Return the median per group.
+     */
+    median(): DataFrame;
+    /**
+     * Reduce the groups to the minimal value.
+     */
+    min(): DataFrame;
+    /**
+     * Count the unique values per group.
+     */
+    nUnique(): DataFrame;
+    /**
+     * Do a pivot operation based on the group key, a pivot column and an aggregation function on the values column.
+     * @param pivotCol - Column to pivot.
+     * @param valuesCol - Column that will be aggregated.
+     *
+     */
+    pivot(pivotCol: string, valuesCol: string): PivotOps;
+    pivot({ pivotCol, valuesCol, }: {
+        pivotCol: string;
+        valuesCol: string;
+    }): PivotOps;
+    /**
+     * Compute the quantile per group.
+     */
+    quantile(quantile: number): DataFrame;
+    /**
+     * Reduce the groups to the sum.
+     */
+    sum(): DataFrame;
+    tail(n?: number): DataFrame;
+    toString(): string;
+}
+export type PivotOps = Pick<GroupBy, "len" | "first" | "max" | "mean" | "median" | "min" | "sum"> & {
+    [inspect](): string;
+};
+/** @ignore */
+export declare function _GroupBy(df: any, by: string[], maintainOrder?: boolean): GroupBy;
+/**
+ * intermediate state of a rolling groupby
+ */
+export interface RollingGroupBy {
+    agg(column: ColumnsOrExpr, ...columns: ColumnsOrExpr[]): DataFrame;
+}
+/** @ignore */
+export declare function RollingGroupBy(df: any, indexColumn: ColumnsOrExpr, period: string, offset?: string, closed?: any, by?: ColumnsOrExpr): RollingGroupBy;
+/**
+ * intermediate state of a dynamic groupby
+ */
+export interface DynamicGroupBy {
+    agg(column: ColumnsOrExpr, ...columns: ColumnsOrExpr[]): DataFrame;
+}
+/** @ignore */
+export declare function DynamicGroupBy(df: any, indexColumn: string, every: string, period?: string, offset?: string, label?: string, includeBoundaries?: boolean, closed?: string, by?: ColumnsOrExpr, startBy?: StartBy): DynamicGroupBy;
+export {};

package/bin/groupby.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._GroupBy = _GroupBy;
+exports.RollingGroupBy = RollingGroupBy;
+exports.DynamicGroupBy = DynamicGroupBy;
+const node_util_1 = __importDefault(require("node:util"));
+const dataframe_1 = require("./dataframe");
+const functions_1 = require("./lazy/functions");
+const utils = __importStar(require("./utils"));
+const inspect = Symbol.for("nodejs.util.inspect.custom");
+const inspectOpts = { colors: true, depth: null };
+/** @ignore */
+function _GroupBy(df, by, maintainOrder = false) {
+    const customInspect = () => node_util_1.default.formatWithOptions(inspectOpts, "GroupBy {by: %O}", by);
+    const pivot = (opts, valuesCol) => {
+        if (typeof opts === "string") {
+            if (valuesCol) {
+                return pivot({ pivotCol: opts, valuesCol });
+            }
+            throw new Error("must specify both pivotCol and valuesCol");
+        }
+        return PivotOps((0, dataframe_1._DataFrame)(df), by, opts.pivotCol, opts.valuesCol);
+    };
+    const agg = (...aggs) => {
+        if (utils.isExprArray(aggs)) {
+            aggs = [aggs].flat(2);
+            return (0, dataframe_1._DataFrame)(df)
+                .lazy()
+                .groupBy(by, maintainOrder)
+                .agg(...aggs)
+                .collectSync({ noOptimization: true });
+        }
+        const pairs = Object.entries(aggs[0]).flatMap(([key, values]) => {
+            return [values].flat(2).map((v) => (0, functions_1.col)(key)[v]());
+        });
+        return (0, dataframe_1._DataFrame)(df)
+            .lazy()
+            .groupBy(by, maintainOrder)
+            .agg(...pairs)
+            .collectSync({ noOptimization: true });
+    };
+    return Object.seal({
+        [inspect]: customInspect,
+        agg,
+        pivot,
+        aggList: () => agg((0, functions_1.exclude)(by)),
+        len() {
+            return (0, dataframe_1._DataFrame)(df.groupby([by].flat(), by, "count"));
+        },
+        first: () => agg((0, functions_1.exclude)(by).first()),
+        groups() {
+            return (0, dataframe_1._DataFrame)(df.groupby([by].flat(), null, "groups"));
+        },
+        head: (n = 5) => agg((0, functions_1.exclude)(by).head(n)),
+        last: () => agg((0, functions_1.exclude)(by).last()),
+        max: () => agg((0, functions_1.exclude)(by).max()),
+        mean: () => agg((0, functions_1.exclude)(by).mean()),
+        median: () => agg((0, functions_1.exclude)(by).median()),
+        min: () => agg((0, functions_1.exclude)(by).min()),
+        nUnique: () => agg((0, functions_1.exclude)(by).nUnique()),
+        quantile: (q) => agg((0, functions_1.exclude)(by).quantile(q)),
+        sum: () => agg((0, functions_1.exclude)(by).sum()),
+        tail: (n = 5) => agg((0, functions_1.exclude)(by).tail(n)),
+        toString: () => "GroupBy",
+    });
+}
+function PivotOps(df, by, pivotCol, valueCol) {
+    const pivot = (agg) => () => df.pivot(valueCol, { on: pivotCol, index: by, aggregateFunc: agg });
+    const customInspect = () => node_util_1.default.formatWithOptions(inspectOpts, "PivotOps {by: %O}", by);
+    return {
+        [inspect]: customInspect,
+        first: pivot("first"),
+        sum: pivot("sum"),
+        min: pivot("min"),
+        max: pivot("max"),
+        mean: pivot("mean"),
+        len: pivot("len"),
+        median: pivot("median"),
+    };
+}
+/** @ignore */
+function RollingGroupBy(df, indexColumn, period, offset, closed, by) {
+    return {
+        agg(column, ...columns) {
+            return df
+                .lazy()
+                .groupByRolling({
+                indexColumn,
+                period,
+                offset,
+                closed,
+                by,
+            })
+                .agg(column, ...columns)
+                .collectSync();
+        },
+    };
+}
+/** @ignore */
+function DynamicGroupBy(df, indexColumn, every, period, offset, label, includeBoundaries, closed, by, startBy) {
+    return {
+        agg(column, ...columns) {
+            return df
+                .lazy()
+                .groupByDynamic({
+                indexColumn,
+                every,
+                period,
+                offset,
+                label,
+                includeBoundaries,
+                closed,
+                by,
+                startBy,
+            })
+                .agg(column, ...columns)
+                .collectSync({ noOptimizations: true });
+        },
+    };
+}

package/bin/html.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Escapes text for safe interpolation into HTML text content and quoted attributes
+ */
+export declare function escapeHTML(str: string): string;

package/bin/html.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeHTML = escapeHTML;
+const rawToEntityEntries = [
+    ["&", "&"],
+    ["<", "&lt;"],
+    [">", "&gt;"],
+    ['"', "&quot;"],
+    ["'", "&#39;"],
+];
+const rawToEntity = new Map(rawToEntityEntries);
+const rawRe = new RegExp(`[${[...rawToEntity.keys()].join("")}]`, "g");
+/**
+ * Escapes text for safe interpolation into HTML text content and quoted attributes
+ */
+function escapeHTML(str) {
+    return str.replaceAll(rawRe, (m) => rawToEntity.get(m) ?? m);
+}