@genome-spy/core 0.36.1 → 0.37.1

package/dist/src/data/transforms/sample.test.js

@@ -0,0 +1,38 @@
+import { expect, test } from "vitest";
+import SampleTransform from "./sample";
+import { extent } from "d3-array";
+import { createChain } from "../../view/flowBuilder";
+
+test("SampleTransform produces roughly uniform distributions", () => {
+    const size = 10;
+    const n = 20;
+    const rounds = 10000;
+
+    const freqs = [];
+    for (let i = 0; i < n; i++) {
+        freqs[i] = 0;
+    }
+
+    const { dataSource, collector } = createChain(
+        new SampleTransform({ type: "sample", size })
+    );
+
+    for (let r = 0; r < rounds; r++) {
+        for (let i = 0; i < n; i++) {
+            dataSource.handle({ data: i });
+        }
+        dataSource.complete();
+
+        for (const datum of collector.getData()) {
+            freqs[datum.data] = freqs[datum.data] + 1;
+        }
+
+        dataSource.reset();
+    }
+
+    const e = extent(freqs);
+
+    // Not a deterministic test! TODO: Come up with some sensical testing method
+    expect(e[0]).toBeGreaterThan(4800);
+    expect(e[1]).toBeLessThan(5200);
+});

package/dist/src/data/transforms/stack.d.ts

@@ -0,0 +1,11 @@
+export default class StackTransform extends FlowNode {
+    /**
+     * @param {import("../../spec/transform").StackParams} params
+     */
+    constructor(params: import("../../spec/transform").StackParams);
+    params: import("../../spec/transform").StackParams;
+    /** @type {any[]} */
+    buffer: any[];
+}
+import FlowNode from "../flowNode";
+//# sourceMappingURL=stack.d.ts.map

package/dist/src/data/transforms/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/stack.js"],"names":[],"mappings":"AAKA;IAKI;;OAEG;IACH,oBAFW,OAAO,sBAAsB,EAAE,WAAW,EAQpD;IAJG,mDAAoB;IAEpB,oBAAoB;IACpB,QADW,GAAG,EAAE,CACA;CAmHvB;qBAnI2C,aAAa"}

package/dist/src/data/transforms/stack.js

