binary-decision-diagram 4.0.0 → 5.0.0

package/src/ordering/shared-diagram.ts

@@ -0,0 +1,310 @@
+import type { DenseTruthTable } from './dense-truth-table.js';
+import { naturalOrdering } from './dense-truth-table.js';
+import { OrderingEvaluator } from './ordering-evaluator.js';
+import { IntPairMap } from './int-pair-map.js';
+
+/**
+ * thrown by SharedDiagram when more nodes than allowed would be created
+ */
+export class DiagramBudgetExceededError extends Error {
+    constructor() {
+        super('the exact search would need more diagram nodes than allowed');
+    }
+}
+
+export const DEFAULT_MAX_DIAGRAM_NODES = 4000000;
+
+/**
+ * A hash-consed decision diagram of a fully specified truth table in the
+ * natural variable order, with a restrict() operation.
+ *
+ * Because the variable order is fixed, two functions are equal if and only if
+ * they have the same node id. The exact searches rely on this to recognize
+ * equal cofactors.
+ */
+export class SharedDiagram {
+    public readonly variableCount: number;
+    public readonly terminalCount: number;
+    public readonly rootId: number;
+    /** the boolean functions the truth table depends on, ascending */
+    public readonly relevant: number[];
+    /** bit index of each relevant boolean function inside support masks, -1 for irrelevant ones */
+    public readonly compactOf: Int32Array;
+
+    private nodeVar: Int32Array;
+    private nodeLo: Int32Array;
+    private nodeHi: Int32Array;
+    private nodeSupport: Int32Array;
+    private nodeCount: number;
+    private readonly uniqueTables: IntPairMap[];
+    private readonly restrictMemo: IntPairMap = new IntPairMap(1 << 16);
+    private readonly maxNodes: number;
+
+    constructor(
+        public readonly table: DenseTruthTable,
+        /**
+         * restrict() creates nodes for the restricted functions, which can be a lot
+         * on unstructured functions. More nodes than this throw a DiagramBudgetExceededError.
+         * Default: 4000000 (roughly 400 MB)
+         */
+        maxNodes: number = DEFAULT_MAX_DIAGRAM_NODES
+    ) {
+        this.maxNodes = maxNodes;
+        this.variableCount = table.variableCount;
+        this.terminalCount = table.terminalValues.length;
+        const evaluator = new OrderingEvaluator(table);
+        const diagram = evaluator.buildDiagram(naturalOrdering(this.variableCount));
+        const count = diagram.nodeLevel.length;
+        const capacity = Math.max(1024, count * 2);
+        this.nodeVar = new Int32Array(capacity);
+        this.nodeLo = new Int32Array(capacity);
+        this.nodeHi = new Int32Array(capacity);
+        this.nodeSupport = new Int32Array(capacity);
+        this.nodeVar.set(diagram.nodeLevel);
+        this.nodeLo.set(diagram.nodeLo);
+        this.nodeHi.set(diagram.nodeHi);
+        this.nodeCount = count;
+        this.rootId = diagram.root;
+
+        // relevant variables and their compact bit index
+        this.compactOf = new Int32Array(this.variableCount).fill(-1);
+        this.relevant = [];
+        const rootSupport = this.rawSupport(diagram.root);
+        for (let v = 0; v < this.variableCount; v++) {
+            if ((rootSupport & (1 << v)) !== 0) {
+                this.compactOf[v] = this.relevant.length;
+                this.relevant.push(v);
+            }
+        }
+        // support masks in compact bit indexes; children always have smaller ids
+        for (let i = 0; i < count; i++) {
+            this.nodeSupport[i] = this.supportOf(this.nodeLo[i]) |
+                this.supportOf(this.nodeHi[i]) |
+                (1 << this.compactOf[this.nodeVar[i]]);
+        }
+        this.uniqueTables = [];
+        for (let v = 0; v < this.variableCount; v++) {
+            this.uniqueTables.push(new IntPairMap(256));
+        }
+        for (let id = this.terminalCount; id < this.terminalCount + count; id++) {
+            const i = id - this.terminalCount;
+            this.uniqueTables[this.nodeVar[i]].set(this.nodeLo[i], this.nodeHi[i], id);
+        }
+    }
+
+    public isTerminal(id: number): boolean {
+        return id < this.terminalCount;
+    }
+
+    /** amount of internal nodes created so far */
+    public get size(): number {
+        return this.nodeCount;
+    }
+
+    /** true when the diagram of the natural ordering alone already exceeds the node budget */
+    public get overBudget(): boolean {
+        return this.nodeCount > this.maxNodes;
+    }
+
+    /**
+     * support mask (compact bit indexes) of a node, 0 for terminals
+     */
+    public supportOf(id: number): number {
+        return id < this.terminalCount ? 0 : this.nodeSupport[id - this.terminalCount];
+    }
+
+    public dependsOn(id: number, variable: number): boolean {
+        return (this.supportOf(id) & (1 << this.compactOf[variable])) !== 0;
+    }
+
+    /**
+     * the function with `variable` fixed to `value`
+     */
+    public restrict(g: number, variable: number, value: number): number {
+        if (g < this.terminalCount) {
+            return g;
+        }
+        const index = g - this.terminalCount;
+        if ((this.nodeSupport[index] & (1 << this.compactOf[variable])) === 0) {
+            return g;
+        }
+        const v = this.nodeVar[index];
+        if (v === variable) {
+            return value === 0 ? this.nodeLo[index] : this.nodeHi[index];
+        }
+        const memoKey = variable * 2 + value;
+        const memo = this.restrictMemo.get(g, memoKey);
+        if (memo !== -1) {
+            return memo;
+        }
+        const lo = this.restrict(this.nodeLo[index], variable, value);
+        const hi = this.restrict(this.nodeHi[index], variable, value);
+        const result = this.makeNode(v, lo, hi);
+        this.restrictMemo.set(g, memoKey, result);
+        return result;
+    }
+
+    /**
+     * Moves the boolean functions the truth table does not depend on
+     * to the bottom, keeping the order of the others.
+     */
+    public normalizeOrdering(ordering: ArrayLike<number>): number[] {
+        const relevant: number[] = [];
+        const irrelevant: number[] = [];
+        for (let i = 0; i < ordering.length; i++) {
+            if (this.compactOf[ordering[i]] === -1) {
+                irrelevant.push(ordering[i]);
+            } else {
+                relevant.push(ordering[i]);
+            }
+        }
+        return relevant.concat(irrelevant);
+    }
+
+    public irrelevantVariables(): number[] {
+        return naturalOrdering(this.variableCount).filter(v => this.compactOf[v] === -1);
+    }
+
+    private makeNode(variable: number, lo: number, hi: number): number {
+        if (lo === hi) {
+            return lo;
+        }
+        const table = this.uniqueTables[variable];
+        const existing = table.get(lo, hi);
+        if (existing !== -1) {
+            return existing;
+        }
+        if (this.nodeCount >= this.maxNodes) {
+            throw new DiagramBudgetExceededError();
+        }
+        if (this.nodeCount === this.nodeVar.length) {
+            this.growNodes();
+        }
+        const index = this.nodeCount++;
+        const id = index + this.terminalCount;
+        this.nodeVar[index] = variable;
+        this.nodeLo[index] = lo;
+        this.nodeHi[index] = hi;
+        this.nodeSupport[index] = this.supportOf(lo) | this.supportOf(hi) | (1 << this.compactOf[variable]);
+        table.set(lo, hi, id);
+        return id;
+    }
+
+    /**
+     * support in natural variable bits, only used before the compact mapping exists
+     */
+    private rawSupport(id: number): number {
+        const memo: Map<number, number> = new Map();
+        const recurse = (node: number): number => {
+            if (node < this.terminalCount) {
+                return 0;
+            }
+            const known = memo.get(node);
+            if (known !== undefined) {
+                return known;
+            }
+            const index = node - this.terminalCount;
+            const ret = recurse(this.nodeLo[index]) | recurse(this.nodeHi[index]) | (1 << this.nodeVar[index]);
+            memo.set(node, ret);
+            return ret;
+        };
+        return recurse(id);
+    }
+
+    private growNodes() {
+        const capacity = this.nodeVar.length * 2;
+        const grow = (old: Int32Array) => {
+            const ret = new Int32Array(capacity);
+            ret.set(old);
+            return ret;
+        };
+        this.nodeVar = grow(this.nodeVar);
+        this.nodeLo = grow(this.nodeLo);
+        this.nodeHi = grow(this.nodeHi);
+        this.nodeSupport = grow(this.nodeSupport);
+    }
+}
+
+/**
+ * binary min-heap of search states, deterministic tie breaking:
+ * smaller estimate first, then larger cost (deeper states), then smaller subset
+ */
+export class StateHeap {
+    private readonly estimates: number[] = [];
+    private readonly costs: number[] = [];
+    private readonly subsets: number[] = [];
+
+    get size(): number {
+        return this.estimates.length;
+    }
+
+    public push(estimate: number, cost: number, subset: number) {
+        this.estimates.push(estimate);
+        this.costs.push(cost);
+        this.subsets.push(subset);
+        let i = this.estimates.length - 1;
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            if (this.less(i, parent)) {
+                this.swap(i, parent);
+                i = parent;
+            } else {
+                break;
+            }
+        }
+    }
+
+    public pop(): { estimate: number, cost: number, subset: number } {
+        const ret = {
+            estimate: this.estimates[0],
+            cost: this.costs[0],
+            subset: this.subsets[0]
+        };
+        const last = this.estimates.length - 1;
+        this.swap(0, last);
+        this.estimates.pop();
+        this.costs.pop();
+        this.subsets.pop();
+        let i = 0;
+        const size = this.estimates.length;
+        while (true) {
+            const left = i * 2 + 1;
+            const right = left + 1;
+            let smallest = i;
+            if (left < size && this.less(left, smallest)) {
+                smallest = left;
+            }
+            if (right < size && this.less(right, smallest)) {
+                smallest = right;
+            }
+            if (smallest === i) {
+                break;
+            }
+            this.swap(i, smallest);
+            i = smallest;
+        }
+        return ret;
+    }
+
+    private less(a: number, b: number): boolean {
+        if (this.estimates[a] !== this.estimates[b]) {
+            return this.estimates[a] < this.estimates[b];
+        }
+        if (this.costs[a] !== this.costs[b]) {
+            return this.costs[a] > this.costs[b];
+        }
+        return this.subsets[a] < this.subsets[b];
+    }
+
+    private swap(a: number, b: number) {
+        let tmp = this.estimates[a];
+        this.estimates[a] = this.estimates[b];
+        this.estimates[b] = tmp;
+        tmp = this.costs[a];
+        this.costs[a] = this.costs[b];
+        this.costs[b] = tmp;
+        tmp = this.subsets[a];
+        this.subsets[a] = this.subsets[b];
+        this.subsets[b] = tmp;
+    }
+}

