@cplieger/deadset-ts 8.0.0-dev.20 → 8.0.0-dev.21

package/dist/src/alias-chain.js

@@ -1,12 +1,12 @@
 /**
  * Where an import or export chain leads in one project: from one symbol to each
  * declaration of the target it is, and along the chain of aliases it heads to each
- * declaration every link of that chain is.
+ * declaration every link of that chain is, and what a name resolves to through them.
  */
 import { isExportAssignment, isExportSpecifier, isIdentifier, isImportClause, isImportSpecifier, isNamespaceExport, isNamespaceImport, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { isParameterProperty, nodeKey } from "./inventory.js";
-import { UNANSWERED } from "./query.js";
+import { must, UNANSWERED } from "./query.js";
 /**
  * The chain walks over one project, against the declarations of `held`, the same
  * project's inventory.
@@ -145,3 +145,34 @@ export function aliasChains(project, held) {
         nextDeclared,
     };
 }
+/**
+ * What each of a batch of nodes resolves to, every alias followed to the declaration
+ * it stands for. A node the checker resolves to nothing, and an alias that resolves
+ * to nothing, are absent from the answer. Each alias is followed once. A question the
+ * checker does not answer stops the pass, as {@link must} stops.
+ */
+export function resolvedTargets(project, nodes) {
+    const followed = new Map();
+    const targets = new Map();
+    project
+        .symbolsAt(nodes.map((node) => project.handle(node)))
+        .map(must)
+        .forEach((symbol, index) => {
+        const node = nodes[index];
+        if (symbol === undefined || node === undefined) {
+            return;
+        }
+        let target = symbol;
+        if ((symbol.flags & SymbolFlags.Alias) !== 0) {
+            if (!followed.has(symbol.id)) {
+                const aliased = must(project.queries.aliased(symbol));
+                followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
+            }
+            target = followed.get(symbol.id);
+        }
+        if (target !== undefined) {
+            targets.set(node, target);
+        }
+    });
+    return targets;
+}

package/dist/src/analysis.js

@@ -10,7 +10,6 @@ import { lineOf, readComponent } from "./component-files.js";
 import { kindOf } from "./config.js";
 import { consumerReferences } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./roots/configured-declarations.js";
-import { decorator } from "./decorator.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
 import { carriersOf, NO_CARRIERS } from "./exposure.js";
 import { deprecatedDeclarations } from "./deprecation.js";
@@ -19,19 +18,16 @@ import { loadRun } from "./load/load.js";
 import { readSources } from "./entries/sources.js";
 import { readWorkflows } from "./entries/workflow-steps.js";
 import { readEdgeSides } from "./edges.js";
-import { enumGroup } from "./enum-group.js";
 import { bindingsOf, distinctBindings } from "./bindings.js";
-import { generatedFile, generatedFilesOf } from "./generated-file.js";
+import { generatedFilesOf } from "./exemptions/generated-file.js";
 import { inOperandNames } from "./findings/in-operands.js";
 import { sourceFilesOf } from "./source-files.js";
-import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, isUnansweredRecord, writtenRecords, } from "./exempt.js";
+import { DETECTORS, detection } from "./exemptions/detectors.js";
+import { exemptionsOf, settle } from "./exemptions/lifecycle.js";
 import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { unmatchedRootFindings } from "./findings/self-check.js";
-import { frameworkLifecycle } from "./framework-lifecycle.js";
 import { implementations, mergeImplementations } from "./findings/implementations.js";
-import { injectionContainer } from "./injection-container.js";
-import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import {} from "./inventory.js";
 import { inventory } from "./inventory/enumerate.js";
@@ -40,10 +36,9 @@ import { matrixOf, referenceKey } from "./liveness/matrix.js";
 import { ancestors, dirnamePath, extensionOf, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { skippedUnits } from "./type-errors.js";
-import { reflectiveLookup } from "./reflective-lookup.js";
 import { references } from "./references.js";
 import { rootSet, unmatchedEverywhere, } from "./roots/root-set.js";
-import { decodedMembers, serializationContract } from "./serialization-contract.js";
+import { decodedMembers } from "./exemptions/serialization-contract.js";
 import { outsideTestReferences, testFilesAt } from "./tests/outside.js";
 import { formedForNode } from "./load/synthesize.js";
 import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.js";
@@ -54,7 +49,6 @@ import { isPartKind } from "./suppress.js";
 import { bindRows, readBaseline, readIgnoreFile } from "./suppress-file.js";
 import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
 import { sweep } from "./liveness/sweep.js";
-import { readTemplates, templateField } from "./template-field.js";
 import { bytewise } from "./text/compare.js";
 import { holdsManifest, manifestAt } from "./fs/manifest.js";
 import { runDirectories } from "./entries/run-directories.js";
@@ -230,18 +224,6 @@ export function productionMode(config) {
         consumerTestsProduction: config.analysis.consumer_tests === "production",
     };
 }