@@ -0,0 +1,134 @@
+import { compare } from "vega-util";
+import { groups as d3groups, sum as d3sum } from "d3-array";
+import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
+import { field } from "../../utils/field";
+
+export default class StackTransform extends FlowNode {
+    get behavior() {
+        return BEHAVIOR_MODIFIES;
+    }
+
+    /**
+     * @param {import("../../spec/transform").StackParams} params
+     */
+    constructor(params) {
+        super();
+        this.params = params;
+
+        /** @type {any[]} */
+        this.buffer = [];
+    }
+
+    reset() {
+        this.buffer = [];
+    }
+
+    /**
+     *
+     * @param {import("../flowNode").Datum} datum
+     */
+    handle(datum) {
+        this.buffer.push(datum);
+    }
+
+    complete() {
+        const params = this.params;
+
+        const as = params.as || ["y0", "y1"]; // TODO: Validate
+
+        const comparator = params.sort
+            ? compare(params.sort.field, params.sort.order)
+            : undefined;
+
+        const valueAccessor = params.field ? field(params.field) : () => 1;
+
+        const groupFields = params.groupby.map((f) => field(f));
+
+        const groups = d3groups(this.buffer, (row) =>
+            groupFields.map((f) => f(row)).join()
+        ).map((a) => a[1]);
+
+        /** @type {(datum: any) => boolean} */
+        let inclusionPredicate = (_datum) => true;
+
+        if (params.baseField) {
+            const baseAccessor = field(params.baseField);
+            inclusionPredicate = (datum) => baseAccessor(datum) !== null;
+        }
+
+        /** @type {(value: number, sum: number) => number} */
+        let offsetF;
+
+        /** @type {(values: number[], accessor: (datum: any) => number) => number} */
+        let sumF;
+
+        switch (params.offset) {
+            case "normalize":
+                offsetF = (value, sum) => value / sum;
+                sumF = (values, accessor) => d3sum(values, accessor);
+                break;
+            case "center":
+                offsetF = (value, sum) => value - sum / 2;
+                sumF = (values, accessor) => d3sum(values, accessor);
+                break;
+            case "information":
+                {
+                    // Sequence logos: a new way to display consensus sequences (Schneider and Stephens)
+                    // doi://10.1093/nar/18.20.6097
+
+                    const maxBits = Math.log2(params.cardinality ?? 4);
+                    offsetF = (value, sum) => value / sum;
+                    sumF = (values, accessor) => {
+                        const e = 0; // TODO: Correction factor for small sample sizes
+
+                        const gaps = d3sum(
+                            values,
+                            (d) => +!inclusionPredicate(d)
+                        );
+                        const total = d3sum(values, accessor);
+                        const nonGaps = total - gaps;
+
+                        let H = 0;
+                        for (let i = 0; i < values.length; i++) {
+                            const datum = values[i];
+                            if (inclusionPredicate(datum)) {
+                                const b = accessor(datum) / nonGaps;
+                                H -= b * Math.log2(b);
+                            }
+                        }
+
+                        return (
+                            (nonGaps / (maxBits - (H + e))) * (nonGaps / total)
+                        );
+                    };
+                }
+                break;
+            default:
+                offsetF = (value, sum) => value;
+                sumF = (_values, _accessor) => 1;
+        }
+
+        for (const group of groups) {
+            if (comparator) {
+                group.sort(comparator);
+            }
+
+            const sum = sumF(group, valueAccessor);
+
+            let prev = 0;
+            for (const datum of group) {
+                const current = prev + valueAccessor(datum);
+
+                if (inclusionPredicate(datum)) {
+                    datum[as[0]] = offsetF(prev, sum);
+                    datum[as[1]] = offsetF(current, sum);
+
+                    this._propagate(datum);
+                    prev = current;
+                }
+            }
+        }
+
+        super.complete();
+    }
+}

package/dist/src/data/transforms/stack.test.js

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "vitest";
+import { processData } from "../flowTestUtils";
+import StackTransform from "./stack";
+
+const sampleData = [
+    { group: "a", choice: "q", value: 1 },
+    { group: "b", choice: "x", value: 1 },
+    { group: "b", choice: "y", value: 3 },
+];
+
+/** @type {import("./stack").StackParams} */
+const baseConf = {
+    type: "stack",
+    field: "value",
+    groupby: ["group"],
+    sort: {
+        field: "value",
+        order: "ascending",
+    },
+    offset: "zero",
+    as: ["z0", "z1"],
+};
+
+/**
+ *
+ * @param {import("./stack").StackParams} params
+ * @param {any[]} data
+ */
+function transform(params, data) {
+    return processData(new StackTransform(params), data);
+}
+
+describe("Stack transform", () => {
+    test("No field", () => {
+        const conf = Object.assign({}, baseConf, {
+            field: undefined,
+        });
+
+        expect(transform(conf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "y", value: 3, z0: 1, z1: 2 },
+        ]);
+    });
+
+    test("Zero offset", () => {
+        expect(transform(baseConf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "y", value: 3, z0: 1, z1: 4 },
+        ]);
+    });
+
+    test("Normalize offset", () => {
+        const conf = Object.assign({}, baseConf, {
+            offset: "normalize",
+        });
+
+        expect(transform(conf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "x", value: 1, z0: 0, z1: 0.25 },
+            { group: "b", choice: "y", value: 3, z0: 0.25, z1: 1 },
+        ]);
+    });
+
+    test("Center offset", () => {
+        const conf = Object.assign({}, baseConf, {
+            offset: "center",
+        });
+
+        expect(transform(conf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: -0.5, z1: 0.5 },
+            { group: "b", choice: "x", value: 1, z0: -2, z1: -1 },
+            { group: "b", choice: "y", value: 3, z0: -1, z1: 2 },
+        ]);
+    });
+
+    test("Descending sort", () => {
+        const conf = Object.assign({}, baseConf, {
+            sort: {
+                field: "value",
+                order: "descending",
+            },
+        });
+        expect(transform(conf, sampleData)).toEqual([
+            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
+            { group: "b", choice: "y", value: 3, z0: 0, z1: 3 },
+            { group: "b", choice: "x", value: 1, z0: 3, z1: 4 },
+        ]);
+    });
+});

