first commit

node_modules/@fast-csv/parse/build/src/CsvParserStream.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { Transform, TransformCallback } from 'stream';
+import { ParserOptions } from './ParserOptions';
+import { Row, RowTransformFunction, RowValidate } from './types';
+export declare class CsvParserStream<I extends Row, O extends Row> extends Transform {
+    private readonly parserOptions;
+    private readonly decoder;
+    private readonly parser;
+    private readonly headerTransformer;
+    private readonly rowTransformerValidator;
+    private lines;
+    private rowCount;
+    private parsedRowCount;
+    private parsedLineCount;
+    private endEmitted;
+    private headersEmitted;
+    constructor(parserOptions: ParserOptions);
+    private get hasHitRowLimit();
+    private get shouldEmitRows();
+    private get shouldSkipLine();
+    transform(transformFunction: RowTransformFunction<I, O>): CsvParserStream<I, O>;
+    validate(validateFunction: RowValidate<O>): CsvParserStream<I, O>;
+    emit(event: string | symbol, ...rest: any[]): boolean;
+    _transform(data: Buffer, encoding: string, done: TransformCallback): void;
+    _flush(done: TransformCallback): void;
+    private parse;
+    private processRows;
+    private transformRow;
+    private checkAndEmitHeaders;
+    private skipRow;
+    private pushRow;
+    private static wrapDoneCallback;
+}

