@nshiab/simple-data-analysis 5.19.8

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/dataviz/updateNotesDW.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = updateNotesDW;
+const node_process_1 = __importDefault(require("node:process"));
+/**
+ * Updates the notes field for a specified Datawrapper chart, table, or map. This function provides a programmatic way to add or modify descriptive text associated with your Datawrapper visualizations, which can include data sources, methodologies, or any other relevant context.
+ *
+ * Authentication is handled via an API key, which can be provided through environment variables (`DATAWRAPPER_KEY`) or explicitly in the options.
+ *
+ * @param chartId - The unique ID of the Datawrapper chart, table, or map to update. This ID can be found in the Datawrapper URL or dashboard.
+ * @param note - The string content to update the chart's notes field with.
+ * @param options - Optional parameters to configure the notes update process.
+ *   @param options.apiKey - The name of the environment variable that stores your Datawrapper API key (e.g., `"DATAWRAPPER_KEY"`). If not provided, the function defaults to looking for the `DATAWRAPPER_KEY` environment variable.
+ *   @param options.returnResponse - If `true`, the function will return the full `Response` object from the Datawrapper API call. This can be useful for debugging or for more detailed handling of the API response. Defaults to `false`.
+ * @returns A Promise that resolves to `void` if `returnResponse` is `false` (default), or a `Response` object if `returnResponse` is `true`.
+ *
+ * @example
+ * ```ts
+ * // Update the notes field of a Datawrapper chart with a simple text string.
+ * import { updateNotesDW, formatDate } from "journalism";
+ *
+ * const chartID = "myChartId";
+ * const dateString = formatDate(new Date(), "Month DD, YYYY, at HH:MM period", { abbreviations: true });
+ * const note = `This chart was last updated on ${dateString}`;
+ *
+ * await updateNotesDW(chartID, note);
+ * console.log(`Notes updated for chart ${chartID}.`);
+ * ```
+ * @example
+ * ```ts
+ * // If your API key is stored under a different name in process.env (e.g., `DW_KEY`).
+ * const customApiKeyChartID = "anotherChartId";
+ * const customNote = "This is a note using a custom API key.";
+ * await updateNotesDW(customApiKeyChartID, customNote, { apiKey: "DW_KEY" });
+ * console.log(`Notes updated for chart ${customApiKeyChartID} using custom API key.`);
+ * ```
+ * @category Dataviz
+ */
+async function updateNotesDW(chartId, note, options = {}) {
+    const envVar = options.apiKey ?? "DATAWRAPPER_KEY";
+    const apiKey = node_process_1.default.env[envVar];
+    if (apiKey === undefined || apiKey === "") {
+        throw new Error(`process.env.${envVar} is undefined or ''.`);
+    }
+    const response = await fetch(`https://api.datawrapper.de/v3/charts/${chartId}`, {
+        method: "PATCH",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            metadata: {
+                annotate: {
+                    notes: note,
+                },
+            },
+        }),
+    });
+    await response.json();
+    // if returning a response, do it before the response.status checks
+    if (options.returnResponse === true) {
+        return response;
+    }
+    if (response.status !== 200) {
+        throw new Error(`updateNotesDW ${chartId}: Upstream HTTP ${response.status} - ${response.statusText}`);
+    }
+}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/index.d.ts

@@ -0,0 +1,11 @@
+import updateDataDW from "./dataviz/updateDataDW.js";
+import updateAnnotationsDW from "./dataviz/updateAnnotationsDW.js";
+import updateNotesDW from "./dataviz/updateNotesDW.js";
+import publishChartDW from "./dataviz/publishChartDW.js";
+import logBarChart from "./dataviz/logBarChart.js";
+import logLineChart from "./dataviz/logLineChart.js";
+import logDotChart from "./dataviz/logDotChart.js";
+import saveChart from "./dataviz/saveChart.js";
+import rewind from "./dataviz/rewind.js";
+export { logBarChart, logDotChart, logLineChart, publishChartDW, rewind, saveChart, updateAnnotationsDW, updateDataDW, updateNotesDW, };
+//# sourceMappingURL=index.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,2BAA2B,CAAC;AACrD,OAAO,mBAAmB,MAAM,kCAAkC,CAAC;AACnE,OAAO,aAAa,MAAM,4BAA4B,CAAC;AACvD,OAAO,cAAc,MAAM,6BAA6B,CAAC;AACzD,OAAO,WAAW,MAAM,0BAA0B,CAAC;AACnD,OAAO,YAAY,MAAM,2BAA2B,CAAC;AACrD,OAAO,WAAW,MAAM,0BAA0B,CAAC;AACnD,OAAO,SAAS,MAAM,wBAAwB,CAAC;AAC/C,OAAO,MAAM,MAAM,qBAAqB,CAAC;AAEzC,OAAO,EACL,WAAW,EACX,WAAW,EACX,YAAY,EACZ,cAAc,EACd,MAAM,EACN,SAAS,EACT,mBAAmB,EACnB,YAAY,EACZ,aAAa,GACd,CAAC"}