package/dist/src/data/transforms/transformFactory.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {import("../../spec/transform").TransformParamsBase} params
+ * @param {import("../../view/view").default} [view]
+ */
+export default function createTransform(params: import("../../spec/transform").TransformParamsBase, view?: import("../../view/view").default): import("../flowNode").default;
+/**
+ * TODO: Make this dynamic
+ *
+ * @type {Record<string, new (params: any, view?: import("../../view/view").default) => import("../flowNode").default>}
+ */
+export const transforms: Record<string, new (params: any, view?: import("../../view/view").default) => import("../flowNode").default>;
+//# sourceMappingURL=transformFactory.d.ts.map

package/dist/src/data/transforms/transformFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformFactory.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/transformFactory.js"],"names":[],"mappings":"AA+CA;;;GAGG;AACH,gDAHW,OAAO,sBAAsB,EAAE,mBAAmB,SAClD,OAAO,iBAAiB,EAAE,OAAO,iCAS3C;AAtCD;;;;GAIG;AACH,qDAFsC,GAAG,SAAS,OAAO,iBAAiB,EAAE,OAAO,KAAK,OAAO,aAAa,EAAE,OAAO,EAsBnH"}

package/dist/src/data/transforms/transformFactory.js

@@ -0,0 +1,59 @@
+import Collector from "../collector";
+import CoverageTransform from "./coverage";
+import FilterScoredLabelsTransform from "./filterScoredLabels";
+import FilterTransform from "./filter";
+import FlattenTransform from "./flatten";
+import FlattenCompressedExonsTransform from "./flattenCompressedExons";
+import FlattenDelimitedTransform from "./flattenDelimited";
+import FormulaTransform from "./formula";
+import LinearizeGenomicCoordinate from "./linearizeGenomicCoordinate";
+import MeasureTextTransform from "./measureText";
+import PileupTransform from "./pileup";
+import ProjectTransform from "./project";
+import RegexExtractTransform from "./regexExtract";
+import RegexFoldTransform from "./regexFold";
+import SampleTransform from "./sample";
+import StackTransform from "./stack";
+import FlattenSequenceTransform from "./flattenSequence";
+import AggregateTransform from "./aggregate";
+import IdentifierTransform from "./identifier";
+
+/**
+ * TODO: Make this dynamic
+ *
+ * @type {Record<string, new (params: any, view?: import("../../view/view").default) => import("../flowNode").default>}
+ */
+export const transforms = {
+    aggregate: AggregateTransform,
+    collect: Collector,
+    coverage: CoverageTransform,
+    filterScoredLabels: FilterScoredLabelsTransform,
+    filter: FilterTransform,
+    flatten: FlattenTransform,
+    flattenCompressedExons: FlattenCompressedExonsTransform,
+    flattenDelimited: FlattenDelimitedTransform,
+    flattenSequence: FlattenSequenceTransform,
+    formula: FormulaTransform,
+    identifier: IdentifierTransform,
+    linearizeGenomicCoordinate: LinearizeGenomicCoordinate,
+    measureText: MeasureTextTransform,
+    pileup: PileupTransform,
+    project: ProjectTransform,
+    regexExtract: RegexExtractTransform,
+    regexFold: RegexFoldTransform,
+    sample: SampleTransform,
+    stack: StackTransform,
+};
+
+/**
+ * @param {import("../../spec/transform").TransformParamsBase} params
+ * @param {import("../../view/view").default} [view]
+ */
+export default function createTransform(params, view) {
+    const Transform = transforms[params.type];
+    if (Transform) {
+        return new Transform(params, view);
+    } else {
+        throw new Error("Unknown transform: " + params.type);
+    }
+}

package/dist/src/encoder/accessor.d.ts