-/** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-export const DETECTORS = new Map([
-    ["interface-satisfaction", interfaceSatisfaction],
-    ["enum-group", enumGroup],
-    ["generated-file", generatedFile],
-    ["template-field", templateField],
-    ["reflective-lookup", reflectiveLookup],
-    ["decorator", decorator],
-    ["injection-container", injectionContainer],
-    ["framework-lifecycle", frameworkLifecycle],
-    ["serialization-contract", serializationContract],
-]);
 /** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
 const DEV_SECTION = "devDependencies";
 const OTHER_SECTIONS = ["dependencies", "peerDependencies", "optionalDependencies"];
@@ -288,11 +270,8 @@ function testEvidence(host, targetRoot, projects) {
  */
 function readRun(engine, host, scope, config, mode, detectors, extra) {
     const targetRoot = scope.target.path;
-    const disabled = disabledClasses(config);
-    const templates = disabled.has("template-field")
-        ? { delimiters: config.analysis.template_delimiters, files: [] }
-        : readTemplates(host, targetRoot, config.analysis);
     const consumers = scope.consumers.map((consumer) => consumer.path);
+    const detect = detection(host, targetRoot, config, consumers, detectors);
     const directories = runDirectories(host, targetRoot, (fileName, text) => engine.parseSourceFile(fileName, text));
     const read = readProjects(engine, host, scope, config, (project, opened) => {
         const projectRead = opened.read();
@@ -303,17 +282,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             formedForNode: projectRead.formedForNode,
         });
         const testFiles = testFilePaths(project, targetRoot, testFile);
-        const evidence = evidenceRecords({
-            project,
-            held: projectRead.held,
-            targetRoot,
-            templates,
-            ts: config.ts,
-            consumers,
-            ...(config.analysis.generated_files === "include"
-                ? {}
-                : { generated: projectRead.generated }),
-        }, detectors, disabled);
+        const evidence = detect({ project, held: projectRead.held, generated: projectRead.generated });
         const components = project.ownSourceFiles().filter(isComponentFile);
         const injected = project.program
             .getSourceFileNames()
@@ -378,27 +347,26 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             ...one.decoded.copied,
         ]),
     ]);
-    const evidence = withOutside.map((one) => writtenRecords(one.evidence, written));
-    const settled = settledSatisfaction(withOutside.map((one, index) => ({
-        evidence: evidence[index] ?? [],
+    const settled = settle(withOutside.map((one) => ({
+        records: one.evidence,
         held: one.projectRead.held,
-    })), [...withOutside.flatMap((one) => one.references), ...read.result.references]);
+        testFiles: new Set([...one.testFiles, ...support]),
+    })), {
+        references: [...withOutside.flatMap((one) => one.references), ...read.result.references],
+        written,
+        mode,
+    });
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
-        const satisfied = settled[index];
-        const detected = heldRecords(satisfied?.evidence ?? evidence[index] ?? [], {
-            mode,
-            testFiles: new Set([...one.testFiles, ...support]),
-        });
-        const exempt = detected.records;
-        const made = [...one.references, ...(satisfied?.references ?? [])];
+        const exempt = settled[index]?.records ?? [];
+        const made = [...one.references, ...(settled[index]?.references ?? [])];
         const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
         const supportFiles = [...support].filter((path) => held.has(path)).sort(bytewise);
         const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort(bytewise);
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
-            references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
+            references: made,
             roots: projectRead.rooted.liveUnderReachability,
             testFiles: [...one.testFiles, ...supportFiles],
             ...(supportFiles.length === 0 ? {} : { supportFiles }),
@@ -420,7 +388,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 ...projectRead.rooted.unanswered,
                 ...made.filter((reference) => reference.guessed === true).map((reference) => reference.to),
                 ...one.held,
-                ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+                ...exempt.filter((record) => record.unanswered === true).map((record) => record.id),
                 ...one.decoded.unanswered,
             ],
             filledOutside: one.decoded.filled,
@@ -470,33 +438,6 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         workflows: read.result.workflows,
     };
 }
