auditok 0.1.0

package/dist/node/index.js

@@ -0,0 +1,54 @@
+/**
+ * Node entry point: everything from the core, plus file loading
+ * (native WAV parser, ffmpeg for everything else), microphone capture
+ * through ffmpeg, and WAV saving. Zero npm runtime dependencies.
+ */
+import { readFile, writeFile } from "node:fs/promises";
+import { AudioRegion } from "../region.js";
+import { decodeWav, encodeWav, isWav, } from "../wav.js";
+import { decodeFileStream } from "./ffmpeg.js";
+export * from "../index.js";
+export { decodeFileStream, microphone, } from "./ffmpeg.js";
+/**
+ * Load an audio file into an {@link AudioRegion}. WAV files are parsed
+ * natively; every other format is decoded with ffmpeg (which must be
+ * on the PATH). To detect events while a large compressed file is
+ * still being decoded, use {@link decodeFileStream} with `split`
+ * instead of loading it fully.
+ */
+export async function load(path, options = {}) {
+    if (options.forceFfmpeg !== true) {
+        const bytes = await readFile(path);
+        if (isWav(bytes)) {
+            const { channelData, sampleRate } = decodeWav(bytes);
+            return new AudioRegion(channelData, sampleRate);
+        }
+    }
+    const stream = decodeFileStream(path, options);
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of stream.chunks) {
+        chunks.push(chunk);
+        total += chunk.length;
+    }
+    const { channels, sampleRate } = stream;
+    const sampleCount = Math.floor(total / channels);
+    const channelData = Array.from({ length: channels }, () => new Float32Array(sampleCount));
+    let sample = 0;
+    let channelCursor = 0;
+    for (const chunk of chunks) {
+        for (let i = 0; i < chunk.length && sample < sampleCount; i++) {
+            channelData[channelCursor][sample] = chunk[i];
+            channelCursor += 1;
+            if (channelCursor === channels) {
+                channelCursor = 0;
+                sample += 1;
+            }
+        }
+    }
+    return new AudioRegion(channelData, sampleRate);
+}
+/** Save a region (or any `{ channelData, sampleRate }`) as a WAV file. */
+export async function save(path, audio, options) {
+    await writeFile(path, encodeWav(audio, options));
+}

package/dist/region.d.ts

@@ -0,0 +1,31 @@
+/**
+ * AudioRegion: a chunk of audio with a position in time. What `split`
+ * yields and what `trim`/`fixPauses` return.
+ */
+import { type WavEncodeOptions } from "./wav.js";
+export declare class AudioRegion {
+    /** Planar samples, one Float32Array per channel, values nominally in
+     * [-1, 1]. */
+    readonly channelData: readonly Float32Array[];
+    readonly sampleRate: number;
+    /** Start time in seconds relative to the beginning of the input this
+     * region was detected in (0 for regions built directly). */
+    readonly start: number;
+    constructor(channelData: readonly Float32Array[], sampleRate: number, start?: number);
+    get channels(): number;
+    /** Number of samples per channel. */
+    get sampleCount(): number;
+    /** Duration in seconds. */
+    get duration(): number;
+    /** End time in seconds (`start + duration`). */
+    get end(): number;
+    /** Encode the region as a WAV file (16-bit PCM by default). */
+    toWav(options?: WavEncodeOptions): Uint8Array;
+}
+/** A region of digital silence of the given duration. */
+export declare function makeSilence(duration: number, sampleRate?: number, channels?: number): AudioRegion;
+/**
+ * Concatenate `regions` into one region, inserting `gap` (e.g. a
+ * silence built with {@link makeSilence}) between consecutive regions.
+ */
+export declare function concatRegions(regions: readonly AudioRegion[], gap?: AudioRegion): AudioRegion;

package/dist/region.js