@@ -0,0 +1,15 @@
+export default class AccessorFactory {
+    /** @type {(function(import("../spec/channel").ChannelDef):Accessor)[]} */
+    accessorCreators: ((arg0: import("../spec/channel").ChannelDef) => import("../types/encoder").Accessor)[];
+    /**
+     *
+     * @param {function(import("../spec/channel").ChannelDef):Accessor} creator
+     */
+    register(creator: (arg0: import("../spec/channel").ChannelDef) => import("../types/encoder").Accessor): void;
+    /**
+     *
+     * @param {import("../spec/channel").ChannelDef} encoding
+     */
+    createAccessor(encoding: import("../spec/channel").ChannelDef): import("../types/encoder").Accessor;
+}
+//# sourceMappingURL=accessor.d.ts.map

package/dist/src/encoder/accessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessor.d.ts","sourceRoot":"","sources":["../../../src/encoder/accessor.js"],"names":[],"mappings":"AAMA;IAKQ,0EAA0E;IAC1E,0BADqB,OAAO,iBAAiB,EAAE,UAAU,4CAC/B;IAkC9B;;;OAGG;IACH,yBAFoB,OAAO,iBAAiB,EAAE,UAAU,gDAIvD;IAED;;;OAGG;IACH,yBAFW,OAAO,iBAAiB,EAAE,UAAU,uCAS9C;CACJ"}

package/dist/src/encoder/accessor.js

@@ -0,0 +1,76 @@
+import createFunction from "../utils/expression";
+
+import { accessorFields, constant } from "vega-util";
+import { isDatumDef, isExprDef, isFieldDef } from "./encoder";
+import { field } from "../utils/field";
+
+export default class AccessorFactory {
+    /**
+     * @typedef {import("../types/encoder").Accessor} Accessor
+     */
+    constructor() {
+        /** @type {(function(import("../spec/channel").ChannelDef):Accessor)[]} */
+        this.accessorCreators = [];
+
+        this.register((channelDef) => {
+            if (isFieldDef(channelDef)) {
+                try {
+                    const accessor = /** @type {Accessor} */ (
+                        field(channelDef.field)
+                    );
+                    accessor.constant = false;
+                    accessor.fields = accessorFields(accessor);
+                    return accessor;
+                } catch (e) {
+                    throw new Error(`Invalid field definition: ${e.message}`);
+                }
+            }
+        });
+
+        this.register((channelDef) =>
+            isExprDef(channelDef)
+                ? createExpressionAccessor(channelDef.expr)
+                : undefined
+        );
+
+        this.register((channelDef) => {
+            if (isDatumDef(channelDef)) {
+                const c = /** @type {any} */ (constant(channelDef.datum));
+                const accessor = /** @type {Accessor} */ (c);
+                accessor.constant = true; // Can be optimized downstream
+                accessor.fields = [];
+                return accessor;
+            }
+        });
+    }
+
+    /**
+     *
+     * @param {function(import("../spec/channel").ChannelDef):Accessor} creator
+     */
+    register(creator) {
+        this.accessorCreators.push(creator);
+    }
+
+    /**
+     *
+     * @param {import("../spec/channel").ChannelDef} encoding
+     */
+    createAccessor(encoding) {
+        for (const creator of this.accessorCreators) {
+            const accessor = creator(encoding);
+            if (accessor) {
+                return accessor;
+            }
+        }
+    }
+}
+
+/**
+ * @param {string} expr
+ */
+function createExpressionAccessor(expr) {
+    const accessor = /** @type {Accessor} */ (createFunction(expr));
+    accessor.constant = accessor.fields.length == 0; // Not bulletproof, eh
+    return accessor;
+}

package/dist/src/encoder/accessor.test.js

