@atlaspack/graph 3.5.19 → 3.5.21-dev-ts-project-refs-d30e9754f.0

package/dist/BitSet.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitSet = void 0;
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32#implementing_count_leading_ones_and_beyond
+function ctz32(n) {
+    if (n === 0) {
+        return 32;
+    }
+    let reversed = n & -n;
+    return 31 - Math.clz32(reversed);
+}
+class BitSet {
+    constructor(maxBits) {
+        this.bits = new Uint32Array(Math.ceil(maxBits / 32));
+    }
+    clone() {
+        let res = new BitSet(this.capacity);
+        res.bits.set(this.bits);
+        return res;
+    }
+    static union(a, b) {
+        let res = a.clone();
+        res.union(b);
+        return res;
+    }
+    static intersect(a, b) {
+        let res = a.clone();
+        res.intersect(b);
+        return res;
+    }
+    get capacity() {
+        return this.bits.length * 32;
+    }
+    add(bit) {
+        let i = bit >>> 5;
+        let b = bit & 31;
+        this.bits[i] |= 1 << b;
+    }
+    delete(bit) {
+        let i = bit >>> 5;
+        let b = bit & 31;
+        this.bits[i] &= ~(1 << b);
+    }
+    has(bit) {
+        let i = bit >>> 5;
+        let b = bit & 31;
+        return Boolean(this.bits[i] & (1 << b));
+    }
+    empty() {
+        for (let k = 0; k < this.bits.length; k++) {
+            if (this.bits[k] !== 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    clear() {
+        this.bits.fill(0);
+    }
+    intersect(other) {
+        for (let i = 0; i < this.bits.length; i++) {
+            this.bits[i] &= other.bits[i];
+        }
+    }
+    union(other) {
+        for (let i = 0; i < this.bits.length; i++) {
+            this.bits[i] |= other.bits[i];
+        }
+    }
+    remove(other) {
+        for (let i = 0; i < this.bits.length; i++) {
+            this.bits[i] &= ~other.bits[i];
+        }
+    }
+    size() {
+        let bits = this.bits;
+        let setBitsCount = 0;
+        for (let k = 0; k < bits.length; k++) {
+            let chunk = bits[k];
+            while (chunk !== 0) {
+                chunk &= chunk - 1; // Clear the least significant bit set
+                setBitsCount++;
+            }
+        }
+        return setBitsCount;
+    }
+    equals(other) {
+        for (let i = 0; i < this.bits.length; i++) {
+            if (this.bits[i] !== other.bits[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    forEach(fn) {
+        // https://lemire.me/blog/2018/02/21/iterating-over-set-bits-quickly/
+        let bits = this.bits;
+        for (let k = 0; k < bits.length; k++) {
+            let v = bits[k];
+            while (v !== 0) {
+                let t = (v & -v) >>> 0;
+                fn((k << 5) + ctz32(v));
+                v ^= t;
+            }
+        }
+    }
+}
+exports.BitSet = BitSet;

package/dist/ContentGraph.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Graph_1 = __importDefault(require("./Graph"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+class ContentGraph extends Graph_1.default {
+    constructor(opts) {
+        if (opts) {
+            let { _contentKeyToNodeId, _nodeIdToContentKey, ...rest } = opts;
+            super(rest);
+            this._contentKeyToNodeId = _contentKeyToNodeId;
+            this._nodeIdToContentKey = _nodeIdToContentKey;
+        }
+        else {
+            super();
+            this._contentKeyToNodeId = new Map();
+            this._nodeIdToContentKey = new Map();
+        }
+    }
+    static deserialize(opts) {
+        return new ContentGraph(opts);
+    }
+    serialize() {
+        return {
+            ...super.serialize(),
+            _contentKeyToNodeId: this._contentKeyToNodeId,
+            // @ts-expect-error TS2353
+            _nodeIdToContentKey: this._nodeIdToContentKey,
+        };
+    }
+    addNodeByContentKey(contentKey, node) {
+        if (this.hasContentKey(contentKey)) {
+            throw new Error('Graph already has content key ' + contentKey);
+        }
+        let nodeId = super.addNode(node);
+        this._contentKeyToNodeId.set(contentKey, nodeId);
+        this._nodeIdToContentKey.set(nodeId, contentKey);
+        return nodeId;
+    }
+    addNodeByContentKeyIfNeeded(contentKey, node) {
+        return this.hasContentKey(contentKey)
+            ? this.getNodeIdByContentKey(contentKey)
+            : this.addNodeByContentKey(contentKey, node);
+    }
+    getNodeByContentKey(contentKey) {
+        let nodeId = this._contentKeyToNodeId.get(contentKey);
+        if (nodeId != null) {
+            return super.getNode(nodeId);
+        }
+    }
+    getContentKeyByNodeId(nodeId) {
+        return (0, nullthrows_1.default)(this._nodeIdToContentKey.get(nodeId), `Expected node id ${nodeId} to exist`);
+    }
+    getNodeIdByContentKey(contentKey) {
+        return (0, nullthrows_1.default)(this._contentKeyToNodeId.get(contentKey), `Expected content key ${contentKey} to exist`);
+    }
+    hasContentKey(contentKey) {
+        return this._contentKeyToNodeId.has(contentKey);
+    }
+    removeNode(nodeId, removeOrphans = true) {
+        this._assertHasNodeId(nodeId);
+        let contentKey = (0, nullthrows_1.default)(this._nodeIdToContentKey.get(nodeId));
+        this._contentKeyToNodeId.delete(contentKey);
+        this._nodeIdToContentKey.delete(nodeId);
+        super.removeNode(nodeId, removeOrphans);
+    }
+}
+exports.default = ContentGraph;

package/dist/Graph.js

@@ -0,0 +1,498 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_EDGE_TYPES = exports.NULL_EDGE_TYPE = void 0;
+exports.mapVisitor = mapVisitor;
+const types_1 = require("./types");
+const AdjacencyList_1 = __importDefault(require("./AdjacencyList"));
+const BitSet_1 = require("./BitSet");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+exports.NULL_EDGE_TYPE = 1;
+exports.ALL_EDGE_TYPES = -1;
+class Graph {
+    constructor(opts) {
+        this.nodes = opts?.nodes || [];
+        this.setRootNodeId(opts?.rootNodeId);
+        let adjacencyList = opts?.adjacencyList;
+        let initialCapacity = opts?.initialCapacity;
+        this.adjacencyList = adjacencyList
+            ? AdjacencyList_1.default.deserialize(adjacencyList)
+            : new AdjacencyList_1.default(typeof initialCapacity === 'number' ? { initialCapacity } : undefined);
+    }
+    setRootNodeId(id) {
+        this.rootNodeId = id;
+    }
+    static deserialize(opts) {
+        return new this({
+            nodes: opts.nodes,
+            adjacencyList: opts.adjacencyList,
+            rootNodeId: opts.rootNodeId,
+        });
+    }
+    serialize() {
+        return {
+            nodes: this.nodes,
+            adjacencyList: this.adjacencyList.serialize(),
+            rootNodeId: this.rootNodeId,
+        };
+    }
+    // Returns an iterator of all edges in the graph. This can be large, so iterating
+    // the complete list can be costly in large graphs. Used when merging graphs.
+    getAllEdges() {
+        return this.adjacencyList.getAllEdges();
+    }
+    addNode(node) {
+        let id = this.adjacencyList.addNode();
+        this.nodes.push(node);
+        return id;
+    }
+    hasNode(id) {
+        return this.nodes[id] != null;
+    }
+    getNode(id) {
+        return this.nodes[id];
+    }
+    addEdge(from, to, type = exports.NULL_EDGE_TYPE) {
+        if (Number(type) === 0) {
+            throw new Error(`Edge type "${type}" not allowed`);
+        }
+        if (this.getNode(from) == null) {
+            throw new Error(`"from" node '${(0, types_1.fromNodeId)(from)}' not found`);
+        }
+        if (this.getNode(to) == null) {
+            throw new Error(`"to" node '${(0, types_1.fromNodeId)(to)}' not found`);
+        }
+        return this.adjacencyList.addEdge(from, to, type);
+    }
+    hasEdge(from, to, type = exports.NULL_EDGE_TYPE) {
+        return this.adjacencyList.hasEdge(from, to, type);
+    }
+    forEachNodeIdConnectedTo(to, fn, type = exports.NULL_EDGE_TYPE) {
+        this._assertHasNodeId(to);
+        this.adjacencyList.forEachNodeIdConnectedTo(to, fn, type);
+    }
+    forEachNodeIdConnectedFrom(from, fn, type = exports.NULL_EDGE_TYPE) {
+        this._assertHasNodeId(from);
+        this.adjacencyList.forEachNodeIdConnectedFromReverse(from, (id) => {
+            fn(id);
+            return false;
+        }, type);
+    }
+    getNodeIdsConnectedTo(nodeId, type = exports.NULL_EDGE_TYPE) {
+        this._assertHasNodeId(nodeId);
+        return this.adjacencyList.getNodeIdsConnectedTo(nodeId, type);
+    }
+    getNodeIdsConnectedFrom(nodeId, type = exports.NULL_EDGE_TYPE) {
+        this._assertHasNodeId(nodeId);
+        return this.adjacencyList.getNodeIdsConnectedFrom(nodeId, type);
+    }
+    // Removes node and any edges coming from or to that node
+    removeNode(nodeId, removeOrphans = true) {
+        if (!this.hasNode(nodeId)) {
+            return;
+        }
+        for (let { type, from } of this.adjacencyList.getInboundEdgesByType(nodeId)) {
+            this._removeEdge(from, nodeId, type, 
+            // Do not allow orphans to be removed as this node could be one
+            // and is already being removed.
+            false);
+        }
+        for (let { type, to } of this.adjacencyList.getOutboundEdgesByType(nodeId)) {
+            this._removeEdge(nodeId, to, type, removeOrphans);
+        }
+        this.nodes[nodeId] = null;
+    }
+    removeEdges(nodeId, type = exports.NULL_EDGE_TYPE) {
+        if (!this.hasNode(nodeId)) {
+            return;
+        }
+        for (let to of this.getNodeIdsConnectedFrom(nodeId, type)) {
+            this._removeEdge(nodeId, to, type);
+        }
+    }
+    removeEdge(from, to, type = exports.NULL_EDGE_TYPE, removeOrphans = true) {
+        if (!this.adjacencyList.hasEdge(from, to, type)) {
+            throw new Error(`Edge from ${(0, types_1.fromNodeId)(from)} to ${(0, types_1.fromNodeId)(to)} not found!`);
+        }
+        this._removeEdge(from, to, type, removeOrphans);
+    }
+    // Removes edge and node the edge is to if the node is orphaned
+    _removeEdge(from, to, type = exports.NULL_EDGE_TYPE, removeOrphans = true) {
+        if (!this.adjacencyList.hasEdge(from, to, type)) {
+            return;
+        }
+        this.adjacencyList.removeEdge(from, to, type);
+        if (removeOrphans && this.isOrphanedNode(to)) {
+            this.removeNode(to);
+        }
+    }
+    isOrphanedNode(nodeId) {
+        if (!this.hasNode(nodeId)) {
+            return false;
+        }
+        if (this.rootNodeId == null) {
+            // If the graph does not have a root, and there are inbound edges,
+            // this node should not be considered orphaned.
+            return !this.adjacencyList.hasInboundEdges(nodeId);
+        }
+        // Otherwise, attempt to traverse backwards to the root. If there is a path,
+        // then this is not an orphaned node.
+        let hasPathToRoot = false;
+        // go back to traverseAncestors
+        this.traverseAncestors(nodeId, (ancestorId, _, actions) => {
+            if (ancestorId === this.rootNodeId) {
+                hasPathToRoot = true;
+                actions.stop();
+            }
+        }, exports.ALL_EDGE_TYPES);
+        if (hasPathToRoot) {
+            return false;
+        }
+        return true;
+    }
+    updateNode(nodeId, node) {
+        this._assertHasNodeId(nodeId);
+        this.nodes[nodeId] = node;
+    }
+    // Update a node's downstream nodes making sure to prune any orphaned branches
+    replaceNodeIdsConnectedTo(fromNodeId, toNodeIds, replaceFilter, type = exports.NULL_EDGE_TYPE, removeOrphans = true) {
+        this._assertHasNodeId(fromNodeId);
+        let outboundEdges = this.getNodeIdsConnectedFrom(fromNodeId, type);
+        let childrenToRemove = new Set(replaceFilter
+            ? outboundEdges.filter((toNodeId) => replaceFilter(toNodeId))
+            : outboundEdges);
+        for (let toNodeId of toNodeIds) {
+            childrenToRemove.delete(toNodeId);
+            if (!this.hasEdge(fromNodeId, toNodeId, type)) {
+                this.addEdge(fromNodeId, toNodeId, type);
+            }
+        }
+        for (let child of childrenToRemove) {
+            this._removeEdge(fromNodeId, child, type, removeOrphans);
+        }
+    }
+    traverse(visit, startNodeId, type = exports.NULL_EDGE_TYPE) {
+        let enter = typeof visit === 'function' ? visit : visit.enter;
+        if (type === exports.ALL_EDGE_TYPES &&
+            enter &&
+            (typeof visit === 'function' || !visit.exit)) {
+            return this.dfsFast(enter, startNodeId);
+        }
+        else {
+            return this.dfs({
+                visit,
+                startNodeId,
+                getChildren: (nodeId) => this.getNodeIdsConnectedFrom(nodeId, type),
+            });
+        }
+    }
+    filteredTraverse(filter, visit, startNodeId, type) {
+        return this.traverse(mapVisitor(filter, visit), startNodeId, type);
+    }
+    traverseAncestors(startNodeId, visit, type = exports.NULL_EDGE_TYPE) {
+        return this.dfs({
+            visit,
+            startNodeId,
+            getChildren: (nodeId) => this.getNodeIdsConnectedTo(nodeId, type),
+        });
+    }
+    dfsFast(visit, startNodeId) {
+        let traversalStartNode = (0, nullthrows_1.default)(startNodeId ?? this.rootNodeId, 'A start node is required to traverse');
+        this._assertHasNodeId(traversalStartNode);
+        let visited;
+        if (!this._visited || this._visited.capacity < this.nodes.length) {
+            this._visited = new BitSet_1.BitSet(this.nodes.length);
+            visited = this._visited;
+        }
+        else {
+            visited = this._visited;
+            visited.clear();
+        }
+        // Take shared instance to avoid re-entrancy issues.
+        this._visited = null;
+        let stopped = false;
+        let skipped = false;
+        let actions = {
+            skipChildren() {
+                skipped = true;
+            },
+            stop() {
+                stopped = true;
+            },
+        };
+        let queue = [{ nodeId: traversalStartNode, context: null }];
+        while (queue.length !== 0) {
+            // @ts-expect-error TS2339
+            let { nodeId, context } = queue.pop();
+            if (!this.hasNode(nodeId) || visited.has(nodeId))
+                continue;
+            visited.add(nodeId);
+            skipped = false;
+            let newContext = visit(nodeId, context, actions);
+            if (typeof newContext !== 'undefined') {
+                context = newContext;
+            }
+            if (skipped) {
+                continue;
+            }
+            if (stopped) {
+                this._visited = visited;
+                return context;
+            }
+            this.adjacencyList.forEachNodeIdConnectedFromReverse(nodeId, (child) => {
+                if (!visited.has(child)) {
+                    queue.push({ nodeId: child, context });
+                }
+                return false;
+            });
+        }
+        this._visited = visited;
+        return null;
+    }
+    // A post-order implementation of dfsFast
+    postOrderDfsFast(visit, startNodeId) {
+        let traversalStartNode = (0, nullthrows_1.default)(startNodeId ?? this.rootNodeId, 'A start node is required to traverse');
+        this._assertHasNodeId(traversalStartNode);
+        let visited;
+        if (!this._visited || this._visited.capacity < this.nodes.length) {
+            this._visited = new BitSet_1.BitSet(this.nodes.length);
+            visited = this._visited;
+        }
+        else {
+            visited = this._visited;
+            visited.clear();
+        }
+        this._visited = null;
+        let stopped = false;
+        let actions = {
+            stop() {
+                stopped = true;
+            },
+            skipChildren() {
+                throw new Error('Calling skipChildren inside a post-order traversal is not allowed');
+            },
+        };
+        let queue = [traversalStartNode];
+        while (queue.length !== 0) {
+            let nodeId = queue[queue.length - 1];
+            if (!visited.has(nodeId)) {
+                visited.add(nodeId);
+                this.adjacencyList.forEachNodeIdConnectedFromReverse(nodeId, (child) => {
+                    if (!visited.has(child)) {
+                        queue.push(child);
+                    }
+                    return false;
+                });
+            }
+            else {
+                queue.pop();
+                visit(nodeId, null, actions);
+                if (stopped) {
+                    this._visited = visited;
+                    return;
+                }
+            }
+        }
+        this._visited = visited;
+        return;
+    }
+    /**
+     * Iterative implementation of DFS that supports all use-cases.
+     *
+     * This replaces `dfs` and will replace `dfsFast`.
+     */
+    dfs({ visit, startNodeId, getChildren, }) {
+        let traversalStartNode = (0, nullthrows_1.default)(startNodeId ?? this.rootNodeId, 'A start node is required to traverse');
+        this._assertHasNodeId(traversalStartNode);
+        let visited;
+        if (!this._visited || this._visited.capacity < this.nodes.length) {
+            this._visited = new BitSet_1.BitSet(this.nodes.length);
+            visited = this._visited;
+        }
+        else {
+            visited = this._visited;
+            visited.clear();
+        }
+        // Take shared instance to avoid re-entrancy issues.
+        this._visited = null;
+        let stopped = false;
+        let skipped = false;
+        let actions = {
+            skipChildren() {
+                skipped = true;
+            },
+            stop() {
+                stopped = true;
+            },
+        };
+        const queue = [
+            { nodeId: traversalStartNode, context: null },
+        ];
+        const enter = typeof visit === 'function' ? visit : visit.enter;
+        while (queue.length !== 0) {
+            const command = queue.pop();
+            // @ts-expect-error TS18048
+            if (command.exit != null) {
+                // @ts-expect-error TS2339
+                let { nodeId, context, exit } = command;
+                // @ts-expect-error TS18048
+                let newContext = exit(nodeId, command.context, actions);
+                if (typeof newContext !== 'undefined') {
+                    context = newContext;
+                }
+                if (skipped) {
+                    continue;
+                }
+                if (stopped) {
+                    this._visited = visited;
+                    return context;
+                }
+            }
+            else {
+                // @ts-expect-error TS2339
+                let { nodeId, context } = command;
+                if (!this.hasNode(nodeId) || visited.has(nodeId))
+                    continue;
+                visited.add(nodeId);
+                skipped = false;
+                if (enter) {
+                    let newContext = enter(nodeId, context, actions);
+                    if (typeof newContext !== 'undefined') {
+                        context = newContext;
+                    }
+                }
+                if (skipped) {
+                    continue;
+                }
+                if (stopped) {
+                    this._visited = visited;
+                    return context;
+                }
+                if (typeof visit !== 'function' && visit.exit) {
+                    queue.push({
+                        nodeId,
+                        exit: visit.exit,
+                        context,
+                    });
+                }
+                // TODO turn into generator function
+                const children = getChildren(nodeId);
+                for (let i = children.length - 1; i > -1; i -= 1) {
+                    const child = children[i];
+                    if (visited.has(child)) {
+                        continue;
+                    }
+                    queue.push({ nodeId: child, context });
+                }
+            }
+        }
+        this._visited = visited;
+    }
+    bfs(visit) {
+        let rootNodeId = (0, nullthrows_1.default)(this.rootNodeId, 'A root node is required to traverse');
+        let queue = [rootNodeId];
+        let visited = new Set([rootNodeId]);
+        while (queue.length > 0) {
+            let node = queue.shift();
+            let stop = visit(rootNodeId);
+            if (stop === true) {
+                return node;
+            }
+            // @ts-expect-error TS2345
+            for (let child of this.getNodeIdsConnectedFrom(node)) {
+                if (!visited.has(child)) {
+                    visited.add(child);
+                    queue.push(child);
+                }
+            }
+        }
+        return null;
+    }
+    topoSort(type) {
+        let sorted = [];
+        this.traverse({
+            exit: (nodeId) => {
+                sorted.push(nodeId);
+            },
+        }, null, type);
+        return sorted.reverse();
+    }
+    findAncestor(nodeId, fn) {
+        let res = null;
+        this.traverseAncestors(nodeId, (nodeId, ctx, traversal) => {
+            if (fn(nodeId)) {
+                res = nodeId;
+                traversal.stop();
+            }
+        });
+        return res;
+    }
+    findAncestors(nodeId, fn) {
+        let res = [];
+        this.traverseAncestors(nodeId, (nodeId, ctx, traversal) => {
+            if (fn(nodeId)) {
+                res.push(nodeId);
+                traversal.skipChildren();
+            }
+        });
+        return res;
+    }
+    findDescendant(nodeId, fn) {
+        let res = null;
+        this.traverse((nodeId, ctx, traversal) => {
+            if (fn(nodeId)) {
+                res = nodeId;
+                traversal.stop();
+            }
+        }, nodeId);
+        return res;
+    }
+    findDescendants(nodeId, fn) {
+        let res = [];
+        this.traverse((nodeId, ctx, traversal) => {
+            if (fn(nodeId)) {
+                res.push(nodeId);
+                traversal.skipChildren();
+            }
+        }, nodeId);
+        return res;
+    }
+    _assertHasNodeId(nodeId) {
+        if (!this.hasNode(nodeId)) {
+            throw new Error('Does not have node ' + (0, types_1.fromNodeId)(nodeId));
+        }
+    }
+}
+exports.default = Graph;
+function mapVisitor(filter, visit) {
+    function makeEnter(visit) {
+        return function mappedEnter(nodeId, context, actions) {
+            let value = filter(nodeId, actions);
+            if (value != null) {
+                return visit(value, context, actions);
+            }
+        };
+    }
+    if (typeof visit === 'function') {
+        return makeEnter(visit);
+    }
+    let mapped = {};
+    if (visit.enter != null) {
+        mapped.enter = makeEnter(visit.enter);
+    }
+    if (visit.exit != null) {
+        mapped.exit = function mappedExit(nodeId, context, actions) {
+            let exit = visit.exit;
+            if (!exit) {
+                return;
+            }
+            let value = filter(nodeId, actions);
+            if (value != null) {
+                return exit(value, context, actions);
+            }
+        };
+    }
+    return mapped;
+}

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitSet = exports.ContentGraph = exports.mapVisitor = exports.ALL_EDGE_TYPES = exports.Graph = exports.fromNodeId = exports.toNodeId = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "toNodeId", { enumerable: true, get: function () { return types_1.toNodeId; } });
+Object.defineProperty(exports, "fromNodeId", { enumerable: true, get: function () { return types_1.fromNodeId; } });
+var Graph_1 = require("./Graph");
+Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return __importDefault(Graph_1).default; } });
+Object.defineProperty(exports, "ALL_EDGE_TYPES", { enumerable: true, get: function () { return Graph_1.ALL_EDGE_TYPES; } });
+Object.defineProperty(exports, "mapVisitor", { enumerable: true, get: function () { return Graph_1.mapVisitor; } });
+var ContentGraph_1 = require("./ContentGraph");
+Object.defineProperty(exports, "ContentGraph", { enumerable: true, get: function () { return __importDefault(ContentGraph_1).default; } });
+var BitSet_1 = require("./BitSet");
+Object.defineProperty(exports, "BitSet", { enumerable: true, get: function () { return BitSet_1.BitSet; } });