node_modules/@fast-csv/parse/build/src/CsvParserStream.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CsvParserStream = void 0;
+const string_decoder_1 = require("string_decoder");
+const stream_1 = require("stream");
+const transforms_1 = require("./transforms");
+const parser_1 = require("./parser");
+class CsvParserStream extends stream_1.Transform {
+    constructor(parserOptions) {
+        super({ objectMode: parserOptions.objectMode });
+        this.lines = '';
+        this.rowCount = 0;
+        this.parsedRowCount = 0;
+        this.parsedLineCount = 0;
+        this.endEmitted = false;
+        this.headersEmitted = false;
+        this.parserOptions = parserOptions;
+        this.parser = new parser_1.Parser(parserOptions);
+        this.headerTransformer = new transforms_1.HeaderTransformer(parserOptions);
+        this.decoder = new string_decoder_1.StringDecoder(parserOptions.encoding);
+        this.rowTransformerValidator = new transforms_1.RowTransformerValidator();
+    }
+    get hasHitRowLimit() {
+        return this.parserOptions.limitRows && this.rowCount >= this.parserOptions.maxRows;
+    }
+    get shouldEmitRows() {
+        return this.parsedRowCount > this.parserOptions.skipRows;
+    }
+    get shouldSkipLine() {
+        return this.parsedLineCount <= this.parserOptions.skipLines;
+    }
+    transform(transformFunction) {
+        this.rowTransformerValidator.rowTransform = transformFunction;
+        return this;
+    }
+    validate(validateFunction) {
+        this.rowTransformerValidator.rowValidator = validateFunction;
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    emit(event, ...rest) {
+        if (event === 'end') {
+            if (!this.endEmitted) {
+                this.endEmitted = true;
+                super.emit('end', this.rowCount);
+            }
+            return false;
+        }
+        return super.emit(event, ...rest);
+    }
+    _transform(data, encoding, done) {
+        // if we have hit our maxRows parsing limit then skip parsing
+        if (this.hasHitRowLimit) {
+            return done();
+        }
+        const wrappedCallback = CsvParserStream.wrapDoneCallback(done);
+        try {
+            const { lines } = this;
+            const newLine = lines + this.decoder.write(data);
+            const rows = this.parse(newLine, true);
+            return this.processRows(rows, wrappedCallback);
+        }
+        catch (e) {
+            return wrappedCallback(e);
+        }
+    }
+    _flush(done) {
+        const wrappedCallback = CsvParserStream.wrapDoneCallback(done);
+        // if we have hit our maxRows parsing limit then skip parsing
+        if (this.hasHitRowLimit) {
+            return wrappedCallback();
+        }
+        try {
+            const newLine = this.lines + this.decoder.end();
+            const rows = this.parse(newLine, false);
+            return this.processRows(rows, wrappedCallback);
+        }
+        catch (e) {
+            return wrappedCallback(e);
+        }
+    }
+    parse(data, hasMoreData) {
+        if (!data) {
+            return [];
+        }
+        const { line, rows } = this.parser.parse(data, hasMoreData);
+        this.lines = line;
+        return rows;
+    }
+    processRows(rows, cb) {
+        const rowsLength = rows.length;
+        const iterate = (i) => {
+            const callNext = (err) => {
+                if (err) {
+                    return cb(err);
+                }
+                if (i % 100 === 0) {
+                    // incase the transform are sync insert a next tick to prevent stack overflow
+                    setImmediate(() => iterate(i + 1));
+                    return undefined;
+                }
+                return iterate(i + 1);
+            };
+            this.checkAndEmitHeaders();
+            // if we have emitted all rows or we have hit the maxRows limit option
+            // then end
+            if (i >= rowsLength || this.hasHitRowLimit) {
+                return cb();
+            }
+            this.parsedLineCount += 1;
+            if (this.shouldSkipLine) {
+                return callNext();
+            }
+            const row = rows[i];
+            this.rowCount += 1;
+            this.parsedRowCount += 1;
+            const nextRowCount = this.rowCount;
+            return this.transformRow(row, (err, transformResult) => {
+                if (err) {
+                    this.rowCount -= 1;
+                    return callNext(err);
+                }
+                if (!transformResult) {
+                    return callNext(new Error('expected transform result'));
+                }
+                if (!transformResult.isValid) {
+                    this.emit('data-invalid', transformResult.row, nextRowCount, transformResult.reason);
+                }
+                else if (transformResult.row) {
+                    return this.pushRow(transformResult.row, callNext);
+                }
+                return callNext();
+            });
+        };
+        iterate(0);
+    }
+    transformRow(parsedRow, cb) {
+        try {
+            this.headerTransformer.transform(parsedRow, (err, withHeaders) => {
+                if (err) {
+                    return cb(err);
+                }
+                if (!withHeaders) {
+                    return cb(new Error('Expected result from header transform'));
+                }
+                if (!withHeaders.isValid) {
+                    if (this.shouldEmitRows) {
+                        return cb(null, { isValid: false, row: parsedRow });
+                    }
+                    // skipped because of skipRows option remove from total row count
+                    return this.skipRow(cb);
+                }
+                if (withHeaders.row) {
+                    if (this.shouldEmitRows) {
+                        return this.rowTransformerValidator.transformAndValidate(withHeaders.row, cb);
+                    }
+                    // skipped because of skipRows option remove from total row count
+                    return this.skipRow(cb);
+                }
+                // this is a header row dont include in the rowCount or parsedRowCount
+                this.rowCount -= 1;
+                this.parsedRowCount -= 1;
+                return cb(null, { row: null, isValid: true });
+            });
+        }
+        catch (e) {
+            cb(e);
+        }
+    }
+    checkAndEmitHeaders() {
+        if (!this.headersEmitted && this.headerTransformer.headers) {
+            this.headersEmitted = true;
+            this.emit('headers', this.headerTransformer.headers);
+        }
+    }
+    skipRow(cb) {
+        // skipped because of skipRows option remove from total row count
+        this.rowCount -= 1;
+        return cb(null, { row: null, isValid: true });
+    }
+    pushRow(row, cb) {
+        try {
+            if (!this.parserOptions.objectMode) {
+                this.push(JSON.stringify(row));
+            }
+            else {
+                this.push(row);
+            }
+            cb();
+        }
+        catch (e) {
+            cb(e);
+        }
+    }
+    static wrapDoneCallback(done) {
+        let errorCalled = false;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (err, ...args) => {
+            if (err) {
+                if (errorCalled) {
+                    throw err;
+                }
+                errorCalled = true;
+                done(err);
+                return;
+            }
+            done(...args);
+        };
+    }
+}
+exports.CsvParserStream = CsvParserStream;
+//# sourceMappingURL=CsvParserStream.js.map

node_modules/@fast-csv/parse/build/src/ParserOptions.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import { HeaderArray, HeaderTransformFunction } from './types';
+export interface ParserOptionsArgs {
+    objectMode?: boolean;
+    delimiter?: string;
+    quote?: string | null;
+    escape?: string;
+    headers?: boolean | HeaderTransformFunction | HeaderArray;
+    renameHeaders?: boolean;
+    ignoreEmpty?: boolean;
+    comment?: string;
+    strictColumnHandling?: boolean;
+    discardUnmappedColumns?: boolean;
+    trim?: boolean;
+    ltrim?: boolean;
+    rtrim?: boolean;
+    encoding?: string;
+    maxRows?: number;
+    skipLines?: number;
+    skipRows?: number;
+}
+export declare class ParserOptions {
+    readonly escapedDelimiter: string;
+    readonly objectMode: boolean;
+    readonly delimiter: string;
+    readonly ignoreEmpty: boolean;
+    readonly quote: string | null;
+    readonly escape: string | null;
+    readonly escapeChar: string | null;
+    readonly comment: string | null;
+    readonly supportsComments: boolean;
+    readonly ltrim: boolean;
+    readonly rtrim: boolean;
+    readonly trim: boolean;
+    readonly headers: boolean | HeaderTransformFunction | HeaderArray | null;
+    readonly renameHeaders: boolean;
+    readonly strictColumnHandling: boolean;
+    readonly discardUnmappedColumns: boolean;
+    readonly carriageReturn: string;
+    readonly NEXT_TOKEN_REGEXP: RegExp;
+    readonly encoding: BufferEncoding;
+    readonly limitRows: boolean;
+    readonly maxRows: number;
+    readonly skipLines: number;
+    readonly skipRows: number;
+    constructor(opts?: ParserOptionsArgs);
+}

node_modules/@fast-csv/parse/build/src/ParserOptions.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserOptions = void 0;
+const lodash_escaperegexp_1 = __importDefault(require("lodash.escaperegexp"));
+const lodash_isnil_1 = __importDefault(require("lodash.isnil"));
+class ParserOptions {
+    constructor(opts) {
+        var _a;
+        this.objectMode = true;
+        this.delimiter = ',';
+        this.ignoreEmpty = false;
+        this.quote = '"';
+        this.escape = null;
+        this.escapeChar = this.quote;
+        this.comment = null;
+        this.supportsComments = false;
+        this.ltrim = false;
+        this.rtrim = false;
+        this.trim = false;
+        this.headers = null;
+        this.renameHeaders = false;
+        this.strictColumnHandling = false;
+        this.discardUnmappedColumns = false;
+        this.carriageReturn = '\r';
+        this.encoding = 'utf8';
+        this.limitRows = false;
+        this.maxRows = 0;
+        this.skipLines = 0;
+        this.skipRows = 0;
+        Object.assign(this, opts || {});
+        if (this.delimiter.length > 1) {
+            throw new Error('delimiter option must be one character long');
+        }
+        this.escapedDelimiter = lodash_escaperegexp_1.default(this.delimiter);
+        this.escapeChar = (_a = this.escape) !== null && _a !== void 0 ? _a : this.quote;
+        this.supportsComments = !lodash_isnil_1.default(this.comment);
+        this.NEXT_TOKEN_REGEXP = new RegExp(`([^\\s]|\\r\\n|\\n|\\r|${this.escapedDelimiter})`);
+        if (this.maxRows > 0) {
+            this.limitRows = true;
+        }
+    }
+}
+exports.ParserOptions = ParserOptions;
+//# sourceMappingURL=ParserOptions.js.map

node_modules/@fast-csv/parse/build/src/ParserOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParserOptions.js","sourceRoot":"","sources":["../../src/ParserOptions.ts"],"names":[],"mappings":";;;;;;AAAA,8EAA+C;AAC/C,gEAAiC;AAuBjC,MAAa,aAAa;IA+CtB,YAAmB,IAAwB;;QA5C3B,eAAU,GAAY,IAAI,CAAC;QAE3B,cAAS,GAAW,GAAG,CAAC;QAExB,gBAAW,GAAY,KAAK,CAAC;QAE7B,UAAK,GAAkB,GAAG,CAAC;QAE3B,WAAM,GAAkB,IAAI,CAAC;QAE7B,eAAU,GAAkB,IAAI,CAAC,KAAK,CAAC;QAEvC,YAAO,GAAkB,IAAI,CAAC;QAE9B,qBAAgB,GAAY,KAAK,CAAC;QAElC,UAAK,GAAY,KAAK,CAAC;QAEvB,UAAK,GAAY,KAAK,CAAC;QAEvB,SAAI,GAAY,KAAK,CAAC;QAEtB,YAAO,GAA2D,IAAI,CAAC;QAEvE,kBAAa,GAAY,KAAK,CAAC;QAE/B,yBAAoB,GAAY,KAAK,CAAC;QAEtC,2BAAsB,GAAY,KAAK,CAAC;QAExC,mBAAc,GAAW,IAAI,CAAC;QAI9B,aAAQ,GAAmB,MAAM,CAAC;QAElC,cAAS,GAAY,KAAK,CAAC;QAE3B,YAAO,GAAW,CAAC,CAAC;QAEpB,cAAS,GAAW,CAAC,CAAC;QAEtB,aAAQ,GAAW,CAAC,CAAC;QAGjC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;QAChC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;SAClE;QACD,IAAI,CAAC,gBAAgB,GAAG,6BAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACrD,IAAI,CAAC,UAAU,SAAG,IAAI,CAAC,MAAM,mCAAI,IAAI,CAAC,KAAK,CAAC;QAC5C,IAAI,CAAC,gBAAgB,GAAG,CAAC,sBAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7C,IAAI,CAAC,iBAAiB,GAAG,IAAI,MAAM,CAAC,0BAA0B,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;QAExF,IAAI,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE;YAClB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;SACzB;IACL,CAAC;CACJ;AA7DD,sCA6DC"}

node_modules/@fast-csv/parse/build/src/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { ParserOptionsArgs } from './ParserOptions';
+import { CsvParserStream } from './CsvParserStream';
+import { Row } from './types';
+export * from './types';
+export { CsvParserStream } from './CsvParserStream';
+export { ParserOptions, ParserOptionsArgs } from './ParserOptions';
+export declare const parse: <I extends Row<any>, O extends Row<any>>(args?: ParserOptionsArgs | undefined) => CsvParserStream<I, O>;
+export declare const parseStream: <I extends Row<any>, O extends Row<any>>(stream: NodeJS.ReadableStream, options?: ParserOptionsArgs | undefined) => CsvParserStream<I, O>;
+export declare const parseFile: <I extends Row<any>, O extends Row<any>>(location: string, options?: ParserOptionsArgs) => CsvParserStream<I, O>;
+export declare const parseString: <I extends Row<any>, O extends Row<any>>(string: string, options?: ParserOptionsArgs | undefined) => CsvParserStream<I, O>;

node_modules/@fast-csv/parse/build/src/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseString = exports.parseFile = exports.parseStream = exports.parse = exports.ParserOptions = exports.CsvParserStream = void 0;
+const fs = __importStar(require("fs"));
+const stream_1 = require("stream");
+const ParserOptions_1 = require("./ParserOptions");
+const CsvParserStream_1 = require("./CsvParserStream");
+__exportStar(require("./types"), exports);
+var CsvParserStream_2 = require("./CsvParserStream");
+Object.defineProperty(exports, "CsvParserStream", { enumerable: true, get: function () { return CsvParserStream_2.CsvParserStream; } });
+var ParserOptions_2 = require("./ParserOptions");
+Object.defineProperty(exports, "ParserOptions", { enumerable: true, get: function () { return ParserOptions_2.ParserOptions; } });
+exports.parse = (args) => new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(args));
+exports.parseStream = (stream, options) => stream.pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
+exports.parseFile = (location, options = {}) => fs.createReadStream(location).pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
+exports.parseString = (string, options) => {
+    const rs = new stream_1.Readable();
+    rs.push(string);
+    rs.push(null);
+    return rs.pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
+};
+//# sourceMappingURL=index.js.map