@@ -0,0 +1,47 @@
+import { expect, test } from "vitest";
+import AccessorFactory from "./accessor";
+
+const af = new AccessorFactory();
+
+const datum = {
+    a: 1,
+    b: 2,
+    "x.c": 3,
+};
+
+test("Creates a field accessor", () => {
+    const a = af.createAccessor({ field: "a" });
+    expect(a(datum)).toEqual(1);
+    expect(a.constant).toBeFalsy();
+    expect(a.fields).toEqual(["a"]);
+});
+
+test("Creates an expression accessor", () => {
+    const a = af.createAccessor({ expr: `datum.b + datum['x\.c']` });
+    expect(a(datum)).toEqual(5);
+    expect(a.constant).toBeFalsy();
+    expect(a.fields.sort()).toEqual(["b", "x.c"].sort());
+});
+
+test("Creates a constant accessor", () => {
+    const a = af.createAccessor({ datum: 0 });
+    expect(a(datum)).toEqual(0);
+    expect(a.constant).toBeTruthy();
+    expect(a.fields).toEqual([]);
+});
+
+test("Returns undefined on incomplete encoding spec", () => {
+    expect(af.createAccessor({})).toBeUndefined();
+});
+
+test("Registers and creates a custom accessor", () => {
+    const af = new AccessorFactory();
+    af.register((encoding) => {
+        if (encoding.iddqd && encoding.idkfa) {
+            return (datum) =>
+                `${datum[encoding.iddqd]}-${datum[encoding.idkfa]}`;
+        }
+    });
+
+    expect(af.createAccessor({ iddqd: "a", idkfa: "b" })(datum)).toEqual("1-2");
+});