@@ -0,0 +1,81 @@
+/**
+ * AudioRegion: a chunk of audio with a position in time. What `split`
+ * yields and what `trim`/`fixPauses` return.
+ */
+import { encodeWav } from "./wav.js";
+export class AudioRegion {
+    constructor(channelData, sampleRate, start = 0) {
+        if (channelData.length === 0) {
+            throw new RangeError("'channelData' must contain at least one channel");
+        }
+        const length = channelData[0].length;
+        for (const channel of channelData) {
+            if (channel.length !== length) {
+                throw new RangeError("all channels must have the same length");
+            }
+        }
+        if (!(sampleRate > 0)) {
+            throw new RangeError(`'sampleRate' must be > 0, given: ${sampleRate}`);
+        }
+        this.channelData = channelData;
+        this.sampleRate = sampleRate;
+        this.start = start;
+    }
+    get channels() {
+        return this.channelData.length;
+    }
+    /** Number of samples per channel. */
+    get sampleCount() {
+        return this.channelData[0].length;
+    }
+    /** Duration in seconds. */
+    get duration() {
+        return this.sampleCount / this.sampleRate;
+    }
+    /** End time in seconds (`start + duration`). */
+    get end() {
+        return this.start + this.duration;
+    }
+    /** Encode the region as a WAV file (16-bit PCM by default). */
+    toWav(options) {
+        return encodeWav(this, options);
+    }
+}
+/** A region of digital silence of the given duration. */
+export function makeSilence(duration, sampleRate = 16000, channels = 1) {
+    const sampleCount = Math.round(duration * sampleRate);
+    const channelData = Array.from({ length: channels }, () => new Float32Array(sampleCount));
+    return new AudioRegion(channelData, sampleRate);
+}
+/**
+ * Concatenate `regions` into one region, inserting `gap` (e.g. a
+ * silence built with {@link makeSilence}) between consecutive regions.
+ */
+export function concatRegions(regions, gap) {
+    if (regions.length === 0) {
+        throw new RangeError("'regions' must contain at least one region");
+    }
+    const { sampleRate, channels } = regions[0];
+    const parts = [];
+    let totalSamples = 0;
+    regions.forEach((region, i) => {
+        if (region.sampleRate !== sampleRate || region.channels !== channels) {
+            throw new RangeError("all regions must have the same sample rate and channel count");
+        }
+        if (i > 0 && gap !== undefined) {
+            parts.push(gap.channelData);
+            totalSamples += gap.sampleCount;
+        }
+        parts.push(region.channelData);
+        totalSamples += region.sampleCount;
+    });
+    const channelData = Array.from({ length: channels }, () => new Float32Array(totalSamples));
+    let offset = 0;
+    for (const part of parts) {
+        for (let c = 0; c < channels; c++) {
+            channelData[c].set(part[c], offset);
+        }
+        offset += part[0].length;
+    }
+    return new AudioRegion(channelData, sampleRate);
+}

package/dist/signal.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Signal-level operations: window energy and automatic threshold
+ * estimation.
+ *
+ * Samples are Float32Array values nominally in [-1, 1] (the Web Audio
+ * convention). Energies are expressed in dB relative to 16-bit full
+ * scale — samples are scaled by 32768 before the log — so thresholds
+ * mean exactly the same thing as in Python auditok, and its
+ * documentation transfers 1:1.
+ */
+export declare const EPSILON = 1e-10;
+/** Amplitude scale applied before the log so that dB values are relative
+ * to int16 full scale, like in Python auditok. */
+export declare const INT16_SCALE = 32768;
+/** Energy assigned to an all-zero (digitally silent) window:
+ * 20 * log10(EPSILON) = -200 dB. A sentinel, not a measurement. */
+export declare const SILENCE_ENERGY: number;
+/** Channel used for energy computation on multichannel audio:
+ * "any" (default) takes the maximum energy over channels, "mix"
+ * averages the channels into one before computing the energy, an
+ * integer selects one channel (negative counts from the end). */
+export type ChannelSelection = "any" | "mix" | number;
+/**
+ * Compute the energy of `samples` as
+ * `20 * log10(sqrt(mean(x^2)))` with `x` on the int16 amplitude scale.
+ * An all-zero window yields {@link SILENCE_ENERGY} (-200 dB).
+ */
+export declare function calculateEnergy(samples: ArrayLike<number>): number;
+/**
+ * Energy of one analysis window given as planar channel data,
+ * aggregated over channels according to `useChannel`.
+ */
+export declare function windowEnergy(channelData: readonly Float32Array[], useChannel?: ChannelSelection): number;
+/**
+ * Energy of each analysis window of `channelData`, one value per whole
+ * window of `frameSamples` samples. A final partial window, if any, is
+ * ignored. This is what automatic threshold estimation runs on; the
+ * energy formula and channel aggregation are exactly those used by the
+ * tokenizer's energy validator, so an estimated threshold means the
+ * same thing at detection time.
+ */
+export declare function computeFrameEnergies(channelData: readonly Float32Array[], frameSamples: number, useChannel?: ChannelSelection): Float64Array;
+export type ThresholdMethod = "otsu" | "percentile";
+export interface ThresholdMethodOptions {
+    /** Percentile read as the noise floor (method "percentile" only),
+     * default 10. */
+    percentile?: number;
+    /** dB margin added to the noise floor (method "percentile" only),
+     * default 6. */
+    margin?: number;
+}
+/**
+ * Estimate an energy threshold from analysis-window energies (as
+ * returned by {@link computeFrameEnergies}). The returned value is on
+ * the same dB scale as `energyThreshold` and can be passed to `split`
+ * directly.
+ *
+ * All-zero windows carry the -200 dB silence sentinel and are excluded
+ * from the estimate; if nothing else remains the input is entirely
+ * digitally silent and the function returns `Infinity` (every window
+ * must fail validation — there is nothing to detect).
+ */
+export declare function estimateEnergyThreshold(frameEnergies: ArrayLike<number>, method?: ThresholdMethod, options?: ThresholdMethodOptions): number;

