@nibapp/ui 0.0.0-stage → 0.1.0

package/dist/lib/number-format.d.ts

@@ -0,0 +1,114 @@
+/**
+ * The one count and money formatter: counts and money render the same in every view that uses it, at
+ * most one decimal in a compact count, cents below 100 of a currency and whole units above, and
+ * tabular figures where they are shown (wrap them in `.tabular`, or use `<Count>` / `<Money>`).
+ *
+ * Every locale gets its own digits, separators, unit words and currency pattern from `Intl`
+ * ("58.7k", "58,7 тыс.", "$0.42", "0,42 $"); nothing is special-cased per language. Components get
+ * the provider's locale through `useFormatters()` (`@nibapp/ui/i18n`).
+ */
+import { type CurrencyCode, type Money, type ShowableMoney } from "../_bundled/money/index.js";
+/**
+ * An amount to show: `Money`, in its own currency, or a number in the formatters' currency (major
+ * units). Never a usage cost (`UsageCost`): what work cost reaches a person only through the usage
+ * display policy (`shownUsage`, `<UsageAmount>`), which decides by who paid.
+ */
+export type Amount = ShowableMoney | number;
+/** A whole number as two digits ("04"), for a clock's minutes and seconds. */
+export declare const pad2: (n: number) => string;
+/**
+ * The value a count shows: 950 → 950, 1001 → 1000, 58_740 → 58_700, 1_250_000 → 1_300_000. Pass it
+ * as the `count` (plural selector) of a message whose noun follows a formatted count, so "1 тыс."
+ * agrees as a thousand ("1 тыс. токенов"), not as one.
+ */
+export declare function shownCount(n: number): number;
+export interface NumberFormatters {
+    /** `formatCount` for the locale. */
+    readonly count: (n: number) => string;
+    /** `formatMoney` for the locale. */
+    readonly money: (amount: Amount) => string;
+    /** Rounded to whole units, for amounts people set or prices that are round: "$25", "25 $". */
+    readonly wholeMoney: (amount: Amount) => string;
+    /**
+     * An amount exactly as set or billed: whole units when it's whole ("$25"), else with the currency's
+     * minor digits ("$2.50", "$1,204.50"); never rounded to whole units like `money` above 100.
+     */
+    readonly exactMoney: (amount: Amount) => string;
+    /** An amount in the currency's minor units (an invoice line): 1240 → "$12.40"; 500 JPY → "¥500". */
+    readonly minorUnits: (minor: number) => string;
+    /** A low–high range in one pattern: "$0.05–$0.20", "0,05–0,20 $"; one amount when they match. */
+    readonly moneyRange: (low: Amount, high: Amount) => string;
+    /** An amount in words, for meters and screen readers: "1.84 US dollars", "1,84 доллара США". */
+    readonly spokenMoney: (amount: Amount) => string;
+    /**
+     * The smallest amount its currency shows when `amount` is less than that (dust: "<$0.01"), in the
+     * same currency; `undefined` when it shows as it is.
+     */
+    readonly dustFloor: (amount: Amount) => Amount | undefined;
+    /** A unit price, sub-cent digits kept: "$4", "$2.50", "$0.075" (per million tokens, per hour). */
+    readonly unitPrice: (amount: Amount) => string;
+    /**
+     * A currency's symbol and which side of an amount the locale writes it on ("$12", "12 $"): `currency`'s,
+     * else the formatters' own.
+     */
+    readonly currencySymbol: (currency?: string) => {
+        readonly symbol: string;
+        readonly leading: boolean;
+    };
+}
+/**
+ * Count and money formatters for one locale. The `Intl` objects are built on first use and owned
+ * by the returned object, never cached at module scope (one process may render several locales):
+ * keep one per locale, e.g. in a provider's memo. `Money` is shown in its own currency; a number in
+ * `currency`, the host's. There's no default currency: pass `undefined` for formatters that show only
+ * `Money`, and formatting a number as money with them fails.
+ */
+export declare function createNumberFormatters(locale: string, currency: string | undefined): NumberFormatters;
+/**
+ * 950 → "950", 1234 → "1.2k", 58_700 → "58.7k", 202_400 → "202k", 1_250_000 → "1.3m" in en-GB;
+ * "58,7\u00A0тыс.", "1,3\u00A0млн" in ru. Values that round up to the next unit move to it
+ * (999_960 → "1m", never "1000k").
+ */
+export declare function formatCount(n: number, locale: string): string;
+/**
+ * "$0", "<$0.01", "$0.42", "$12.30", "$140", "$1,204" in en-GB; "0 $", "<0,01 $", "12,30 $",
+ * "1 204 $" in ru (Intl's no-break spaces). Cents below 100, whole units (with the locale's
+ * thousands separators) from 100. Never colored: money is information, not brand. `Money` carries
+ * its currency; a number needs the `currency` it's in.
+ */
+export declare function formatMoney(amount: ShowableMoney, locale: string): string;
+export declare function formatMoney(amount: number, locale: string, currency: string): string;
+/**
+ * An amount as typed in the locale: its own digits (Arabic-Indic in ar-EG, Devanagari in hi with
+ * `nu-deva`) or ASCII ones, its group separator and decimal mark ("1,250.50", "1 250,50",
+ * "1.250,50", "1'234.5", "١٬٢٣٤٫٥"), its minus sign; any currency symbol, spaces and direction marks
+ * ignored. Where the locale doesn't group with "." or ",", either reads as the decimal mark too
+ * ("12.5" in ru, "1234.5" in ar-EG). Where it does, its group mark counts only where it groups
+ * ("1,234" in en); one that doesn't is the decimal mark typed the other way ("12,34" is 12.34 in en,
+ * "12.5" is 12.5 in de), never a figure 100 times larger. Undefined when it isn't a number.
+ */
+export declare function parseAmount(text: string, locale: string): number | undefined;
+/**
+ * An amount typed in major units (`parseAmount`, `readAmount`, a `MoneyInput`'s `onAmountChange`) as
+ * `Money` of `currency`, rounded half to even at the micro; `undefined` past what `Money` holds (its
+ * micros are safe integers).
+ */
+export declare function typedMoney(units: number, currency: CurrencyCode): Money | undefined;
+/** What an amount field accepts. */
+export interface AmountBounds {
+    /** The smallest amount, inclusive. */
+    readonly min?: number | undefined;
+    /** The largest amount, inclusive. */
+    readonly max?: number | undefined;
+    /** Amounts are whole multiples of it: 1 for whole units. Any precision when omitted. */
+    readonly step?: number | undefined;
+    /** Zero isn't an amount (with `min: 0`, only amounts above zero are). */
+    readonly nonZero?: boolean | undefined;
+    /** An empty field is `null` ("no limit", "the default"); otherwise it isn't an amount. */
+    readonly allowEmpty?: boolean | undefined;
+}
+/**
+ * The amount typed in the locale (`parseAmount`) within `bounds`: the number, `null` for an empty
+ * field that `allowEmpty`, `undefined` for anything else.
+ */
+export declare function readAmount(text: string, locale: string, bounds?: AmountBounds): number | null | undefined;