package/src/packed/index.ts

@@ -0,0 +1,2 @@
+export * from './packed-bdd.js';
+export * from './packed-bdd-base64-string.js';

package/src/packed/packed-bdd-base64-string.ts

@@ -0,0 +1,47 @@
+import type { PackedBdd } from './packed-bdd.js';
+
+/*
+
+String transport format of a PackedBdd, to embed it into JavaScript source code.
+The string only contains ASCII characters that are safe inside of quotes,
+so bundlers and minifiers never have to escape anything.
+
+- The first char is the byte width of the entries: '1', '2' or '4'
+- The rest is the standard base64 of the memory of the typed array
+
+The base64 is decoded with the native Uint8Array.fromBase64() where it exists
+and with atob() everywhere else, both are faster than decoding it in JavaScript.
+The typed array then directly uses the decoded memory. This assumes a little-endian
+platform, which are all browsers and nearly all Node.js servers.
+
+*/
+
+export function packedBddToBase64String(packedBdd: PackedBdd): string {
+    const bytes = new Uint8Array(packedBdd.buffer, packedBdd.byteOffset, packedBdd.byteLength);
+
+    let binary = '';
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunkSize) as any);
+    }
+    return packedBdd.BYTES_PER_ELEMENT + btoa(binary);
+}
+
+function base64ToBytes(base64: string): Uint8Array {
+    const fromBase64 = (Uint8Array as any).fromBase64;
+    if (fromBase64) {
+        return fromBase64(base64);
+    }
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+
+export function packedBddFromBase64String(str: string): PackedBdd {
+    const width = str.charCodeAt(0) - 48;
+    const bytes = base64ToBytes(str.slice(1));
+    return width === 1 ? bytes : width === 2 ? new Uint16Array(bytes.buffer) : new Uint32Array(bytes.buffer);
+}

package/src/packed/packed-bdd.ts

@@ -0,0 +1,98 @@
+import type { RootNode } from '../root-node.js';
+import type { AbstractNode } from '../abstract-node.js';
+import type { NonLeafNode, ResolverFunctions } from '../types.js';
+
+/*
+
+A PackedBdd is the whole BDD in a single typed array.
+It can be resolved directly without creating any JavaScript objects,
+so there is nothing to parse on startup.
+
+Layout:
+- Every non-leaf node takes three consecutive entries: [level, ref0, ref1]
+  - level is the index of the boolean function
+  - ref0 is the reference that is followed when the boolean function returns false
+  - ref1 is the reference that is followed when it returns true
+- The node with the id x starts at index 3 * x, the root node has the id 0.
+- With n = array.length / 3 (the amount of non-leaf nodes), a reference r
+    - r < n points to the non-leaf node with the id r
+    - r >= n is a leaf node with the value r - n
+
+The narrowest array type that fits all entries is used,
+so a BDD with less than ~250 nodes and values only needs 3 bytes per node.
+
+*/
+
+export type PackedBdd = Uint8Array | Uint16Array | Uint32Array;
+
+/**
+ * Creates a PackedBdd from a (minimized) BDD.
+ * The leaf values must be non-negative integers.
+ */
+export function bddToPackedBdd(bdd: RootNode): PackedBdd {
+    const branchesOf = (node: AbstractNode) => (node as NonLeafNode).branches;
+
+    // breadth first, branch 0 before branch 1, so the output is deterministic
+    const nonLeafNodes: AbstractNode[] = [bdd];
+    const idByNode = new Map<AbstractNode, number>([[bdd, 0]]);
+    for (let i = 0; i < nonLeafNodes.length; i++) {
+        const branches = branchesOf(nonLeafNodes[i]);
+        for (const child of [branches.getBranch('0'), branches.getBranch('1')]) {
+            if (!child.isLeafNode() && !idByNode.has(child)) {
+                idByNode.set(child, nonLeafNodes.length);
+                nonLeafNodes.push(child);
+            }
+        }
+    }
+
+    const n = nonLeafNodes.length;
+    const ref = (node: AbstractNode): number => {
+        if (!node.isLeafNode()) {
+            return idByNode.get(node) as number;
+        }
+        const value = node.asLeafNode().value;
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error('PackedBdd only supports non-negative integer leaf values, got ' + value);
+        }
+        return n + value;
+    };
+    const entries: number[] = [];
+    let max = 0;
+    nonLeafNodes.forEach(node => {
+        const branches = branchesOf(node);
+        const nodeEntries = [node.level, ref(branches.getBranch('0')), ref(branches.getBranch('1'))];
+        nodeEntries.forEach(entry => {
+            entries.push(entry);
+            max = Math.max(max, entry);
+        });
+    });
+
+    if (max <= 0xFF) {
+        return Uint8Array.from(entries);
+    } else if (max <= 0xFFFF) {
+        return Uint16Array.from(entries);
+    } else if (max <= 0xFFFFFFFF) {
+        return Uint32Array.from(entries);
+    }
+    throw new Error('BDD too big for a PackedBdd');
+}
+
+/**
+ * Resolves a value by walking directly over the PackedBdd.
+ * Works with every array type (also a plain number[]).
+ */
+export function resolveWithPackedBdd<T = any>(
+    packedBdd: ArrayLike<number>,
+    fns: ResolverFunctions<T>,
+    input: T
+): number {
+    const n = packedBdd.length / 3;
+    let i = 0;
+    while (true) {
+        const ref = packedBdd[fns[packedBdd[i]](input) ? i + 2 : i + 1];
+        if (ref >= n) {
+            return ref - n;
+        }
+        i = ref * 3;
+    }
+}