package/dist/signal.js

@@ -0,0 +1,240 @@
+/**
+ * Signal-level operations: window energy and automatic threshold
+ * estimation.
+ *
+ * Samples are Float32Array values nominally in [-1, 1] (the Web Audio
+ * convention). Energies are expressed in dB relative to 16-bit full
+ * scale — samples are scaled by 32768 before the log — so thresholds
+ * mean exactly the same thing as in Python auditok, and its
+ * documentation transfers 1:1.
+ */
+export const EPSILON = 1e-10;
+/** Amplitude scale applied before the log so that dB values are relative
+ * to int16 full scale, like in Python auditok. */
+export const INT16_SCALE = 32768;
+/** Energy assigned to an all-zero (digitally silent) window:
+ * 20 * log10(EPSILON) = -200 dB. A sentinel, not a measurement. */
+export const SILENCE_ENERGY = 20 * Math.log10(EPSILON);
+/**
+ * Compute the energy of `samples` as
+ * `20 * log10(sqrt(mean(x^2)))` with `x` on the int16 amplitude scale.
+ * An all-zero window yields {@link SILENCE_ENERGY} (-200 dB).
+ */
+export function calculateEnergy(samples) {
+    const n = samples.length;
+    if (n === 0) {
+        return SILENCE_ENERGY;
+    }
+    let sumSquares = 0;
+    for (let i = 0; i < n; i++) {
+        const x = samples[i];
+        sumSquares += x * x;
+    }
+    const rms = Math.sqrt(sumSquares / n) * INT16_SCALE;
+    return 20 * Math.log10(Math.max(rms, EPSILON));
+}
+function resolveChannelIndex(index, channels) {
+    const selected = index < 0 ? index + channels : index;
+    if (!Number.isInteger(index) || selected < 0 || selected >= channels) {
+        throw new RangeError(`Selected channel must be >= -channels and < channels, given: ${index}`);
+    }
+    return selected;
+}
+function mixChannels(channelData, start, end) {
+    const mixed = new Float32Array(end - start);
+    for (const channel of channelData) {
+        for (let i = start; i < end; i++) {
+            mixed[i - start] += channel[i];
+        }
+    }
+    const channels = channelData.length;
+    for (let i = 0; i < mixed.length; i++) {
+        mixed[i] /= channels;
+    }
+    return mixed;
+}
+/**
+ * Energy of one analysis window given as planar channel data,
+ * aggregated over channels according to `useChannel`.
+ */
+export function windowEnergy(channelData, useChannel = "any") {
+    if (channelData.length === 1) {
+        return calculateEnergy(channelData[0]);
+    }
+    if (useChannel === "any") {
+        let maxEnergy = -Infinity;
+        for (const channel of channelData) {
+            const energy = calculateEnergy(channel);
+            if (energy > maxEnergy) {
+                maxEnergy = energy;
+            }
+        }
+        return maxEnergy;
+    }
+    if (useChannel === "mix") {
+        return calculateEnergy(mixChannels(channelData, 0, channelData[0].length));
+    }
+    const index = resolveChannelIndex(useChannel, channelData.length);
+    return calculateEnergy(channelData[index]);
+}
+/**
+ * Energy of each analysis window of `channelData`, one value per whole
+ * window of `frameSamples` samples. A final partial window, if any, is
+ * ignored. This is what automatic threshold estimation runs on; the
+ * energy formula and channel aggregation are exactly those used by the
+ * tokenizer's energy validator, so an estimated threshold means the
+ * same thing at detection time.
+ */
+export function computeFrameEnergies(channelData, frameSamples, useChannel = "any") {
+    if (!Number.isInteger(frameSamples) || frameSamples <= 0) {
+        throw new RangeError(`'frameSamples' must be a positive integer, given: ${frameSamples}`);
+    }
+    const totalSamples = channelData[0]?.length ?? 0;
+    const nFrames = Math.floor(totalSamples / frameSamples);
+    const energies = new Float64Array(nFrames);
+    for (let i = 0; i < nFrames; i++) {
+        const start = i * frameSamples;
+        const end = start + frameSamples;
+        const frame = channelData.map((channel) => channel.subarray(start, end));
+        energies[i] = windowEnergy(frame, useChannel);
+    }
+    return energies;
+}
+/** Equal-width histogram matching numpy.histogram: `bins` bins over
+ * [min, max], the last bin including its right edge. */
+function histogram(values, bins, min, max) {
+    const hist = new Float64Array(bins);
+    const edges = new Float64Array(bins + 1);
+    for (let i = 0; i <= bins; i++) {
+        edges[i] = min + ((max - min) * i) / bins;
+    }
+    const scale = bins / (max - min);
+    for (let i = 0; i < values.length; i++) {
+        let bin = Math.floor((values[i] - min) * scale);
+        if (bin >= bins) {
+            bin = bins - 1;
+        }
+        else if (bin < 0) {
+            bin = 0;
+        }
+        hist[bin] += 1;
+    }
+    return { hist, edges };
+}
+/** Otsu's method: split the energy histogram in two classes maximizing
+ * the between-class variance. Parameter-free; assumes the energy
+ * distribution is roughly bimodal (background vs. activity). */
+function estimateThresholdOtsu(energies, bins = 128) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (const e of energies) {
+        if (e < min)
+            min = e;
+        if (e > max)
+            max = e;
+    }
+    const { hist, edges } = histogram(energies, bins, min, max);
+    const centers = new Float64Array(bins);
+    for (let i = 0; i < bins; i++) {
+        centers[i] = (edges[i] + edges[i + 1]) / 2;
+    }
+    let total = 0;
+    let totalMass = 0;
+    for (let i = 0; i < bins; i++) {
+        total += hist[i];
+        totalMass += hist[i] * centers[i];
+    }
+    // between-class variance at each split point (split after bin i)
+    const betweenVar = new Float64Array(bins - 1);
+    let weight0 = 0;
+    let cumMass = 0;
+    for (let i = 0; i < bins - 1; i++) {
+        weight0 += hist[i];
+        cumMass += hist[i] * centers[i];
+        const weight1 = total - weight0;
+        if (weight0 === 0 || weight1 === 0) {
+            betweenVar[i] = -1; // matches numpy's nan_to_num(nan=-1)
+            continue;
+        }
+        const mu0 = cumMass / weight0;
+        const mu1 = (totalMass - cumMass) / weight1;
+        betweenVar[i] = weight0 * weight1 * (mu0 - mu1) ** 2;
+    }
+    let best = -Infinity;
+    for (let i = 0; i < betweenVar.length; i++) {
+        if (betweenVar[i] > best)
+            best = betweenVar[i];
+    }
+    // empty bins between the two modes make the between-class variance
+    // exactly flat over the gap; take the middle of the plateau (max
+    // margin) rather than the leftmost point
+    const candidates = [];
+    for (let i = 0; i < betweenVar.length; i++) {
+        if (betweenVar[i] === best)
+            candidates.push(i);
+    }
+    const split = candidates[(candidates.length - 1) >> 1];
+    return edges[split + 1];
+}
+/** Linear-interpolation percentile, matching numpy.percentile. */
+function percentileOf(sorted, percentile) {
+    const rank = ((sorted.length - 1) * percentile) / 100;
+    const lo = Math.floor(rank);
+    const frac = rank - lo;
+    if (lo + 1 >= sorted.length) {
+        return sorted[sorted.length - 1];
+    }
+    return sorted[lo] + frac * (sorted[lo + 1] - sorted[lo]);
+}
+/** Noise floor (low percentile of window energies) plus a margin. */
+function estimateThresholdPercentile(energies, percentile, margin) {
+    const sorted = [...energies].sort((a, b) => a - b);
+    return percentileOf(sorted, percentile) + margin;
+}
+/**
+ * Estimate an energy threshold from analysis-window energies (as
+ * returned by {@link computeFrameEnergies}). The returned value is on
+ * the same dB scale as `energyThreshold` and can be passed to `split`
+ * directly.
+ *
+ * All-zero windows carry the -200 dB silence sentinel and are excluded
+ * from the estimate; if nothing else remains the input is entirely
+ * digitally silent and the function returns `Infinity` (every window
+ * must fail validation — there is nothing to detect).
+ */
+export function estimateEnergyThreshold(frameEnergies, method = "otsu", options = {}) {
+    if (frameEnergies.length === 0) {
+        throw new RangeError("Cannot estimate an energy threshold from an empty energy array " +
+            "(input audio shorter than one analysis window?)");
+    }
+    const energies = [];
+    for (let i = 0; i < frameEnergies.length; i++) {
+        if (frameEnergies[i] > SILENCE_ENERGY) {
+            energies.push(frameEnergies[i]);
+        }
+    }
+    if (energies.length === 0) {
+        // the input is entirely digitally silent: there is no energy
+        // distribution to estimate from and nothing to detect
+        return Infinity;
+    }
+    let min = Infinity;
+    let max = -Infinity;
+    for (const e of energies) {
+        if (e < min)
+            min = e;
+        if (e > max)
+            max = e;
+    }
+    if (min === max) {
+        return min;
+    }
+    if (method === "otsu") {
+        return estimateThresholdOtsu(energies);
+    }
+    if (method === "percentile") {
+        return estimateThresholdPercentile(energies, options.percentile ?? 10, options.margin ?? 6);
+    }
+    throw new RangeError(`Unknown threshold estimation method '${method}', expected ` +
+        `"otsu" or "percentile"`);
+}