-/**
- * The test references exemption evidence written in a test file makes: each is a read of
- * the declaration it would retain, made by the test file at the evidence's site.
- */
-function evidenceReferences(symbols, inTestFiles) {
-    if (inTestFiles.length === 0) {
-        return [];
-    }
-    const files = new Map(symbols
-        .filter((symbol) => symbol.kind === "file")
-        .map((symbol) => [symbol.position.path, symbol.id]));
-    return inTestFiles.flatMap((record) => {
-        const from = files.get(record.site.path);
-        return from === undefined
-            ? []
-            : [
-                {
-                    from,
-                    to: record.id,
-                    position: record.site,
-                    use: "read",
-                    resolution: "syntax",
-                    test: true,
-                },
-            ];
-    });
-}
 /**
  * The declarations a write the mode counts stores into, a write a test-support file
  * makes being a test's.

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "6.0.0",
+        corpusVersion: "6.1.0",
         result: "pass",
-        digest: "sha256:e4af2b9bcd07fd745101bf3215cd21e9df1448bdc332a791f25d5676cf15c794",
+        digest: "sha256:352b870acbc05213d4869bc18611137d0782cc0c9a8379e7a998a3d9cea2d966",
     },
     gaps: [],
 };

package/dist/src/contract/contract.generated.js

@@ -3,7 +3,7 @@ export const CONTRACT_VERSION = "8.0.0";
 export const SCHEMA_VERSIONS = ["9.0.0"];
 export const SCHEMA_VERSION = "9.0.0";
 export const FACTS_VERSION = "1.0.0";
-export const CORPUS_VERSION = "6.0.0";
+export const CORPUS_VERSION = "6.1.0";
 export const CODE_PREFIX = "DS";
 export const FAMILY_KEY_LENGTH = 4;
 export const LANGUAGES = ["go", "ts", "proto"];
@@ -371,7 +371,7 @@ export const KIND_ROWS = [
         languages: ["go", "ts"],
         subject: "declaration",
         holdsLive: true,
-        rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
+        rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Four subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. A Go function a driver finds by its exported name is excluded, whatever else refers to it, because unexporting it stops the driver from running it: a test, a benchmark, a fuzz test or an example of a test file, TestMain, a test method a suite runner calls, and a go-fuzz entry point. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
         precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the package reaches its values through its own package's exported declarations: a reference to an exported function or method whose parameters or results name the type, to an exported variable or constant whose type names it, to an exported field or property whose type names it, an embedded field included, or to an exported member of the type itself, a field promoted through an embedding included. A type a reference from outside the package names, or whose values such a reference reaches, passes the reach on to each type its definition names other than through an unexported member, whether it is exported or not, so an unexported type an exported function returns passes it to the types its exported fields name. A type names another through every composite that spells it: a pointer, an array, a slice, a map key or value, a channel, a function signature and a type argument. The referencing code holds values of the type, so unexporting it would leave an exported declaration naming a type its users cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
@@ -386,7 +386,7 @@ export const KIND_ROWS = [
         languages: ["go"],
         subject: "declaration",
         holdsLive: true,
-        rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
+        rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Four subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. A Go function a driver finds by its exported name is excluded, whatever else refers to it, because unexporting it stops the driver from running it: a test, a benchmark, a fuzz test or an example of a test file, TestMain, a test method a suite runner calls, and a go-fuzz entry point. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
         precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the target module reaches its values through its own package's exported declarations, as DS1501 defines that reach, because the referencing code holds values of the type, and moving it behind an internal boundary would leave an exported declaration naming a type its users cannot name.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
@@ -1361,6 +1361,7 @@ export const FAILURE_CLASSES = {
     "unwritten-output": "run",
     "unreportable-path": "run",
     "memory-exhausted": "run",
+    "missing-toolchain": "run",
     "missing-analyzer": "run",
     "unadmitted-analyzer": "run",
     "unresolved-edge": "run",

package/dist/src/dependencies.js

@@ -67,7 +67,7 @@ export function packageOfSpecifier(specifier) {
     return second === undefined || second === "" || first === "@" ? undefined : `${first}/${second}`;
 }
 /** The package an installed file belongs to, read below the last dependency directory of its path. */