node_modules/@fast-csv/parse/build/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAyB;AACzB,mCAAkC;AAClC,mDAAmE;AACnE,uDAAoD;AAGpD,0CAAwB;AACxB,qDAAoD;AAA3C,kHAAA,eAAe,OAAA;AACxB,iDAAmE;AAA1D,8GAAA,aAAa,OAAA;AAET,QAAA,KAAK,GAAG,CAA+B,IAAwB,EAAyB,EAAE,CACnG,IAAI,iCAAe,CAAC,IAAI,6BAAa,CAAC,IAAI,CAAC,CAAC,CAAC;AAEpC,QAAA,WAAW,GAAG,CACvB,MAA6B,EAC7B,OAA2B,EACN,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,iCAAe,CAAC,IAAI,6BAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAE5E,QAAA,SAAS,GAAG,CACrB,QAAgB,EAChB,UAA6B,EAAE,EACV,EAAE,CAAC,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,iCAAe,CAAC,IAAI,6BAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAEnG,QAAA,WAAW,GAAG,CACvB,MAAc,EACd,OAA2B,EACN,EAAE;IACvB,MAAM,EAAE,GAAG,IAAI,iBAAQ,EAAE,CAAC;IAC1B,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,OAAO,EAAE,CAAC,IAAI,CAAC,IAAI,iCAAe,CAAC,IAAI,6BAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACpE,CAAC,CAAC"}

node_modules/@fast-csv/parse/build/src/parser/Parser.d.ts

@@ -0,0 +1,15 @@
+import { ParserOptions } from '../ParserOptions';
+export interface ParseResult {
+    line: string;
+    rows: string[][];
+}
+export declare class Parser {
+    private static removeBOM;
+    private readonly parserOptions;
+    private readonly rowParser;
+    constructor(parserOptions: ParserOptions);
+    parse(line: string, hasMoreData: boolean): ParseResult;
+    private parseWithoutComments;
+    private parseWithComments;
+    private parseRow;
+}

node_modules/@fast-csv/parse/build/src/parser/Parser.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const Scanner_1 = require("./Scanner");
+const RowParser_1 = require("./RowParser");
+const Token_1 = require("./Token");
+class Parser {
+    constructor(parserOptions) {
+        this.parserOptions = parserOptions;
+        this.rowParser = new RowParser_1.RowParser(this.parserOptions);
+    }
+    static removeBOM(line) {
+        // Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+        // conversion translates it to FEFF (UTF-16 BOM)
+        if (line && line.charCodeAt(0) === 0xfeff) {
+            return line.slice(1);
+        }
+        return line;
+    }
+    parse(line, hasMoreData) {
+        const scanner = new Scanner_1.Scanner({
+            line: Parser.removeBOM(line),
+            parserOptions: this.parserOptions,
+            hasMoreData,
+        });
+        if (this.parserOptions.supportsComments) {
+            return this.parseWithComments(scanner);
+        }
+        return this.parseWithoutComments(scanner);
+    }
+    parseWithoutComments(scanner) {
+        const rows = [];
+        let shouldContinue = true;
+        while (shouldContinue) {
+            shouldContinue = this.parseRow(scanner, rows);
+        }
+        return { line: scanner.line, rows };
+    }
+    parseWithComments(scanner) {
+        const { parserOptions } = this;
+        const rows = [];
+        for (let nextToken = scanner.nextCharacterToken; nextToken !== null; nextToken = scanner.nextCharacterToken) {
+            if (Token_1.Token.isTokenComment(nextToken, parserOptions)) {
+                const cursor = scanner.advancePastLine();
+                if (cursor === null) {
+                    return { line: scanner.lineFromCursor, rows };
+                }
+                if (!scanner.hasMoreCharacters) {
+                    return { line: scanner.lineFromCursor, rows };
+                }
+                scanner.truncateToCursor();
+            }
+            else if (!this.parseRow(scanner, rows)) {
+                break;
+            }
+        }
+        return { line: scanner.line, rows };
+    }
+    parseRow(scanner, rows) {
+        const nextToken = scanner.nextNonSpaceToken;
+        if (!nextToken) {
+            return false;
+        }
+        const row = this.rowParser.parse(scanner);
+        if (row === null) {
+            return false;
+        }
+        if (this.parserOptions.ignoreEmpty && RowParser_1.RowParser.isEmptyRow(row)) {
+            return true;
+        }
+        rows.push(row);
+        return true;
+    }
+}
+exports.Parser = Parser;
+//# sourceMappingURL=Parser.js.map

node_modules/@fast-csv/parse/build/src/parser/Parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parser.js","sourceRoot":"","sources":["../../../src/parser/Parser.ts"],"names":[],"mappings":"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"}

node_modules/@fast-csv/parse/build/src/parser/RowParser.d.ts

@@ -0,0 +1,12 @@
+import { Scanner } from './Scanner';
+import { ParserOptions } from '../ParserOptions';
+import { RowArray } from '../types';
+export declare class RowParser {
+    static isEmptyRow(row: RowArray): boolean;
+    private readonly parserOptions;
+    private readonly columnParser;
+    constructor(parserOptions: ParserOptions);
+    parse(scanner: Scanner): RowArray | null;
+    private getStartToken;
+    private shouldSkipColumnParse;
+}