package/dist/split.d.ts

@@ -0,0 +1,121 @@
+/**
+ * High-level API: split audio into events, trim leading/trailing
+ * silence, normalize pauses. Environment-free — inputs are samples
+ * (in-memory or streamed); the io layers (Node, browser) only provide
+ * ways to obtain them.
+ */
+import { AudioRegion } from "./region.js";
+import { type ChannelSelection } from "./signal.js";
+/** One analysis window as planar per-channel samples. This is what a
+ * custom validator function receives. */
+export type AudioFrame = readonly Float32Array[];
+/** Minimal structural type for a Web Audio `AudioBuffer`. */
+export interface AudioBufferLike {
+    numberOfChannels: number;
+    sampleRate: number;
+    getChannelData(channel: number): Float32Array;
+}
+/**
+ * Audio input accepted by {@link split}, {@link trim} and
+ * {@link fixPauses}:
+ *
+ * - `Float32Array`: mono samples (requires `sampleRate` in options);
+ * - `Float32Array[]`: planar channels of equal length (requires
+ *   `sampleRate`);
+ * - {@link AudioRegion} or any `{ channelData, sampleRate }` object;
+ * - a Web Audio `AudioBuffer`;
+ * - a sync or async iterable of `Float32Array` chunks of *interleaved*
+ *   samples (requires `sampleRate`; `channels` defaults to 1). This is
+ *   the streaming path: events are yielded while the input is still
+ *   being read.
+ */
+export type AudioInput = Float32Array | Float32Array[] | AudioRegion | {
+    channelData: readonly Float32Array[];
+    sampleRate: number;
+} | AudioBufferLike | Iterable<Float32Array> | AsyncIterable<Float32Array>;
+export interface SplitOptions {
+    /** Sample rate in Hz. Required when the input does not carry its
+     * own (bare samples or chunk streams). */
+    sampleRate?: number;
+    /** Number of interleaved channels for chunk-stream input, default 1.
+     * Ignored for in-memory input, which is planar. */
+    channels?: number;
+    /** Minimum duration in seconds of a detected event, default 0.2. */
+    minDur?: number;
+    /** Maximum duration in seconds of an event, default 5; longer events
+     * are truncated. `null` or `Infinity` disables the limit. */
+    maxDur?: number | null;
+    /** Maximum duration of continuous silence allowed *within* an event,
+     * default 0.3. Controls when an event ends. */
+    maxSilence?: number;
+    /** Silence in seconds to retain before each event (natural attack),
+     * default 0. */
+    maxLeadingSilence?: number;
+    /** Trailing silence in seconds to keep at the end of each event.
+     * `null` (default) keeps all trailing silence up to `maxSilence`;
+     * `0` drops it; a value larger than `maxSilence` keeps collecting
+     * past the event boundary (natural fadeout). */
+    maxTrailingSilence?: number | null;
+    /** Reject events shorter than `minDur` even when contiguous with a
+     * truncated event, default false. */
+    strictMinDur?: boolean;
+    /** Duration in seconds of the analysis window, default 0.05. */
+    analysisWindow?: number;
+    /** Energy threshold in dB for detection, default 50. Used when no
+     * `validator` is given. Same scale as Python auditok: dB relative to
+     * int16 full scale. */
+    energyThreshold?: number;
+    /**
+     * Frame validation strategy; if set, it is the whole story and
+     * `energyThreshold` is overlooked. A string selects automatic
+     * threshold estimation: `"otsu"`, `"percentile"` (alias of `"p10"`)
+     * or `"pXX"` (noise floor read at the XXth percentile of window
+     * energies, plus a 6 dB margin). For in-memory input the threshold
+     * is estimated from the whole input before detection starts; for
+     * chunk-stream input it is calibrated on the first `calibrationDur`
+     * seconds (clamped to `minEnergyThreshold`), and the calibration
+     * audio is replayed so no data is lost. A function is called with
+     * each analysis window (planar per-channel samples) and returns
+     * whether the window is valid.
+     */
+    validator?: string | ((frame: AudioFrame) => boolean);
+    /** Duration in seconds of chunk-stream audio used to calibrate the
+     * threshold when `validator` is an estimation string, default 3.
+     * Ignored for in-memory input, which is estimated as a whole. */
+    calibrationDur?: number;
+    /** Lower bound in dB for a threshold calibrated on a chunk stream,
+     * default 40. Guards against a too-quiet calibration window; also
+     * used as the threshold when the calibration audio is digitally
+     * silent (e.g., a muted microphone), so detection keeps running. */
+    minEnergyThreshold?: number;
+    /** Channel used for energy computation on multichannel audio:
+     * `"any"` (default, maximum over channels), `"mix"` or a channel
+     * index. */
+    useChannel?: ChannelSelection;
+}
+/**
+ * Split audio into events. Returns an async generator of
+ * {@link AudioRegion} objects, yielded as soon as each event's end is
+ * decided — for chunk-stream input, while the input is still being
+ * read.
+ */
+export declare function split(input: AudioInput, options?: SplitOptions): AsyncGenerator<AudioRegion, void, void>;
+/** Like {@link split}, but collects all events into an array. */
+export declare function splitAll(input: AudioInput, options?: SplitOptions): Promise<AudioRegion[]>;
+type TrimFixPausesOptions = Omit<SplitOptions, "maxDur" | "strictMinDur">;
+/**
+ * Detect audio activity in `input` and return the audio between the
+ * start of the first detection and the end of the last, removing
+ * leading and trailing silence. Chunk-stream input is read once and
+ * recorded as it is consumed. Returns an empty region (zero duration)
+ * if no activity is detected.
+ */
+export declare function trim(input: AudioInput, options?: TrimFixPausesOptions): Promise<AudioRegion>;
+/**
+ * Normalize pauses: detect events (never truncated) and join them
+ * with exactly `silenceDuration` seconds of silence between them.
+ * Events shorter than `minDur` are discarded. Returns an empty region
+ * (zero duration) if no events are detected.
+ */
+export declare function fixPauses(input: AudioInput, silenceDuration: number, options?: TrimFixPausesOptions): Promise<AudioRegion>;
+export {};