-function packageOfPath(path) {
+export function packageOfPath(path) {
     const at = path.lastIndexOf(MODULES_SEGMENT);
     return at < 0 ? undefined : packageOfSpecifier(path.slice(at + MODULES_SEGMENT.length));
 }

package/dist/src/exemptions/argument-places.js

@@ -0,0 +1,131 @@
+/**
+ * Which parameter place each argument of a call binds, the one reading every question
+ * about a call's arguments asks. A plain argument fills the next place, and a spread or
+ * an `apply` list typed as a tuple whose elements are all required fills one place per
+ * element. Any other spread or list has no known length: from its first place on, each of
+ * its element types, and every later argument, may fill any place, so a value is never
+ * read as missing a parameter only because its place could not be read. The type at each
+ * place is the checker's answer for it, so this reading names places and never types them.
+ */
+import { isSpreadElement } from "@typescript/native/ast";
+import { ElementFlags } from "@typescript/native/sync";
+import { must } from "../query.js";
+/** The element flags of a tuple type; none for another type. */
+function elementFlags(project, type) {
+    const target = type.isTupleType() ? must(project.queries.targetOf(type)) : undefined;
+    return target?.isTupleTypeTarget() === true ? target.elementFlags : [];
+}
+/** What a spread argument puts at the places it fills, and how many it fills at least. */
+function spread(project, type) {
+    const { queries } = project;
+    if (type === undefined) {
+        return { types: [undefined], fixed: false, least: 0 };
+    }
+    if (type.isTupleType()) {
+        const flags = elementFlags(project, type);
+        return {
+            types: must(queries.typeArguments(type)).slice(0, flags.length),
+            fixed: flags.every((flag) => (flag & ElementFlags.Required) !== 0),
+            least: flags.filter((flag) => (flag & ElementFlags.Required) !== 0).length,
+        };
+    }
+    if (must(queries.isArray(type))) {
+        return { types: must(queries.typeArguments(type)), fixed: false, least: 0 };
+    }
+    // Another iterable's elements are read off its type arguments, as `Set<T>` holds `T`.
+    return { types: [type, ...must(queries.typeArguments(type))], fixed: false, least: 0 };
+}
+/** The element types of a tuple of `count` required elements; none for another type. */
+export function knownElements(project, type, count) {
+    if (!type.isTupleType()) {
+        return undefined;
+    }
+    const elements = spread(project, type);
+    return elements.fixed && elements.types.length === count ? elements.types : undefined;
+}
+/**
+ * The places each argument fills, `types` holding the type of each argument's value; it
+ * may be empty where no argument is a spread and no given type is read. `listed` reads
+ * the last argument as a list whose elements the places bind.
+ */
+export function spansOf(project, args, listed, types) {
+    const spans = [];
+    let place = 0;
+    let open = false;
+    for (const [at, argument] of args.entries()) {
+        const type = types[at];
+        if (!isSpreadElement(argument) && !(listed && at === args.length - 1)) {
+            spans.push({ argument: at, first: place, given: [type], open, spread: false });
+            place += 1;
+            continue;
+        }
+        const elements = spread(project, type);
+        open ||= !elements.fixed;
+        spans.push({ argument: at, first: place, given: elements.types, open, spread: true });
+        place += elements.least;
+    }
+    return spans;
+}
+/**
+ * The places of one signature as the checker counts them: one per parameter, and in
+ * place of a rest as many as the `length` the checker answers for its type, where that
+ * is a number literal or a union of them. Any other `length`, an array's or an array-like
+ * interface's `number` among them, leaves the rest open.
+ */
+export function layoutOf(project, signature) {
+    const { queries } = project;
+    const fixed = signature.parameters.length;
+    const rest = must(queries.restTypeOf(signature));
+    if (rest === undefined) {
+        return { count: fixed, repeats: false };
+    }
+    const length = must(queries.propertyTypeOf(rest, "length"));
+    const lengths = length === undefined ? [] : must(queries.constituents(length));
+    const bounds = lengths.flatMap((one) => (one.isNumberLiteralType() ? [one.value] : []));
+    if (bounds.length > 0 && bounds.length === lengths.length) {
+        return { count: fixed - 1 + Math.max(...bounds), repeats: false };
+    }
+    return { count: fixed, repeats: true };
+}
+/**
+ * The parameter place each argument binds in a signature of `layout`, with the type it
+ * gives there. A span of unknown length binds every place from its first to the last the
+ * layout counts, and past them, where the rest is open, one `rest` placement for every
+ * later place, or else its first place alone. A place past every place of a layout that
+ * does not repeat is `uncovered`.
+ */
+export function placesIn(spans, layout) {
+    const placed = [];
+    const add = (span, place, rest) => {
+        const uncovered = place >= layout.count && !layout.repeats;
+        const elements = span.open
+            ? span.given.map((given, element) => ({ given, element }))
+            : [{ given: span.given[place - span.first], element: place - span.first }];
+        placed.push(...elements.map((one) => ({ argument: span.argument, place, uncovered, rest, ...one })));
+    };
+    for (const span of spans) {
+        const open = span.open && layout.repeats;
+        const end = !span.open
+            ? span.first + span.given.length
+            : Math.max(layout.count, open ? span.first : span.first + 1);
+        for (let place = span.first; place < end; place += 1) {
+            add(span, place, false);
+        }
+        if (open) {
+            add(span, Math.max(layout.count, span.first), true);
+        }
+    }
+    return placed;
+}
+/**
+ * Whether a span fills the parameter declared at `index`, a rest parameter every place
+ * from it on; with `element`, whether that element of a span that is not open does.
+ */
+export function fills(span, index, rest, element) {
+    if (element !== undefined && !span.open) {
+        const place = span.first + element;
+        return rest ? place >= index : place === index;
+    }
+    const last = span.open ? Number.POSITIVE_INFINITY : span.first + span.given.length - 1;
+    return rest ? last >= index : span.first <= index && index <= last;
+}