gff-nostream 1.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Robert Buels
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,163 @@
+# gff-nostream
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/cmdcolin/gff-nostream/push.yml?branch=master&logo=github&style=for-the-badge)](https://github.com/cmdcolin/gff-nostream/actions?query=branch%3Amaster+workflow%3APush+)
+
+Parse GFF3 data. This is a simplified version of
+[@gmod/gff](https://github.com/GMOD/gff-js) for with just basic parsing and no
+node.js stream module usage
+
+## Install
+
+    $ npm install --save gff-nostream
+
+## Usage
+
+```js
+const { parseStringSync } = require('gff-nostream')
+// or in ES6 (recommended)
+import { parseStringSync } from 'gff-nostream'
+
+const fs = require('fs')
+
+// parse a string of gff3 synchronously
+const stringOfGFF3 = fs.readFileSync('my_annotations.gff3', 'utf8')
+const arrayOfThings = gff.parseStringSync(stringOfGFF3)
+```
+
+## Object format
+
+### features
+
+In GFF3, features can have more than one location. We parse features as
+arrayrefs of all the lines that share that feature's ID. Values that are `.` in
+the GFF3 are `null` in the output.
+
+A simple feature that's located in just one place:
+
+```json
+[
+  {
+    "seq_id": "ctg123",
+    "source": null,
+    "type": "gene",
+    "start": 1000,
+    "end": 9000,
+    "score": null,
+    "strand": "+",
+    "phase": null,
+    "attributes": {
+      "ID": ["gene00001"],
+      "Name": ["EDEN"]
+    },
+    "child_features": [],
+    "derived_features": []
+  }
+]
+```
+
+A CDS called `cds00001` located in two places:
+
+```json
+[
+  {
+    "seq_id": "ctg123",
+    "source": null,
+    "type": "CDS",
+    "start": 1201,
+    "end": 1500,
+    "score": null,
+    "strand": "+",
+    "phase": "0",
+    "attributes": {
+      "ID": ["cds00001"],
+      "Parent": ["mRNA00001"]
+    },
+    "child_features": [],
+    "derived_features": []
+  },
+  {
+    "seq_id": "ctg123",
+    "source": null,
+    "type": "CDS",
+    "start": 3000,
+    "end": 3902,
+    "score": null,
+    "strand": "+",
+    "phase": "0",
+    "attributes": {
+      "ID": ["cds00001"],
+      "Parent": ["mRNA00001"]
+    },
+    "child_features": [],
+    "derived_features": []
+  }
+]
+```
+
+## API
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+#### Table of Contents
+
+- [ParseOptions](#parseoptions)
+  - [disableDerivesFromReferences](#disablederivesfromreferences)
+  - [encoding](#encoding)
+  - [parseFeatures](#parsefeatures)
+  - [parseDirectives](#parsedirectives)
+  - [parseComments](#parsecomments)
+  - [parseSequences](#parsesequences)
+  - [parseAll](#parseall)
+
+### ParseOptions
+
+Parser options
+
+#### disableDerivesFromReferences
+
+Whether to resolve references to derives from features
+
+Type:
+[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+
+#### encoding
+
+Text encoding of the input GFF3. default 'utf8'
+
+Type: BufferEncoding
+
+#### parseFeatures
+
+Whether to parse features, default true
+
+Type:
+[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+
+#### parseDirectives
+
+Whether to parse directives, default false
+
+Type:
+[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+
+#### parseComments
+
+Whether to parse comments, default false
+
+Type:
+[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+
+#### parseSequences
+
+Whether to parse sequences, default true
+
+Type:
+[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)
+
+#### parseAll
+
+Parse all features, directives, comments, and sequences. Overrides other parsing
+options. Default false.
+
+Type:
+[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)

package/dist/api.d.ts

@@ -0,0 +1,23 @@
+import { GFF3Item } from './util';
+/** Parser options */
+export interface ParseOptions {
+    /** Whether to resolve references to derives from features */
+    disableDerivesFromReferences?: boolean;
+    /** Text encoding of the input GFF3. default 'utf8' */
+    encoding?: BufferEncoding;
+    /** Whether to parse features, default true */
+    parseFeatures?: boolean;
+    /** Whether to parse directives, default false */
+    parseDirectives?: boolean;
+    /** Whether to parse comments, default false */
+    parseComments?: boolean;
+    /** Whether to parse sequences, default true */
+    parseSequences?: boolean;
+    /**
+     * Parse all features, directives, comments, and sequences. Overrides other
+     * parsing options. Default false.
+     */
+    parseAll?: boolean;
+}
+export declare function parseStringSync(str: string, inputOptions?: ParseOptions): GFF3Item[];
+export { type GFF3FeatureLine, type GFF3Comment, type GFF3FeatureLineWithRefs, type GFF3Directive, type GFF3Sequence, type GFF3Feature, type GFF3Item, } from './util';

package/dist/api.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStringSync = parseStringSync;
+const parse_1 = __importDefault(require("./parse"));
+// shared arg processing for the parse routines
+function _processParseOptions(options) {
+    const out = Object.assign({ encoding: 'utf8', parseFeatures: true, parseDirectives: false, parseSequences: true, parseComments: false, disableDerivesFromReferences: false }, options);
+    if (options.parseAll) {
+        out.parseFeatures = true;
+        out.parseDirectives = true;
+        out.parseComments = true;
+        out.parseSequences = true;
+    }
+    return out;
+}
+function parseStringSync(str, inputOptions = {}) {
+    if (!str) {
+        return [];
+    }
+    const options = _processParseOptions(inputOptions);
+    const items = [];
+    const push = items.push.bind(items);
+    const parser = new parse_1.default({
+        featureCallback: options.parseFeatures ? push : undefined,
+        directiveCallback: options.parseDirectives ? push : undefined,
+        commentCallback: options.parseComments ? push : undefined,
+        sequenceCallback: options.parseSequences ? push : undefined,
+        disableDerivesFromReferences: options.disableDerivesFromReferences || false,
+        errorCallback: err => {
+            throw err;
+        },
+    });
+    str.split(/\r?\n/).forEach(parser.addLine.bind(parser));
+    parser.finish();
+    return items;
+}
+//# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":";;;;;AAgDA,0CA2BC;AA3ED,oDAA4B;AA0B5B,+CAA+C;AAC/C,SAAS,oBAAoB,CAAC,OAAqB;IACjD,MAAM,GAAG,mBACP,QAAQ,EAAE,MAAe,EACzB,aAAa,EAAE,IAAI,EACnB,eAAe,EAAE,KAAK,EACtB,cAAc,EAAE,IAAI,EACpB,aAAa,EAAE,KAAK,EACpB,4BAA4B,EAAE,KAAK,IAChC,OAAO,CACX,CAAA;IAED,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;QACrB,GAAG,CAAC,aAAa,GAAG,IAAI,CAAA;QACxB,GAAG,CAAC,eAAe,GAAG,IAAI,CAAA;QAC1B,GAAG,CAAC,aAAa,GAAG,IAAI,CAAA;QACxB,GAAG,CAAC,cAAc,GAAG,IAAI,CAAA;IAC3B,CAAC;IAED,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,SAAgB,eAAe,CAC7B,GAAW,EACX,eAA6B,EAAE;IAE/B,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,OAAO,EAAE,CAAA;IACX,CAAC;IAED,MAAM,OAAO,GAAG,oBAAoB,CAAC,YAAY,CAAC,CAAA;IAClD,MAAM,KAAK,GAAe,EAAE,CAAA;IAC5B,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAEnC,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC;QACxB,eAAe,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;QACzD,iBAAiB,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;QAC7D,eAAe,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;QACzD,gBAAgB,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;QAC3D,4BAA4B,EAAE,OAAO,CAAC,4BAA4B,IAAI,KAAK;QAC3E,aAAa,EAAE,GAAG,CAAC,EAAE;YACnB,MAAM,GAAG,CAAA;QACX,CAAC;KACF,CAAC,CAAA;IAEF,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;IACvD,MAAM,CAAC,MAAM,EAAE,CAAA;IAEf,OAAO,KAAK,CAAA;AACd,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { parseStringSync } from './api';
+export { parseStringSync };
+export type { GFF3Comment, GFF3Feature, GFF3Directive, GFF3FeatureLineWithRefs, GFF3FeatureLine, GFF3Item, GFF3Sequence, } from './api';

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStringSync = void 0;
+const api_1 = require("./api");
+Object.defineProperty(exports, "parseStringSync", { enumerable: true, get: function () { return api_1.parseStringSync; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,+BAAuC;AAC9B,gGADA,qBAAe,OACA"}

package/dist/parse.d.ts

@@ -0,0 +1,55 @@
+import * as GFF3 from './util';
+export declare class FASTAParser {
+    seqCallback: (sequence: GFF3.GFF3Sequence) => void;
+    currentSequence: {
+        id: string;
+        sequence: string;
+        description?: string;
+    } | undefined;
+    constructor(seqCallback: (sequence: GFF3.GFF3Sequence) => void);
+    addLine(line: string): void;
+    private _flush;
+    finish(): void;
+}
+interface ParserArgs {
+    featureCallback?(feature: GFF3.GFF3Feature): void;
+    endCallback?(): void;
+    commentCallback?(comment: GFF3.GFF3Comment): void;
+    errorCallback?(error: string): void;
+    directiveCallback?(directive: GFF3.GFF3Directive): void;
+    sequenceCallback?(sequence: GFF3.GFF3Sequence): void;
+    bufferSize?: number;
+    disableDerivesFromReferences?: boolean;
+}
+export default class Parser {
+    featureCallback: (feature: GFF3.GFF3Feature) => void;
+    endCallback: () => void;
+    commentCallback: (comment: GFF3.GFF3Comment) => void;
+    errorCallback: (error: string) => void;
+    disableDerivesFromReferences: boolean;
+    directiveCallback: (directive: GFF3.GFF3Directive) => void;
+    sequenceCallback: (sequence: GFF3.GFF3Sequence) => void;
+    bufferSize: number;
+    fastaParser: FASTAParser | undefined;
+    eof: boolean;
+    lineNumber: number;
+    private _underConstructionTopLevel;
+    private _underConstructionById;
+    private _completedReferences;
+    private _underConstructionOrphans;
+    constructor(args: ParserArgs);
+    addLine(line: string): void;
+    finish(): void;
+    private _emitItem;
+    private _enforceBufferSizeLimit;
+    /**
+     * return all under-construction features, called when we know
+     * there will be no additional data to attach to them
+     */
+    private _emitAllUnderConstructionFeatures;
+    private _bufferLine;
+    private _resolveReferencesTo;
+    private _parseError;
+    private _resolveReferencesFrom;
+}
+export {};

package/dist/parse.js

@@ -0,0 +1,341 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FASTAParser = void 0;
+const GFF3 = __importStar(require("./util"));
+const containerAttributes = {
+    Parent: 'child_features',
+    Derives_from: 'derived_features',
+};
+class FASTAParser {
+    constructor(seqCallback) {
+        this.seqCallback = seqCallback;
+        this.currentSequence = undefined;
+    }
+    addLine(line) {
+        const defMatch = /^>\s*(\S+)\s*(.*)/.exec(line);
+        if (defMatch) {
+            this._flush();
+            this.currentSequence = { id: defMatch[1], sequence: '' };
+            if (defMatch[2]) {
+                this.currentSequence.description = defMatch[2].trim();
+            }
+        }
+        else if (this.currentSequence && /\S/.test(line)) {
+            this.currentSequence.sequence += line.replaceAll(/\s/g, '');
+        }
+    }
+    _flush() {
+        if (this.currentSequence) {
+            this.seqCallback(this.currentSequence);
+        }
+    }
+    finish() {
+        this._flush();
+    }
+}
+exports.FASTAParser = FASTAParser;
+class Parser {
+    constructor(args) {
+        this.fastaParser = undefined;
+        // if this is true, the parser ignores the
+        // rest of the lines in the file.  currently
+        // set when the file switches over to FASTA
+        this.eof = false;
+        this.lineNumber = 0;
+        // features that we have to keep on hand for now because they
+        // might be referenced by something else
+        this._underConstructionTopLevel = [];
+        // index of the above by ID
+        this._underConstructionById = {};
+        this._completedReferences = {};
+        // features that reference something we have not seen yet
+        // structured as:
+        // {  'some_id' : {
+        //     'Parent' : [ orphans that have a Parent attr referencing it ],
+        //     'Derives_from' : [ orphans that have a Derives_from attr referencing it ],
+        //    }
+        // }
+        this._underConstructionOrphans = {};
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        const nullFunc = () => { };
+        this.featureCallback = args.featureCallback || nullFunc;
+        this.endCallback = args.endCallback || nullFunc;
+        this.commentCallback = args.commentCallback || nullFunc;
+        this.errorCallback = args.errorCallback || nullFunc;
+        this.directiveCallback = args.directiveCallback || nullFunc;
+        this.sequenceCallback = args.sequenceCallback || nullFunc;
+        this.disableDerivesFromReferences =
+            args.disableDerivesFromReferences || false;
+        // number of lines to buffer
+        this.bufferSize = args.bufferSize === undefined ? 1000 : args.bufferSize;
+    }
+    addLine(line) {
+        // if we have transitioned to a fasta section, just delegate to that parser
+        if (this.fastaParser) {
+            this.fastaParser.addLine(line);
+            return;
+        }
+        if (this.eof) {
+            // otherwise, if we are done, ignore this line
+            return;
+        }
+        this.lineNumber += 1;
+        if (/^\s*[^#\s>]/.test(line)) {
+            // feature line, most common case
+            this._bufferLine(line);
+            return;
+        }
+        const match = /^\s*(#+)(.*)/.exec(line);
+        if (match) {
+            // directive or comment
+            const [, hashsigns] = match;
+            let [, , contents] = match;
+            if (hashsigns.length === 3) {
+                // sync directive, all forward-references are resolved.
+                this._emitAllUnderConstructionFeatures();
+            }
+            else if (hashsigns.length === 2) {
+                const directive = GFF3.parseDirective(line);
+                if (directive) {
+                    if (directive.directive === 'FASTA') {
+                        this._emitAllUnderConstructionFeatures();
+                        this.eof = true;
+                        this.fastaParser = new FASTAParser(this.sequenceCallback);
+                    }
+                    else {
+                        this._emitItem(directive);
+                    }
+                }
+            }
+            else {
+                contents = contents.replace(/\s*/, '');
+                this._emitItem({ comment: contents });
+            }
+        }
+        else if (/^\s*$/.test(line)) {
+            // blank line, do nothing
+        }
+        else if (/^\s*>/.test(line)) {
+            // implicit beginning of a FASTA section
+            this._emitAllUnderConstructionFeatures();
+            this.eof = true;
+            this.fastaParser = new FASTAParser(this.sequenceCallback);
+            this.fastaParser.addLine(line);
+        }
+        else {
+            // it's a parse error
+            const errLine = line.replaceAll(/\r?\n?$/g, '');
+            throw new Error(`GFF3 parse error.  Cannot parse '${errLine}'.`);
+        }
+    }
+    finish() {
+        this._emitAllUnderConstructionFeatures();
+        if (this.fastaParser) {
+            this.fastaParser.finish();
+        }
+        this.endCallback();
+    }
+    _emitItem(i) {
+        if (Array.isArray(i)) {
+            this.featureCallback(i);
+        }
+        else if ('directive' in i) {
+            this.directiveCallback(i);
+        }
+        else if ('comment' in i) {
+            this.commentCallback(i);
+        }
+    }
+    _enforceBufferSizeLimit(additionalItemCount = 0) {
+        const _unbufferItem = (item) => {
+            var _a, _b;
+            if (item && Array.isArray(item) && ((_b = (_a = item[0].attributes) === null || _a === void 0 ? void 0 : _a.ID) === null || _b === void 0 ? void 0 : _b[0])) {
+                const ids = item[0].attributes.ID;
+                ids.forEach(id => {
+                    delete this._underConstructionById[id];
+                    delete this._completedReferences[id];
+                });
+                item.forEach(i => {
+                    if (i.child_features) {
+                        i.child_features.forEach(c => _unbufferItem(c));
+                    }
+                    if (i.derived_features) {
+                        i.derived_features.forEach(d => _unbufferItem(d));
+                    }
+                });
+            }
+        };
+        while (this._underConstructionTopLevel.length + additionalItemCount >
+            this.bufferSize) {
+            const item = this._underConstructionTopLevel.shift();
+            if (item) {
+                this._emitItem(item);
+                _unbufferItem(item);
+            }
+        }
+    }
+    /**
+     * return all under-construction features, called when we know
+     * there will be no additional data to attach to them
+     */
+    _emitAllUnderConstructionFeatures() {
+        this._underConstructionTopLevel.forEach(this._emitItem.bind(this));
+        this._underConstructionTopLevel = [];
+        this._underConstructionById = {};
+        this._completedReferences = {};
+        // if we have any orphans hanging around still, this is a
+        // problem. die with a parse error
+        if (Array.from(Object.values(this._underConstructionOrphans)).length) {
+            throw new Error(`some features reference other features that do not exist in the file (or in the same '###' scope). ${Object.keys(this._underConstructionOrphans).join(',')}`);
+        }
+    }
+    // do the right thing with a newly-parsed feature line
+    _bufferLine(line) {
+        var _a, _b, _c;
+        const rawFeatureLine = GFF3.parseFeature(line);
+        const featureLine = Object.assign(Object.assign({}, rawFeatureLine), { child_features: [], derived_features: [] });
+        // featureLine._lineNumber = this.lineNumber //< debugging aid
+        // NOTE: a feature is an arrayref of one or more feature lines.
+        const ids = ((_a = featureLine.attributes) === null || _a === void 0 ? void 0 : _a.ID) || [];
+        const parents = ((_b = featureLine.attributes) === null || _b === void 0 ? void 0 : _b.Parent) || [];
+        const derives = this.disableDerivesFromReferences
+            ? []
+            : ((_c = featureLine.attributes) === null || _c === void 0 ? void 0 : _c.Derives_from) || [];
+        if (!ids.length && !parents.length && !derives.length) {
+            // if it has no IDs and does not refer to anything, we can just
+            // output it
+            this._emitItem([featureLine]);
+            return;
+        }
+        let feature = undefined;
+        ids.forEach(id => {
+            const existing = this._underConstructionById[id];
+            if (existing) {
+                // another location of the same feature
+                if (existing[existing.length - 1].type !== featureLine.type) {
+                    this._parseError(`multi-line feature "${id}" has inconsistent types: "${featureLine.type}", "${existing[existing.length - 1].type}"`);
+                }
+                existing.push(featureLine);
+                feature = existing;
+            }
+            else {
+                // haven't seen it yet, so buffer it so we can attach
+                // child features to it
+                feature = [featureLine];
+                this._enforceBufferSizeLimit(1);
+                if (!parents.length && !derives.length) {
+                    this._underConstructionTopLevel.push(feature);
+                }
+                this._underConstructionById[id] = feature;
+                // see if we have anything buffered that refers to it
+                this._resolveReferencesTo(feature, id);
+            }
+        });
+        // try to resolve all its references
+        this._resolveReferencesFrom(feature || [featureLine], { Parent: parents, Derives_from: derives }, ids);
+    }
+    _resolveReferencesTo(feature, id) {
+        const references = this._underConstructionOrphans[id];
+        //   references is of the form
+        //   {
+        //     'Parent' : [ orphans that have a Parent attr referencing this feature ],
+        //     'Derives_from' : [ orphans that have a Derives_from attr referencing this feature ],
+        //    }
+        if (!references) {
+            return;
+        }
+        feature.forEach(loc => {
+            loc.child_features.push(...references.Parent);
+        });
+        feature.forEach(loc => {
+            loc.derived_features.push(...references.Derives_from);
+        });
+        delete this._underConstructionOrphans[id];
+    }
+    _parseError(message) {
+        this.eof = true;
+        this.errorCallback(`${this.lineNumber}: ${message}`);
+    }
+    _resolveReferencesFrom(feature, references, ids) {
+        // this is all a bit more awkward in javascript than it was in perl
+        function postSet(obj, slot1, slot2) {
+            let subObj = obj[slot1];
+            if (!subObj) {
+                subObj = {};
+                obj[slot1] = subObj;
+            }
+            const returnVal = subObj[slot2] || false;
+            subObj[slot2] = true;
+            return returnVal;
+        }
+        references.Parent.forEach(toId => {
+            const otherFeature = this._underConstructionById[toId];
+            if (otherFeature) {
+                const pname = containerAttributes.Parent;
+                if (!ids.filter(id => postSet(this._completedReferences, id, `Parent,${toId}`)).length) {
+                    otherFeature.forEach(location => {
+                        location[pname].push(feature);
+                    });
+                }
+            }
+            else {
+                let ref = this._underConstructionOrphans[toId];
+                if (!ref) {
+                    ref = {
+                        Parent: [],
+                        Derives_from: [],
+                    };
+                    this._underConstructionOrphans[toId] = ref;
+                }
+                ref.Parent.push(feature);
+            }
+        });
+        references.Derives_from.forEach(toId => {
+            const otherFeature = this._underConstructionById[toId];
+            if (otherFeature) {
+                const pname = containerAttributes.Derives_from;
+                if (!ids.filter(id => postSet(this._completedReferences, id, `Derives_from,${toId}`)).length) {
+                    otherFeature.forEach(location => {
+                        location[pname].push(feature);
+                    });
+                }
+            }
+            else {
+                let ref = this._underConstructionOrphans[toId];
+                if (!ref) {
+                    ref = {
+                        Parent: [],
+                        Derives_from: [],
+                    };
+                    this._underConstructionOrphans[toId] = ref;
+                }
+                ref.Derives_from.push(feature);
+            }
+        });
+    }
+}
+exports.default = Parser;
+//# sourceMappingURL=parse.js.map