package/dist/lib/number-format.js

@@ -0,0 +1,313 @@
+/**
+ * The one count and money formatter: counts and money render the same in every view that uses it, at
+ * most one decimal in a compact count, cents below 100 of a currency and whole units above, and
+ * tabular figures where they are shown (wrap them in `.tabular`, or use `<Count>` / `<Money>`).
+ *
+ * Every locale gets its own digits, separators, unit words and currency pattern from `Intl`
+ * ("58.7k", "58,7 тыс.", "$0.42", "0,42 $"); nothing is special-cased per language. Components get
+ * the provider's locale through `useFormatters()` (`@nibapp/ui/i18n`).
+ */
+import { CurrencyMismatchError, currencyDigits, MICROS_PER_UNIT, moneyFormat, moneyFromUnits, moneyToUnits, } from "../_bundled/money/index.js";
+/** A whole number as two digits ("04"), for a clock's minutes and seconds. */
+export const pad2 = (n) => String(n).padStart(2, "0");
+const UNITS = [1e3, 1e6, 1e9];
+/** One decimal below 100 of a unit (58.7 thousand), whole above it (202 thousand). */
+function scaled(value) {
+    return value < 99.95 ? Number(value.toFixed(1)) : Math.round(value);
+}
+/**
+ * The value a count shows: 950 → 950, 1001 → 1000, 58_740 → 58_700, 1_250_000 → 1_300_000. Pass it
+ * as the `count` (plural selector) of a message whose noun follows a formatted count, so "1 тыс."
+ * agrees as a thousand ("1 тыс. токенов"), not as one.
+ */
+export function shownCount(n) {
+    if (!Number.isFinite(n))
+        return 0;
+    const sign = n < 0 ? -1 : 1;
+    const abs = Math.abs(n);
+    if (Math.round(abs) < 1000)
+        return sign * Math.round(abs);
+    for (const [index, unit] of UNITS.entries()) {
+        const value = scaled(abs / unit);
+        if (index === UNITS.length - 1 || value < 1000)
+            return sign * Math.round(value * unit);
+    }
+    return sign * Math.round(abs);
+}
+function currencyFormatters(locale, currency) {
+    let spoken;
+    let price;
+    let digits;
+    const moneyFormats = new Map();
+    // The currency in the locale's pattern ("$0.42", "0,42 $"), with exactly `fraction` decimals.
+    const currencyFormat = (fraction) => {
+        let format = moneyFormats.get(fraction);
+        if (format === undefined) {
+            format = moneyFormat(locale, currency, fraction);
+            moneyFormats.set(fraction, format);
+        }
+        return format;
+    };
+    const inCurrency = (value, fraction) => currencyFormat(fraction).format(value);
+    // The currency's minor digits: 2 for USD ("cents"), 0 for JPY.
+    const minor = () => {
+        digits ??= currencyDigits(currency, locale);
+        return digits;
+    };
+    const dustFloor = (amount) => {
+        const smallest = 10 ** -minor();
+        const abs = Math.abs(amount);
+        return abs > 0 && abs < smallest ? smallest : undefined;
+    };
+    const money = (amount) => {
+        if (!Number.isFinite(amount))
+            return "—";
+        const abs = Math.abs(amount);
+        if (abs === 0)
+            return inCurrency(0, 0);
+        // Dust: less than the smallest amount the minor unit shows.
+        const floor = dustFloor(amount);
+        if (floor !== undefined)
+            return `<${inCurrency(floor, minor())}`;
+        return abs < 100 ? inCurrency(amount, minor()) : inCurrency(Math.round(amount), 0);
+    };
+    const wholeMoney = (amount) => Number.isFinite(amount) ? inCurrency(Math.round(amount), 0) : "—";
+    const exactMoney = (amount) => {
+        if (!Number.isFinite(amount))
+            return "—";
+        return Number.isInteger(amount) ? inCurrency(amount, 0) : inCurrency(amount, minor());
+    };
+    const minorUnits = (amount) => Number.isFinite(amount) ? inCurrency(amount / 10 ** minor(), minor()) : "—";
+    const moneyRange = (low, high) => {
+        if (!Number.isFinite(low) || !Number.isFinite(high))
+            return "—";
+        if (money(low) === money(high))
+            return money(low);
+        return Math.max(Math.abs(low), Math.abs(high)) < 100
+            ? currencyFormat(minor()).formatRange(low, high)
+            : currencyFormat(0).formatRange(Math.round(low), Math.round(high));
+    };
+    const spokenMoney = (amount) => {
+        spoken ??= new Intl.NumberFormat(locale, {
+            style: "currency",
+            currency,
+            currencyDisplay: "name",
+            trailingZeroDisplay: "stripIfInteger",
+        });
+        const scale = 10 ** minor();
+        return spoken.format(Math.round(amount * scale) / scale);
+    };
+    const unitPrice = (amount) => {
+        if (Number.isInteger(amount))
+            return inCurrency(amount, 0);
+        price ??= new Intl.NumberFormat(locale, {
+            style: "currency",
+            currency,
+            currencyDisplay: "narrowSymbol",
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 3,
+        });
+        return price.format(amount);
+    };
+    const currencySymbol = () => {
+        const parts = currencyFormat(0).formatToParts(1);
+        const at = parts.findIndex((part) => part.type === "currency");
+        const number = parts.findIndex((part) => part.type === "integer");
+        return { symbol: parts[at]?.value ?? currency, leading: at < number };
+    };
+    return {
+        money,
+        wholeMoney,
+        exactMoney,
+        minorUnits,
+        moneyRange,
+        spokenMoney,
+        dustFloor,
+        unitPrice,
+        currencySymbol,
+    };
+}
+/**
+ * Count and money formatters for one locale. The `Intl` objects are built on first use and owned
+ * by the returned object, never cached at module scope (one process may render several locales):
+ * keep one per locale, e.g. in a provider's memo. `Money` is shown in its own currency; a number in
+ * `currency`, the host's. There's no default currency: pass `undefined` for formatters that show only
+ * `Money`, and formatting a number as money with them fails.
+ */
+export function createNumberFormatters(locale, currency) {
+    let compact;
+    const byCurrency = new Map();
+    const formattersFor = (code) => {
+        let formatters = byCurrency.get(code);
+        if (formatters === undefined) {
+            formatters = currencyFormatters(locale, code);
+            byCurrency.set(code, formatters);
+        }
+        return formatters;
+    };
+    // A number is money in the host's currency, which only the host knows.
+    const hostCurrency = () => {
+        if (currency === undefined)
+            throw new Error("showing a number as money needs a currency: give UiI18nProvider one, or createNumberFormatters its second argument");
+        return currency;
+    };
+    // An amount's major units and the formatters of its currency.
+    const split = (amount) => typeof amount === "number"
+        ? [amount, formattersFor(hostCurrency())]
+        : [moneyToUnits(amount), formattersFor(amount.currency)];
+    const count = (n) => {
+        if (!Number.isFinite(n))
+            return "—";
+        // One decimal or three significant digits, whichever is coarser: "58.7k", "202k", "1.3m".
+        compact ??= new Intl.NumberFormat(locale, {
+            notation: "compact",
+            maximumFractionDigits: 1,
+            maximumSignificantDigits: 3,
+            roundingPriority: "lessPrecision",
+        });
+        return compact.format(Math.round(n));
+    };
+    const via = (format) => (amount) => {
+        const [units, formatters] = split(amount);
+        return format(formatters, units);
+    };
+    return {
+        count,
+        money: via((f, units) => f.money(units)),
+        wholeMoney: via((f, units) => f.wholeMoney(units)),
+        exactMoney: via((f, units) => f.exactMoney(units)),
+        minorUnits: (minor) => formattersFor(hostCurrency()).minorUnits(minor),
+        moneyRange: (low, high) => {
+            const lowCurrency = typeof low === "number" ? hostCurrency() : low.currency;
+            const highCurrency = typeof high === "number" ? hostCurrency() : high.currency;
+            if (lowCurrency !== highCurrency)
+                throw new CurrencyMismatchError(lowCurrency, highCurrency);
+            const [from, formatters] = split(low);
+            return formatters.moneyRange(from, split(high)[0]);
+        },
+        spokenMoney: via((f, units) => f.spokenMoney(units)),
+        dustFloor: (amount) => {
+            const [units, formatters] = split(amount);
+            const floor = formatters.dustFloor(units);
+            if (floor === undefined)
+                return undefined;
+            return typeof amount === "number" ? floor : moneyFromUnits(floor, amount.currency);
+        },
+        unitPrice: via((f, units) => f.unitPrice(units)),
+        currencySymbol: (code) => formattersFor(code ?? hostCurrency()).currencySymbol(),
+    };
+}
+/**
+ * 950 → "950", 1234 → "1.2k", 58_700 → "58.7k", 202_400 → "202k", 1_250_000 → "1.3m" in en-GB;
+ * "58,7\u00A0тыс.", "1,3\u00A0млн" in ru. Values that round up to the next unit move to it
+ * (999_960 → "1m", never "1000k").
+ */
+export function formatCount(n, locale) {
+    return createNumberFormatters(locale, undefined).count(n);
+}
+export function formatMoney(amount, locale, currency) {
+    return createNumberFormatters(locale, currency).money(amount);
+}
+const NUMBER_MARKS = new Map();
+function numberMarks(locale) {
+    let marks = NUMBER_MARKS.get(locale);
+    if (marks === undefined) {
+        const format = new Intl.NumberFormat(locale, { useGrouping: false });
+        const parts = new Intl.NumberFormat(locale).formatToParts(-12_345.6);
+        marks = {
+            digits: Array.from({ length: 10 }, (_, digit) => format.format(digit)),
+            group: parts.find((part) => part.type === "group")?.value ?? ",",
+            decimal: parts.find((part) => part.type === "decimal")?.value ?? ".",
+            minus: parts.find((part) => part.type === "minusSign")?.value ?? "-",
+        };
+        NUMBER_MARKS.set(locale, marks);
+    }
+    return marks;
+}
+/** Thousands grouped by "," or ".": one to three digits, then groups of three. */
+const WELL_GROUPED = {
+    ",": /^\d{1,3}(?:,\d{3})+$/u,
+    ".": /^\d{1,3}(?:\.\d{3})+$/u,
+};
+/**
+ * An amount in a locale that groups with "," or "." as plain "-1234.5": the group mark where it
+ * groups thousands, else (once, with no decimal mark) the decimal mark typed the other way.
+ */
+function groupedAmount(text, group, decimal) {
+    const parts = text.split(decimal);
+    if (parts.length > 2)
+        return undefined;
+    const [whole = "", fraction] = parts;
+    const sign = whole.startsWith("-") ? "-" : "";
+    const integer = whole.slice(sign.length);
+    const tail = fraction === undefined ? "" : `.${fraction}`;
+    if (!integer.includes(group))
+        return `${sign}${integer}${tail}`;
+    if (WELL_GROUPED[group].test(integer))
+        return `${sign}${integer.replaceAll(group, "")}${tail}`;
+    return fraction === undefined && integer.split(group).length === 2
+        ? `${sign}${integer.replace(group, ".")}`
+        : undefined;
+}
+/** Apostrophe-like group marks, typed for one another (de-CH: 1’234.5 or 1'234.5). */
+const APOSTROPHES = /['’]/gu;
+const isApostrophe = (mark) => mark === "'" || mark === "’";
+/**
+ * An amount as typed in the locale: its own digits (Arabic-Indic in ar-EG, Devanagari in hi with
+ * `nu-deva`) or ASCII ones, its group separator and decimal mark ("1,250.50", "1 250,50",
+ * "1.250,50", "1'234.5", "١٬٢٣٤٫٥"), its minus sign; any currency symbol, spaces and direction marks
+ * ignored. Where the locale doesn't group with "." or ",", either reads as the decimal mark too
+ * ("12.5" in ru, "1234.5" in ar-EG). Where it does, its group mark counts only where it groups
+ * ("1,234" in en); one that doesn't is the decimal mark typed the other way ("12,34" is 12.34 in en,
+ * "12.5" is 12.5 in de), never a figure 100 times larger. Undefined when it isn't a number.
+ */
+export function parseAmount(text, locale) {
+    const { digits, group, decimal, minus } = numberMarks(locale);
+    let clean = text.replaceAll(/[\p{Sc}\s\p{Cf}]/gu, "");
+    for (const [value, digit] of digits.entries())
+        clean = clean.replaceAll(digit, String(value));
+    clean = clean.replaceAll(minus, "-").replaceAll("\u2212", "-");
+    if (group === "." || group === ",") {
+        const read = groupedAmount(clean, group, decimal);
+        if (read === undefined)
+            return undefined;
+        clean = read;
+    }
+    else {
+        clean = isApostrophe(group) ? clean.replaceAll(APOSTROPHES, "") : clean.replaceAll(group, "");
+        clean = clean.replaceAll(decimal, ".").replaceAll(",", ".");
+    }
+    if (!/^-?(?:\d+\.?\d*|\.\d+)$/u.test(clean))
+        return undefined;
+    const value = Number(clean);
+    return Number.isFinite(value) ? value : undefined;
+}
+/**
+ * An amount typed in major units (`parseAmount`, `readAmount`, a `MoneyInput`'s `onAmountChange`) as
+ * `Money` of `currency`, rounded half to even at the micro; `undefined` past what `Money` holds (its
+ * micros are safe integers).
+ */
+export function typedMoney(units, currency) {
+    return Math.abs(units) * MICROS_PER_UNIT <= Number.MAX_SAFE_INTEGER
+        ? moneyFromUnits(units, currency)
+        : undefined;
+}
+/**
+ * The amount typed in the locale (`parseAmount`) within `bounds`: the number, `null` for an empty
+ * field that `allowEmpty`, `undefined` for anything else.
+ */
+export function readAmount(text, locale, bounds = {}) {
+    if (text.trim() === "")
+        return bounds.allowEmpty === true ? null : undefined;
+    const value = parseAmount(text, locale);
+    if (value === undefined)
+        return undefined;
+    const { min, max, step, nonZero } = bounds;
+    if ((min !== undefined && value < min) || (max !== undefined && value > max))
+        return undefined;
+    if (nonZero === true && value === 0)
+        return undefined;
+    if (step !== undefined && Math.abs(value / step - Math.round(value / step)) > 1e-9)
+        return undefined;
+    return value;
+}

package/dist/lib/patch.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Unified diffs as `git diff`, other diff tools and models write them: split into files, cut into
+ * hunks, counted and built. Every reader takes CRLF as LF, leaves `` out
+ * of the counts and decodes git's C-quoted paths, so every view of a change, DiffView included,
+ * reads one patch the same way.
+ */
+import type { FileDiffMetadata } from "@pierre/diffs";
+export interface DiffStats {
+    additions: number;
+    deletions: number;
+}
+/** What a file's patch does to it; a rename or copy is a modification that also has `oldPath`. */
+export type PatchChange = "added" | "deleted" | "modified";
+/** One file's slice of a patch. */
+export interface FilePatch {
+    /** Repo-relative path on the new side (old side for deletions); undefined when no header names it. */
+    readonly path: string | undefined;
+    /** Previous path when the file was renamed or copied. */
+    readonly oldPath: string | undefined;
+    readonly change: PatchChange;
+    /** The file's section of the patch, from its first header line, with LF line ends. */
+    readonly patch: string;
+    readonly additions: number;
+    readonly deletions: number;
+    readonly binary: boolean;
+}
+/** One `@@` hunk of a file's patch. */
+export interface PatchHunk {
+    /** First line on each side, from the `@@` line (0 on the side a new or deleted file lacks). */
+    readonly oldStart: number;
+    readonly newStart: number;
+    /** The hunk as unified-diff text: its `@@` line, then its body. */
+    readonly text: string;
+    /** The body alone: the same change wherever other hunks shifted its line numbers. */
+    readonly key: string;
+}
+/** Whether `text` holds at least one `@@ -a,b +c,d @@` hunk. */
+export declare function isUnifiedDiff(text: string): boolean;
+/**
+ * Git C-quotes paths with special characters (`"a/caf\303\251.txt"`). Octal escapes are UTF-8
+ * bytes, so they are collected and decoded together; anything else is written raw (`core.quotePath`
+ * off), taken a code point at a time so a character outside the BMP stays whole.
+ */
+export declare function unquoteGitPath(raw: string): string;
+/**
+ * Splits a patch (`git diff`, `diff -u`, or bare hunks) into one entry per file, with line counts.
+ * Text before the first file is ignored; text without hunks or file headers has no files.
+ */
+export declare function splitPatch(patch: string): FilePatch[];
+/** `+`/`-` line counts across every file of a patch; file headers never count. */
+export declare function patchStats(patch: string): DiffStats;
+/** The `@@` hunks of a patch, in order (the order DiffView indexes them). */
+export declare function parseHunks(patch: string): PatchHunk[];
+/** The text of `line` on one side of a patch, when the patch shows it. */
+export declare function lineText(patch: string, side: "old" | "new", line: number): string | undefined;
+/**
+ * Makes hand-written / model-written patches parse cleanly: CRLF → LF, no trailing newline, and
+ * bare empty lines inside hunks become the " " context lines they were meant to be (editors and
+ * LLMs routinely strip that leading space).
+ */
+export declare function normalizePatch(patch: string): string;
+/** A git-style patch of one file from its hunks' unified-diff text, so DiffView can render it. */
+export declare function buildFilePatch(path: string, change: PatchChange, hunks: readonly string[]): string;
+/** A patch that adds `content` as a new file, so new files render like any other diff. */
+export declare function newFilePatch(path: string, content: string): string;
+/** Counts `+` / `−` lines across all hunks. */
+export declare function getDiffStats(diff: FileDiffMetadata): DiffStats;
+/**
+ * One hunk as unified-diff text (`@@ … @@` header plus ` `/`-`/`+` lines and the no-newline
+ * marker), e.g. to quote in a message or to compare with a patch's hunk.
+ */
+export declare function getHunkExcerpt(diff: FileDiffMetadata, hunkIndex: number): string;