package/dist/src/encoder/encoder.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Creates an object that contains encoders for every channel of a mark
+ *
+ * TODO: This should actually receive the mark as parameter
+ *
+ * TODO: This method should have a test. But how to mock Mark...
+ *
+ * @param {import("../marks/mark").default} mark
+ * @param {import("../spec/channel").Encoding} [encoding] Taken from the mark if not provided
+ * @returns {Partial<Record<Channel, Encoder>>}
+ */
+export default function createEncoders(mark: import("../marks/mark").default, encoding?: import("../spec/channel").Encoding): Partial<Record<import("../spec/channel").Channel, import("../types/encoder").Encoder>>;
+/**
+ *
+ * @param {import("../spec/channel").ChannelDef} channelDef
+ * @param {any} scale
+ * @param {Accessor} accessor
+ * @param {Channel} channel
+ * @returns {Encoder}
+ */
+export function createEncoder(channelDef: import("../spec/channel").ChannelDef, scale: any, accessor: import("../types/encoder").Accessor, channel: import("../spec/channel").Channel): import("../types/encoder").Encoder;
+/**
+ * TODO: Move to a more generic place
+ *
+ * @param {import("../spec/channel").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel").ValueDef}
+ */
+export function isValueDef(channelDef: import("../spec/channel").ChannelDef): channelDef is import("../spec/channel").ValueDef<import("../spec/channel").Scalar>;
+/**
+ * @param {import("../spec/channel").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel").FieldDefBase<string>}
+ */
+export function isFieldDef(channelDef: import("../spec/channel").ChannelDef): channelDef is import("../spec/channel").FieldDefBase<string>;
+/**
+ * @param {import("../spec/channel").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel").DatumDef}
+ */
+export function isDatumDef(channelDef: import("../spec/channel").ChannelDef): channelDef is import("../spec/channel").DatumDef;
+/**
+ * @param {import("../spec/channel").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel").ChannelDefWithScale}
+ */
+export function isChannelDefWithScale(channelDef: import("../spec/channel").ChannelDef): channelDef is import("../spec/channel").ChannelDefWithScale;
+/**
+ * @param {import("../view/unitView").default} view
+ * @param {import("../spec/channel").Channel} channel
+ */
+export function getChannelDefWithScale(view: import("../view/unitView").default, channel: import("../spec/channel").Channel): import("../spec/channel").ChromPosDef | import("../spec/channel").PositionDatumDef | import("../spec/channel").MarkPropExprDef<import("../spec/channel").Type> | import("../spec/channel").MarkPropDatumDef<import("../spec/channel").Type> | import("../spec/channel").MarkPropDatumDef<import("../spec/channel").TypeForShape> | import("../spec/channel").PositionFieldDef<string> | import("../spec/channel").MarkPropFieldDef<string, import("../spec/channel").Type> | import("../spec/channel").MarkPropFieldDef<string, import("../spec/channel").TypeForShape>;
+/**
+ * @param {import("../spec/channel").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel").ChromPosDef}
+ */
+export function isChromPosDef(channelDef: import("../spec/channel").ChannelDef): channelDef is import("../spec/channel").ChromPosDef;
+/**
+ * @param {import("../spec/channel").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel").ExprDef}
+ */
+export function isExprDef(channelDef: import("../spec/channel").ChannelDef): channelDef is import("../spec/channel").ExprDef;
+/**
+ * @param {import("../spec/channel").Channel} channel
+ * @returns {channel is import("../spec/channel").PrimaryPositionalChannel}
+ */
+export function isPrimaryPositionalChannel(channel: import("../spec/channel").Channel): channel is import("../spec/channel").PrimaryPositionalChannel;
+/**
+ * @param {import("../spec/channel").Channel} channel
+ * @returns {channel is import("../spec/channel").PositionalChannel}
+ */
+export function isPositionalChannel(channel: import("../spec/channel").Channel): channel is import("../spec/channel").PositionalChannel;
+/**
+ *
+ * @param {string} channel
+ */
+export function isSecondaryChannel(channel: string): boolean;
+/**
+ * Return the matching secondary channel or throws if one does not exist.
+ *
+ * @param {import("../spec/channel").Channel} primaryChannel
+ */
+export function getSecondaryChannel(primaryChannel: import("../spec/channel").Channel): import("../spec/channel").SecondaryPositionalChannel;
+/**
+ * Finds the primary channel for the provided channel, which may be
+ * the primary or secondary.
+ *
+ * @param {import("../spec/channel").Channel} channel
+ */
+export function getPrimaryChannel(channel: import("../spec/channel").Channel): import("../spec/channel").Channel;
+/**
+ * Returns an array that contains the given channel and its secondary channel if one exists.
+ *
+ * @param {import("../spec/channel").Channel} channel
+ */
+export function getChannelWithSecondarys(channel: import("../spec/channel").Channel): import("../spec/channel").Channel[];
+/**
+ * @param {import("../spec/channel").Channel} channel
+ */
+export function isColorChannel(channel: import("../spec/channel").Channel): boolean;
+/**
+ * Returns true if the channel has a discrete range.
+ *
+ * @param {import("../spec/channel").Channel} channel
+ */
+export function isDiscreteChannel(channel: import("../spec/channel").Channel): boolean;
+/**
+ * @param {import("../spec/channel").Channel} channel
+ * @returns {channel is import("../spec/channel").ChannelWithScale}
+ */
+export function isChannelWithScale(channel: import("../spec/channel").Channel): channel is import("../spec/channel").ChannelWithScale;
+/**
+ * Returns valid discrete values for a discrete channel.
+ *
+ * @param {import("../spec/channel").Channel} channel
+ * @returns {any[]}
+ */
+export function getDiscreteRange(channel: import("../spec/channel").Channel): any[];
+/**
+ * @param {import("../spec/channel").Channel} channel
+ * @returns {function(any):number}
+ */
+export function getDiscreteRangeMapper(channel: import("../spec/channel").Channel): (arg0: any) => number;
+/**
+ * @type {import("../spec/channel").PrimaryPositionalChannel[]}
+ */
+export const primaryPositionalChannels: import("../spec/channel").PrimaryPositionalChannel[];
+/**
+ * @type {import("../spec/channel").SecondaryPositionalChannel[]}
+ */
+export const secondaryPositionalChannels: import("../spec/channel").SecondaryPositionalChannel[];
+/**
+ * @type {import("../spec/channel").PositionalChannel[]}
+ */
+export const positionalChannels: import("../spec/channel").PositionalChannel[];
+/**
+ * Map primary channels to secondarys
+ *
+ * @type {Partial<Record<import("../spec/channel").Channel, import("../spec/channel").SecondaryPositionalChannel>>}
+ */
+export const secondaryChannels: Partial<Record<import("../spec/channel").Channel, import("../spec/channel").SecondaryPositionalChannel>>;
+/**
+ * Map secondary channels to primaries
+ *
+ * @type {Partial<Record<import("../spec/channel").Channel, import("../spec/channel").Channel>>}
+ */
+export const primaryChannels: Partial<Record<import("../spec/channel").Channel, import("../spec/channel").Channel>>;
+//# sourceMappingURL=encoder.d.ts.map

