convention_builder 1.4.4 → 1.5.1

package/dist/module/index.js

@@ -1180,12 +1180,12 @@ var require_util = __commonJS({
     __name(alwaysValidSchema, "alwaysValidSchema");
     exports.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}"`);
@@ -1595,8 +1595,8 @@ var require_applicability = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.shouldUseRule = exports.shouldUseGroup = exports.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");
@@ -2104,7 +2104,7 @@ var require_keyword = __commonJS({
     }
     __name(validSchemaType, "validSchemaType");
     exports.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");
       }
@@ -2115,9 +2115,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);
         }
@@ -2621,11 +2621,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;
     }
@@ -2659,9 +2659,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");
@@ -2714,8 +2714,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;
@@ -5103,11 +5103,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)
@@ -6678,11 +6678,11 @@ var require_dynamicAnchor = __commonJS({
     __name(dynamicAnchor, "dynamicAnchor");
     exports.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");
@@ -6999,7 +6999,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)
@@ -7008,7 +7008,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}]`);
@@ -7031,7 +7031,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;
@@ -7043,7 +7043,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());
@@ -8196,17 +8196,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}]`);
@@ -8215,7 +8215,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") {
@@ -8614,7 +8614,12 @@ var require_schema_utilities = __commonJS({
     __name(apiComposeTaxonomiesTransformation, "apiComposeTaxonomiesTransformation");
     function exampleImporter(filename, basePath = `${__dirname}/../../../definitions/examples/raw_examples_and_scripts/`, schemataSource = `${__dirname}/../../../input/collection`) {
       let rawData = JSON.parse(fs.readFileSync(`${basePath}/${filename}`)).map((obj) => {
-        let output = obj.entity;
+        let output = obj.entity ? obj.entity : obj;
+        if (!output) {
+          console.log(obj);
+          console.log(output);
+        }
+        ;
         if (output.attributes.relationships) {
           output.relationships = output.attributes.relationships;
           delete output.attributes.relationships;
@@ -8631,7 +8636,7 @@ var require_schema_utilities = __commonJS({
       });
       let newEntities = [];
       let entities = rawData.flatMap((entity) => {
-        let transformedData = apiComposeTaxonomiesTransformation(entity);
+        let transformedData = entity.relationships ? apiComposeTaxonomiesTransformation(entity) : { mainEntity: entity, newEntities: [] };
         return [transformedData.mainEntity, ...transformedData.newEntities];
       });
       return entities;
@@ -9052,6 +9057,20 @@ var require_schema_utilities = __commonJS({
       return output;
     }
     __name(findAllNonObjectAttributesInTree, "findAllNonObjectAttributesInTree");
+    function gitlabConventionURLTemplate({ conventionName, projectID }) {
+      return `https://gitlab.com/api/v4/projects/${projectID}/jobs/artifacts/main/raw/output/collection/conventions/${conventionName}/schema.json?job=copy_schemas`;
+    }
+    __name(gitlabConventionURLTemplate, "gitlabConventionURLTemplate");
+    function gitlabOverlayURLTemplate({ overlayName, projectID, baseEntityTypeAndbundle = "" }) {
+      return `https://gitlab.com/api/v4/projects/${projectID}/jobs/artifacts/main/raw/input/collection/${overlayName}/schema.json?job=copy_schemas`;
+    }
+    __name(gitlabOverlayURLTemplate, "gitlabOverlayURLTemplate");
+    function basicSchemaURLTemplate({ baseEntityTypeAndBundle, projectID }) {
+      let type = baseEntityTypeAndBundle.split("--")[0];
+      let bundle = baseEntityTypeAndBundle.split("--")[1];
+      return `https://gitlab.com/api/v4/projects/${projectID}/jobs/artifacts/main/raw/input/collection/${type}/${bundle}/schema.json?job=copy_schemas`;
+    }
+    __name(basicSchemaURLTemplate, "basicSchemaURLTemplate");
     exports.dig = dig;
     exports.bury = bury;
     exports.fixRelationshipDataField = fixRelationshipDataField;
@@ -9074,6 +9093,1347 @@ var require_schema_utilities = __commonJS({
     exports.listAttributesAndSubAttributes = listAttributesAndSubAttributes;
     exports.findAllObjectAttributesInTree = findAllObjectAttributesInTree;
     exports.findAllNonObjectAttributesInTree = findAllNonObjectAttributesInTree;
+    exports.gitlabConventionURLTemplate = gitlabConventionURLTemplate;
+    exports.gitlabOverlayURLTemplate = gitlabOverlayURLTemplate;
+    exports.basicSchemaURLTemplate = basicSchemaURLTemplate;
+  }
+});
+
+// node_modules/papaparse/papaparse.js
+var require_papaparse = __commonJS({
+  "node_modules/papaparse/papaparse.js"(exports, module) {
+    (function(root, factory) {
+      if (typeof define === "function" && define.amd) {
+        define([], factory);
+      } else if (typeof module === "object" && typeof exports !== "undefined") {
+        module.exports = factory();
+      } else {
+        root.Papa = factory();
+      }
+    })(exports, /* @__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"));
   }
 });
 
@@ -9088,8 +10448,14 @@ var require_convention_builder = __commonJS({
       bury,
       listAttributesAndSubAttributes,
       findAllObjectAttributesInTree,
-      findAllNonObjectAttributesInTree
+      findAllNonObjectAttributesInTree,
+      gitlabOverlayURLTemplate,
+      gitlabConventionURLTemplate,
+      basicSchemaURLTemplate,
+      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 = {};
@@ -9103,21 +10469,24 @@ var require_convention_builder = __commonJS({
         name,
         validExamples,
         erroredExamples,
-        repoURL,
+        repoURLTemplateFunction = gitlabOverlayURLTemplate,
         storageFolder = `${__dirname}/../../../../output/collection/overlays`,
         strictEnums = true,
         overlay = false,
         originalSrcScript,
         trivial = false,
         baseSchemataFolder = `${__dirname}/../../../../input/collection`,
+        baseSchema,
+        gitlabProjectId = process.env.CI_PROJECT_ID,
         requiredFields = [],
-        modifiedAttributes
+        modifiedAttributes,
+        deletedAttributes = []
       }) {
         this.name = name;
         this.typeAndBundle = typeAndBundle;
         this.validExamples = validExamples;
         this.erroredExamples = erroredExamples;
-        this.repoURL = repoURL;
+        this.repoURLTemplateFunction = repoURLTemplateFunction;
         this.schemaName = `${typeAndBundle}--${name}`;
         this.storageFolder = storageFolder;
         this.strictEnums = strictEnums;
@@ -9131,15 +10500,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;
+            }
+            ;
           }
           ;
         }
@@ -9147,6 +10518,7 @@ var require_convention_builder = __commonJS({
         this.baseSchema = baseSchema;
         this.unmodifiedAttributes = listAttributesAndSubAttributes(this.baseSchema);
         this.modifiedAttributes = modifiedAttributes ? modifiedAttributes : /* @__PURE__ */ new Set([]);
+        this.deletedAttributes = deletedAttributes;
         if (!overlay) {
           this.overlay = {
             properties: {
@@ -9178,8 +10550,8 @@ var require_convention_builder = __commonJS({
        */
       updateSchema() {
         this.schema = {};
-        this.schema.$id = `${this.repoURL}/schemata/${this.typeAndBundle.replace("--", "/")}/schema.json`;
         Object.assign(this.schema, this.baseSchema);
+        this.schema.$id = this.repoURLTemplateFunction({ overlayName: this.name, projectID: this.gitlabProjectId, baseEntityTypeAndBundle: this.typeAndBundle });
         let allModifiedAttributes = listAttributesAndSubAttributes(this.overlay);
         this.modifiedAttributes = allModifiedAttributes;
         this.unmodifiedAttributes = listAttributesAndSubAttributes(this.baseSchema);
@@ -9188,6 +10560,7 @@ var require_convention_builder = __commonJS({
           let currentValue = dig(this.overlay.properties.attributes.properties, attr);
           bury(this.schema, `properties.attributes.properties.${attr}`, currentValue, false);
         });
+        this.deletedAttributes.forEach((deletedAttr) => delete this.schema.properties.attributes.properties[deletedAttr]);
         let originalRequiredFields = this.schema.properties.attributes.required ? this.schema.properties.attributes.required : [];
         let allRequiredSet = Array.from(/* @__PURE__ */ new Set([...originalRequiredFields, ...Array.from(this.requiredFields)]));
         this.schema.properties.attributes.required = allRequiredSet;
@@ -9290,6 +10663,22 @@ var require_convention_builder = __commonJS({
         ;
         this.setGenericSection({ attribute, section: subschema, description });
       }
+      /**
+       * Mark an attribute to be omitted from the resulting schema.
+       * @param {} attribute
+       */
+      deleteAttribute(attribute) {
+        this.deletedAttributes.push(attribute);
+        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).
        */
@@ -9380,16 +10769,18 @@ var require_convention_builder = __commonJS({
       constructor({
         typeAndBundle,
         attributeOverlayName,
-        repoURL,
+        repoURLTemplateFunction = basicSchemaURLTemplate,
         strictEnums = true,
-        baseSchemataFolder = `${__dirname}/../../../../input/collection`
+        baseSchemataFolder = `${__dirname}/../../../../input/collection`,
+        gitlabProjectId = process.env.CI_PROJECT_ID
       }) {
         super({
           typeAndBundle,
-          repoURL,
+          repoURLTemplateFunction,
           storageFolder: baseSchemataFolder,
           baseSchemataFolder,
-          strictEnums
+          strictEnums,
+          gitlabProjectId
         });
         this.attributeOverlayName = attributeOverlayName;
       }
@@ -9417,12 +10808,13 @@ var require_convention_builder = __commonJS({
         title,
         schemaName,
         version,
-        repoURL,
+        repoURLTemplateFunction = gitlabConventionURLTemplate,
         description,
         validExamples = [],
         erroredExamples = [],
         storageFolder = `${__dirname}/../../../../output/collection`,
         baseSchemataFolder = `${__dirname}/../../../../input/collection`,
+        gitlabProjectId = process.env.CI_PROJECT_ID,
         strictEnums = false,
         overlays = false,
         relationships = false,
@@ -9437,13 +10829,14 @@ var require_convention_builder = __commonJS({
         this.description = description;
         this.schemaName = schemaName;
         this.version = version;
-        this.repoURL = repoURL, this.validExamples = validExamples;
+        this.repoURLTemplateFunction = repoURLTemplateFunction, this.validExamples = validExamples;
         this.erroredExamples = erroredExamples;
         this.overlays = {};
         this.relationships = [];
         this.required = [];
         this.storageFolder = storageFolder;
         this.baseSchemataFolder = baseSchemataFolder;
+        this.gitlabProjectId = gitlabProjectId;
         if (overlays) {
           let overlayNames = Object.keys(overlays);
           this.overlays = {};
@@ -9519,7 +10912,7 @@ var require_convention_builder = __commonJS({
         this.schema = {
           title: this.title,
           type: "object",
-          $id: `${this.repoURL}/${this.version}/conventions/${this.schemaName}`,
+          $id: this.repoURLTemplateFunction({ conventionName: this.schemaName, projectID: this.gitlabProjectId }),
           $schema: "https://json-schema.org/draft/2020-12/schema",
           properties: {},
           description: this.description,
@@ -9775,8 +11168,13 @@ import TabItem from '@theme/TabItem';
        * @param {string} path -- A string representing an absolute path, leading to either a JSON file containing an individual example or a folder containing several examples. 
        * @param {object|array} object -- Either an array of examples or an individual example. 
        * @param {boolean} is_valid_example -- Whether to store the provided examples as valid examples or errors, for the tests.
+       * @param {boolean} structured_as_array -- Mark as "true" if the provided example is structured as a loose array of entities, as FarmOS delivers them (instead of structured as a convention object in which every entity is a property). The method will try to structure the entity and return meaningful information if it is not successful in doing so.
        */
-      addExample({ path, object, is_valid_example }) {
+      addExample({ path, object, is_valid_example, structured_as_array }) {
+        let output = {
+          success: false,
+          errors: []
+        };
         if (!path && !object) {
           throw new Error(`Either an object or a path leading to a folder or a json file need to be provided. Both arguments are empty.`);
         }
@@ -9793,12 +11191,43 @@ import TabItem from '@theme/TabItem';
           newExamples = this.getExamplesFromFile({ path });
         }
         ;
+        if (structured_as_array) {
+          newExamples = newExamples.map((exampleArray) => {
+            let exampleObject = arrayToStructuredConvention({
+              entitiesArray: exampleArray,
+              conventionObject: this
+            });
+            if (!exampleObject.is_valid && is_valid_example) {
+              output.errors.push("The `arrayToStructuredConvention` function wasn't able to rebuild a valid instance of this convention's schema from the provided array of loose entities. Look into the '.structuringAttempt' attribute for more information.");
+            }
+            ;
+            if (!is_valid_example) {
+              output.warning = "Since the example is not marked as 'valid', we can't check it is being properly parsed. Please review the output 'assembled_entity' to check it looks as it should.";
+            }
+            ;
+            output.structuringAttempt = exampleObject;
+            return exampleObject.assembled_entity;
+          });
+        }
+        ;
         if (is_valid_example) {
           this.validExamples.push(...newExamples);
         } else {
           this.erroredExamples.push(...newExamples);
         }
         ;
+        if (output.errors.length == 0) {
+          output.success = true;
+        }
+        ;
+        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).
@@ -9881,6 +11310,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);
         });
@@ -9916,7 +11347,7 @@ import TabItem from '@theme/TabItem';
     };
     __name(_ConventionSchema, "ConventionSchema");
     var ConventionSchema = _ConventionSchema;
-    var _AttributeOverlay = class _AttributeOverlay {
+    var _InputConventionChanges = class _InputConventionChanges {
       constructor({
         type,
         bundle,
@@ -9924,7 +11355,8 @@ import TabItem from '@theme/TabItem';
         baseSchemataFolder = `${__dirname}/../../../../input/collection`,
         sourceSchemataFile = `${__dirname}/../../../../input/farmos.json`,
         overlayName,
-        overlayDescription
+        overlayDescription,
+        gitlabProjectId = process.env.CI_PROJECT_ID
       }) {
         let integralSchemataFile = JSON.parse(fs.readFileSync(sourceSchemataFile));
         this.type = type;
@@ -9935,6 +11367,7 @@ import TabItem from '@theme/TabItem';
         this.sourceSchemata = integralSchemataFile;
         this.lexicon = [...findAllObjectAttributesInTree(this.sourceSchemata), ...findAllNonObjectAttributesInTree(this.sourceSchemata)];
         this.baseSchemataFolder = baseSchemataFolder;
+        this.gitlabProjectId = gitlabProjectId;
         let involvedSchemata = this.lexicon.filter((entry) => this.attribute == entry.attribute).flatMap((entry) => entry.instances).filter((instance) => this.type ? instance.type == this.type : true).filter((instance) => this.bundle ? instance.bundle == this.bundle : true).map((d) => d.schema);
         this.targetSchemata = Array.from(new Set(involvedSchemata));
         this.overlays = [];
@@ -9942,8 +11375,10 @@ import TabItem from '@theme/TabItem';
           let currentOverlay = new AttributePatchingSchemaOverlay({
             typeAndBundle: target,
             attributeOverlayName: this.overlayName,
-            baseSchemataFolder: this.baseSchemataFolder
+            baseSchemataFolder: this.baseSchemataFolder,
+            gitlabProjectId: this.gitlabProjectId
           });
+          currentOverlay.gitlabProjectId = this.gitlabProjectId;
           this.overlays.push(currentOverlay);
         });
       }
@@ -10004,6 +11439,15 @@ import TabItem from '@theme/TabItem';
           });
         });
       }
+      /**
+       * Mark an attribute to be omitted from the resulting schema.
+       * @param {} attribute
+       */
+      deleteAttribute() {
+        this.overlays.forEach((overlay) => {
+          overlay.deleteAttribute(this.attribute);
+        });
+      }
       /**
        * Stores all involved schemas into the folder structure for `base schemata` (provided as the parameter `baseSchemataFolder`) which will be consumed by our conventions later.
        * @returns {} -- It returns objects containing all paths.
@@ -10016,21 +11460,21 @@ import TabItem from '@theme/TabItem';
         return output;
       }
     };
-    __name(_AttributeOverlay, "AttributeOverlay");
-    var AttributeOverlay = _AttributeOverlay;
+    __name(_InputConventionChanges, "InputConventionChanges");
+    var InputConventionChanges = _InputConventionChanges;
     exports.SchemaOverlay = SchemaOverlay;
     exports.ConventionSchema = ConventionSchema;
-    exports.AttributeOverlay = AttributeOverlay;
+    exports.InputConventionChanges = InputConventionChanges;
   }
 });
 
 // src/index.js
 var require_src = __commonJS({
   "src/index.js"(exports) {
-    var { SchemaOverlay, ConventionSchema, AttributeOverlay } = require_convention_builder();
+    var { SchemaOverlay, ConventionSchema, InputConventionChanges } = require_convention_builder();
     var schemaUtils = require_schema_utilities();
     exports.SchemaOverlay = SchemaOverlay;
-    exports.AttributeOverlay = AttributeOverlay;
+    exports.InputConventionChanges = InputConventionChanges;
     exports.ConventionSchema = ConventionSchema;
     exports.fixRelationshipDataField = schemaUtils.fixRelationshipDataField;
     exports.buildValidator = schemaUtils.buildValidator;
@@ -10054,5 +11498,13 @@ export default require_src();
 
 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