package/script/deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNotesDW = exports.updateDataDW = exports.updateAnnotationsDW = exports.saveChart = exports.rewind = exports.publishChartDW = exports.logLineChart = exports.logDotChart = exports.logBarChart = void 0;
+const updateDataDW_js_1 = __importDefault(require("./dataviz/updateDataDW.js"));
+exports.updateDataDW = updateDataDW_js_1.default;
+const updateAnnotationsDW_js_1 = __importDefault(require("./dataviz/updateAnnotationsDW.js"));
+exports.updateAnnotationsDW = updateAnnotationsDW_js_1.default;
+const updateNotesDW_js_1 = __importDefault(require("./dataviz/updateNotesDW.js"));
+exports.updateNotesDW = updateNotesDW_js_1.default;
+const publishChartDW_js_1 = __importDefault(require("./dataviz/publishChartDW.js"));
+exports.publishChartDW = publishChartDW_js_1.default;
+const logBarChart_js_1 = __importDefault(require("./dataviz/logBarChart.js"));
+exports.logBarChart = logBarChart_js_1.default;
+const logLineChart_js_1 = __importDefault(require("./dataviz/logLineChart.js"));
+exports.logLineChart = logLineChart_js_1.default;
+const logDotChart_js_1 = __importDefault(require("./dataviz/logDotChart.js"));
+exports.logDotChart = logDotChart_js_1.default;
+const saveChart_js_1 = __importDefault(require("./dataviz/saveChart.js"));
+exports.saveChart = saveChart_js_1.default;
+const rewind_js_1 = __importDefault(require("./dataviz/rewind.js"));
+exports.rewind = rewind_js_1.default;

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/arraysToData.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Transforms an object of arrays into an array of objects. This function is useful for converting data from a columnar format to a row-based format, which is common in data processing and visualization.
+ *
+ * It is assumed that all arrays in the input object have the same length.
+ *
+ * @param data An object where each key is a string and its corresponding value is an array of any type. All arrays are expected to have the same length.
+ *
+ * @returns An array of objects, where each object is a "row" of data created by combining values from the input arrays at the same index.
+ *
+ * @example
+ * ```ts
+ * // Basic usage with mixed data types
+ * const columnarData = {
+ *   name: ['Alice', 'Bob', 'Charlie'],
+ *   age: [30, 25, 35],
+ *   city: ['New York', 'London', 'Paris']
+ * };
+ *
+ * const rowData = arraysToData(columnarData);
+ *
+ * console.log(rowData);
+ * // Expected output:
+ * // [
+ * //   { name: 'Alice', age: 30, city: 'New York' },
+ * //   { name: 'Bob', age: 25, city: 'London' },
+ * //   { name: 'Charlie', age: 35, city: 'Paris' }
+ * // ]
+ * ```
+ * @example
+ * ```ts
+ * // Usage with numerical data for charting
+ * const chartData = {
+ *   x: [1, 2, 3, 4, 5],
+ *   y: [10, 20, 15, 25, 30]
+ * };
+ *
+ * const plotPoints = arraysToData(chartData);
+ *
+ * console.log(plotPoints);
+ * // Expected output:
+ * // [
+ * //   { x: 1, y: 10 },
+ * //   { x: 2, y: 20 },
+ * //   { x: 3, y: 15 },
+ * //   { x: 4, y: 25 },
+ * //   { x: 5, y: 30 }
+ * // ]
+ * ```
+ * @category Formatting
+ */
+export default function arraysToData<T extends Record<string, unknown[]>>(data: T): Array<{
+    [K in keyof T]: T[K][number];
+}>;
+//# sourceMappingURL=arraysToData.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/arraysToData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arraysToData.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/arraysToData.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EACtE,IAAI,EAAE,CAAC,GACN,KAAK,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;CAAE,CAAC,CAczC"}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/arraysToData.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Transforms an object of arrays into an array of objects. This function is useful for converting data from a columnar format to a row-based format, which is common in data processing and visualization.
+ *
+ * It is assumed that all arrays in the input object have the same length.
+ *
+ * @param data An object where each key is a string and its corresponding value is an array of any type. All arrays are expected to have the same length.
+ *
+ * @returns An array of objects, where each object is a "row" of data created by combining values from the input arrays at the same index.
+ *
+ * @example
+ * ```ts
+ * // Basic usage with mixed data types
+ * const columnarData = {
+ *   name: ['Alice', 'Bob', 'Charlie'],
+ *   age: [30, 25, 35],
+ *   city: ['New York', 'London', 'Paris']
+ * };
+ *
+ * const rowData = arraysToData(columnarData);
+ *
+ * console.log(rowData);
+ * // Expected output:
+ * // [
+ * //   { name: 'Alice', age: 30, city: 'New York' },
+ * //   { name: 'Bob', age: 25, city: 'London' },
+ * //   { name: 'Charlie', age: 35, city: 'Paris' }
+ * // ]
+ * ```
+ * @example
+ * ```ts
+ * // Usage with numerical data for charting
+ * const chartData = {
+ *   x: [1, 2, 3, 4, 5],
+ *   y: [10, 20, 15, 25, 30]
+ * };
+ *
+ * const plotPoints = arraysToData(chartData);
+ *
+ * console.log(plotPoints);
+ * // Expected output:
+ * // [
+ * //   { x: 1, y: 10 },
+ * //   { x: 2, y: 20 },
+ * //   { x: 3, y: 15 },
+ * //   { x: 4, y: 25 },
+ * //   { x: 5, y: 30 }
+ * // ]
+ * ```
+ * @category Formatting
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = arraysToData;
+function arraysToData(data) {
+    const keys = Object.keys(data);
+    const nbItems = data[keys[0]].length;
+    const newData = [];
+    for (let i = 0; i < nbItems; i++) {
+        const newItem = {};
+        for (const key of keys) {
+            newItem[key] = data[key][i];
+        }
+        newData.push(newItem);
+    }
+    return newData;
+}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/camelCase.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Converts a string into camelCase. This is useful for creating variable names or object keys from human-readable text.
+ *
+ * @param input The string to convert to camelCase. It can contain spaces, punctuation, and mixed casing.
+ *
+ * @returns The camelCased version of the input string.
+ *
+ * @example
+ * ```ts
+ * // Basic conversion
+ * const result1 = camelCase("hello world");
+ * console.log(result1); // "helloWorld"
+ * ```
+ * @example
+ * ```ts
+ * // With punctuation and mixed case
+ * const result2 = camelCase("  --Some@Thing is- happening--  ");
+ * console.log(result2); // "someThingsHappening"
+ * ```
+ * @example
+ * ```ts
+ * // With a single word
+ * const result3 = camelCase("Journalism");
+ * console.log(result3); // "journalism"
+ * ```
+ * @category Formatting
+ */
+export default function camelCase(input: string): string;
+//# sourceMappingURL=camelCase.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/camelCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camelCase.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/camelCase.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAsBvD"}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/camelCase.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = camelCase;
+const capitalize_js_1 = __importDefault(require("./capitalize.js"));
+/**
+ * Converts a string into camelCase. This is useful for creating variable names or object keys from human-readable text.
+ *
+ * @param input The string to convert to camelCase. It can contain spaces, punctuation, and mixed casing.
+ *
+ * @returns The camelCased version of the input string.
+ *
+ * @example
+ * ```ts
+ * // Basic conversion
+ * const result1 = camelCase("hello world");
+ * console.log(result1); // "helloWorld"
+ * ```
+ * @example
+ * ```ts
+ * // With punctuation and mixed case
+ * const result2 = camelCase("  --Some@Thing is- happening--  ");
+ * console.log(result2); // "someThingsHappening"
+ * ```
+ * @example
+ * ```ts
+ * // With a single word
+ * const result3 = camelCase("Journalism");
+ * console.log(result3); // "journalism"
+ * ```
+ * @category Formatting
+ */
+function camelCase(input) {
+    const words = input
+        .replace(/[^a-zA-Z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((d) => d !== "");
+    // Convert to camelCase
+    const camelCaseString = words
+        .map((word, index) => {
+        // Lowercase the entire string first
+        word = word.toLowerCase();
+        // Capitalize the first letter of each word except the first one
+        if (index > 0) {
+            word = (0, capitalize_js_1.default)(word);
+        }
+        return word;
+    })
+        .join("");
+    return camelCaseString;
+}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/capitalize.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Capitalizes the first letter of a given string.
+ *
+ * @param input The string to be capitalized.
+ *
+ * @returns A new string with the first letter in uppercase.
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const capitalized = capitalize("hello world");
+ * console.log(capitalized); // "Hello world"
+ * ```
+ * @example
+ * ```ts
+ * // With an already capitalized string
+ * const alreadyCapitalized = capitalize("Journalism");
+ * console.log(alreadyCapitalized); // "Journalism"
+ * ```
+ * @example
+ * ```ts
+ * // With a single character
+ * const singleChar = capitalize("a");
+ * console.log(singleChar); // "A"
+ * ```
+ * @category Formatting
+ */
+export default function capitalize(string: string): string;
+//# sourceMappingURL=capitalize.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/capitalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/capitalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGzD"}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/capitalize.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = capitalize;
+/**
+ * Capitalizes the first letter of a given string.
+ *
+ * @param input The string to be capitalized.
+ *
+ * @returns A new string with the first letter in uppercase.
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const capitalized = capitalize("hello world");
+ * console.log(capitalized); // "Hello world"
+ * ```
+ * @example
+ * ```ts
+ * // With an already capitalized string
+ * const alreadyCapitalized = capitalize("Journalism");
+ * console.log(alreadyCapitalized); // "Journalism"
+ * ```
+ * @example
+ * ```ts
+ * // With a single character
+ * const singleChar = capitalize("a");
+ * console.log(singleChar); // "A"
+ * ```
+ * @category Formatting
+ */
+function capitalize(string) {
+    const first = string[0];
+    return first.toUpperCase() + string.slice(1);
+}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/dataAsCsv.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Converts an array of objects into a CSV (Comma-Separated Values) string.
+ *
+ * The function takes an array of objects and returns a string in CSV format. The first line of the string will be the headers, which are derived from the keys of the first object in the array. Each subsequent line will represent an object, with the values in the same order as the headers.
+ *
+ * @param data An array of objects to be converted. All objects in the array should have the same keys.
+ *
+ * @returns A string representing the data in CSV format.
+ *
+ * @example
+ * ```ts
+ * // Basic usage with a simple dataset
+ * const dataset = [
+ *   { make: "Toyota", model: "Camry", year: 2021 },
+ *   { make: "Honda", model: "Accord", year: 2022 },
+ *   { make: "Ford", model: "Mustang", year: 2020 }
+ * ];
+ *
+ * const csvString = dataAsCsv(dataset);
+ *
+ * console.log(csvString);
+ * // Expected output:
+ * // "make,model,year\nToyota,Camry,2021\nHonda,Accord,2022\nFord,Mustang,2020"
+ * ```
+ * @category Formatting
+ */
+export default function dataAsCsv(arrayOfObjects: {
+    [key: string]: unknown;
+}[]): string;
+//# sourceMappingURL=dataAsCsv.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/dataAsCsv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataAsCsv.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/dataAsCsv.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,cAAc,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,GAC3C,MAAM,CAER"}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/dataAsCsv.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dataAsCsv;
+const d3_dsv_1 = require("d3-dsv");
+/**
+ * Converts an array of objects into a CSV (Comma-Separated Values) string.
+ *
+ * The function takes an array of objects and returns a string in CSV format. The first line of the string will be the headers, which are derived from the keys of the first object in the array. Each subsequent line will represent an object, with the values in the same order as the headers.
+ *
+ * @param data An array of objects to be converted. All objects in the array should have the same keys.
+ *
+ * @returns A string representing the data in CSV format.
+ *
+ * @example
+ * ```ts
+ * // Basic usage with a simple dataset
+ * const dataset = [
+ *   { make: "Toyota", model: "Camry", year: 2021 },
+ *   { make: "Honda", model: "Accord", year: 2022 },
+ *   { make: "Ford", model: "Mustang", year: 2020 }
+ * ];
+ *
+ * const csvString = dataAsCsv(dataset);
+ *
+ * console.log(csvString);
+ * // Expected output:
+ * // "make,model,year\nToyota,Camry,2021\nHonda,Accord,2022\nFord,Mustang,2020"
+ * ```
+ * @category Formatting
+ */
+function dataAsCsv(arrayOfObjects) {
+    return (0, d3_dsv_1.csvFormat)(arrayOfObjects);
+}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/dataToArrays.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Transforms an array of objects into an object of arrays. This function is the inverse of `arraysToData` and is useful for converting data from a row-based format to a columnar format.
+ *
+ * @param data An array of objects. Each object is expected to have the same set of keys.
+ *
+ * @returns An object where each key maps to an array of values, effectively representing the data in a columnar format.
+ *
+ * @example
+ * ```ts
+ * // Basic usage with a simple dataset
+ * const rowData = [
+ *   { name: 'Alice', age: 30, city: 'New York' },
+ *   { name: 'Bob', age: 25, city: 'London' },
+ *   { name: 'Charlie', age: 35, city: 'Paris' }
+ * ];
+ *
+ * const columnarData = dataToArrays(rowData);
+ *
+ * console.log(columnarData);
+ * // Expected output:
+ * // {
+ * //   name: ['Alice', 'Bob', 'Charlie'],
+ * //   age: [30, 25, 35],
+ * //   city: ['New York', 'London', 'Paris']
+ * // }
+ * ```
+ * @example
+ * ```ts
+ * // Preparing data for statistical analysis
+ * const measurements = [
+ *   { id: 1, temp: 20, humidity: 60 },
+ *   { id: 2, temp: 22, humidity: 65 },
+ *   { id: 3, temp: 18, humidity: 55 }
+ * ];
+ *
+ * const separatedVariables = dataToArrays(measurements);
+ *
+ * console.log(separatedVariables);
+ * // Expected output:
+ * // {
+ * //   id: [1, 2, 3],
+ * //   temp: [20, 22, 18],
+ * //   humidity: [60, 65, 55]
+ * // }
+ * ```
+ * @category Formatting
+ */
+export default function dataToArrays<T extends Record<string, unknown>>(data: T[]): {
+    [K in keyof T]: T[K][];
+};
+//# sourceMappingURL=dataToArrays.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/dataToArrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataToArrays.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/dataToArrays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpE,IAAI,EAAE,CAAC,EAAE,GACR;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;CAAE,CAU5B"}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/dataToArrays.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Transforms an array of objects into an object of arrays. This function is the inverse of `arraysToData` and is useful for converting data from a row-based format to a columnar format.
+ *
+ * @param data An array of objects. Each object is expected to have the same set of keys.
+ *
+ * @returns An object where each key maps to an array of values, effectively representing the data in a columnar format.
+ *
+ * @example
+ * ```ts
+ * // Basic usage with a simple dataset
+ * const rowData = [
+ *   { name: 'Alice', age: 30, city: 'New York' },
+ *   { name: 'Bob', age: 25, city: 'London' },
+ *   { name: 'Charlie', age: 35, city: 'Paris' }
+ * ];
+ *
+ * const columnarData = dataToArrays(rowData);
+ *
+ * console.log(columnarData);
+ * // Expected output:
+ * // {
+ * //   name: ['Alice', 'Bob', 'Charlie'],
+ * //   age: [30, 25, 35],
+ * //   city: ['New York', 'London', 'Paris']
+ * // }
+ * ```
+ * @example
+ * ```ts
+ * // Preparing data for statistical analysis
+ * const measurements = [
+ *   { id: 1, temp: 20, humidity: 60 },
+ *   { id: 2, temp: 22, humidity: 65 },
+ *   { id: 3, temp: 18, humidity: 55 }
+ * ];
+ *
+ * const separatedVariables = dataToArrays(measurements);
+ *
+ * console.log(separatedVariables);
+ * // Expected output:
+ * // {
+ * //   id: [1, 2, 3],
+ * //   temp: [20, 22, 18],
+ * //   humidity: [60, 65, 55]
+ * // }
+ * ```
+ * @category Formatting
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dataToArrays;
+function dataToArrays(data) {
+    const newData = {};
+    const keys = Object.keys(data[0]);
+    for (const key of keys) {
+        newData[key] = data.map((d) => d[key]);
+    }
+    return newData;
+}

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/formatDate.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Formats a `Date` object into a human-readable string based on a specified format, style, and time zone. This function provides flexible date and time formatting options, including support for UTC, different linguistic styles (English/French), and various display preferences like abbreviations and zero-padding.
+ *
+ * @param date The `Date` object to be formatted.
+ * @param format A predefined string literal specifying the desired output format. Examples include "YYYY-MM-DD", "Month DD, YYYY", "HH:MM period", etc.
+ * @param options Optional settings to customize the formatting behavior.
+ * @param options.utc If `true`, the date will be formatted in UTC (Coordinated Universal Time). Defaults to `false`.
+ * @param options.style The linguistic style for formatting. Use "cbc" for English (default) or "rc" for French. This affects month and day names, and time representations.
+ * @param options.abbreviations If `true`, month and day names will be abbreviated (e.g., "Jan.", "Mon."). Defaults to `false`.
+ * @param options.noZeroPadding If `true`, single-digit days and months will not be padded with a leading zero (e.g., "1" instead of "01"). Defaults to `false`.
+ * @param options.threeLetterMonth If `true`, month abbreviations will be three letters (e.g., "Jan", "Feb"). Defaults to `false`.
+ * @param options.timeZone Specifies a time zone for formatting. Accepts standard IANA time zone names (e.g., "America/New_York") or specific Canadian time zones. If `utc` is `true`, this option is ignored.
+ *
+ * @returns The formatted date string.
+ *
+ * @example
+ * ```ts
+ * // Basic usage: Format a date in default English style.
+ * const date = new Date("2023-01-01T01:35:00.000Z");
+ * const formatted = formatDate(date, "Month DD, YYYY, at HH:MM period", { utc: true });
+ * console.log(formatted); // "January 1, 2023, at 1:35 a.m."
+ * ```
+ * @example
+ * ```ts
+ * // Formatting in French style with abbreviations.
+ * const frenchFormatted = formatDate(date, "Month DD, YYYY, at HH:MM period", {
+ *   style: "rc",
+ *   abbreviations: true,
+ *   utc: true
+ * });
+ * console.log(frenchFormatted); // "1 janv. 2023 à 1 h 35"
+ * ```
+ * @example
+ * ```ts
+ * // Formatting with a specific time zone.
+ * const estFormatted = formatDate(date, "Month DD, YYYY, at HH:MM period TZ", {
+ *   timeZone: "Canada/Eastern"
+ * });
+ * console.log(estFormatted); // "January 1, 2023, at 8:35 p.m. EST" (assuming date is UTC)
+ * ```
+ * @example
+ * ```ts
+ * // Custom format: YYYY-MM-DD
+ * const isoFormatted = formatDate(new Date("2024-03-15T10:00:00Z"), "YYYY-MM-DD");
+ * console.log(isoFormatted); // "2024-03-15"
+ * ```
+ * @category Formatting
+ */
+export default function formatDate(date: Date, format: "YYYY-MM-DD" | "YYYY-MM-DD HH:MM:SS TZ" | "DayOfWeek, Month Day" | "Month DD" | "Month DD, HH:MM period" | "Month DD, HH:MM period TZ" | "DayOfWeek, HH:MM period" | "DayOfWeek, HH:MM period TZ" | "Month DD, YYYY" | "Month DD, YYYY, at HH:MM period" | "Month DD, YYYY, at HH:MM period TZ" | "DayOfWeek" | "Month" | "YYYY" | "MM" | "DD" | "HH:MM period" | "HH:MM period TZ" | "HH:MM period TZ on Month DD, YYYY" | "HH:MM period on Month DD, YYYY" | "HH:MM period TZ on Month DD" | "HH:MM period on Month DD", options?: {
+    utc?: boolean;
+    style?: "cbc" | "rc";
+    abbreviations?: boolean;
+    noZeroPadding?: boolean;
+    threeLetterMonth?: boolean;
+    timeZone?: "Canada/Atlantic" | "Canada/Central" | "Canada/Eastern" | "Canada/Mountain" | "Canada/Newfoundland" | "Canada/Pacific" | "Canada/Saskatchewan" | "Canada/Yukon";
+}): string;
+//# sourceMappingURL=formatDate.d.ts.map

package/script/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/formatDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/journalism-format/1.1.5/src/format/formatDate.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,IAAI,EAAE,IAAI,EACV,MAAM,EACF,YAAY,GACZ,wBAAwB,GACxB,sBAAsB,GACtB,UAAU,GACV,wBAAwB,GACxB,2BAA2B,GAC3B,yBAAyB,GACzB,4BAA4B,GAC5B,gBAAgB,GAChB,iCAAiC,GACjC,oCAAoC,GACpC,WAAW,GACX,OAAO,GACP,MAAM,GACN,IAAI,GACJ,IAAI,GACJ,cAAc,GACd,iBAAiB,GACjB,mCAAmC,GACnC,gCAAgC,GAChC,6BAA6B,GAC7B,0BAA0B,EAC9B,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,EACL,iBAAiB,GACjB,gBAAgB,GAChB,gBAAgB,GAChB,iBAAiB,GACjB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,cAAc,CAAC;CACf,GACL,MAAM,CAwLR"}