node_modules/@fast-csv/parse/build/src/parser/RowParser.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowParser = void 0;
+const column_1 = require("./column");
+const Token_1 = require("./Token");
+const EMPTY_STRING = '';
+class RowParser {
+    constructor(parserOptions) {
+        this.parserOptions = parserOptions;
+        this.columnParser = new column_1.ColumnParser(parserOptions);
+    }
+    static isEmptyRow(row) {
+        return row.join(EMPTY_STRING).replace(/\s+/g, EMPTY_STRING) === EMPTY_STRING;
+    }
+    parse(scanner) {
+        const { parserOptions } = this;
+        const { hasMoreData } = scanner;
+        const currentScanner = scanner;
+        const columns = [];
+        let currentToken = this.getStartToken(currentScanner, columns);
+        while (currentToken) {
+            if (Token_1.Token.isTokenRowDelimiter(currentToken)) {
+                currentScanner.advancePastToken(currentToken);
+                // if ends with CR and there is more data, keep unparsed due to possible
+                // coming LF in CRLF
+                if (!currentScanner.hasMoreCharacters &&
+                    Token_1.Token.isTokenCarriageReturn(currentToken, parserOptions) &&
+                    hasMoreData) {
+                    return null;
+                }
+                currentScanner.truncateToCursor();
+                return columns;
+            }
+            if (!this.shouldSkipColumnParse(currentScanner, currentToken, columns)) {
+                const item = this.columnParser.parse(currentScanner);
+                if (item === null) {
+                    return null;
+                }
+                columns.push(item);
+            }
+            currentToken = currentScanner.nextNonSpaceToken;
+        }
+        if (!hasMoreData) {
+            currentScanner.truncateToCursor();
+            return columns;
+        }
+        return null;
+    }
+    getStartToken(scanner, columns) {
+        const currentToken = scanner.nextNonSpaceToken;
+        if (currentToken !== null && Token_1.Token.isTokenDelimiter(currentToken, this.parserOptions)) {
+            columns.push('');
+            return scanner.nextNonSpaceToken;
+        }
+        return currentToken;
+    }
+    shouldSkipColumnParse(scanner, currentToken, columns) {
+        const { parserOptions } = this;
+        if (Token_1.Token.isTokenDelimiter(currentToken, parserOptions)) {
+            scanner.advancePastToken(currentToken);
+            // if the delimiter is at the end of a line
+            const nextToken = scanner.nextCharacterToken;
+            if (!scanner.hasMoreCharacters || (nextToken !== null && Token_1.Token.isTokenRowDelimiter(nextToken))) {
+                columns.push('');
+                return true;
+            }
+            if (nextToken !== null && Token_1.Token.isTokenDelimiter(nextToken, parserOptions)) {
+                columns.push('');
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.RowParser = RowParser;
+//# sourceMappingURL=RowParser.js.map

node_modules/@fast-csv/parse/build/src/parser/RowParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RowParser.js","sourceRoot":"","sources":["../../../src/parser/RowParser.ts"],"names":[],"mappings":"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"}

node_modules/@fast-csv/parse/build/src/parser/Scanner.d.ts

@@ -0,0 +1,25 @@
+import { ParserOptions } from '../ParserOptions';
+import { MaybeToken, Token } from './Token';
+export interface ScannerArgs {
+    line: string;
+    parserOptions: ParserOptions;
+    hasMoreData: boolean;
+    cursor?: number;
+}
+export declare class Scanner {
+    line: string;
+    private readonly parserOptions;
+    lineLength: number;
+    readonly hasMoreData: boolean;
+    cursor: number;
+    constructor(args: ScannerArgs);
+    get hasMoreCharacters(): boolean;
+    get nextNonSpaceToken(): MaybeToken;
+    get nextCharacterToken(): MaybeToken;
+    get lineFromCursor(): string;
+    advancePastLine(): Scanner | null;
+    advanceTo(cursor: number): Scanner;
+    advanceToToken(token: Token): Scanner;
+    advancePastToken(token: Token): Scanner;
+    truncateToCursor(): Scanner;
+}

node_modules/@fast-csv/parse/build/src/parser/Scanner.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scanner = void 0;
+const Token_1 = require("./Token");
+const ROW_DELIMITER = /((?:\r\n)|\n|\r)/;
+class Scanner {
+    constructor(args) {
+        this.cursor = 0;
+        this.line = args.line;
+        this.lineLength = this.line.length;
+        this.parserOptions = args.parserOptions;
+        this.hasMoreData = args.hasMoreData;
+        this.cursor = args.cursor || 0;
+    }
+    get hasMoreCharacters() {
+        return this.lineLength > this.cursor;
+    }
+    get nextNonSpaceToken() {
+        const { lineFromCursor } = this;
+        const regex = this.parserOptions.NEXT_TOKEN_REGEXP;
+        if (lineFromCursor.search(regex) === -1) {
+            return null;
+        }
+        const match = regex.exec(lineFromCursor);
+        if (match == null) {
+            return null;
+        }
+        const token = match[1];
+        const startCursor = this.cursor + (match.index || 0);
+        return new Token_1.Token({
+            token,
+            startCursor,
+            endCursor: startCursor + token.length - 1,
+        });
+    }
+    get nextCharacterToken() {
+        const { cursor, lineLength } = this;
+        if (lineLength <= cursor) {
+            return null;
+        }
+        return new Token_1.Token({
+            token: this.line[cursor],
+            startCursor: cursor,
+            endCursor: cursor,
+        });
+    }
+    get lineFromCursor() {
+        return this.line.substr(this.cursor);
+    }
+    advancePastLine() {
+        const match = ROW_DELIMITER.exec(this.lineFromCursor);
+        if (!match) {
+            if (this.hasMoreData) {
+                return null;
+            }
+            this.cursor = this.lineLength;
+            return this;
+        }
+        this.cursor += (match.index || 0) + match[0].length;
+        return this;
+    }
+    advanceTo(cursor) {
+        this.cursor = cursor;
+        return this;
+    }
+    advanceToToken(token) {
+        this.cursor = token.startCursor;
+        return this;
+    }
+    advancePastToken(token) {
+        this.cursor = token.endCursor + 1;
+        return this;
+    }
+    truncateToCursor() {
+        this.line = this.lineFromCursor;
+        this.lineLength = this.line.length;
+        this.cursor = 0;
+        return this;
+    }
+}
+exports.Scanner = Scanner;
+//# sourceMappingURL=Scanner.js.map

node_modules/@fast-csv/parse/build/src/parser/Scanner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scanner.js","sourceRoot":"","sources":["../../../src/parser/Scanner.ts"],"names":[],"mappings":";;;AACA,mCAA4C;AAE5C,MAAM,aAAa,GAAG,kBAAkB,CAAC;AASzC,MAAa,OAAO;IAWhB,YAAmB,IAAiB;QAF7B,WAAM,GAAG,CAAC,CAAC;QAGd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;QACnC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACxC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,IAAW,iBAAiB;QACxB,OAAO,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC;IACzC,CAAC;IAED,IAAW,iBAAiB;QACxB,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC;QACnD,IAAI,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE;YACrC,OAAO,IAAI,CAAC;SACf;QACD,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACzC,IAAI,KAAK,IAAI,IAAI,EAAE;YACf,OAAO,IAAI,CAAC;SACf;QACD,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACvB,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;QACrD,OAAO,IAAI,aAAK,CAAC;YACb,KAAK;YACL,WAAW;YACX,SAAS,EAAE,WAAW,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC;SAC5C,CAAC,CAAC;IACP,CAAC;IAED,IAAW,kBAAkB;QACzB,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;QACpC,IAAI,UAAU,IAAI,MAAM,EAAE;YACtB,OAAO,IAAI,CAAC;SACf;QACD,OAAO,IAAI,aAAK,CAAC;YACb,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;YACxB,WAAW,EAAE,MAAM;YACnB,SAAS,EAAE,MAAM;SACpB,CAAC,CAAC;IACP,CAAC;IAED,IAAW,cAAc;QACrB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAEM,eAAe;QAClB,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACtD,IAAI,CAAC,KAAK,EAAE;YACR,IAAI,IAAI,CAAC,WAAW,EAAE;gBAClB,OAAO,IAAI,CAAC;aACf;YACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;YAC9B,OAAO,IAAI,CAAC;SACf;QACD,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QACpD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,SAAS,CAAC,MAAc;QAC3B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,cAAc,CAAC,KAAY;QAC9B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,WAAW,CAAC;QAChC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,gBAAgB,CAAC,KAAY;QAChC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC;QAClC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,gBAAgB;QACnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC;QAChC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChB,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ;AA5FD,0BA4FC"}

node_modules/@fast-csv/parse/build/src/parser/Token.d.ts

@@ -0,0 +1,19 @@
+import { ParserOptions } from '../ParserOptions';
+export declare type MaybeToken = Token | null;
+export interface TokenArgs {
+    token: string;
+    startCursor: number;
+    endCursor: number;
+}
+export declare class Token {
+    static isTokenRowDelimiter(token: Token): boolean;
+    static isTokenCarriageReturn(token: Token, parserOptions: ParserOptions): boolean;
+    static isTokenComment(token: Token, parserOptions: ParserOptions): boolean;
+    static isTokenEscapeCharacter(token: Token, parserOptions: ParserOptions): boolean;
+    static isTokenQuote(token: Token, parserOptions: ParserOptions): boolean;
+    static isTokenDelimiter(token: Token, parserOptions: ParserOptions): boolean;
+    readonly token: string;
+    readonly startCursor: number;
+    readonly endCursor: number;
+    constructor(tokenArgs: TokenArgs);
+}

node_modules/@fast-csv/parse/build/src/parser/Token.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+class Token {
+    constructor(tokenArgs) {
+        this.token = tokenArgs.token;
+        this.startCursor = tokenArgs.startCursor;
+        this.endCursor = tokenArgs.endCursor;
+    }
+    static isTokenRowDelimiter(token) {
+        const content = token.token;
+        return content === '\r' || content === '\n' || content === '\r\n';
+    }
+    static isTokenCarriageReturn(token, parserOptions) {
+        return token.token === parserOptions.carriageReturn;
+    }
+    static isTokenComment(token, parserOptions) {
+        return parserOptions.supportsComments && !!token && token.token === parserOptions.comment;
+    }
+    static isTokenEscapeCharacter(token, parserOptions) {
+        return token.token === parserOptions.escapeChar;
+    }
+    static isTokenQuote(token, parserOptions) {
+        return token.token === parserOptions.quote;
+    }
+    static isTokenDelimiter(token, parserOptions) {
+        return token.token === parserOptions.delimiter;
+    }
+}
+exports.Token = Token;
+//# sourceMappingURL=Token.js.map

node_modules/@fast-csv/parse/build/src/parser/Token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Token.js","sourceRoot":"","sources":["../../../src/parser/Token.ts"],"names":[],"mappings":";;;AAUA,MAAa,KAAK;IAgCd,YAAmB,SAAoB;QACnC,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;QAC7B,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC;QACzC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC;IACzC,CAAC;IAnCM,MAAM,CAAC,mBAAmB,CAAC,KAAY;QAC1C,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC;QAC5B,OAAO,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,MAAM,CAAC;IACtE,CAAC;IAEM,MAAM,CAAC,qBAAqB,CAAC,KAAY,EAAE,aAA4B;QAC1E,OAAO,KAAK,CAAC,KAAK,KAAK,aAAa,CAAC,cAAc,CAAC;IACxD,CAAC;IAEM,MAAM,CAAC,cAAc,CAAC,KAAY,EAAE,aAA4B;QACnE,OAAO,aAAa,CAAC,gBAAgB,IAAI,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,KAAK,aAAa,CAAC,OAAO,CAAC;IAC9F,CAAC;IAEM,MAAM,CAAC,sBAAsB,CAAC,KAAY,EAAE,aAA4B;QAC3E,OAAO,KAAK,CAAC,KAAK,KAAK,aAAa,CAAC,UAAU,CAAC;IACpD,CAAC;IAEM,MAAM,CAAC,YAAY,CAAC,KAAY,EAAE,aAA4B;QACjE,OAAO,KAAK,CAAC,KAAK,KAAK,aAAa,CAAC,KAAK,CAAC;IAC/C,CAAC;IAEM,MAAM,CAAC,gBAAgB,CAAC,KAAY,EAAE,aAA4B;QACrE,OAAO,KAAK,CAAC,KAAK,KAAK,aAAa,CAAC,SAAS,CAAC;IACnD,CAAC;CAaJ;AArCD,sBAqCC"}

node_modules/@fast-csv/parse/build/src/parser/column/ColumnFormatter.d.ts

@@ -0,0 +1,5 @@
+import { ParserOptions } from '../../ParserOptions';
+export declare class ColumnFormatter {
+    readonly format: (col: string) => string;
+    constructor(parserOptions: ParserOptions);
+}

node_modules/@fast-csv/parse/build/src/parser/column/ColumnFormatter.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnFormatter = void 0;
+class ColumnFormatter {
+    constructor(parserOptions) {
+        if (parserOptions.trim) {
+            this.format = (col) => col.trim();
+        }
+        else if (parserOptions.ltrim) {
+            this.format = (col) => col.trimLeft();
+        }
+        else if (parserOptions.rtrim) {
+            this.format = (col) => col.trimRight();
+        }
+        else {
+            this.format = (col) => col;
+        }
+    }
+}
+exports.ColumnFormatter = ColumnFormatter;
+//# sourceMappingURL=ColumnFormatter.js.map

node_modules/@fast-csv/parse/build/src/parser/column/ColumnFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColumnFormatter.js","sourceRoot":"","sources":["../../../../src/parser/column/ColumnFormatter.ts"],"names":[],"mappings":";;;AAEA,MAAa,eAAe;IAGxB,YAAmB,aAA4B;QAC3C,IAAI,aAAa,CAAC,IAAI,EAAE;YACpB,IAAI,CAAC,MAAM,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;SACrD;aAAM,IAAI,aAAa,CAAC,KAAK,EAAE;YAC5B,IAAI,CAAC,MAAM,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;SACzD;aAAM,IAAI,aAAa,CAAC,KAAK,EAAE;YAC5B,IAAI,CAAC,MAAM,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;SAC1D;aAAM;YACH,IAAI,CAAC,MAAM,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,GAAG,CAAC;SAC9C;IACL,CAAC;CACJ;AAdD,0CAcC"}

node_modules/@fast-csv/parse/build/src/parser/column/ColumnParser.d.ts

@@ -0,0 +1,11 @@
+import { ParserOptions } from '../../ParserOptions';
+import { NonQuotedColumnParser } from './NonQuotedColumnParser';
+import { QuotedColumnParser } from './QuotedColumnParser';
+import { Scanner } from '../Scanner';
+export declare class ColumnParser {
+    private readonly parserOptions;
+    readonly nonQuotedColumnParser: NonQuotedColumnParser;
+    readonly quotedColumnParser: QuotedColumnParser;
+    constructor(parserOptions: ParserOptions);
+    parse(scanner: Scanner): string | null;
+}

node_modules/@fast-csv/parse/build/src/parser/column/ColumnParser.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnParser = void 0;
+const NonQuotedColumnParser_1 = require("./NonQuotedColumnParser");
+const QuotedColumnParser_1 = require("./QuotedColumnParser");
+const Token_1 = require("../Token");
+class ColumnParser {
+    constructor(parserOptions) {
+        this.parserOptions = parserOptions;
+        this.quotedColumnParser = new QuotedColumnParser_1.QuotedColumnParser(parserOptions);
+        this.nonQuotedColumnParser = new NonQuotedColumnParser_1.NonQuotedColumnParser(parserOptions);
+    }
+    parse(scanner) {
+        const { nextNonSpaceToken } = scanner;
+        if (nextNonSpaceToken !== null && Token_1.Token.isTokenQuote(nextNonSpaceToken, this.parserOptions)) {
+            scanner.advanceToToken(nextNonSpaceToken);
+            return this.quotedColumnParser.parse(scanner);
+        }
+        return this.nonQuotedColumnParser.parse(scanner);
+    }
+}
+exports.ColumnParser = ColumnParser;
+//# sourceMappingURL=ColumnParser.js.map

node_modules/@fast-csv/parse/build/src/parser/column/ColumnParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColumnParser.js","sourceRoot":"","sources":["../../../../src/parser/column/ColumnParser.ts"],"names":[],"mappings":";;;AACA,mEAAgE;AAChE,6DAA0D;AAE1D,oCAAiC;AAEjC,MAAa,YAAY;IAOrB,YAAmB,aAA4B;QAC3C,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,kBAAkB,GAAG,IAAI,uCAAkB,CAAC,aAAa,CAAC,CAAC;QAChE,IAAI,CAAC,qBAAqB,GAAG,IAAI,6CAAqB,CAAC,aAAa,CAAC,CAAC;IAC1E,CAAC;IAEM,KAAK,CAAC,OAAgB;QACzB,MAAM,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC;QACtC,IAAI,iBAAiB,KAAK,IAAI,IAAI,aAAK,CAAC,YAAY,CAAC,iBAAiB,EAAE,IAAI,CAAC,aAAa,CAAC,EAAE;YACzF,OAAO,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;YAC1C,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;SACjD;QACD,OAAO,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;CACJ;AArBD,oCAqBC"}

node_modules/@fast-csv/parse/build/src/parser/column/NonQuotedColumnParser.d.ts

@@ -0,0 +1,8 @@
+import { ParserOptions } from '../../ParserOptions';
+import { Scanner } from '../Scanner';
+export declare class NonQuotedColumnParser {
+    private readonly parserOptions;
+    private readonly columnFormatter;
+    constructor(parserOptions: ParserOptions);
+    parse(scanner: Scanner): string | null;
+}

node_modules/@fast-csv/parse/build/src/parser/column/NonQuotedColumnParser.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonQuotedColumnParser = void 0;
+const ColumnFormatter_1 = require("./ColumnFormatter");
+const Token_1 = require("../Token");
+class NonQuotedColumnParser {
+    constructor(parserOptions) {
+        this.parserOptions = parserOptions;
+        this.columnFormatter = new ColumnFormatter_1.ColumnFormatter(parserOptions);
+    }
+    parse(scanner) {
+        if (!scanner.hasMoreCharacters) {
+            return null;
+        }
+        const { parserOptions } = this;
+        const characters = [];
+        let nextToken = scanner.nextCharacterToken;
+        for (; nextToken; nextToken = scanner.nextCharacterToken) {
+            if (Token_1.Token.isTokenDelimiter(nextToken, parserOptions) || Token_1.Token.isTokenRowDelimiter(nextToken)) {
+                break;
+            }
+            characters.push(nextToken.token);
+            scanner.advancePastToken(nextToken);
+        }
+        return this.columnFormatter.format(characters.join(''));
+    }
+}
+exports.NonQuotedColumnParser = NonQuotedColumnParser;
+//# sourceMappingURL=NonQuotedColumnParser.js.map

node_modules/@fast-csv/parse/build/src/parser/column/NonQuotedColumnParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NonQuotedColumnParser.js","sourceRoot":"","sources":["../../../../src/parser/column/NonQuotedColumnParser.ts"],"names":[],"mappings":";;;AACA,uDAAoD;AAEpD,oCAAiC;AAEjC,MAAa,qBAAqB;IAK9B,YAAmB,aAA4B;QAC3C,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,eAAe,GAAG,IAAI,iCAAe,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAEM,KAAK,CAAC,OAAgB;QACzB,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE;YAC5B,OAAO,IAAI,CAAC;SACf;QACD,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;QAC/B,MAAM,UAAU,GAAG,EAAE,CAAC;QACtB,IAAI,SAAS,GAAG,OAAO,CAAC,kBAAkB,CAAC;QAC3C,OAAO,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,kBAAkB,EAAE;YACtD,IAAI,aAAK,CAAC,gBAAgB,CAAC,SAAS,EAAE,aAAa,CAAC,IAAI,aAAK,CAAC,mBAAmB,CAAC,SAAS,CAAC,EAAE;gBAC1F,MAAM;aACT;YACD,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACjC,OAAO,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;SACvC;QACD,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5D,CAAC;CACJ;AA1BD,sDA0BC"}

node_modules/@fast-csv/parse/build/src/parser/column/QuotedColumnParser.d.ts

@@ -0,0 +1,10 @@
+import { ParserOptions } from '../../ParserOptions';
+import { Scanner } from '../Scanner';
+export declare class QuotedColumnParser {
+    private readonly parserOptions;
+    private readonly columnFormatter;
+    constructor(parserOptions: ParserOptions);
+    parse(scanner: Scanner): string | null;
+    private gatherDataBetweenQuotes;
+    private checkForMalformedColumn;
+}

node_modules/@fast-csv/parse/build/src/parser/column/QuotedColumnParser.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotedColumnParser = void 0;
+const ColumnFormatter_1 = require("./ColumnFormatter");
+const Token_1 = require("../Token");
+class QuotedColumnParser {
+    constructor(parserOptions) {
+        this.parserOptions = parserOptions;
+        this.columnFormatter = new ColumnFormatter_1.ColumnFormatter(parserOptions);
+    }
+    parse(scanner) {
+        if (!scanner.hasMoreCharacters) {
+            return null;
+        }
+        const originalCursor = scanner.cursor;
+        const { foundClosingQuote, col } = this.gatherDataBetweenQuotes(scanner);
+        if (!foundClosingQuote) {
+            // reset the cursor to the original
+            scanner.advanceTo(originalCursor);
+            // if we didnt find a closing quote but we potentially have more data then skip the parsing
+            // and return the original scanner.
+            if (!scanner.hasMoreData) {
+                throw new Error(`Parse Error: missing closing: '${this.parserOptions.quote || ''}' in line: at '${scanner.lineFromCursor.replace(/[\r\n]/g, "\\n'")}'`);
+            }
+            return null;
+        }
+        this.checkForMalformedColumn(scanner);
+        return col;
+    }
+    gatherDataBetweenQuotes(scanner) {
+        const { parserOptions } = this;
+        let foundStartingQuote = false;
+        let foundClosingQuote = false;
+        const characters = [];
+        let nextToken = scanner.nextCharacterToken;
+        for (; !foundClosingQuote && nextToken !== null; nextToken = scanner.nextCharacterToken) {
+            const isQuote = Token_1.Token.isTokenQuote(nextToken, parserOptions);
+            // ignore first quote
+            if (!foundStartingQuote && isQuote) {
+                foundStartingQuote = true;
+            }
+            else if (foundStartingQuote) {
+                if (Token_1.Token.isTokenEscapeCharacter(nextToken, parserOptions)) {
+                    // advance past the escape character so we can get the next one in line
+                    scanner.advancePastToken(nextToken);
+                    const tokenFollowingEscape = scanner.nextCharacterToken;
+                    // if the character following the escape is a quote character then just add
+                    // the quote and advance to that character
+                    if (tokenFollowingEscape !== null &&
+                        (Token_1.Token.isTokenQuote(tokenFollowingEscape, parserOptions) ||
+                            Token_1.Token.isTokenEscapeCharacter(tokenFollowingEscape, parserOptions))) {
+                        characters.push(tokenFollowingEscape.token);
+                        nextToken = tokenFollowingEscape;
+                    }
+                    else if (isQuote) {
+                        // if the escape is also a quote then we found our closing quote and finish early
+                        foundClosingQuote = true;
+                    }
+                    else {
+                        // other wise add the escape token to the characters since it wast escaping anything
+                        characters.push(nextToken.token);
+                    }
+                }
+                else if (isQuote) {
+                    // we found our closing quote!
+                    foundClosingQuote = true;
+                }
+                else {
+                    // add the token to the characters
+                    characters.push(nextToken.token);
+                }
+            }
+            scanner.advancePastToken(nextToken);
+        }
+        return { col: this.columnFormatter.format(characters.join('')), foundClosingQuote };
+    }
+    checkForMalformedColumn(scanner) {
+        const { parserOptions } = this;
+        const { nextNonSpaceToken } = scanner;
+        if (nextNonSpaceToken) {
+            const isNextTokenADelimiter = Token_1.Token.isTokenDelimiter(nextNonSpaceToken, parserOptions);
+            const isNextTokenARowDelimiter = Token_1.Token.isTokenRowDelimiter(nextNonSpaceToken);
+            if (!(isNextTokenADelimiter || isNextTokenARowDelimiter)) {
+                // if the final quote was NOT followed by a column (,) or row(\n) delimiter then its a bad column
+                // tldr: only part of the column was quoted
+                const linePreview = scanner.lineFromCursor.substr(0, 10).replace(/[\r\n]/g, "\\n'");
+                throw new Error(`Parse Error: expected: '${parserOptions.escapedDelimiter}' OR new line got: '${nextNonSpaceToken.token}'. at '${linePreview}`);
+            }
+            scanner.advanceToToken(nextNonSpaceToken);
+        }
+        else if (!scanner.hasMoreData) {
+            scanner.advancePastLine();
+        }
+    }
+}
+exports.QuotedColumnParser = QuotedColumnParser;
+//# sourceMappingURL=QuotedColumnParser.js.map

node_modules/@fast-csv/parse/build/src/parser/column/QuotedColumnParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuotedColumnParser.js","sourceRoot":"","sources":["../../../../src/parser/column/QuotedColumnParser.ts"],"names":[],"mappings":"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"}

node_modules/@fast-csv/parse/build/src/parser/column/index.d.ts

@@ -0,0 +1,4 @@
+export { ColumnParser } from './ColumnParser';
+export { NonQuotedColumnParser } from './NonQuotedColumnParser';
+export { QuotedColumnParser } from './QuotedColumnParser';
+export { ColumnFormatter } from './ColumnFormatter';

node_modules/@fast-csv/parse/build/src/parser/column/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnFormatter = exports.QuotedColumnParser = exports.NonQuotedColumnParser = exports.ColumnParser = void 0;
+var ColumnParser_1 = require("./ColumnParser");
+Object.defineProperty(exports, "ColumnParser", { enumerable: true, get: function () { return ColumnParser_1.ColumnParser; } });
+var NonQuotedColumnParser_1 = require("./NonQuotedColumnParser");
+Object.defineProperty(exports, "NonQuotedColumnParser", { enumerable: true, get: function () { return NonQuotedColumnParser_1.NonQuotedColumnParser; } });
+var QuotedColumnParser_1 = require("./QuotedColumnParser");
+Object.defineProperty(exports, "QuotedColumnParser", { enumerable: true, get: function () { return QuotedColumnParser_1.QuotedColumnParser; } });
+var ColumnFormatter_1 = require("./ColumnFormatter");
+Object.defineProperty(exports, "ColumnFormatter", { enumerable: true, get: function () { return ColumnFormatter_1.ColumnFormatter; } });
+//# sourceMappingURL=index.js.map

node_modules/@fast-csv/parse/build/src/parser/column/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/parser/column/index.ts"],"names":[],"mappings":";;;AAAA,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,iEAAgE;AAAvD,8HAAA,qBAAqB,OAAA;AAC9B,2DAA0D;AAAjD,wHAAA,kBAAkB,OAAA;AAC3B,qDAAoD;AAA3C,kHAAA,eAAe,OAAA"}

node_modules/@fast-csv/parse/build/src/parser/index.d.ts

@@ -0,0 +1,5 @@
+export { Parser } from './Parser';
+export { RowParser } from './RowParser';
+export { Scanner } from './Scanner';
+export { Token, MaybeToken } from './Token';
+export { ColumnParser, NonQuotedColumnParser, QuotedColumnParser } from './column';

node_modules/@fast-csv/parse/build/src/parser/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuotedColumnParser = exports.NonQuotedColumnParser = exports.ColumnParser = exports.Token = exports.Scanner = exports.RowParser = exports.Parser = void 0;
+var Parser_1 = require("./Parser");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return Parser_1.Parser; } });
+var RowParser_1 = require("./RowParser");
+Object.defineProperty(exports, "RowParser", { enumerable: true, get: function () { return RowParser_1.RowParser; } });
+var Scanner_1 = require("./Scanner");
+Object.defineProperty(exports, "Scanner", { enumerable: true, get: function () { return Scanner_1.Scanner; } });
+var Token_1 = require("./Token");
+Object.defineProperty(exports, "Token", { enumerable: true, get: function () { return Token_1.Token; } });
+var column_1 = require("./column");
+Object.defineProperty(exports, "ColumnParser", { enumerable: true, get: function () { return column_1.ColumnParser; } });
+Object.defineProperty(exports, "NonQuotedColumnParser", { enumerable: true, get: function () { return column_1.NonQuotedColumnParser; } });
+Object.defineProperty(exports, "QuotedColumnParser", { enumerable: true, get: function () { return column_1.QuotedColumnParser; } });
+//# sourceMappingURL=index.js.map

node_modules/@fast-csv/parse/build/src/parser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/parser/index.ts"],"names":[],"mappings":";;;AAAA,mCAAkC;AAAzB,gGAAA,MAAM,OAAA;AACf,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAClB,qCAAoC;AAA3B,kGAAA,OAAO,OAAA;AAChB,iCAA4C;AAAnC,8FAAA,KAAK,OAAA;AACd,mCAAmF;AAA1E,sGAAA,YAAY,OAAA;AAAE,+GAAA,qBAAqB,OAAA;AAAE,4GAAA,kBAAkB,OAAA"}

node_modules/@fast-csv/parse/build/src/transforms/HeaderTransformer.d.ts

@@ -0,0 +1,17 @@
+import { ParserOptions } from '../ParserOptions';
+import { HeaderArray, Row, RowArray, RowValidatorCallback } from '../types';
+export declare class HeaderTransformer<O extends Row> {
+    private readonly parserOptions;
+    headers: HeaderArray | null;
+    private receivedHeaders;
+    private readonly shouldUseFirstRow;
+    private processedFirstRow;
+    private headersLength;
+    private readonly headersTransform?;
+    constructor(parserOptions: ParserOptions);
+    transform(row: RowArray, cb: RowValidatorCallback<O>): void;
+    private shouldMapRow;
+    private processRow;
+    private mapHeaders;
+    private setHeaders;
+}

node_modules/@fast-csv/parse/build/src/transforms/HeaderTransformer.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderTransformer = void 0;
+const lodash_isundefined_1 = __importDefault(require("lodash.isundefined"));
+const lodash_isfunction_1 = __importDefault(require("lodash.isfunction"));
+const lodash_uniq_1 = __importDefault(require("lodash.uniq"));
+const lodash_groupby_1 = __importDefault(require("lodash.groupby"));
+class HeaderTransformer {
+    constructor(parserOptions) {
+        this.headers = null;
+        this.receivedHeaders = false;
+        this.shouldUseFirstRow = false;
+        this.processedFirstRow = false;
+        this.headersLength = 0;
+        this.parserOptions = parserOptions;
+        if (parserOptions.headers === true) {
+            this.shouldUseFirstRow = true;
+        }
+        else if (Array.isArray(parserOptions.headers)) {
+            this.setHeaders(parserOptions.headers);
+        }
+        else if (lodash_isfunction_1.default(parserOptions.headers)) {
+            this.headersTransform = parserOptions.headers;
+        }
+    }
+    transform(row, cb) {
+        if (!this.shouldMapRow(row)) {
+            return cb(null, { row: null, isValid: true });
+        }
+        return cb(null, this.processRow(row));
+    }
+    shouldMapRow(row) {
+        const { parserOptions } = this;
+        if (!this.headersTransform && parserOptions.renameHeaders && !this.processedFirstRow) {
+            if (!this.receivedHeaders) {
+                throw new Error('Error renaming headers: new headers must be provided in an array');
+            }
+            this.processedFirstRow = true;
+            return false;
+        }
+        if (!this.receivedHeaders && Array.isArray(row)) {
+            if (this.headersTransform) {
+                this.setHeaders(this.headersTransform(row));
+            }
+            else if (this.shouldUseFirstRow) {
+                this.setHeaders(row);
+            }
+            else {
+                // dont do anything with the headers if we didnt receive a transform or shouldnt use the first row.
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    processRow(row) {
+        if (!this.headers) {
+            return { row: row, isValid: true };
+        }
+        const { parserOptions } = this;
+        if (!parserOptions.discardUnmappedColumns && row.length > this.headersLength) {
+            if (!parserOptions.strictColumnHandling) {
+                throw new Error(`Unexpected Error: column header mismatch expected: ${this.headersLength} columns got: ${row.length}`);
+            }
+            return {
+                row: row,
+                isValid: false,
+                reason: `Column header mismatch expected: ${this.headersLength} columns got: ${row.length}`,
+            };
+        }
+        if (parserOptions.strictColumnHandling && row.length < this.headersLength) {
+            return {
+                row: row,
+                isValid: false,
+                reason: `Column header mismatch expected: ${this.headersLength} columns got: ${row.length}`,
+            };
+        }
+        return { row: this.mapHeaders(row), isValid: true };
+    }
+    mapHeaders(row) {
+        const rowMap = {};
+        const { headers, headersLength } = this;
+        for (let i = 0; i < headersLength; i += 1) {
+            const header = headers[i];
+            if (!lodash_isundefined_1.default(header)) {
+                const val = row[i];
+                // eslint-disable-next-line no-param-reassign
+                if (lodash_isundefined_1.default(val)) {
+                    rowMap[header] = '';
+                }
+                else {
+                    rowMap[header] = val;
+                }
+            }
+        }
+        return rowMap;
+    }
+    setHeaders(headers) {
+        var _a;
+        const filteredHeaders = headers.filter((h) => !!h);
+        if (lodash_uniq_1.default(filteredHeaders).length !== filteredHeaders.length) {
+            const grouped = lodash_groupby_1.default(filteredHeaders);
+            const duplicates = Object.keys(grouped).filter((dup) => grouped[dup].length > 1);
+            throw new Error(`Duplicate headers found ${JSON.stringify(duplicates)}`);
+        }
+        this.headers = headers;
+        this.receivedHeaders = true;
+        this.headersLength = ((_a = this.headers) === null || _a === void 0 ? void 0 : _a.length) || 0;
+    }
+}
+exports.HeaderTransformer = HeaderTransformer;
+//# sourceMappingURL=HeaderTransformer.js.map

node_modules/@fast-csv/parse/build/src/transforms/HeaderTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeaderTransformer.js","sourceRoot":"","sources":["../../../src/transforms/HeaderTransformer.ts"],"names":[],"mappings":"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"}

node_modules/@fast-csv/parse/build/src/transforms/RowTransformerValidator.d.ts

@@ -0,0 +1,12 @@
+import { Row, RowTransformFunction, RowValidatorCallback, RowValidate } from '../types';
+export declare class RowTransformerValidator<I extends Row, O extends Row> {
+    private static createTransform;
+    private static createValidator;
+    private _rowTransform;
+    private _rowValidator;
+    set rowTransform(transformFunction: RowTransformFunction<I, O>);
+    set rowValidator(validateFunction: RowValidate<O>);
+    transformAndValidate(row: I, cb: RowValidatorCallback<O>): void;
+    private callTransformer;
+    private callValidator;
+}

node_modules/@fast-csv/parse/build/src/transforms/RowTransformerValidator.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowTransformerValidator = void 0;
+const lodash_isfunction_1 = __importDefault(require("lodash.isfunction"));
+const types_1 = require("../types");
+class RowTransformerValidator {
+    constructor() {
+        this._rowTransform = null;
+        this._rowValidator = null;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    static createTransform(transformFunction) {
+        if (types_1.isSyncTransform(transformFunction)) {
+            return (row, cb) => {
+                let transformed = null;
+                try {
+                    transformed = transformFunction(row);
+                }
+                catch (e) {
+                    return cb(e);
+                }
+                return cb(null, transformed);
+            };
+        }
+        return transformFunction;
+    }
+    static createValidator(validateFunction) {
+        if (types_1.isSyncValidate(validateFunction)) {
+            return (row, cb) => {
+                cb(null, { row, isValid: validateFunction(row) });
+            };
+        }
+        return (row, cb) => {
+            validateFunction(row, (err, isValid, reason) => {
+                if (err) {
+                    return cb(err);
+                }
+                if (isValid) {
+                    return cb(null, { row, isValid, reason });
+                }
+                return cb(null, { row, isValid: false, reason });
+            });
+        };
+    }
+    set rowTransform(transformFunction) {
+        if (!lodash_isfunction_1.default(transformFunction)) {
+            throw new TypeError('The transform should be a function');
+        }
+        this._rowTransform = RowTransformerValidator.createTransform(transformFunction);
+    }
+    set rowValidator(validateFunction) {
+        if (!lodash_isfunction_1.default(validateFunction)) {
+            throw new TypeError('The validate should be a function');
+        }
+        this._rowValidator = RowTransformerValidator.createValidator(validateFunction);
+    }
+    transformAndValidate(row, cb) {
+        return this.callTransformer(row, (transformErr, transformedRow) => {
+            if (transformErr) {
+                return cb(transformErr);
+            }
+            if (!transformedRow) {
+                return cb(null, { row: null, isValid: true });
+            }
+            return this.callValidator(transformedRow, (validateErr, validationResult) => {
+                if (validateErr) {
+                    return cb(validateErr);
+                }
+                if (validationResult && !validationResult.isValid) {
+                    return cb(null, { row: transformedRow, isValid: false, reason: validationResult.reason });
+                }
+                return cb(null, { row: transformedRow, isValid: true });
+            });
+        });
+    }
+    callTransformer(row, cb) {
+        if (!this._rowTransform) {
+            return cb(null, row);
+        }
+        return this._rowTransform(row, cb);
+    }
+    callValidator(row, cb) {
+        if (!this._rowValidator) {
+            return cb(null, { row, isValid: true });
+        }
+        return this._rowValidator(row, cb);
+    }
+}
+exports.RowTransformerValidator = RowTransformerValidator;
+//# sourceMappingURL=RowTransformerValidator.js.map

node_modules/@fast-csv/parse/build/src/transforms/RowTransformerValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RowTransformerValidator.js","sourceRoot":"","sources":["../../../src/transforms/RowTransformerValidator.ts"],"names":[],"mappings":"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"}

node_modules/@fast-csv/parse/build/src/transforms/index.d.ts

@@ -0,0 +1,2 @@
+export { RowTransformerValidator } from './RowTransformerValidator';
+export { HeaderTransformer } from './HeaderTransformer';

node_modules/@fast-csv/parse/build/src/transforms/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderTransformer = exports.RowTransformerValidator = void 0;
+var RowTransformerValidator_1 = require("./RowTransformerValidator");
+Object.defineProperty(exports, "RowTransformerValidator", { enumerable: true, get: function () { return RowTransformerValidator_1.RowTransformerValidator; } });
+var HeaderTransformer_1 = require("./HeaderTransformer");
+Object.defineProperty(exports, "HeaderTransformer", { enumerable: true, get: function () { return HeaderTransformer_1.HeaderTransformer; } });
+//# sourceMappingURL=index.js.map

node_modules/@fast-csv/parse/build/src/transforms/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/transforms/index.ts"],"names":[],"mappings":";;;AAAA,qEAAoE;AAA3D,kIAAA,uBAAuB,OAAA;AAChC,yDAAwD;AAA/C,sHAAA,iBAAiB,OAAA"}

node_modules/@fast-csv/parse/build/src/types.d.ts

@@ -0,0 +1,21 @@
+export declare type RowMap<V = any> = Record<string, V>;
+export declare type RowArray<V = any> = V[];
+export declare type Row<V = any> = RowMap<V> | RowArray<V>;
+export interface RowValidationResult<R extends Row> {
+    row: R | null;
+    isValid: boolean;
+    reason?: string;
+}
+export declare type RowValidatorCallback<R extends Row> = (error: Error | null, result?: RowValidationResult<R>) => void;
+export declare type RowTransformCallback<R extends Row> = (error?: Error | null, row?: R) => void;
+export declare type SyncRowTransform<I extends Row, O extends Row> = (row: I) => O;
+export declare type AsyncRowTransform<I extends Row, O extends Row> = (row: I, cb: RowTransformCallback<O>) => void;
+export declare type RowTransformFunction<I extends Row, O extends Row> = SyncRowTransform<I, O> | AsyncRowTransform<I, O>;
+export declare const isSyncTransform: <I extends Row<any>, O extends Row<any>>(transform: RowTransformFunction<I, O>) => transform is SyncRowTransform<I, O>;
+export declare type RowValidateCallback = (error?: Error | null, isValid?: boolean, reason?: string) => void;
+export declare type SyncRowValidate<R extends Row> = (row: R) => boolean;
+export declare type AsyncRowValidate<R extends Row> = (row: R, cb: RowValidateCallback) => void;
+export declare type RowValidate<R extends Row> = AsyncRowValidate<R> | SyncRowValidate<R>;
+export declare const isSyncValidate: <R extends Row<any>>(validate: RowValidate<R>) => validate is SyncRowValidate<R>;
+export declare type HeaderArray = (string | undefined | null)[];
+export declare type HeaderTransformFunction = (headers: HeaderArray) => HeaderArray;

node_modules/@fast-csv/parse/build/src/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSyncValidate = exports.isSyncTransform = void 0;
+exports.isSyncTransform = (transform) => transform.length === 1;
+exports.isSyncValidate = (validate) => validate.length === 1;
+//# sourceMappingURL=types.js.map

node_modules/@fast-csv/parse/build/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";;;AAoBa,QAAA,eAAe,GAAG,CAC3B,SAAqC,EACF,EAAE,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC;AAQpD,QAAA,cAAc,GAAG,CAAgB,QAAwB,EAAkC,EAAE,CACtG,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC"}