ixbrl-viewer 1.4.13__py3-none-any.whl → 1.4.15__py3-none-any.whl

iXBRLViewerPlugin/viewer/src/js/factset.js

@@ -2,16 +2,29 @@
 
 import { Fact } from "./fact.js";
 import { Footnote } from "./footnote.js";
+import { Interval } from './interval.js';
 
 export class FactSet {
-    constructor(items) {
-        this._items = items;
+
+    constructor (items) {
+        this.itemMap = new Map();
+        for (const item of items ?? []) {
+            this.add(item)
+        }
+    }
+
+    add(item) {
+        this.itemMap.set(item.vuid, item);
+    }
+
+    items() {
+        return Array.from(this.itemMap.values());
     }
 
     /* Returns the union of dimensions present on facts in the set */
     _allDimensions() {
         const dims = {};
-        const facts = this._items.filter((item) => item instanceof Fact);
+        const facts = this.items().filter((item) => item instanceof Fact);
         for (const fact of facts) {
             const dd = Object.keys(fact.dimensions());
             for (var j = 0; j < dd.length; j++) {
@@ -30,7 +43,7 @@ export class FactSet {
      */
     minimallyUniqueLabel(fact) {
         if (!this._minimallyUniqueLabels) {
-            var facts = this._items.filter((item) => item instanceof Fact);
+            var facts = this.items().filter((item) => item instanceof Fact);
             var allLabels = {};
             var allAspects = ["c", "p"].concat(this._allDimensions());
             /* Assemble a map of arrays of all aspect labels for all facts, in a
@@ -86,7 +99,7 @@ export class FactSet {
                 }
             }
 
-            this._items.filter((item) => item instanceof Footnote).forEach((fn) => {
+            this.items().filter((item) => item instanceof Footnote).forEach((fn) => {
                 uniqueLabels[fn.vuid] = [fn.title];
             });
 
@@ -94,4 +107,40 @@ export class FactSet {
         }
         return this._minimallyUniqueLabels[fact.vuid].join(", ");
     }
+
+    isEmpty() {
+        return this.itemMap.size == 0;
+    }
+
+    /*
+     * Returns an Interval for the intersection of all values in the set, or
+     * undefined if there is no intersection (inconsistent duplicates)
+     */
+    valueIntersection() {
+        const duplicates = this.items().map(fact => Interval.fromFact(fact));
+        return Interval.intersection(...duplicates);
+    }
+
+    completeDuplicates() {
+        return this.items().every(f => f.isCompleteDuplicate(this.items()[0]));
+    }
+
+    isConsistent() {
+        if (this.itemMap.size == 0) {
+            return true;
+        }
+        const duplicates = this.items().map(fact => Interval.fromFact(fact));
+        return Interval.intersection(...duplicates) !== undefined;
+    }
+
+    size() {
+        return this.itemMap.size;
+    }
+
+    /*
+     * Return the most precise (highest decimals) value within the set.
+     */
+    mostPrecise() {
+        return this.items().reduce((a, b) => b.isMorePrecise(a) ? b : a);
+    }
 }

iXBRLViewerPlugin/viewer/src/js/factset.test.js

@@ -1,8 +1,10 @@
 // See COPYRIGHT.md for copyright information
 
 import { FactSet } from "./factset.js";
+import { Fact  } from "./fact.js";
 import { NAMESPACE_ISO4217, viewerUniqueId } from "./util.js";
 import { ReportSet } from "./reportset.js";
+import './test-utils.js';
 
 var i = 0;
 
@@ -71,7 +73,7 @@ var testReportData = {
     }
 };
 
-function testReport(facts) {
+function testReportSet(facts) {
     // Deep copy of standing data
     const data = JSON.parse(JSON.stringify(testReportData));
     data.facts = facts;
@@ -90,7 +92,7 @@ function getFact(reportSet, id) {
 }
 
 describe("Minimally unique labels (non-dimensional)", () => {
-  const reportSet = testReport({ 
+  const reportSet = testReportSet({ 
       "f1": testFact({"c": "eg:Concept1", "p": "2018-01-01"}),
       "f2": testFact({"c": "eg:Concept2", "p": "2018-01-01"}),
       "f3": testFact({"c": "eg:Concept2", "p": "2019-01-01"}),
@@ -133,7 +135,7 @@ describe("Minimally unique labels (non-dimensional)", () => {
 });
 
 describe("Minimally unique labels (dimensional)", () => {
-  const reportSet = testReport({ 
+  const reportSet = testReportSet({ 
       "f1": testFact({"c": "eg:Concept1", "p": "2018-01-01", "eg:Dimension1": "eg:DimensionValue1"}),
       "f2": testFact({"c": "eg:Concept1", "p": "2018-01-01", "eg:Dimension1": "eg:DimensionValue2"}),
       "f3": testFact({"c": "eg:Concept1", "p": "2019-01-01", "eg:Dimension1": "eg:DimensionValue2"}),
@@ -172,7 +174,7 @@ describe("Minimally unique labels (dimensional)", () => {
 });
 
 describe("Minimally unique labels (duplicate facts)", () => {
-  const reportSet = testReport({ 
+  const reportSet = testReportSet({ 
       "f1": testFact({"c": "eg:Concept1", "p": "2018-01-01", "eg:Dimension1": "eg:DimensionValue1"}),
       "f2": testFact({"c": "eg:Concept1", "p": "2018-01-01", "eg:Dimension1": "eg:DimensionValue1"}),
   });
@@ -189,7 +191,7 @@ describe("Minimally unique labels (duplicate facts)", () => {
 });
 
 describe("Minimally unique labels (missing labels)", () => {
-  const reportSet = testReport({ 
+  const reportSet = testReportSet({ 
       "f1": testFact({"c": "eg:Concept1", "p": "2018-01-01" }),
       "f2": testFact({"c": "eg:Concept4", "p": "2018-01-01" }),
   });
@@ -204,3 +206,67 @@ describe("Minimally unique labels (missing labels)", () => {
     expect(fs.minimallyUniqueLabel(f2)).toEqual("eg:Concept4");
   });
 });
+
+function numericTestFact(value, decimals) {
+    var factData = { "d": decimals, "v": value, "a": { "c": "eg:Concept1", "u": "eg:pure" }};
+    return factData;
+}
+
+describe("Consistency", () => {
+    const reportSet = testReportSet({ 
+        "f1": numericTestFact(150, -1), // 145-155
+        "f2": numericTestFact(200, -2), // 150-250
+        "f3": numericTestFact(140, -1), // 135-145
+    });
+
+    const f1 = getFact(reportSet, "f1");
+    const f2 = getFact(reportSet, "f2");
+    const f3 = getFact(reportSet, "f3");
+
+    test("Inconsistent fact set", () => {
+      const factSet = new FactSet([f1, f2, f3]);
+      expect(factSet.valueIntersection()).toBeUndefined();
+      expect(factSet.isConsistent()).toBeFalsy();
+    });
+
+    test("Consistent fact sets - overlap", () => {
+      const factSet = new FactSet([f1, f2]);
+      const intersection = factSet.valueIntersection();
+      expect(intersection.a).toEqualDecimal(150);
+      expect(intersection.b).toEqualDecimal(155);
+      expect(factSet.isConsistent()).toBeTruthy();
+    });
+
+    test("Consistent fact sets - bounds coincide", () => {
+      const factSet = new FactSet([f1, f3]);
+      const intersection = factSet.valueIntersection();
+      expect(intersection.a).toEqualDecimal(145);
+      expect(intersection.b).toEqualDecimal(145);
+      expect(factSet.isConsistent()).toBeTruthy();
+    });
+  
+});
+
+describe("Most precise", () => {
+    const reportSet = testReportSet({ 
+        "f1": numericTestFact(150, -1), 
+        "f2": numericTestFact(200, 0), 
+        "f3": numericTestFact(140, 2),
+        "f4": numericTestFact(160, undefined)
+    });
+
+    const f1 = getFact(reportSet, "f1");
+    const f2 = getFact(reportSet, "f2");
+    const f3 = getFact(reportSet, "f3");
+    const f4 = getFact(reportSet, "f4");
+
+    test("Most precise - finite decimals", () => {
+        const factSet = new FactSet([f1, f2, f3]);
+        expect(factSet.mostPrecise()).toEqual(f3);
+    });
+
+    test("Most precise - mixture of finite and infinite", () => {
+        const factSet = new FactSet([f1, f2, f3, f4]);
+        expect(factSet.mostPrecise()).toEqual(f4);
+    });
+});

iXBRLViewerPlugin/viewer/src/js/inspector.js

@@ -1,12 +1,11 @@
 // See COPYRIGHT.md for copyright information
 
 import $ from 'jquery'
+import i18next from 'i18next';
+import jqueryI18next from 'jquery-i18next';
 import { formatNumber, wrapLabel, truncateLabel, runGenerator, SHOW_FACT, HIGHLIGHT_COLORS, viewerUniqueId } from "./util.js";
 import { ReportSearch } from "./search.js";
-import { Calculation } from "./calculations.js";
 import { IXBRLChart } from './chart.js';
-import i18next from 'i18next';
-import jqueryI18next from 'jquery-i18next';
 import { ViewerOptions } from './viewerOptions.js';
 import { Identifiers } from './identifiers.js';
 import { Menu } from './menu.js';
@@ -17,6 +16,9 @@ import { Footnote } from './footnote.js';
 import { ValidationReportDialog } from './validationreport.js';
 import { TextBlockViewerDialog } from './textblockviewer.js';
 import { MessageBox } from './messagebox.js';
+import { Interval } from './interval.js';
+import { Calculation } from "./calculation.js";
+import { CalculationInspector } from './calculationInspector.js';
 import { ReportSetOutline } from './outline.js';
 import { DIMENSIONS_KEY, DocumentSummary, MEMBERS_KEY, PRIMARY_ITEMS_KEY, TOTAL_KEY } from './summary.js';
 
@@ -27,6 +29,7 @@ export class Inspector {
         this._iv = iv;
         this._viewerOptions = new ViewerOptions()
         this._currentItem = null;
+        this._useCalc11 = true;
     }
 
     i18nInit() {
@@ -215,6 +218,7 @@ export class Inspector {
         const iv = this._iv;
         this._toolbarMenu.reset();
         this._toolbarMenu.addCheckboxItem(i18next.t("toolbar.xbrlElements"), (checked) => this.highlightAllTags(checked), "highlight-tags", null, this._iv.options.highlightTagsOnStartup);
+        this._toolbarMenu.addCheckboxItem(i18next.t("calculation.calculations11"), (useCalc11) => this.setCalculationMode(useCalc11), "calculation-mode", "select-language", this._useCalc11);
         if (iv.isReviewModeEnabled()) {
             this._toolbarMenu.addCheckboxItem("Untagged Numbers", function (checked) {
                 const body = iv.viewer.contents().find("body");
@@ -262,6 +266,13 @@ export class Inspector {
         }
     }
 
+    setCalculationMode(useCalc11) {
+        this._useCalc11 = useCalc11;
+        if (this._currentItem instanceof Fact) {
+            this.updateCalculation(this._currentItem);
+        }
+    }
+
     highlightAllTags(checked) {
         this._viewer.highlightAllTags(checked, this._reportSet.namespaceGroups());
     }
@@ -464,7 +475,7 @@ export class Inspector {
     }
 
     updateCalculation(fact, elr) {
-        $('.calculations .tree').empty().append(this._calculationHTML(fact, elr));
+        $('.calculations .tree').empty().append(this._calculationHTML(fact));
     }
 
     createSummary() {
@@ -682,47 +693,91 @@ export class Inspector {
     }
 
     _calculationHTML(fact, elr) {
-        const calc = new Calculation(fact);
+        const calc = new Calculation(fact, this._useCalc11);
         if (!calc.hasCalculations()) {
             return "";
         }
         const tableFacts = this._viewer.factsInSameTable(fact);
-        if (!elr) {
-            elr = calc.bestELRForFactSet(tableFacts);
-        }
+        const selectedELR = calc.bestELRForFactSet(tableFacts);
         const report = fact.report;
         const inspector = this;
         const a = new Accordian();
 
-        for (const [e, rolePrefix] of Object.entries(calc.elrs())) {
-            const label = report.getRoleLabel(rolePrefix);
-
-            const rCalc = calc.resolvedCalculation(e);
+        for (const rCalc of calc.resolvedCalculations()) {
+            const label = report.getRoleLabel(rCalc.elr);
             const calcBody = $('<div></div>');
-            for (const [i, r] of rCalc.entries()) {
-                const itemHTML = $("<div></div>")
+            const calcTable = $('<table></table>')
+                .addClass("calculation-table")
+                .appendTo(calcBody);
+
+            for (const r of rCalc.rows) {
+                const itemHTML = $("<tr></tr>")
                     .addClass("item")
-                    .append($("<span></span>").addClass("weight").text(r.weightSign + " "))
-                    .append($("<span></span>").addClass("concept-name").text(report.getLabelOrName(r.concept, "std")))
-                    .appendTo(calcBody);
+                    .append($("<td></td>").addClass("weight").text(r.weightSign + " "))
+                    .append($("<td></td>").addClass("concept-name").text(r.concept.label()))
+                    .append($("<td></td>").addClass("value"))
+                    .appendTo(calcTable);
 
-                // r.facts is a map of fact IDs to Fact objects
-                if (r.facts) {
+                if (!r.facts.isEmpty()) {
+                    itemHTML.addClass("calc-fact-link");
                     itemHTML.addClass("calc-fact-link");
-                    itemHTML.data('ivids', Object.keys(r.facts));
-                    itemHTML.click(() => inspector.selectItem(Object.values(r.facts)[0].vuid));
-                    itemHTML.mouseenter(() => Object.values(r.facts).forEach(f => this._viewer.linkedHighlightFact(f)));
-                    itemHTML.mouseleave(() => Object.values(r.facts).forEach(f => this._viewer.clearLinkedHighlightFact(f)));
-                    Object.values(r.facts).forEach(f => this._viewer.highlightRelatedFact(f));
+                    itemHTML.data('ivids', r.facts.items().map(f => f.vuid));
+                    itemHTML.click(() => this.selectItem(r.facts.items[0].vuid));
+                    itemHTML.mouseenter(() => r.facts.items().forEach(f => this._viewer.linkedHighlightFact(f)));
+                    itemHTML.mouseleave(() => r.facts.items().forEach(f => this._viewer.clearLinkedHighlightFact(f)));
+                    r.facts.items().forEach(f => this._viewer.highlightRelatedFact(f));
+                    itemHTML.find(".value").text(r.facts.mostPrecise().readableValue());
                 }
             }
-            $("<div></div>").addClass("item").addClass("total")
-                .append($("<span></span>").addClass("weight"))
-                .append($("<span></span>").addClass("concept-name").text(fact.getLabelOrName("std")))
+            $("<tr></tr>").addClass("item").addClass("total")
+                .append($("<td></td>").addClass("weight"))
+                .append($("<td></td>").addClass("concept-name").text(fact.concept().label()))
+                .append($("<td></td>").addClass("value").text(fact.readableValue()))
+                .appendTo(calcTable);
+
+            const calcStatusIcon = $("<span></span>");
+            const cardTitle = $("<span></span>")
+                .append(calcStatusIcon)
+                .append($("<span></span>").text(label));
+            const calcStatusText = $("<span></span>");
+            const calcDetailsLink = $("<span></span>")
+                    .addClass("calculation-details-link")
+                    .attr("title", i18next.t('factDetails.viewCalculationDetails'))
+                    .text("details")
+                    .click((e) => {
+                        const dialog = new CalculationInspector();
+                        dialog.displayCalculation(rCalc);
+                        dialog.show();
+                        e.stopPropagation();
+                    })
+            const calcStatus = $("<p></p>")
+                .append(calcStatusText)
+                .append($("<span></span>").text(" ("))
+                .append(calcDetailsLink)
+                .append($("<span></span>").text(")"))
                 .appendTo(calcBody);
+            if (rCalc.binds()) {
+                if (rCalc.isConsistent()) {
+                    calcStatusIcon
+                        .addClass("consistent-flag")
+                        .attr("title", i18next.t('factDetails.calculationIsConsistent'))
+                    calcStatusText.text(i18next.t('factDetails.calculationIsConsistent'));
+                }
+                else {
+                    calcStatusIcon
+                        .addClass("inconsistent-flag")
+                        .attr("title", i18next.t('factDetails.calculationIsInconsistent'))
+                    calcStatusText.text(i18next.t('factDetails.calculationIsInconsistent'));
+                }
+            }
+            else if (rCalc.unchecked()) {
+                calcStatusIcon
+                    .addClass("unchecked-flag")
+                    .attr("title", i18next.t('factDetails.calculationUnchecked'))
+                calcStatusText.text(i18next.t('factDetails.calculationUnchecked'));
+            }
 
-            a.addCard($("<span></span>").text(label), calcBody, e == elr);
-
+            a.addCard(cardTitle, calcBody, rCalc.elr == selectedELR);
         }
         return a.contents();
     }
@@ -813,7 +868,7 @@ export class Inspector {
             }
         }
         else {
-            s = $("<i>").text("n/a").attr("title", "non-numeric fact");
+            s = $("<i>").text("n/a").attr("title", i18next.t('factDetails.nonNumericFact'));
         }
         $(".fact-properties tr.change td").html(s);
 

iXBRLViewerPlugin/viewer/src/js/interval.js

@@ -0,0 +1,70 @@
+// See COPYRIGHT.md for copyright information
+
+import Decimal from 'decimal.js';
+
+/*
+ * Class for working with numeric intervals, of the form: [a, b]
+ *
+ * Interval is closed (includes both bounds)
+ * a must be <= b
+ */
+export class Interval {
+
+    constructor(a, b) {
+        this.a = typeof a == 'object' ? a : new Decimal(a);
+        this.b = typeof b == 'object' ? b : new Decimal(b);
+    }
+
+    static fromFact(fact) {
+        if (!fact.isNumeric()) {
+            return undefined;
+        }
+        const decimals = fact.decimals();
+        let width = 0;
+        if (decimals !== undefined) {
+            const x = new Decimal(10);
+            width = x.pow(0-decimals).times(0.5);
+        }
+        let value;
+        const factValue = fact.value();
+        try {
+            value = new Decimal(factValue);
+        } catch (e) {
+            if (e instanceof Error && /DecimalError/.test(e.message)) {
+                return undefined;
+            }
+            throw e;
+        }
+        return new Interval(value.minus(width), value.plus(width));
+    }
+
+    intersection(other) {
+        return Interval.intersection(this, other);
+    }
+
+    static intersection(...intervals) {
+        if (intervals.includes(undefined) || intervals.length == 0) {
+            return undefined;
+        }
+        const aa = intervals.map(x => x.a);
+        const bb = intervals.map(x => x.b);
+        const a = Decimal.max(...aa);
+        const b = Decimal.min(...bb);
+        if (b.lessThan(a)) {
+            return undefined;
+        }
+        return new Interval(a, b);
+    }
+
+    plus(other) {
+        return new Interval(this.a.plus(other.a), this.b.plus(other.b));
+    }
+
+    times(x) {
+        return x > 0 ? new Interval(this.a.times(x), this.b.times(x)) : new Interval(this.b.times(x), this.a.times(x));
+    }
+
+    midpoint() {
+        return Decimal.add(this.a, this.b).div(2);
+    }
+}

iXBRLViewerPlugin/viewer/src/js/interval.test.js

@@ -0,0 +1,153 @@
+// Copyright 2019 Workiva Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { Fact } from "./fact.js";
+import { Interval } from "./interval.js";
+import { ReportSet } from "./reportset.js";
+import Decimal from 'decimal.js';
+import { viewerUniqueId } from "./util.js";
+import './test-utils.js';
+
+function testReportSet(facts) {
+    const reportset = new ReportSet({
+            prefixes: {},
+            concepts: {},
+            facts: facts
+        });
+    reportset._initialize();
+    return reportset;
+}
+
+function testFact(factData) {
+    factData.a = factData.a || {};
+    factData.a.c = factData.a.c || 'eg:Concept1';
+    if (!('u' in factData.a)) {
+        factData.a.u = 'eg:pure';
+    }
+    else if (factData.a.u === undefined) {
+        delete factData.a.u;
+    }
+    return testReportSet({"f1": factData}).getItemById(viewerUniqueId(0, "f1"));
+}
+
+describe("From facts", () => {
+    test("Infinite precision", () => {
+        var i = Interval.fromFact(testFact({v: 20}));
+        expect(i.a).toEqualDecimal(20);
+        expect(i.b).toEqualDecimal(20);
+
+        i = Interval.fromFact(testFact({v: -20}));
+        expect(i.a).toEqualDecimal(-20);
+        expect(i.b).toEqualDecimal(-20);
+    });
+
+    test("Finite precision", () => {
+        var i = Interval.fromFact(testFact({v: 20, d: 0}));
+        expect(i.a).toEqualDecimal(19.5);
+        expect(i.b).toEqualDecimal(20.5);
+
+        i = Interval.fromFact(testFact({v: -20.123, d: 3}));
+        expect(i.a).toEqualDecimal(-20.1235);
+        expect(i.b).toEqualDecimal(-20.1225);
+
+        i = Interval.fromFact(testFact({v: -20.123, d: -1}));
+        expect(i.a).toEqualDecimal(-25.123);
+        expect(i.b).toEqualDecimal(-15.123);
+    });
+
+    test("Non numeric", () => {
+        var i = Interval.fromFact(testFact({v: 20, a: {u: undefined}}));
+        expect(i).toBeUndefined();
+
+        // This would be invalid XBRL
+        i = Interval.fromFact(testFact({v: "abc" }));
+        expect(i).toBeUndefined();
+    });
+});
+
+
+describe("Intersect", () => {
+    test("Intersecting", () => {
+        var x = new Interval(5, 15);
+        var y = new Interval(10, 25);
+        var ii = x.intersection(y);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(15);
+
+        ii = Interval.intersection(x, y);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(15);
+
+        ii = y.intersection(x);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(15);
+
+        y = new Interval(15, 25);
+        ii = x.intersection(y);
+        expect(ii.a).toEqualDecimal(15);
+        expect(ii.b).toEqualDecimal(15);
+
+        x = new Interval(10, 20);
+        y = new Interval(15, 25);
+        var z = new Interval(18, 30);
+        ii = Interval.intersection(x, y, z);
+        expect(ii.a).toEqualDecimal(18);
+        expect(ii.b).toEqualDecimal(20);
+
+    });
+
+    test("No intersection", () => {
+        var x = new Interval(5, 15);
+        expect(x.intersection(new Interval(20, 25))).toBeUndefined();
+        expect(x.intersection(new Interval(1, 4.99))).toBeUndefined();
+
+        x = new Interval(10, 20);
+        var y = new Interval(15, 25);
+        var z = new Interval(21, 30);
+        expect(Interval.intersection(x, y, z)).toBeUndefined();
+    });
+})
+
+describe("Arithmetic", () => {
+    test("Add", () => {
+        var i = new Interval(5, 15);
+        var ii = i.plus(new Interval(10, 20));
+        expect(ii.a).toEqualDecimal(15);
+        expect(ii.b).toEqualDecimal(35);
+    });
+
+    test("Multiply", () => {
+        var i = new Interval(5, 15);
+        var ii = i.times(2);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(30);
+
+        ii = i.times(-2);
+        expect(ii.a).toEqualDecimal(-30);
+        expect(ii.b).toEqualDecimal(-10);
+
+        i = new Interval(-10, -5);
+        ii = i.times(2);
+        expect(ii.a).toEqualDecimal(-20);
+        expect(ii.b).toEqualDecimal(-10);
+
+        ii = i.times(-2);
+        expect(ii.a).toEqualDecimal(10);
+        expect(ii.b).toEqualDecimal(20);
+
+    });
+
+});
+
+

iXBRLViewerPlugin/viewer/src/js/test-utils.js

@@ -11,6 +11,25 @@ export function TestInspector() {
 
 TestInspector.prototype = Object.create(Inspector.prototype);
 
+expect.extend({
+    toEqualDecimal(received, expected) {
+        const options = {
+              comment: 'decimal.js equality',
+              isNot: this.isNot,
+              promise: this.promise,
+        };
+        const pass = received.equals(expected);
+        const message = () =>
+              this.utils.matcherHint('toEqualDecimals', undefined, undefined, options) +
+              '\n\n' +
+              `Expected: ${this.isNot ? '(not) ' : ''}${this.utils.printExpected(new Decimal(expected))}\n` +
+              `Received: ${this.utils.printReceived(received)}`;
+
+        return {actual: received, message, pass};
+        
+    }
+});
+
 export function createSimpleFact(id, concept, options=null) {
     options = options || {};
     return {

iXBRLViewerPlugin/viewer/src/js/viewer.js

@@ -271,14 +271,12 @@ export class Viewer {
         /* Otherwise, insert a <span> as wrapper */
         if (nodes.length == 0) {
             nodes.push(this._wrapNode(domNode));
-
-            // Create a list of the wrapper node, and all absolutely positioned
-            // descendants.
-            for (const e of domNode.querySelectorAll("*")) { 
-                if (getComputedStyle(e).getPropertyValue('position') === "absolute") { 
-                    nodes.push(e);
-                } 
-            }
+        }
+        // Create a list of the wrapper node, and all absolutely positioned descendants.
+        for (const e of nodes[0].querySelectorAll("*")) { 
+            if (getComputedStyle(e).getPropertyValue('position') === "absolute") { 
+                nodes.push(e);
+            } 
         }
         for (const [i, n] of nodes.entries()) {
             // getBoundingClientRect blocks on layout, so only do it if we've actually got absolute nodes