package/src/root-node.ts

@@ -2,15 +2,13 @@ import { AbstractNode } from './abstract-node.js';
 import { Branches } from './branches.js';
 import type {
     NonRootNode,
-    ResolverFunctions,
-    SimpleBdd
+    ResolverFunctions
 } from './types.js';
 import {
     lastOfArray
 } from './util.js';
 import { InternalNode } from './internal-node.js';
 import { LeafNode } from './leaf-node.js';
-import { bddToSimpleBdd } from './minimal-string/index.js';
 
 export class RootNode extends AbstractNode {
     public branches: Branches = new Branches(this);
@@ -87,7 +85,7 @@ export class RootNode extends AbstractNode {
             }
             let successCount = 0;
             let lastLevel = lastOfArray(this.getLevels());
-            while (lastLevel > 0) {
+            while (lastLevel >= 0) {
                 const nodes: InternalNode[] = this.getNodesOfLevel(lastLevel) as InternalNode[];
                 if (logState) {
                     console.log(
@@ -185,8 +183,4 @@ export class RootNode extends AbstractNode {
             }
         }
     }
-
-    public toSimpleBdd(): SimpleBdd {
-        return bddToSimpleBdd(this);
-    }
 }

package/src/types.ts

@@ -17,21 +17,3 @@ export type ResolverFunction<T> = (i: T) => boolean;
 export type ResolverFunctions<T = any> = {
     [k: number]: ResolverFunction<T>;
 };
-
-
-
-
-// 1 char which is the value
-export type SimpleBddLeafNode = number;
-
-/**
- * a simple bdd is a json-representation
- * which could be parsed from the minimal string
- * use this to have great performance
- * when resolving values
- */
-export type SimpleBdd = {
-    0: SimpleBdd | SimpleBddLeafNode; // branch-0
-    1: SimpleBdd | SimpleBddLeafNode; // branch-1
-    l: number; // level of the boolean function
-};

package/src/util.ts

@@ -56,7 +56,8 @@ export function decimalToPaddedBinary(
     decimal: number,
     padding: number
 ) {
-    const binary = (decimal >>> 0).toString(2);
+    // >>> 0 would cut off everything above 32 bits, only use it for the two's complement of negative numbers
+    const binary = (decimal < 0 ? decimal >>> 0 : decimal).toString(2);
     const padded = binary.padStart(padding, '0');
     return padded;
 }
@@ -86,15 +87,23 @@ export function maxBinaryWithLength(length: number): string {
 export function getNextStateSet(
     stateSet: string
 ): string {
-    const decimal = binaryToDecimal(stateSet);
-    const increase = decimal + 1;
-    const binary = decimalToPaddedBinary(increase, stateSet.length);
-    return binary;
+    if (stateSet.length <= 52) {
+        // fast path, the number stays exact
+        const decimal = binaryToDecimal(stateSet);
+        return decimalToPaddedBinary(decimal + 1, stateSet.length);
+    }
+    // longer keys would lose precision as a number, so increment the string directly
+    const lastZero = stateSet.lastIndexOf('0');
+    if (lastZero === -1) {
+        // overflow, the result gets one char longer
+        return '1' + '0'.repeat(stateSet.length);
+    }
+    return stateSet.slice(0, lastZero) + '1' + '0'.repeat(stateSet.length - lastZero - 1);
 }
 
 export function firstKeyOfMap(map: Map<string, any>): string {
     const iterator1 = map.keys();
-    return iterator1.next().value;
+    return iterator1.next().value as string;
 }
 
 /**

package/dist/cjs/src/minimal-string/bdd-to-minimal-string.d.ts

@@ -1,8 +0,0 @@
-import { RootNode } from '../root-node.js';
-import { AbstractNode } from '../abstract-node.js';
-export declare function bddToMinimalString(bdd: RootNode): string;
-export declare function nodeToString(node: AbstractNode, idByNode: Map<AbstractNode, string>, lastCode: number): {
-    id: string;
-    str: string;
-    nextCode: number;
-};

package/dist/cjs/src/minimal-string/bdd-to-minimal-string.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bddToMinimalString = bddToMinimalString;
-exports.nodeToString = nodeToString;
-const string_format_js_1 = require("./string-format.js");
-const string_format_js_2 = require("./string-format.js");
-function bddToMinimalString(bdd) {
-    let ret = '';
-    let currentCharCode = string_format_js_2.FIRST_CHAR_CODE_FOR_ID;
-    // add leaf node count
-    const leafNodeAmount = bdd.getLeafNodes().length;
-    if (leafNodeAmount > 99) {
-        throw new Error('cannot build string with too many leaf nodes');
-    }
-    ret += leafNodeAmount.toString().padStart(2, '0');
-    const levelsHighestFirst = bdd.levels.slice().reverse();
-    const idByNode = new Map();
-    levelsHighestFirst.forEach(level => {
-        const nodes = bdd.getNodesOfLevel(level);
-        nodes.forEach(node => {
-            const stringRep = nodeToString(node, idByNode, currentCharCode);
-            currentCharCode = stringRep.nextCode;
-            idByNode.set(node, stringRep.id);
-            ret += stringRep.str;
-        });
-    });
-    return ret;
-}
-function nodeToString(node, idByNode, lastCode) {
-    const nextId = (0, string_format_js_1.getNextCharId)(lastCode);
-    switch (node.type) {
-        case 'LeafNode':
-            const valueChar = (0, string_format_js_1.getCharOfValue)(node.asLeafNode().value);
-            return {
-                id: nextId.char,
-                nextCode: nextId.nextCode,
-                str: nextId.char + valueChar
-            };
-        case 'InternalNode':
-            const branch0Id = idByNode.get(node.asInternalNode().branches.getBranch('0'));
-            const branch1Id = idByNode.get(node.asInternalNode().branches.getBranch('1'));
-            return {
-                id: nextId.char,
-                nextCode: nextId.nextCode,
-                str: nextId.char + branch0Id + branch1Id + (0, string_format_js_1.getCharOfLevel)(node.level)
-            };
-        case 'RootNode':
-            const branch0IdRoot = idByNode.get(node.asRootNode().branches.getBranch('0'));
-            const branch1IdRoot = idByNode.get(node.asRootNode().branches.getBranch('1'));
-            return {
-                id: nextId.char,
-                nextCode: nextId.nextCode,
-                str: '' + branch0IdRoot + branch1IdRoot + (0, string_format_js_1.getCharOfLevel)(node.level)
-            };
-        default:
-            throw new Error('unknown node type');
-    }
-}
-//# sourceMappingURL=bdd-to-minimal-string.js.map

package/dist/cjs/src/minimal-string/bdd-to-minimal-string.js.map

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

package/dist/cjs/src/minimal-string/bdd-to-simple-bdd.d.ts

@@ -1,11 +0,0 @@
-import { RootNode } from '../root-node.js';
-import { SimpleBdd } from '../types.js';
-import { AbstractNode } from '../abstract-node.js';
-/**
- * @recursive
- */
-export declare function bddToSimpleBdd(bdd: RootNode): SimpleBdd;
-/**
- * @recursive
- */
-export declare function nodeToSimpleBddNode(node: AbstractNode): SimpleBdd;

package/dist/cjs/src/minimal-string/bdd-to-simple-bdd.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bddToSimpleBdd = bddToSimpleBdd;
-exports.nodeToSimpleBddNode = nodeToSimpleBddNode;
-/**
- * @recursive
- */
-function bddToSimpleBdd(bdd) {
-    return nodeToSimpleBddNode(bdd);
-}
-/**
- * @recursive
- */
-function nodeToSimpleBddNode(node) {
-    const branch0 = node.branches.getBranch('0');
-    const branch1 = node.branches.getBranch('1');
-    return {
-        l: node.level,
-        0: branch0.isLeafNode() ? branch0.asLeafNode().value : nodeToSimpleBddNode(branch0),
-        1: branch1.isLeafNode() ? branch1.asLeafNode().value : nodeToSimpleBddNode(branch1),
-    };
-}
-//# sourceMappingURL=bdd-to-simple-bdd.js.map

package/dist/cjs/src/minimal-string/bdd-to-simple-bdd.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bdd-to-simple-bdd.js","sourceRoot":"","sources":["../../../../src/minimal-string/bdd-to-simple-bdd.ts"],"names":[],"mappings":";;AAUA,wCAEC;AAMD,kDAYC;AAvBD;;GAEG;AACH,SAAgB,cAAc,CAAC,GAAa;IACxC,OAAO,mBAAmB,CAAC,GAAG,CAAC,CAAC;AACpC,CAAC;AAGD;;GAEG;AACH,SAAgB,mBAAmB,CAC/B,IAAkB;IAGlB,MAAM,OAAO,GAAkB,IAAqB,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC7E,MAAM,OAAO,GAAkB,IAAqB,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAE7E,OAAO;QACH,CAAC,EAAE,IAAI,CAAC,KAAK;QACb,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,mBAAmB,CAAC,OAAO,CAAC;QACnF,CAAC,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,mBAAmB,CAAC,OAAO,CAAC;KACtF,CAAC;AACN,CAAC"}

package/dist/cjs/src/minimal-string/index.d.ts

@@ -1,5 +0,0 @@
-export * from './bdd-to-minimal-string.js';
-export * from './minimal-string-to-simple-bdd.js';
-export * from './resolve-with-simple-bdd.js';
-export * from './string-format.js';
-export * from './bdd-to-simple-bdd.js';

package/dist/cjs/src/minimal-string/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/minimal-string/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6DAA2C;AAC3C,oEAAkD;AAClD,+DAA6C;AAC7C,qDAAmC;AACnC,yDAAuC"}