convention_builder 1.5.0 → 1.5.1

package/dist/node/index.js

@@ -1173,12 +1173,12 @@ var require_util = __commonJS({
     __name(alwaysValidSchema, "alwaysValidSchema");
     exports2.alwaysValidSchema = alwaysValidSchema;
     function checkUnknownRules(it, schema = it.schema) {
-      const { opts, self } = it;
+      const { opts, self: self2 } = it;
       if (!opts.strictSchema)
         return;
       if (typeof schema === "boolean")
         return;
-      const rules = self.RULES.keywords;
+      const rules = self2.RULES.keywords;
       for (const key in schema) {
         if (!rules[key])
           checkStrictMode(it, `unknown keyword: "${key}"`);
@@ -1588,8 +1588,8 @@ var require_applicability = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.shouldUseRule = exports2.shouldUseGroup = exports2.schemaHasRulesForType = void 0;
-    function schemaHasRulesForType({ schema, self }, type) {
-      const group = self.RULES.types[type];
+    function schemaHasRulesForType({ schema, self: self2 }, type) {
+      const group = self2.RULES.types[type];
       return group && group !== true && shouldUseGroup(schema, group);
     }
     __name(schemaHasRulesForType, "schemaHasRulesForType");
@@ -2097,7 +2097,7 @@ var require_keyword = __commonJS({
     }
     __name(validSchemaType, "validSchemaType");
     exports2.validSchemaType = validSchemaType;
-    function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) {
+    function validateKeywordUsage({ schema, opts, self: self2, errSchemaPath }, def, keyword) {
       if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
         throw new Error("ajv implementation error");
       }
@@ -2108,9 +2108,9 @@ var require_keyword = __commonJS({
       if (def.validateSchema) {
         const valid = def.validateSchema(schema[keyword]);
         if (!valid) {
-          const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def.validateSchema.errors);
+          const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def.validateSchema.errors);
           if (opts.validateSchema === "log")
-            self.logger.error(msg);
+            self2.logger.error(msg);
           else
             throw new Error(msg);
         }
@@ -2614,11 +2614,11 @@ var require_validate = __commonJS({
       (0, boolSchema_1.boolOrEmptySchema)(it, valid);
     }
     __name(subschemaCode, "subschemaCode");
-    function schemaCxtHasRules({ schema, self }) {
+    function schemaCxtHasRules({ schema, self: self2 }) {
       if (typeof schema == "boolean")
         return !schema;
       for (const key in schema)
-        if (self.RULES.all[key])
+        if (self2.RULES.all[key])
           return true;
       return false;
     }
@@ -2652,9 +2652,9 @@ var require_validate = __commonJS({
     }
     __name(typeAndKeywords, "typeAndKeywords");
     function checkRefsAndKeywords(it) {
-      const { schema, errSchemaPath, opts, self } = it;
-      if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) {
-        self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
+      const { schema, errSchemaPath, opts, self: self2 } = it;
+      if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self2.RULES)) {
+        self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
       }
     }
     __name(checkRefsAndKeywords, "checkRefsAndKeywords");
@@ -2707,8 +2707,8 @@ var require_validate = __commonJS({
     }
     __name(assignEvaluated, "assignEvaluated");
     function schemaKeywords(it, types, typeErrors, errsCount) {
-      const { gen, schema, data, allErrors, opts, self } = it;
-      const { RULES } = self;
+      const { gen, schema, data, allErrors, opts, self: self2 } = it;
+      const { RULES } = self2;
       if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
         gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
         return;
@@ -5096,11 +5096,11 @@ var require_ref = __commonJS({
       schemaType: "string",
       code(cxt) {
         const { gen, schema: $ref, it } = cxt;
-        const { baseId, schemaEnv: env, validateName, opts, self } = it;
+        const { baseId, schemaEnv: env, validateName, opts, self: self2 } = it;
         const { root } = env;
         if (($ref === "#" || $ref === "#/") && baseId === root.baseId)
           return callRootRef();
-        const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
+        const schOrEnv = compile_1.resolveRef.call(self2, root, baseId, $ref);
         if (schOrEnv === void 0)
           throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
         if (schOrEnv instanceof compile_1.SchemaEnv)
@@ -6671,11 +6671,11 @@ var require_dynamicAnchor = __commonJS({
     __name(dynamicAnchor, "dynamicAnchor");
     exports2.dynamicAnchor = dynamicAnchor;
     function _getValidate(cxt) {
-      const { schemaEnv, schema, self } = cxt.it;
+      const { schemaEnv, schema, self: self2 } = cxt.it;
       const { root, baseId, localRefs, meta } = schemaEnv.root;
-      const { schemaId } = self.opts;
+      const { schemaId } = self2.opts;
       const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta });
-      compile_1.compileSchema.call(self, sch);
+      compile_1.compileSchema.call(self2, sch);
       return (0, ref_1.getValidate)(cxt, sch);
     }
     __name(_getValidate, "_getValidate");
@@ -6992,7 +6992,7 @@ var require_format = __commonJS({
       error,
       code(cxt, ruleType) {
         const { gen, data, $data, schema, schemaCode, it } = cxt;
-        const { opts, errSchemaPath, schemaEnv, self } = it;
+        const { opts, errSchemaPath, schemaEnv, self: self2 } = it;
         if (!opts.validateFormats)
           return;
         if ($data)
@@ -7001,7 +7001,7 @@ var require_format = __commonJS({
           validateFormat();
         function validate$DataFormat() {
           const fmts = gen.scopeValue("formats", {
-            ref: self.formats,
+            ref: self2.formats,
             code: opts.code.formats
           });
           const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
@@ -7024,7 +7024,7 @@ var require_format = __commonJS({
         }
         __name(validate$DataFormat, "validate$DataFormat");
         function validateFormat() {
-          const formatDef = self.formats[schema];
+          const formatDef = self2.formats[schema];
           if (!formatDef) {
             unknownFormat();
             return;
@@ -7036,7 +7036,7 @@ var require_format = __commonJS({
             cxt.pass(validCondition());
           function unknownFormat() {
             if (opts.strictSchema === false) {
-              self.logger.warn(unknownMsg());
+              self2.logger.warn(unknownMsg());
               return;
             }
             throw new Error(unknownMsg());
@@ -8189,17 +8189,17 @@ var require_limit = __commonJS({
       error,
       code(cxt) {
         const { gen, data, schemaCode, keyword, it } = cxt;
-        const { opts, self } = it;
+        const { opts, self: self2 } = it;
         if (!opts.validateFormats)
           return;
-        const fCxt = new ajv_1.KeywordCxt(it, self.RULES.all.format.definition, "format");
+        const fCxt = new ajv_1.KeywordCxt(it, self2.RULES.all.format.definition, "format");
         if (fCxt.$data)
           validate$DataFormat();
         else
           validateFormat();
         function validate$DataFormat() {
           const fmts = gen.scopeValue("formats", {
-            ref: self.formats,
+            ref: self2.formats,
             code: opts.code.formats
           });
           const fmt = gen.const("fmt", codegen_1._`${fmts}[${fCxt.schemaCode}]`);
@@ -8208,7 +8208,7 @@ var require_limit = __commonJS({
         __name(validate$DataFormat, "validate$DataFormat");
         function validateFormat() {
           const format = fCxt.schema;
-          const fmtDef = self.formats[format];
+          const fmtDef = self2.formats[format];
           if (!fmtDef || fmtDef === true)
             return;
           if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
@@ -9092,6 +9092,1344 @@ var require_schema_utilities = __commonJS({
   }
 });
 
+// node_modules/papaparse/papaparse.js
+var require_papaparse = __commonJS({
+  "node_modules/papaparse/papaparse.js"(exports2, module2) {
+    (function(root, factory) {
+      if (typeof define === "function" && define.amd) {
+        define([], factory);
+      } else if (typeof module2 === "object" && typeof exports2 !== "undefined") {
+        module2.exports = factory();
+      } else {
+        root.Papa = factory();
+      }
+    })(exports2, /* @__PURE__ */ __name(function moduleFactory() {
+      "use strict";
+      var global = function() {
+        if (typeof self !== "undefined") {
+          return self;
+        }
+        if (typeof window !== "undefined") {
+          return window;
+        }
+        if (typeof global !== "undefined") {
+          return global;
+        }
+        return {};
+      }();
+      function getWorkerBlob() {
+        var URL = global.URL || global.webkitURL || null;
+        var code = moduleFactory.toString();
+        return Papa.BLOB_URL || (Papa.BLOB_URL = URL.createObjectURL(new Blob(["var global = (function() { if (typeof self !== 'undefined') { return self; } if (typeof window !== 'undefined') { return window; } if (typeof global !== 'undefined') { return global; } return {}; })(); global.IS_PAPA_WORKER=true; ", "(", code, ")();"], { type: "text/javascript" })));
+      }
+      __name(getWorkerBlob, "getWorkerBlob");
+      var IS_WORKER = !global.document && !!global.postMessage, IS_PAPA_WORKER = global.IS_PAPA_WORKER || false;
+      var workers = {}, workerIdCounter = 0;
+      var Papa = {};
+      Papa.parse = CsvToJson;
+      Papa.unparse = JsonToCsv;
+      Papa.RECORD_SEP = String.fromCharCode(30);
+      Papa.UNIT_SEP = String.fromCharCode(31);
+      Papa.BYTE_ORDER_MARK = "\uFEFF";
+      Papa.BAD_DELIMITERS = ["\r", "\n", '"', Papa.BYTE_ORDER_MARK];
+      Papa.WORKERS_SUPPORTED = !IS_WORKER && !!global.Worker;
+      Papa.NODE_STREAM_INPUT = 1;
+      Papa.LocalChunkSize = 1024 * 1024 * 10;
+      Papa.RemoteChunkSize = 1024 * 1024 * 5;
+      Papa.DefaultDelimiter = ",";
+      Papa.Parser = Parser;
+      Papa.ParserHandle = ParserHandle;
+      Papa.NetworkStreamer = NetworkStreamer;
+      Papa.FileStreamer = FileStreamer;
+      Papa.StringStreamer = StringStreamer;
+      Papa.ReadableStreamStreamer = ReadableStreamStreamer;
+      if (typeof PAPA_BROWSER_CONTEXT === "undefined") {
+        Papa.DuplexStreamStreamer = DuplexStreamStreamer;
+      }
+      if (global.jQuery) {
+        var $ = global.jQuery;
+        $.fn.parse = function(options) {
+          var config = options.config || {};
+          var queue = [];
+          this.each(function(idx) {
+            var supported = $(this).prop("tagName").toUpperCase() === "INPUT" && $(this).attr("type").toLowerCase() === "file" && global.FileReader;
+            if (!supported || !this.files || this.files.length === 0)
+              return true;
+            for (var i = 0; i < this.files.length; i++) {
+              queue.push({
+                file: this.files[i],
+                inputElem: this,
+                instanceConfig: $.extend({}, config)
+              });
+            }
+          });
+          parseNextFile();
+          return this;
+          function parseNextFile() {
+            if (queue.length === 0) {
+              if (isFunction(options.complete))
+                options.complete();
+              return;
+            }
+            var f = queue[0];
+            if (isFunction(options.before)) {
+              var returned = options.before(f.file, f.inputElem);
+              if (typeof returned === "object") {
+                if (returned.action === "abort") {
+                  error("AbortError", f.file, f.inputElem, returned.reason);
+                  return;
+                } else if (returned.action === "skip") {
+                  fileComplete();
+                  return;
+                } else if (typeof returned.config === "object")
+                  f.instanceConfig = $.extend(f.instanceConfig, returned.config);
+              } else if (returned === "skip") {
+                fileComplete();
+                return;
+              }
+            }
+            var userCompleteFunc = f.instanceConfig.complete;
+            f.instanceConfig.complete = function(results) {
+              if (isFunction(userCompleteFunc))
+                userCompleteFunc(results, f.file, f.inputElem);
+              fileComplete();
+            };
+            Papa.parse(f.file, f.instanceConfig);
+          }
+          __name(parseNextFile, "parseNextFile");
+          function error(name, file, elem, reason) {
+            if (isFunction(options.error))
+              options.error({ name }, file, elem, reason);
+          }
+          __name(error, "error");
+          function fileComplete() {
+            queue.splice(0, 1);
+            parseNextFile();
+          }
+          __name(fileComplete, "fileComplete");
+        };
+      }
+      if (IS_PAPA_WORKER) {
+        global.onmessage = workerThreadReceivedMessage;
+      }
+      function CsvToJson(_input, _config) {
+        _config = _config || {};
+        var dynamicTyping = _config.dynamicTyping || false;
+        if (isFunction(dynamicTyping)) {
+          _config.dynamicTypingFunction = dynamicTyping;
+          dynamicTyping = {};
+        }
+        _config.dynamicTyping = dynamicTyping;
+        _config.transform = isFunction(_config.transform) ? _config.transform : false;
+        if (_config.worker && Papa.WORKERS_SUPPORTED) {
+          var w = newWorker();
+          w.userStep = _config.step;
+          w.userChunk = _config.chunk;
+          w.userComplete = _config.complete;
+          w.userError = _config.error;
+          _config.step = isFunction(_config.step);
+          _config.chunk = isFunction(_config.chunk);
+          _config.complete = isFunction(_config.complete);
+          _config.error = isFunction(_config.error);
+          delete _config.worker;
+          w.postMessage({
+            input: _input,
+            config: _config,
+            workerId: w.id
+          });
+          return;
+        }
+        var streamer = null;
+        if (_input === Papa.NODE_STREAM_INPUT && typeof PAPA_BROWSER_CONTEXT === "undefined") {
+          streamer = new DuplexStreamStreamer(_config);
+          return streamer.getStream();
+        } else if (typeof _input === "string") {
+          _input = stripBom(_input);
+          if (_config.download)
+            streamer = new NetworkStreamer(_config);
+          else
+            streamer = new StringStreamer(_config);
+        } else if (_input.readable === true && isFunction(_input.read) && isFunction(_input.on)) {
+          streamer = new ReadableStreamStreamer(_config);
+        } else if (global.File && _input instanceof File || _input instanceof Object)
+          streamer = new FileStreamer(_config);
+        return streamer.stream(_input);
+        function stripBom(string) {
+          if (string.charCodeAt(0) === 65279) {
+            return string.slice(1);
+          }
+          return string;
+        }
+        __name(stripBom, "stripBom");
+      }
+      __name(CsvToJson, "CsvToJson");
+      function JsonToCsv(_input, _config) {
+        var _quotes = false;
+        var _writeHeader = true;
+        var _delimiter = ",";
+        var _newline = "\r\n";
+        var _quoteChar = '"';
+        var _escapedQuote = _quoteChar + _quoteChar;
+        var _skipEmptyLines = false;
+        var _columns = null;
+        var _escapeFormulae = false;
+        unpackConfig();
+        var quoteCharRegex = new RegExp(escapeRegExp(_quoteChar), "g");
+        if (typeof _input === "string")
+          _input = JSON.parse(_input);
+        if (Array.isArray(_input)) {
+          if (!_input.length || Array.isArray(_input[0]))
+            return serialize(null, _input, _skipEmptyLines);
+          else if (typeof _input[0] === "object")
+            return serialize(_columns || Object.keys(_input[0]), _input, _skipEmptyLines);
+        } else if (typeof _input === "object") {
+          if (typeof _input.data === "string")
+            _input.data = JSON.parse(_input.data);
+          if (Array.isArray(_input.data)) {
+            if (!_input.fields)
+              _input.fields = _input.meta && _input.meta.fields || _columns;
+            if (!_input.fields)
+              _input.fields = Array.isArray(_input.data[0]) ? _input.fields : typeof _input.data[0] === "object" ? Object.keys(_input.data[0]) : [];
+            if (!Array.isArray(_input.data[0]) && typeof _input.data[0] !== "object")
+              _input.data = [_input.data];
+          }
+          return serialize(_input.fields || [], _input.data || [], _skipEmptyLines);
+        }
+        throw new Error("Unable to serialize unrecognized input");
+        function unpackConfig() {
+          if (typeof _config !== "object")
+            return;
+          if (typeof _config.delimiter === "string" && !Papa.BAD_DELIMITERS.filter(function(value) {
+            return _config.delimiter.indexOf(value) !== -1;
+          }).length) {
+            _delimiter = _config.delimiter;
+          }
+          if (typeof _config.quotes === "boolean" || typeof _config.quotes === "function" || Array.isArray(_config.quotes))
+            _quotes = _config.quotes;
+          if (typeof _config.skipEmptyLines === "boolean" || typeof _config.skipEmptyLines === "string")
+            _skipEmptyLines = _config.skipEmptyLines;
+          if (typeof _config.newline === "string")
+            _newline = _config.newline;
+          if (typeof _config.quoteChar === "string")
+            _quoteChar = _config.quoteChar;
+          if (typeof _config.header === "boolean")
+            _writeHeader = _config.header;
+          if (Array.isArray(_config.columns)) {
+            if (_config.columns.length === 0)
+              throw new Error("Option columns is empty");
+            _columns = _config.columns;
+          }
+          if (_config.escapeChar !== void 0) {
+            _escapedQuote = _config.escapeChar + _quoteChar;
+          }
+          if (typeof _config.escapeFormulae === "boolean" || _config.escapeFormulae instanceof RegExp) {
+            _escapeFormulae = _config.escapeFormulae instanceof RegExp ? _config.escapeFormulae : /^[=+\-@\t\r].*$/;
+          }
+        }
+        __name(unpackConfig, "unpackConfig");
+        function serialize(fields, data, skipEmptyLines) {
+          var csv = "";
+          if (typeof fields === "string")
+            fields = JSON.parse(fields);
+          if (typeof data === "string")
+            data = JSON.parse(data);
+          var hasHeader = Array.isArray(fields) && fields.length > 0;
+          var dataKeyedByField = !Array.isArray(data[0]);
+          if (hasHeader && _writeHeader) {
+            for (var i = 0; i < fields.length; i++) {
+              if (i > 0)
+                csv += _delimiter;
+              csv += safe(fields[i], i);
+            }
+            if (data.length > 0)
+              csv += _newline;
+          }
+          for (var row = 0; row < data.length; row++) {
+            var maxCol = hasHeader ? fields.length : data[row].length;
+            var emptyLine = false;
+            var nullLine = hasHeader ? Object.keys(data[row]).length === 0 : data[row].length === 0;
+            if (skipEmptyLines && !hasHeader) {
+              emptyLine = skipEmptyLines === "greedy" ? data[row].join("").trim() === "" : data[row].length === 1 && data[row][0].length === 0;
+            }
+            if (skipEmptyLines === "greedy" && hasHeader) {
+              var line = [];
+              for (var c = 0; c < maxCol; c++) {
+                var cx = dataKeyedByField ? fields[c] : c;
+                line.push(data[row][cx]);
+              }
+              emptyLine = line.join("").trim() === "";
+            }
+            if (!emptyLine) {
+              for (var col = 0; col < maxCol; col++) {
+                if (col > 0 && !nullLine)
+                  csv += _delimiter;
+                var colIdx = hasHeader && dataKeyedByField ? fields[col] : col;
+                csv += safe(data[row][colIdx], col);
+              }
+              if (row < data.length - 1 && (!skipEmptyLines || maxCol > 0 && !nullLine)) {
+                csv += _newline;
+              }
+            }
+          }
+          return csv;
+        }
+        __name(serialize, "serialize");
+        function safe(str, col) {
+          if (typeof str === "undefined" || str === null)
+            return "";
+          if (str.constructor === Date)
+            return JSON.stringify(str).slice(1, 25);
+          var needsQuotes = false;
+          if (_escapeFormulae && typeof str === "string" && _escapeFormulae.test(str)) {
+            str = "'" + str;
+            needsQuotes = true;
+          }
+          var escapedQuoteStr = str.toString().replace(quoteCharRegex, _escapedQuote);
+          needsQuotes = needsQuotes || _quotes === true || typeof _quotes === "function" && _quotes(str, col) || Array.isArray(_quotes) && _quotes[col] || hasAny(escapedQuoteStr, Papa.BAD_DELIMITERS) || escapedQuoteStr.indexOf(_delimiter) > -1 || escapedQuoteStr.charAt(0) === " " || escapedQuoteStr.charAt(escapedQuoteStr.length - 1) === " ";
+          return needsQuotes ? _quoteChar + escapedQuoteStr + _quoteChar : escapedQuoteStr;
+        }
+        __name(safe, "safe");
+        function hasAny(str, substrings) {
+          for (var i = 0; i < substrings.length; i++)
+            if (str.indexOf(substrings[i]) > -1)
+              return true;
+          return false;
+        }
+        __name(hasAny, "hasAny");
+      }
+      __name(JsonToCsv, "JsonToCsv");
+      function ChunkStreamer(config) {
+        this._handle = null;
+        this._finished = false;
+        this._completed = false;
+        this._halted = false;
+        this._input = null;
+        this._baseIndex = 0;
+        this._partialLine = "";
+        this._rowCount = 0;
+        this._start = 0;
+        this._nextChunk = null;
+        this.isFirstChunk = true;
+        this._completeResults = {
+          data: [],
+          errors: [],
+          meta: {}
+        };
+        replaceConfig.call(this, config);
+        this.parseChunk = function(chunk, isFakeChunk) {
+          if (this.isFirstChunk && isFunction(this._config.beforeFirstChunk)) {
+            var modifiedChunk = this._config.beforeFirstChunk(chunk);
+            if (modifiedChunk !== void 0)
+              chunk = modifiedChunk;
+          }
+          this.isFirstChunk = false;
+          this._halted = false;
+          var aggregate = this._partialLine + chunk;
+          this._partialLine = "";
+          var results = this._handle.parse(aggregate, this._baseIndex, !this._finished);
+          if (this._handle.paused() || this._handle.aborted()) {
+            this._halted = true;
+            return;
+          }
+          var lastIndex = results.meta.cursor;
+          if (!this._finished) {
+            this._partialLine = aggregate.substring(lastIndex - this._baseIndex);
+            this._baseIndex = lastIndex;
+          }
+          if (results && results.data)
+            this._rowCount += results.data.length;
+          var finishedIncludingPreview = this._finished || this._config.preview && this._rowCount >= this._config.preview;
+          if (IS_PAPA_WORKER) {
+            global.postMessage({
+              results,
+              workerId: Papa.WORKER_ID,
+              finished: finishedIncludingPreview
+            });
+          } else if (isFunction(this._config.chunk) && !isFakeChunk) {
+            this._config.chunk(results, this._handle);
+            if (this._handle.paused() || this._handle.aborted()) {
+              this._halted = true;
+              return;
+            }
+            results = void 0;
+            this._completeResults = void 0;
+          }
+          if (!this._config.step && !this._config.chunk) {
+            this._completeResults.data = this._completeResults.data.concat(results.data);
+            this._completeResults.errors = this._completeResults.errors.concat(results.errors);
+            this._completeResults.meta = results.meta;
+          }
+          if (!this._completed && finishedIncludingPreview && isFunction(this._config.complete) && (!results || !results.meta.aborted)) {
+            this._config.complete(this._completeResults, this._input);
+            this._completed = true;
+          }
+          if (!finishedIncludingPreview && (!results || !results.meta.paused))
+            this._nextChunk();
+          return results;
+        };
+        this._sendError = function(error) {
+          if (isFunction(this._config.error))
+            this._config.error(error);
+          else if (IS_PAPA_WORKER && this._config.error) {
+            global.postMessage({
+              workerId: Papa.WORKER_ID,
+              error,
+              finished: false
+            });
+          }
+        };
+        function replaceConfig(config2) {
+          var configCopy = copy(config2);
+          configCopy.chunkSize = parseInt(configCopy.chunkSize);
+          if (!config2.step && !config2.chunk)
+            configCopy.chunkSize = null;
+          this._handle = new ParserHandle(configCopy);
+          this._handle.streamer = this;
+          this._config = configCopy;
+        }
+        __name(replaceConfig, "replaceConfig");
+      }
+      __name(ChunkStreamer, "ChunkStreamer");
+      function NetworkStreamer(config) {
+        config = config || {};
+        if (!config.chunkSize)
+          config.chunkSize = Papa.RemoteChunkSize;
+        ChunkStreamer.call(this, config);
+        var xhr;
+        if (IS_WORKER) {
+          this._nextChunk = function() {
+            this._readChunk();
+            this._chunkLoaded();
+          };
+        } else {
+          this._nextChunk = function() {
+            this._readChunk();
+          };
+        }
+        this.stream = function(url) {
+          this._input = url;
+          this._nextChunk();
+        };
+        this._readChunk = function() {
+          if (this._finished) {
+            this._chunkLoaded();
+            return;
+          }
+          xhr = new XMLHttpRequest();
+          if (this._config.withCredentials) {
+            xhr.withCredentials = this._config.withCredentials;
+          }
+          if (!IS_WORKER) {
+            xhr.onload = bindFunction(this._chunkLoaded, this);
+            xhr.onerror = bindFunction(this._chunkError, this);
+          }
+          xhr.open(this._config.downloadRequestBody ? "POST" : "GET", this._input, !IS_WORKER);
+          if (this._config.downloadRequestHeaders) {
+            var headers = this._config.downloadRequestHeaders;
+            for (var headerName in headers) {
+              xhr.setRequestHeader(headerName, headers[headerName]);
+            }
+          }
+          if (this._config.chunkSize) {
+            var end = this._start + this._config.chunkSize - 1;
+            xhr.setRequestHeader("Range", "bytes=" + this._start + "-" + end);
+          }
+          try {
+            xhr.send(this._config.downloadRequestBody);
+          } catch (err) {
+            this._chunkError(err.message);
+          }
+          if (IS_WORKER && xhr.status === 0)
+            this._chunkError();
+        };
+        this._chunkLoaded = function() {
+          if (xhr.readyState !== 4)
+            return;
+          if (xhr.status < 200 || xhr.status >= 400) {
+            this._chunkError();
+            return;
+          }
+          this._start += this._config.chunkSize ? this._config.chunkSize : xhr.responseText.length;
+          this._finished = !this._config.chunkSize || this._start >= getFileSize(xhr);
+          this.parseChunk(xhr.responseText);
+        };
+        this._chunkError = function(errorMessage) {
+          var errorText = xhr.statusText || errorMessage;
+          this._sendError(new Error(errorText));
+        };
+        function getFileSize(xhr2) {
+          var contentRange = xhr2.getResponseHeader("Content-Range");
+          if (contentRange === null) {
+            return -1;
+          }
+          return parseInt(contentRange.substring(contentRange.lastIndexOf("/") + 1));
+        }
+        __name(getFileSize, "getFileSize");
+      }
+      __name(NetworkStreamer, "NetworkStreamer");
+      NetworkStreamer.prototype = Object.create(ChunkStreamer.prototype);
+      NetworkStreamer.prototype.constructor = NetworkStreamer;
+      function FileStreamer(config) {
+        config = config || {};
+        if (!config.chunkSize)
+          config.chunkSize = Papa.LocalChunkSize;
+        ChunkStreamer.call(this, config);
+        var reader, slice;
+        var usingAsyncReader = typeof FileReader !== "undefined";
+        this.stream = function(file) {
+          this._input = file;
+          slice = file.slice || file.webkitSlice || file.mozSlice;
+          if (usingAsyncReader) {
+            reader = new FileReader();
+            reader.onload = bindFunction(this._chunkLoaded, this);
+            reader.onerror = bindFunction(this._chunkError, this);
+          } else
+            reader = new FileReaderSync();
+          this._nextChunk();
+        };
+        this._nextChunk = function() {
+          if (!this._finished && (!this._config.preview || this._rowCount < this._config.preview))
+            this._readChunk();
+        };
+        this._readChunk = function() {
+          var input = this._input;
+          if (this._config.chunkSize) {
+            var end = Math.min(this._start + this._config.chunkSize, this._input.size);
+            input = slice.call(input, this._start, end);
+          }
+          var txt = reader.readAsText(input, this._config.encoding);
+          if (!usingAsyncReader)
+            this._chunkLoaded({ target: { result: txt } });
+        };
+        this._chunkLoaded = function(event) {
+          this._start += this._config.chunkSize;
+          this._finished = !this._config.chunkSize || this._start >= this._input.size;
+          this.parseChunk(event.target.result);
+        };
+        this._chunkError = function() {
+          this._sendError(reader.error);
+        };
+      }
+      __name(FileStreamer, "FileStreamer");
+      FileStreamer.prototype = Object.create(ChunkStreamer.prototype);
+      FileStreamer.prototype.constructor = FileStreamer;
+      function StringStreamer(config) {
+        config = config || {};
+        ChunkStreamer.call(this, config);
+        var remaining;
+        this.stream = function(s) {
+          remaining = s;
+          return this._nextChunk();
+        };
+        this._nextChunk = function() {
+          if (this._finished)
+            return;
+          var size = this._config.chunkSize;
+          var chunk;
+          if (size) {
+            chunk = remaining.substring(0, size);
+            remaining = remaining.substring(size);
+          } else {
+            chunk = remaining;
+            remaining = "";
+          }
+          this._finished = !remaining;
+          return this.parseChunk(chunk);
+        };
+      }
+      __name(StringStreamer, "StringStreamer");
+      StringStreamer.prototype = Object.create(StringStreamer.prototype);
+      StringStreamer.prototype.constructor = StringStreamer;
+      function ReadableStreamStreamer(config) {
+        config = config || {};
+        ChunkStreamer.call(this, config);
+        var queue = [];
+        var parseOnData = true;
+        var streamHasEnded = false;
+        this.pause = function() {
+          ChunkStreamer.prototype.pause.apply(this, arguments);
+          this._input.pause();
+        };
+        this.resume = function() {
+          ChunkStreamer.prototype.resume.apply(this, arguments);
+          this._input.resume();
+        };
+        this.stream = function(stream) {
+          this._input = stream;
+          this._input.on("data", this._streamData);
+          this._input.on("end", this._streamEnd);
+          this._input.on("error", this._streamError);
+        };
+        this._checkIsFinished = function() {
+          if (streamHasEnded && queue.length === 1) {
+            this._finished = true;
+          }
+        };
+        this._nextChunk = function() {
+          this._checkIsFinished();
+          if (queue.length) {
+            this.parseChunk(queue.shift());
+          } else {
+            parseOnData = true;
+          }
+        };
+        this._streamData = bindFunction(function(chunk) {
+          try {
+            queue.push(typeof chunk === "string" ? chunk : chunk.toString(this._config.encoding));
+            if (parseOnData) {
+              parseOnData = false;
+              this._checkIsFinished();
+              this.parseChunk(queue.shift());
+            }
+          } catch (error) {
+            this._streamError(error);
+          }
+        }, this);
+        this._streamError = bindFunction(function(error) {
+          this._streamCleanUp();
+          this._sendError(error);
+        }, this);
+        this._streamEnd = bindFunction(function() {
+          this._streamCleanUp();
+          streamHasEnded = true;
+          this._streamData("");
+        }, this);
+        this._streamCleanUp = bindFunction(function() {
+          this._input.removeListener("data", this._streamData);
+          this._input.removeListener("end", this._streamEnd);
+          this._input.removeListener("error", this._streamError);
+        }, this);
+      }
+      __name(ReadableStreamStreamer, "ReadableStreamStreamer");
+      ReadableStreamStreamer.prototype = Object.create(ChunkStreamer.prototype);
+      ReadableStreamStreamer.prototype.constructor = ReadableStreamStreamer;
+      function DuplexStreamStreamer(_config) {
+        var Duplex = require("stream").Duplex;
+        var config = copy(_config);
+        var parseOnWrite = true;
+        var writeStreamHasFinished = false;
+        var parseCallbackQueue = [];
+        var stream = null;
+        this._onCsvData = function(results) {
+          var data = results.data;
+          if (!stream.push(data) && !this._handle.paused()) {
+            this._handle.pause();
+          }
+        };
+        this._onCsvComplete = function() {
+          stream.push(null);
+        };
+        config.step = bindFunction(this._onCsvData, this);
+        config.complete = bindFunction(this._onCsvComplete, this);
+        ChunkStreamer.call(this, config);
+        this._nextChunk = function() {
+          if (writeStreamHasFinished && parseCallbackQueue.length === 1) {
+            this._finished = true;
+          }
+          if (parseCallbackQueue.length) {
+            parseCallbackQueue.shift()();
+          } else {
+            parseOnWrite = true;
+          }
+        };
+        this._addToParseQueue = function(chunk, callback) {
+          parseCallbackQueue.push(bindFunction(function() {
+            this.parseChunk(typeof chunk === "string" ? chunk : chunk.toString(config.encoding));
+            if (isFunction(callback)) {
+              return callback();
+            }
+          }, this));
+          if (parseOnWrite) {
+            parseOnWrite = false;
+            this._nextChunk();
+          }
+        };
+        this._onRead = function() {
+          if (this._handle.paused()) {
+            this._handle.resume();
+          }
+        };
+        this._onWrite = function(chunk, encoding, callback) {
+          this._addToParseQueue(chunk, callback);
+        };
+        this._onWriteComplete = function() {
+          writeStreamHasFinished = true;
+          this._addToParseQueue("");
+        };
+        this.getStream = function() {
+          return stream;
+        };
+        stream = new Duplex({
+          readableObjectMode: true,
+          decodeStrings: false,
+          read: bindFunction(this._onRead, this),
+          write: bindFunction(this._onWrite, this)
+        });
+        stream.once("finish", bindFunction(this._onWriteComplete, this));
+      }
+      __name(DuplexStreamStreamer, "DuplexStreamStreamer");
+      if (typeof PAPA_BROWSER_CONTEXT === "undefined") {
+        DuplexStreamStreamer.prototype = Object.create(ChunkStreamer.prototype);
+        DuplexStreamStreamer.prototype.constructor = DuplexStreamStreamer;
+      }
+      function ParserHandle(_config) {
+        var MAX_FLOAT = Math.pow(2, 53);
+        var MIN_FLOAT = -MAX_FLOAT;
+        var FLOAT = /^\s*-?(\d+\.?|\.\d+|\d+\.\d+)([eE][-+]?\d+)?\s*$/;
+        var ISO_DATE = /^((\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)))$/;
+        var self2 = this;
+        var _stepCounter = 0;
+        var _rowCounter = 0;
+        var _input;
+        var _parser;
+        var _paused = false;
+        var _aborted = false;
+        var _delimiterError;
+        var _fields = [];
+        var _results = {
+          // The last results returned from the parser
+          data: [],
+          errors: [],
+          meta: {}
+        };
+        if (isFunction(_config.step)) {
+          var userStep = _config.step;
+          _config.step = function(results) {
+            _results = results;
+            if (needsHeaderRow())
+              processResults();
+            else {
+              processResults();
+              if (_results.data.length === 0)
+                return;
+              _stepCounter += results.data.length;
+              if (_config.preview && _stepCounter > _config.preview)
+                _parser.abort();
+              else {
+                _results.data = _results.data[0];
+                userStep(_results, self2);
+              }
+            }
+          };
+        }
+        this.parse = function(input, baseIndex, ignoreLastRow) {
+          var quoteChar = _config.quoteChar || '"';
+          if (!_config.newline)
+            _config.newline = guessLineEndings(input, quoteChar);
+          _delimiterError = false;
+          if (!_config.delimiter) {
+            var delimGuess = guessDelimiter(input, _config.newline, _config.skipEmptyLines, _config.comments, _config.delimitersToGuess);
+            if (delimGuess.successful)
+              _config.delimiter = delimGuess.bestDelimiter;
+            else {
+              _delimiterError = true;
+              _config.delimiter = Papa.DefaultDelimiter;
+            }
+            _results.meta.delimiter = _config.delimiter;
+          } else if (isFunction(_config.delimiter)) {
+            _config.delimiter = _config.delimiter(input);
+            _results.meta.delimiter = _config.delimiter;
+          }
+          var parserConfig = copy(_config);
+          if (_config.preview && _config.header)
+            parserConfig.preview++;
+          _input = input;
+          _parser = new Parser(parserConfig);
+          _results = _parser.parse(_input, baseIndex, ignoreLastRow);
+          processResults();
+          return _paused ? { meta: { paused: true } } : _results || { meta: { paused: false } };
+        };
+        this.paused = function() {
+          return _paused;
+        };
+        this.pause = function() {
+          _paused = true;
+          _parser.abort();
+          _input = isFunction(_config.chunk) ? "" : _input.substring(_parser.getCharIndex());
+        };
+        this.resume = function() {
+          if (self2.streamer._halted) {
+            _paused = false;
+            self2.streamer.parseChunk(_input, true);
+          } else {
+            setTimeout(self2.resume, 3);
+          }
+        };
+        this.aborted = function() {
+          return _aborted;
+        };
+        this.abort = function() {
+          _aborted = true;
+          _parser.abort();
+          _results.meta.aborted = true;
+          if (isFunction(_config.complete))
+            _config.complete(_results);
+          _input = "";
+        };
+        function testEmptyLine(s) {
+          return _config.skipEmptyLines === "greedy" ? s.join("").trim() === "" : s.length === 1 && s[0].length === 0;
+        }
+        __name(testEmptyLine, "testEmptyLine");
+        function testFloat(s) {
+          if (FLOAT.test(s)) {
+            var floatValue = parseFloat(s);
+            if (floatValue > MIN_FLOAT && floatValue < MAX_FLOAT) {
+              return true;
+            }
+          }
+          return false;
+        }
+        __name(testFloat, "testFloat");
+        function processResults() {
+          if (_results && _delimiterError) {
+            addError("Delimiter", "UndetectableDelimiter", "Unable to auto-detect delimiting character; defaulted to '" + Papa.DefaultDelimiter + "'");
+            _delimiterError = false;
+          }
+          if (_config.skipEmptyLines) {
+            _results.data = _results.data.filter(function(d) {
+              return !testEmptyLine(d);
+            });
+          }
+          if (needsHeaderRow())
+            fillHeaderFields();
+          return applyHeaderAndDynamicTypingAndTransformation();
+        }
+        __name(processResults, "processResults");
+        function needsHeaderRow() {
+          return _config.header && _fields.length === 0;
+        }
+        __name(needsHeaderRow, "needsHeaderRow");
+        function fillHeaderFields() {
+          if (!_results)
+            return;
+          function addHeader(header, i2) {
+            if (isFunction(_config.transformHeader))
+              header = _config.transformHeader(header, i2);
+            _fields.push(header);
+          }
+          __name(addHeader, "addHeader");
+          if (Array.isArray(_results.data[0])) {
+            for (var i = 0; needsHeaderRow() && i < _results.data.length; i++)
+              _results.data[i].forEach(addHeader);
+            _results.data.splice(0, 1);
+          } else
+            _results.data.forEach(addHeader);
+        }
+        __name(fillHeaderFields, "fillHeaderFields");
+        function shouldApplyDynamicTyping(field) {
+          if (_config.dynamicTypingFunction && _config.dynamicTyping[field] === void 0) {
+            _config.dynamicTyping[field] = _config.dynamicTypingFunction(field);
+          }
+          return (_config.dynamicTyping[field] || _config.dynamicTyping) === true;
+        }
+        __name(shouldApplyDynamicTyping, "shouldApplyDynamicTyping");
+        function parseDynamic(field, value) {
+          if (shouldApplyDynamicTyping(field)) {
+            if (value === "true" || value === "TRUE")
+              return true;
+            else if (value === "false" || value === "FALSE")
+              return false;
+            else if (testFloat(value))
+              return parseFloat(value);
+            else if (ISO_DATE.test(value))
+              return new Date(value);
+            else
+              return value === "" ? null : value;
+          }
+          return value;
+        }
+        __name(parseDynamic, "parseDynamic");
+        function applyHeaderAndDynamicTypingAndTransformation() {
+          if (!_results || !_config.header && !_config.dynamicTyping && !_config.transform)
+            return _results;
+          function processRow(rowSource, i) {
+            var row = _config.header ? {} : [];
+            var j;
+            for (j = 0; j < rowSource.length; j++) {
+              var field = j;
+              var value = rowSource[j];
+              if (_config.header)
+                field = j >= _fields.length ? "__parsed_extra" : _fields[j];
+              if (_config.transform)
+                value = _config.transform(value, field);
+              value = parseDynamic(field, value);
+              if (field === "__parsed_extra") {
+                row[field] = row[field] || [];
+                row[field].push(value);
+              } else
+                row[field] = value;
+            }
+            if (_config.header) {
+              if (j > _fields.length)
+                addError("FieldMismatch", "TooManyFields", "Too many fields: expected " + _fields.length + " fields but parsed " + j, _rowCounter + i);
+              else if (j < _fields.length)
+                addError("FieldMismatch", "TooFewFields", "Too few fields: expected " + _fields.length + " fields but parsed " + j, _rowCounter + i);
+            }
+            return row;
+          }
+          __name(processRow, "processRow");
+          var incrementBy = 1;
+          if (!_results.data.length || Array.isArray(_results.data[0])) {
+            _results.data = _results.data.map(processRow);
+            incrementBy = _results.data.length;
+          } else
+            _results.data = processRow(_results.data, 0);
+          if (_config.header && _results.meta)
+            _results.meta.fields = _fields;
+          _rowCounter += incrementBy;
+          return _results;
+        }
+        __name(applyHeaderAndDynamicTypingAndTransformation, "applyHeaderAndDynamicTypingAndTransformation");
+        function guessDelimiter(input, newline, skipEmptyLines, comments, delimitersToGuess) {
+          var bestDelim, bestDelta, fieldCountPrevRow, maxFieldCount;
+          delimitersToGuess = delimitersToGuess || [",", "	", "|", ";", Papa.RECORD_SEP, Papa.UNIT_SEP];
+          for (var i = 0; i < delimitersToGuess.length; i++) {
+            var delim = delimitersToGuess[i];
+            var delta = 0, avgFieldCount = 0, emptyLinesCount = 0;
+            fieldCountPrevRow = void 0;
+            var preview = new Parser({
+              comments,
+              delimiter: delim,
+              newline,
+              preview: 10
+            }).parse(input);
+            for (var j = 0; j < preview.data.length; j++) {
+              if (skipEmptyLines && testEmptyLine(preview.data[j])) {
+                emptyLinesCount++;
+                continue;
+              }
+              var fieldCount = preview.data[j].length;
+              avgFieldCount += fieldCount;
+              if (typeof fieldCountPrevRow === "undefined") {
+                fieldCountPrevRow = fieldCount;
+                continue;
+              } else if (fieldCount > 0) {
+                delta += Math.abs(fieldCount - fieldCountPrevRow);
+                fieldCountPrevRow = fieldCount;
+              }
+            }
+            if (preview.data.length > 0)
+              avgFieldCount /= preview.data.length - emptyLinesCount;
+            if ((typeof bestDelta === "undefined" || delta <= bestDelta) && (typeof maxFieldCount === "undefined" || avgFieldCount > maxFieldCount) && avgFieldCount > 1.99) {
+              bestDelta = delta;
+              bestDelim = delim;
+              maxFieldCount = avgFieldCount;
+            }
+          }
+          _config.delimiter = bestDelim;
+          return {
+            successful: !!bestDelim,
+            bestDelimiter: bestDelim
+          };
+        }
+        __name(guessDelimiter, "guessDelimiter");
+        function guessLineEndings(input, quoteChar) {
+          input = input.substring(0, 1024 * 1024);
+          var re = new RegExp(escapeRegExp(quoteChar) + "([^]*?)" + escapeRegExp(quoteChar), "gm");
+          input = input.replace(re, "");
+          var r = input.split("\r");
+          var n = input.split("\n");
+          var nAppearsFirst = n.length > 1 && n[0].length < r[0].length;
+          if (r.length === 1 || nAppearsFirst)
+            return "\n";
+          var numWithN = 0;
+          for (var i = 0; i < r.length; i++) {
+            if (r[i][0] === "\n")
+              numWithN++;
+          }
+          return numWithN >= r.length / 2 ? "\r\n" : "\r";
+        }
+        __name(guessLineEndings, "guessLineEndings");
+        function addError(type, code, msg, row) {
+          var error = {
+            type,
+            code,
+            message: msg
+          };
+          if (row !== void 0) {
+            error.row = row;
+          }
+          _results.errors.push(error);
+        }
+        __name(addError, "addError");
+      }
+      __name(ParserHandle, "ParserHandle");
+      function escapeRegExp(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+      __name(escapeRegExp, "escapeRegExp");
+      function Parser(config) {
+        config = config || {};
+        var delim = config.delimiter;
+        var newline = config.newline;
+        var comments = config.comments;
+        var step = config.step;
+        var preview = config.preview;
+        var fastMode = config.fastMode;
+        var quoteChar;
+        if (config.quoteChar === void 0 || config.quoteChar === null) {
+          quoteChar = '"';
+        } else {
+          quoteChar = config.quoteChar;
+        }
+        var escapeChar = quoteChar;
+        if (config.escapeChar !== void 0) {
+          escapeChar = config.escapeChar;
+        }
+        if (typeof delim !== "string" || Papa.BAD_DELIMITERS.indexOf(delim) > -1)
+          delim = ",";
+        if (comments === delim)
+          throw new Error("Comment character same as delimiter");
+        else if (comments === true)
+          comments = "#";
+        else if (typeof comments !== "string" || Papa.BAD_DELIMITERS.indexOf(comments) > -1)
+          comments = false;
+        if (newline !== "\n" && newline !== "\r" && newline !== "\r\n")
+          newline = "\n";
+        var cursor = 0;
+        var aborted = false;
+        this.parse = function(input, baseIndex, ignoreLastRow) {
+          if (typeof input !== "string")
+            throw new Error("Input must be a string");
+          var inputLen = input.length, delimLen = delim.length, newlineLen = newline.length, commentsLen = comments.length;
+          var stepIsFunction = isFunction(step);
+          cursor = 0;
+          var data = [], errors = [], row = [], lastCursor = 0;
+          if (!input)
+            return returnable();
+          if (config.header && !baseIndex) {
+            var firstLine = input.split(newline)[0];
+            var headers = firstLine.split(delim);
+            var separator = "_";
+            var headerMap = [];
+            var headerCount = {};
+            var duplicateHeaders = false;
+            for (var j in headers) {
+              var header = headers[j];
+              if (isFunction(config.transformHeader))
+                header = config.transformHeader(header, j);
+              var headerName = header;
+              var count = headerCount[header] || 0;
+              if (count > 0) {
+                duplicateHeaders = true;
+                headerName = header + separator + count;
+              }
+              headerCount[header] = count + 1;
+              while (headerMap.includes(headerName)) {
+                headerName = headerName + separator + count;
+              }
+              headerMap.push(headerName);
+            }
+            if (duplicateHeaders) {
+              var editedInput = input.split(newline);
+              editedInput[0] = headerMap.join(delim);
+              input = editedInput.join(newline);
+            }
+          }
+          if (fastMode || fastMode !== false && input.indexOf(quoteChar) === -1) {
+            var rows = input.split(newline);
+            for (var i = 0; i < rows.length; i++) {
+              row = rows[i];
+              cursor += row.length;
+              if (i !== rows.length - 1)
+                cursor += newline.length;
+              else if (ignoreLastRow)
+                return returnable();
+              if (comments && row.substring(0, commentsLen) === comments)
+                continue;
+              if (stepIsFunction) {
+                data = [];
+                pushRow(row.split(delim));
+                doStep();
+                if (aborted)
+                  return returnable();
+              } else
+                pushRow(row.split(delim));
+              if (preview && i >= preview) {
+                data = data.slice(0, preview);
+                return returnable(true);
+              }
+            }
+            return returnable();
+          }
+          var nextDelim = input.indexOf(delim, cursor);
+          var nextNewline = input.indexOf(newline, cursor);
+          var quoteCharRegex = new RegExp(escapeRegExp(escapeChar) + escapeRegExp(quoteChar), "g");
+          var quoteSearch = input.indexOf(quoteChar, cursor);
+          for (; ; ) {
+            if (input[cursor] === quoteChar) {
+              quoteSearch = cursor;
+              cursor++;
+              for (; ; ) {
+                quoteSearch = input.indexOf(quoteChar, quoteSearch + 1);
+                if (quoteSearch === -1) {
+                  if (!ignoreLastRow) {
+                    errors.push({
+                      type: "Quotes",
+                      code: "MissingQuotes",
+                      message: "Quoted field unterminated",
+                      row: data.length,
+                      // row has yet to be inserted
+                      index: cursor
+                    });
+                  }
+                  return finish();
+                }
+                if (quoteSearch === inputLen - 1) {
+                  var value = input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar);
+                  return finish(value);
+                }
+                if (quoteChar === escapeChar && input[quoteSearch + 1] === escapeChar) {
+                  quoteSearch++;
+                  continue;
+                }
+                if (quoteChar !== escapeChar && quoteSearch !== 0 && input[quoteSearch - 1] === escapeChar) {
+                  continue;
+                }
+                if (nextDelim !== -1 && nextDelim < quoteSearch + 1) {
+                  nextDelim = input.indexOf(delim, quoteSearch + 1);
+                }
+                if (nextNewline !== -1 && nextNewline < quoteSearch + 1) {
+                  nextNewline = input.indexOf(newline, quoteSearch + 1);
+                }
+                var checkUpTo = nextNewline === -1 ? nextDelim : Math.min(nextDelim, nextNewline);
+                var spacesBetweenQuoteAndDelimiter = extraSpaces(checkUpTo);
+                if (input.substr(quoteSearch + 1 + spacesBetweenQuoteAndDelimiter, delimLen) === delim) {
+                  row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
+                  cursor = quoteSearch + 1 + spacesBetweenQuoteAndDelimiter + delimLen;
+                  if (input[quoteSearch + 1 + spacesBetweenQuoteAndDelimiter + delimLen] !== quoteChar) {
+                    quoteSearch = input.indexOf(quoteChar, cursor);
+                  }
+                  nextDelim = input.indexOf(delim, cursor);
+                  nextNewline = input.indexOf(newline, cursor);
+                  break;
+                }
+                var spacesBetweenQuoteAndNewLine = extraSpaces(nextNewline);
+                if (input.substring(quoteSearch + 1 + spacesBetweenQuoteAndNewLine, quoteSearch + 1 + spacesBetweenQuoteAndNewLine + newlineLen) === newline) {
+                  row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
+                  saveRow(quoteSearch + 1 + spacesBetweenQuoteAndNewLine + newlineLen);
+                  nextDelim = input.indexOf(delim, cursor);
+                  quoteSearch = input.indexOf(quoteChar, cursor);
+                  if (stepIsFunction) {
+                    doStep();
+                    if (aborted)
+                      return returnable();
+                  }
+                  if (preview && data.length >= preview)
+                    return returnable(true);
+                  break;
+                }
+                errors.push({
+                  type: "Quotes",
+                  code: "InvalidQuotes",
+                  message: "Trailing quote on quoted field is malformed",
+                  row: data.length,
+                  // row has yet to be inserted
+                  index: cursor
+                });
+                quoteSearch++;
+                continue;
+              }
+              continue;
+            }
+            if (comments && row.length === 0 && input.substring(cursor, cursor + commentsLen) === comments) {
+              if (nextNewline === -1)
+                return returnable();
+              cursor = nextNewline + newlineLen;
+              nextNewline = input.indexOf(newline, cursor);
+              nextDelim = input.indexOf(delim, cursor);
+              continue;
+            }
+            if (nextDelim !== -1 && (nextDelim < nextNewline || nextNewline === -1)) {
+              row.push(input.substring(cursor, nextDelim));
+              cursor = nextDelim + delimLen;
+              nextDelim = input.indexOf(delim, cursor);
+              continue;
+            }
+            if (nextNewline !== -1) {
+              row.push(input.substring(cursor, nextNewline));
+              saveRow(nextNewline + newlineLen);
+              if (stepIsFunction) {
+                doStep();
+                if (aborted)
+                  return returnable();
+              }
+              if (preview && data.length >= preview)
+                return returnable(true);
+              continue;
+            }
+            break;
+          }
+          return finish();
+          function pushRow(row2) {
+            data.push(row2);
+            lastCursor = cursor;
+          }
+          __name(pushRow, "pushRow");
+          function extraSpaces(index) {
+            var spaceLength = 0;
+            if (index !== -1) {
+              var textBetweenClosingQuoteAndIndex = input.substring(quoteSearch + 1, index);
+              if (textBetweenClosingQuoteAndIndex && textBetweenClosingQuoteAndIndex.trim() === "") {
+                spaceLength = textBetweenClosingQuoteAndIndex.length;
+              }
+            }
+            return spaceLength;
+          }
+          __name(extraSpaces, "extraSpaces");
+          function finish(value2) {
+            if (ignoreLastRow)
+              return returnable();
+            if (typeof value2 === "undefined")
+              value2 = input.substring(cursor);
+            row.push(value2);
+            cursor = inputLen;
+            pushRow(row);
+            if (stepIsFunction)
+              doStep();
+            return returnable();
+          }
+          __name(finish, "finish");
+          function saveRow(newCursor) {
+            cursor = newCursor;
+            pushRow(row);
+            row = [];
+            nextNewline = input.indexOf(newline, cursor);
+          }
+          __name(saveRow, "saveRow");
+          function returnable(stopped) {
+            return {
+              data,
+              errors,
+              meta: {
+                delimiter: delim,
+                linebreak: newline,
+                aborted,
+                truncated: !!stopped,
+                cursor: lastCursor + (baseIndex || 0)
+              }
+            };
+          }
+          __name(returnable, "returnable");
+          function doStep() {
+            step(returnable());
+            data = [];
+            errors = [];
+          }
+          __name(doStep, "doStep");
+        };
+        this.abort = function() {
+          aborted = true;
+        };
+        this.getCharIndex = function() {
+          return cursor;
+        };
+      }
+      __name(Parser, "Parser");
+      function newWorker() {
+        if (!Papa.WORKERS_SUPPORTED)
+          return false;
+        var workerUrl = getWorkerBlob();
+        var w = new global.Worker(workerUrl);
+        w.onmessage = mainThreadReceivedMessage;
+        w.id = workerIdCounter++;
+        workers[w.id] = w;
+        return w;
+      }
+      __name(newWorker, "newWorker");
+      function mainThreadReceivedMessage(e) {
+        var msg = e.data;
+        var worker = workers[msg.workerId];
+        var aborted = false;
+        if (msg.error)
+          worker.userError(msg.error, msg.file);
+        else if (msg.results && msg.results.data) {
+          var abort = /* @__PURE__ */ __name(function() {
+            aborted = true;
+            completeWorker(msg.workerId, { data: [], errors: [], meta: { aborted: true } });
+          }, "abort");
+          var handle = {
+            abort,
+            pause: notImplemented,
+            resume: notImplemented
+          };
+          if (isFunction(worker.userStep)) {
+            for (var i = 0; i < msg.results.data.length; i++) {
+              worker.userStep({
+                data: msg.results.data[i],
+                errors: msg.results.errors,
+                meta: msg.results.meta
+              }, handle);
+              if (aborted)
+                break;
+            }
+            delete msg.results;
+          } else if (isFunction(worker.userChunk)) {
+            worker.userChunk(msg.results, handle, msg.file);
+            delete msg.results;
+          }
+        }
+        if (msg.finished && !aborted)
+          completeWorker(msg.workerId, msg.results);
+      }
+      __name(mainThreadReceivedMessage, "mainThreadReceivedMessage");
+      function completeWorker(workerId, results) {
+        var worker = workers[workerId];
+        if (isFunction(worker.userComplete))
+          worker.userComplete(results);
+        worker.terminate();
+        delete workers[workerId];
+      }
+      __name(completeWorker, "completeWorker");
+      function notImplemented() {
+        throw new Error("Not implemented.");
+      }
+      __name(notImplemented, "notImplemented");
+      function workerThreadReceivedMessage(e) {
+        var msg = e.data;
+        if (typeof Papa.WORKER_ID === "undefined" && msg)
+          Papa.WORKER_ID = msg.workerId;
+        if (typeof msg.input === "string") {
+          global.postMessage({
+            workerId: Papa.WORKER_ID,
+            results: Papa.parse(msg.input, msg.config),
+            finished: true
+          });
+        } else if (global.File && msg.input instanceof File || msg.input instanceof Object) {
+          var results = Papa.parse(msg.input, msg.config);
+          if (results)
+            global.postMessage({
+              workerId: Papa.WORKER_ID,
+              results,
+              finished: true
+            });
+        }
+      }
+      __name(workerThreadReceivedMessage, "workerThreadReceivedMessage");
+      function copy(obj) {
+        if (typeof obj !== "object" || obj === null)
+          return obj;
+        var cpy = Array.isArray(obj) ? [] : {};
+        for (var key in obj)
+          cpy[key] = copy(obj[key]);
+        return cpy;
+      }
+      __name(copy, "copy");
+      function bindFunction(f, self2) {
+        return function() {
+          f.apply(self2, arguments);
+        };
+      }
+      __name(bindFunction, "bindFunction");
+      function isFunction(func) {
+        return typeof func === "function";
+      }
+      __name(isFunction, "isFunction");
+      return Papa;
+    }, "moduleFactory"));
+  }
+});
+
 // src/convention_builder.js
 var require_convention_builder = __commonJS({
   "src/convention_builder.js"(exports2) {
@@ -9107,8 +10445,10 @@ var require_convention_builder = __commonJS({
       gitlabOverlayURLTemplate,
       gitlabConventionURLTemplate,
       basicSchemaURLTemplate,
-      arrayToStructuredConvention
+      arrayToStructuredConvention,
+      flattenJSONSchema
     } = require_schema_utilities();
+    var papa = require_papaparse();
     function getAttributes(root, convention) {
       let branches = convention.relationships.filter((rel) => rel.containerEntity == root).map((d) => d.mentionedEntity);
       let output = {};
@@ -9129,6 +10469,7 @@ var require_convention_builder = __commonJS({
         originalSrcScript,
         trivial = false,
         baseSchemataFolder = `${__dirname}/../../../../input/collection`,
+        baseSchema,
         gitlabProjectId = process.env.CI_PROJECT_ID,
         requiredFields = [],
         modifiedAttributes,
@@ -9152,15 +10493,17 @@ var require_convention_builder = __commonJS({
         ;
         this.type = typeAndBundle.split("--")[0];
         this.bundle = typeAndBundle.split("--")[1];
-        let baseSchema;
-        try {
-          baseSchema = JSON.parse(fs.readFileSync(`${baseSchemataFolder}/${this.type}/${this.bundle}/schema.json`));
-          delete baseSchema.schema;
-        } catch (e) {
-          if (e.code == "ENOENT") {
-            throw new Error(`No schema for ${typeAndBundle} was found. This might be due to the schema not existing in the farm, or the current "input/collection" folder structure being out of date. You can update it using the "getAllSchemas.js" script, in the script folder. Search path was: ${baseSchemataFolder}/${this.type}/${this.bundle}/`);
-          } else {
-            throw e;
+        if (!baseSchema) {
+          try {
+            baseSchema = JSON.parse(fs.readFileSync(`${baseSchemataFolder}/${this.type}/${this.bundle}/schema.json`));
+            delete baseSchema.schema;
+          } catch (e) {
+            if (e.code == "ENOENT") {
+              throw new Error(`No schema for ${typeAndBundle} was found. This might be due to the schema not existing in the farm, or the current "input/collection" folder structure being out of date. You can update it using the "getAllSchemas.js" script, in the script folder. Search path was: ${baseSchemataFolder}/${this.type}/${this.bundle}/`);
+            } else {
+              throw e;
+            }
+            ;
           }
           ;
         }
@@ -9322,6 +10665,13 @@ var require_convention_builder = __commonJS({
         delete this.overlay.properties.attributes.properties[attribute];
         this.updateAttributeStatus(attribute);
       }
+      /**
+      * This method takes this object's schema and returns an array of fixed attributes objects, which is equivalent to a row by row encoded excel spreadsheet and is mostly meant at allowing users to work on said schema via a tabular structure.
+      * The output will include one row for each data entry path (not all of the paths) and will synthesize all of its properties into columns, such as name, Title, Type, etc.
+      */
+      getTabularRepresentation() {
+        return flattenJSONSchema(this.schema, false);
+      }
       /**
        * Build an AJV validator and ensure all valid examples are accepted and all error examples are rejected. Returns an array attribute for each set of examples, plus a general success attribute indicating wether all examples resulted as expected and a failedExamples array only listing entities for which there was no success (meanin unrejected error examples and rejected valid examples).
        */
@@ -9865,6 +11215,13 @@ import TabItem from '@theme/TabItem';
         ;
         return output;
       }
+      /**
+      * This method takes this object's schema and returns an array of fixed attributes objects, which is equivalent to a row by row encoded excel spreadsheet and is mostly meant at allowing users to work on said schema via a tabular structure.
+      * The output will include one row for each data entry path (not all of the paths) and will synthesize all of its properties into columns, such as name, Title, Type, etc.
+      */
+      getTabularRepresentation() {
+        return flattenJSONSchema(this.schema, true);
+      }
       /**
        * Build an AJV validator and ensure all valid examples are accepted and all error examples are rejected. Returns an array attribute for each set of examples, plus a general success attribute indicating wether all examples resulted as expected and a failedExamples array only listing entities for which there was no success (meanin unrejected error examples and rejected valid examples).
        */
@@ -9946,6 +11303,8 @@ import TabItem from '@theme/TabItem';
         fs.mkdirSync(`${targetPath}/examples/correct`, { recursive: true }, console.error);
         fs.mkdirSync(`${targetPath}/examples/incorrect`, { recursive: true }, console.error);
         fs.writeFileSync(`${targetPath}/schema.json`, JSON.stringify(this.schema, null, " "), console.error);
+        let flatTableRepresentation = this.getTabularRepresentation();
+        fs.writeFileSync(`${targetPath}/flat_schema.csv`, papa.unparse(flatTableRepresentation), console.error);
         this.validExamples.forEach((example, i) => {
           fs.writeFileSync(`${targetPath}/examples/correct/example_${i + 1}.json`, JSON.stringify(example, null, " "), console.error);
         });
@@ -10127,5 +11486,13 @@ exports.flattenJSONSchema = schemaUtils.flattenJSONSchema;
 
 uri-js/dist/es5/uri.all.js:
   (** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js *)
+
+papaparse/papaparse.js:
+  (* @license
+  Papa Parse
+  v5.4.1
+  https://github.com/mholt/PapaParse
+  License: MIT
+  *)
 */
 //# sourceMappingURL=index.js.map