4e:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 4f:T1495,import { createCsvNormalizer, padRowsToColumnCount, type CsvNormalizer, } from "./csv-normalizer"; import { createCsvParser } from "./csv-parser"; export { DEFAULT_CSV_DIALECT, extensionOfDelimitedName, inferCsvDialect, isTabDelimited, normalizeCsvDelimiter, resolveCsvDialect, type CsvDialect, type CsvDialectDescriptor, } from "./csv-dialect"; export { createCsvNormalizer, padRowsToColumnCount, type CsvNormalizer, type CsvNormalizerOptions, type CsvTable, type CsvTableEvent, } from "./csv-normalizer"; export { createCsvParser, type CsvParser, type CsvParserOptions, } from "./csv-parser"; export interface ParsedCsv { columns: string[]; rows: string[][]; } export interface ParseCsvOptions { /** Field delimiter. Defaults to ",". */ delimiter?: string; /** Treat the first record as a header row. Defaults to true. */ hasHeader?: boolean; } export function parseCsv( input: string, options: ParseCsvOptions = {}, ): ParsedCsv { const parser = createCsvParser({ delimiter: options.delimiter }); const normalizer = createCsvNormalizer({ hasHeader: options.hasHeader }); const rows: string[][] = []; let columns: string[] = []; handleCsvRecords(parser.push(input), normalizer, rows, (nextColumns) => { columns = nextColumns; padRowsToColumnCount(rows, columns.length); }); handleCsvRecords(parser.flush(), normalizer, rows, (nextColumns) => { columns = nextColumns; padRowsToColumnCount(rows, columns.length); }); return { columns, rows }; } function handleCsvRecords( records: string[][], normalizer: CsvNormalizer, rows: string[][], onColumns: (columns: string[]) => void, ) { for (const record of records) { for (const event of normalizer.accept(record)) { if (event.type === "columns") { onColumns(event.columns); } else { rows.push(event.row); } } } } /** Pad a record to a fixed width. */ export function fitRow(row: string[], width: number): string[] { if (row.length === width) return row; if (row.length < width) return [...row, ...Array(width - row.length).fill("")]; return row; } export interface CsvStreamHandlers { onColumns: (columns: string[]) => void; onRows: (rows: string[][]) => void; onDone?: () => void; onError?: (error: unknown) => void; } export interface CsvStreamOptions extends ParseCsvOptions { /** Rows per batch handed to `onRows`. Defaults to 2000. */ batchSize?: number; signal?: AbortSignal; } export type CsvStreamSource = | Blob | string | ReadableStream | AsyncIterable; export async function streamCsv( source: CsvStreamSource, handlers: CsvStreamHandlers, options: CsvStreamOptions = {}, ): Promise { const batchSize = options.batchSize ?? 2000; const signal = options.signal; const parser = createCsvParser({ delimiter: options.delimiter }); const normalizer = createCsvNormalizer({ hasHeader: options.hasHeader }); let batch: string[][] = []; const handleRecords = (records: string[][]) => { for (const record of records) { for (const event of normalizer.accept(record)) { if (event.type === "columns") { handlers.onColumns(event.columns); padRowsToColumnCount(batch, event.columns.length); } else { batch.push(event.row); } } if (batch.length >= batchSize) { handlers.onRows(batch); batch = []; } } }; try { let lastYield = performance.now(); for await (const chunk of readTextChunks(source)) { if (signal?.aborted) return; handleRecords(parser.push(chunk)); if (performance.now() - lastYield > 12) { await new Promise((resolve) => setTimeout(resolve)); lastYield = performance.now(); } } if (signal?.aborted) return; handleRecords(parser.flush()); if (batch.length) handlers.onRows(batch); handlers.onDone?.(); } catch (error) { handlers.onError?.(error); } } async function* readTextChunks( source: CsvStreamSource, ): AsyncGenerator { if (typeof source === "string") { const size = 1 << 20; for (let offset = 0; offset < source.length; offset += size) { yield source.slice(offset, offset + size); } return; } if ( typeof ReadableStream !== "undefined" && source instanceof ReadableStream ) { yield* decodeByteStream(source); return; } if (Symbol.asyncIterator in Object(source)) { for await (const chunk of source as AsyncIterable) yield chunk; return; } const blob = source as Blob; if (typeof blob.stream === "function") { yield* decodeByteStream(blob.stream()); return; } yield await blob.text(); } async function* decodeByteStream( stream: ReadableStream, ): AsyncGenerator { const reader = stream.getReader(); const decoder = new TextDecoder(); try { while (true) { const { done, value } = await reader.read(); if (done) break; if (value) { const text = decoder.decode(value, { stream: true }); if (text) yield text; } } const rest = decoder.decode(); if (rest) yield rest; } finally { reader.releaseLock(); } } 50:Ta7a,export interface CsvParser { /** Feed a chunk of text; returns any records completed by it. */ push(text: string): string[][]; /** Emit the trailing record (call once at end of input). */ flush(): string[][]; } export interface CsvParserOptions { /** Field delimiter. Defaults to ",". */ delimiter?: string; } /** * Incremental CSV parser. Written in a deliberately plain, closure-free style * so it can run in both the main thread and a worker without adaptation. */ export function createCsvParser(options?: CsvParserOptions): CsvParser { var delimiter = (options && options.delimiter) || ","; var record: string[] = []; var field = ""; var inQuotes = false; var pendingQuote = false; var pendingCR = false; var fieldStarted = false; var sawFirstChar = false; function push(text: string): string[][] { var out: string[][] = []; for (var i = 0; i < text.length; i++) { var c = text.charAt(i); if (!sawFirstChar) { sawFirstChar = true; if (c === "\uFEFF") continue; } if (pendingCR) { pendingCR = false; record.push(field); field = ""; out.push(record); record = []; fieldStarted = false; if (c === "\n") continue; } if (pendingQuote) { pendingQuote = false; if (c === '"') { field += '"'; fieldStarted = true; continue; } inQuotes = false; } if (inQuotes) { if (c === '"') pendingQuote = true; else field += c; continue; } if (c === '"' && !fieldStarted) { inQuotes = true; fieldStarted = true; } else if (c === delimiter) { record.push(field); field = ""; fieldStarted = false; } else if (c === "\r") { pendingCR = true; } else if (c === "\n") { record.push(field); field = ""; out.push(record); record = []; fieldStarted = false; } else { field += c; fieldStarted = true; } } return out; } function flush(): string[][] { var out: string[][] = []; if (pendingQuote) { pendingQuote = false; inQuotes = false; } if (pendingCR) { pendingCR = false; record.push(field); field = ""; out.push(record); record = []; fieldStarted = false; return out; } if (field.length > 0 || record.length > 0 || fieldStarted) { record.push(field); field = ""; out.push(record); record = []; fieldStarted = false; } return out; } return { push: push, flush: flush }; } 51:T89b,export interface CsvTable { columns: string[]; rows: string[][]; } export interface CsvNormalizerOptions { /** Treat the first record as a header row. Defaults to true. */ hasHeader?: boolean; } export type CsvTableEvent = | { type: "columns"; columns: string[] } | { type: "row"; row: string[] }; export interface CsvNormalizer { accept(record: string[]): CsvTableEvent[]; getColumns(): string[]; } export function createCsvNormalizer( options?: CsvNormalizerOptions, ): CsvNormalizer { var hasHeader = !options || options.hasHeader !== false; var columns: string[] | null = null; var width = 0; var sawFirstRecord = false; function makeColumnName(index: number): string { return "Column " + (index + 1); } function copyAndPad(row: string[], nextWidth: number): string[] { var out = row.slice(); while (out.length < nextWidth) out.push(""); return out; } function growColumns(nextWidth: number): CsvTableEvent[] { if (!columns || nextWidth <= width) return []; var next = columns.slice(); for (var i = width; i < nextWidth; i++) { next.push(hasHeader ? "" : makeColumnName(i)); } columns = next; width = nextWidth; return [{ type: "columns", columns: next.slice() }]; } function accept(record: string[]): CsvTableEvent[] { if (!sawFirstRecord) { sawFirstRecord = true; width = record.length; if (hasHeader) { columns = record.slice(); return [{ type: "columns", columns: columns.slice() }]; } columns = []; for (var i = 0; i < width; i++) columns.push(makeColumnName(i)); return [ { type: "columns", columns: columns.slice() }, { type: "row", row: copyAndPad(record, width) }, ]; } return growColumns(record.length).concat({ type: "row", row: copyAndPad(record, width), }); } function getColumns(): string[] { return columns ? columns.slice() : []; } return { accept: accept, getColumns: getColumns }; } export function padRowsToColumnCount( rows: string[][], columnCount: number, ): void { for (const row of rows) { while (row.length < columnCount) row.push(""); } } 52:Ta8b,export interface CsvDialect { delimiter: string; hasHeader: boolean; } export interface CsvDialectDescriptor { src?: string; fileName?: string; mimeType?: string; } export const DEFAULT_CSV_DIALECT: CsvDialect = { delimiter: ",", hasHeader: true, }; export function normalizeCsvDelimiter( delimiter: string | undefined, ): string | undefined { return delimiter === "\\t" ? "\t" : delimiter; } /** * Normalizes a delimiter and discards values the parser cannot honor. A CSV * delimiter must be exactly one character: the incremental parser matches a * field separator one character at a time (`c === delimiter`), so an empty * delimiter makes it fall back to a comma (`delimiter || ","`) while a * multi-character delimiter (e.g. `"::"`) never matches at all and collapses * every row into a single field. In both cases the exporter would still join * with the unusable delimiter, producing output the parser cannot read back. * Callers must never let either through, so anything other than a single * character is discarded here and resolution falls back to the inferred dialect. */ function usableDelimiter(delimiter: string | undefined): string | undefined { const normalized = normalizeCsvDelimiter(delimiter); return normalized && normalized.length === 1 ? normalized : undefined; } export function extensionOfDelimitedName(name: string): string | null { const clean = name.split(/[?#]/)[0]; const base = clean.split("/").pop() ?? clean; const dot = base.lastIndexOf("."); return dot > 0 ? base.slice(dot + 1).toLowerCase() : null; } export function inferCsvDialect({ src, fileName, mimeType, }: CsvDialectDescriptor): CsvDialect { const name = fileName ?? src ?? ""; const ext = extensionOfDelimitedName(name); if (ext === "tsv") return { delimiter: "\t", hasHeader: true }; if (ext === "csv") return DEFAULT_CSV_DIALECT; const normalizedMime = mimeType?.toLowerCase().split(";")[0].trim(); if (normalizedMime === "text/tab-separated-values") { return { delimiter: "\t", hasHeader: true }; } return DEFAULT_CSV_DIALECT; } export function resolveCsvDialect({ dialect, delimiter, hasHeader, descriptor, }: { dialect?: CsvDialect; delimiter?: string; hasHeader?: boolean; descriptor: CsvDialectDescriptor; }): CsvDialect { const inferred = dialect ?? inferCsvDialect(descriptor); return { delimiter: usableDelimiter(delimiter) ?? usableDelimiter(inferred.delimiter) ?? DEFAULT_CSV_DIALECT.delimiter, hasHeader: hasHeader ?? inferred.hasHeader, }; } export function isTabDelimited(dialect: CsvDialect): boolean { return normalizeCsvDelimiter(dialect.delimiter) === "\t"; } 4d:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[null,["$","$L4e",null,{"files":[{"path":"registry/new-york-v4/lib/csv.ts","content":"$4f","type":"registry:lib","target":"@lib/csv.ts"},{"path":"registry/new-york-v4/lib/csv-parser.ts","content":"$50","type":"registry:lib","target":"@lib/csv-parser.ts"},{"path":"registry/new-york-v4/lib/csv-normalizer.ts","content":"$51","type":"registry:lib","target":"@lib/csv-normalizer.ts"},{"path":"registry/new-york-v4/lib/csv-dialect.ts","content":"$52","type":"registry:lib","target":"@lib/csv-dialect.ts"}],"className":"h-[70svh] min-h-80"}]]}]