package/dist/src/encoder/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../../src/encoder/encoder.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,6CAJW,OAAO,eAAe,EAAE,OAAO,aAC/B,OAAO,iBAAiB,EAAE,QAAQ,0FAsC5C;AAED;;;;;;;GAOG;AACH,0CANW,OAAO,iBAAiB,EAAE,UAAU,SACpC,GAAG,iIAyFb;AAED;;;;;GAKG;AACH,uCAHW,OAAO,iBAAiB,EAAE,UAAU,sFAK9C;AAED;;;GAGG;AACH,uCAHW,OAAO,iBAAiB,EAAE,UAAU,gEAK9C;AAED;;;GAGG;AACH,uCAHW,OAAO,iBAAiB,EAAE,UAAU,oDAK9C;AAED;;;GAGG;AACH,kDAHW,OAAO,iBAAiB,EAAE,UAAU,+DAW9C;AAED;;;GAGG;AACH,6CAHW,OAAO,kBAAkB,EAAE,OAAO,WAClC,OAAO,iBAAiB,EAAE,OAAO,2iBAS3C;AAED;;;GAGG;AACH,0CAHW,OAAO,iBAAiB,EAAE,UAAU,uDAK9C;AAED;;;GAGG;AACH,sCAHW,OAAO,iBAAiB,EAAE,UAAU,mDAK9C;AAoBD;;;GAGG;AACH,oDAHW,OAAO,iBAAiB,EAAE,OAAO,iEAM3C;AAED;;;GAGG;AACH,6CAHW,OAAO,iBAAiB,EAAE,OAAO,0DAM3C;AAqBD;;;GAGG;AACH,4CAFW,MAAM,WAIhB;AAED;;;;GAIG;AACH,oDAFW,OAAO,iBAAiB,EAAE,OAAO,wDAS3C;AAED;;;;;GAKG;AACH,2CAFW,OAAO,iBAAiB,EAAE,OAAO,qCAI3C;AAED;;;;GAIG;AACH,kDAFW,OAAO,iBAAiB,EAAE,OAAO,uCAM3C;AAED;;GAEG;AACH,wCAFW,OAAO,iBAAiB,EAAE,OAAO,WAI3C;AAED;;;;GAIG;AACH,2CAFW,OAAO,iBAAiB,EAAE,OAAO,WAI3C;AAED;;;GAGG;AACH,4CAHW,OAAO,iBAAiB,EAAE,OAAO,yDAuB3C;AAED;;;;;GAKG;AACH,0CAHW,OAAO,iBAAiB,EAAE,OAAO,GAC/B,GAAG,EAAE,CAkBjB;AAED;;;GAGG;AACH,gDAHW,OAAO,iBAAiB,EAAE,OAAO,UACtB,GAAG,KAAE,MAAM,CAkBhC;AAxLD;;GAEG;AACH,wCAFU,OAAO,iBAAiB,EAAE,wBAAwB,EAAE,CAEV;AAEpD;;GAEG;AACH,0CAFU,OAAO,iBAAiB,EAAE,0BAA0B,EAAE,CAER;AAExD;;GAEG;AACH,iCAFU,OAAO,iBAAiB,EAAE,iBAAiB,EAAE,CAKrD;AAoBF;;;;GAIG;AACH,gCAFU,QAAQ,OAAO,OAAO,iBAAiB,EAAE,OAAO,EAAE,OAAO,iBAAiB,EAAE,0BAA0B,CAAC,CAAC,CAKhH;AAEF;;;;GAIG;AACH,8BAFU,QAAQ,OAAO,OAAO,iBAAiB,EAAE,OAAO,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC,CAAC,CAI7F"}