@fin.cx/opendata 4.4.0 → 4.5.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@fin.cx/opendata',
-    version: '4.4.0',
+    version: '4.5.0',
     description: 'Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, the statutory public holidays of the German federal states, the base rate of § 247 BGB, the German consumer price index with the arithmetic of index clauses, and stock and crypto prices and fundamentals from several providers.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDBXQUEwVztDQUN4WCxDQUFBIn0=

package/dist_ts/cpi/index.d.ts

@@ -1,5 +1,5 @@
 export * from './interfaces.js';
 export { CpiError, type ICpiErrorDetails, type TCpiErrorCode } from './classes.cpierror.js';
 export { bundesbankCpiBaseUrl, bundesbankVpiAnnualKey, bundesbankVpiFirstMonth, bundesbankVpiFirstYear, bundesbankVpiMonthlyKey, defaultCpiTimeoutMs, destatisLicence, } from './constants.js';
-export { cpiChangePercent, cpiChangePoints, cpiFirstReaching, cpiScaleAmount, cpiThresholds } from './indexmath.js';
+export { cpiChangePercent, cpiChangePoints, cpiFirstReaching, cpiFirstReachingPoints, cpiScaleAmount, cpiThresholds } from './indexmath.js';
 export { BundesbankCpiClient } from './classes.bundesbankcpiclient.js';

package/dist_ts/cpi/index.js

@@ -4,6 +4,6 @@
 export * from './interfaces.js';
 export { CpiError } from './classes.cpierror.js';
 export { bundesbankCpiBaseUrl, bundesbankVpiAnnualKey, bundesbankVpiFirstMonth, bundesbankVpiFirstYear, bundesbankVpiMonthlyKey, defaultCpiTimeoutMs, destatisLicence, } from './constants.js';
-export { cpiChangePercent, cpiChangePoints, cpiFirstReaching, cpiScaleAmount, cpiThresholds } from './indexmath.js';
+export { cpiChangePercent, cpiChangePoints, cpiFirstReaching, cpiFirstReachingPoints, cpiScaleAmount, cpiThresholds } from './indexmath.js';
 export { BundesbankCpiClient } from './classes.bundesbankcpiclient.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jcGkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsNEZBQTRGO0FBQzVGLGtHQUFrRztBQUNsRywwRUFBMEU7QUFDMUUsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxPQUFPLEVBQUUsUUFBUSxFQUE2QyxNQUFNLHVCQUF1QixDQUFDO0FBQzVGLE9BQU8sRUFDTCxvQkFBb0IsRUFDcEIsc0JBQXNCLEVBQ3RCLHVCQUF1QixFQUN2QixzQkFBc0IsRUFDdEIsdUJBQXVCLEVBQ3ZCLG1CQUFtQixFQUNuQixlQUFlLEdBQ2hCLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEIsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxnQkFBZ0IsRUFBRSxjQUFjLEVBQUUsYUFBYSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDcEgsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sa0NBQWtDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jcGkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsNEZBQTRGO0FBQzVGLGtHQUFrRztBQUNsRywwRUFBMEU7QUFDMUUsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxPQUFPLEVBQUUsUUFBUSxFQUE2QyxNQUFNLHVCQUF1QixDQUFDO0FBQzVGLE9BQU8sRUFDTCxvQkFBb0IsRUFDcEIsc0JBQXNCLEVBQ3RCLHVCQUF1QixFQUN2QixzQkFBc0IsRUFDdEIsdUJBQXVCLEVBQ3ZCLG1CQUFtQixFQUNuQixlQUFlLEdBQ2hCLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEIsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxnQkFBZ0IsRUFBRSxzQkFBc0IsRUFBRSxjQUFjLEVBQUUsYUFBYSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDNUksT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sa0NBQWtDLENBQUMifQ==

package/dist_ts/cpi/indexmath.d.ts

@@ -25,6 +25,18 @@ export declare const cpiThresholds: (referenceArg: ICpiValue, percentArg: string
  * given twice is refused.
  */
 export declare const cpiFirstReaching: (valuesArg: readonly ICpiValue[], referenceArg: ICpiValue, percentArg: string, optionsArg: ICpiReachOptions) => ICpiValue | undefined;
+/**
+ * The first value after the reference period whose change from the reference in index points
+ * (`cpiChangePoints`) reaches a points rule's threshold, or `undefined` while none does: a value at or
+ * above reference + points (`up`), at or below reference − points (`down`), or whichever comes first
+ * (`either`). The points are a decimal written with digits and a point, from 0 upward, with any number
+ * of digits (`'5'`, `'2.5'`); nothing is rounded, so a threshold with more digits than the values is
+ * compared exactly. Whether the threshold itself counts (`reached`) or only a value beyond it
+ * (`exceeded`) is the clause's to say. Points depend on the base, so all values must be published
+ * values of the reference value's series and base (`base_mismatch` otherwise); their order does not
+ * matter, a period given twice is refused.
+ */
+export declare const cpiFirstReachingPoints: (valuesArg: readonly ICpiValue[], referenceArg: ICpiValue, pointsArg: string, optionsArg: ICpiReachOptions) => ICpiValue | undefined;
 /**
  * An amount in cents scaled from one index value to another, rounded half away from zero to whole cents:
  * by the index ratio (amount × new / old, the default, as the Statistisches Bundesamt writes it) or by

package/dist_ts/cpi/indexmath.js

@@ -87,18 +87,19 @@ export const cpiThresholds = (referenceArg, percentArg) => {
         lower: formatUnits(lower, scale),
     };
 };
-/**
- * The first value after the reference period that reaches a threshold of a percent rule
- * (`cpiThresholds`), or `undefined` while none does. Whether the threshold itself counts (`reached`) or
- * only a value beyond it (`exceeded`), and which direction, is the clause's to say. All values must be
- * published values of the reference value's series and base; their order does not matter, a period
- * given twice is refused.
- */
-export const cpiFirstReaching = (valuesArg, referenceArg, percentArg, optionsArg) => {
+/** The reach options as the clause gives them; anything else is refused. */
+const requireReachOptions = (optionsArg) => {
     if (!['up', 'down', 'either'].includes(optionsArg.direction) || !['reached', 'exceeded'].includes(optionsArg.reach)) {
         throw new CpiError('invalid_input', 'the direction is up, down or either, and the reach is reached or exceeded.');
     }
-    const thresholds = thresholdUnitsOf(referenceArg, percentArg);
+};
+/**
+ * The first value after the reference period at or beyond the upper threshold or at or below the lower
+ * one, as the options say. The thresholds are units of 10^-scale; the lower one may be zero or less, which
+ * no index value reaches. All values must be published values of the reference value's series and base;
+ * their order does not matter, a period given twice is refused.
+ */
+const firstReachingUnits = (valuesArg, referenceArg, thresholdsArg, optionsArg) => {
     const periods = new Set();
     const candidates = [];
     for (const value of valuesArg) {
@@ -115,10 +116,10 @@ export const cpiFirstReaching = (valuesArg, referenceArg, percentArg, optionsArg
     candidates.sort((leftArg, rightArg) => leftArg.value.period.localeCompare(rightArg.value.period));
     const exceeding = optionsArg.reach === 'exceeded';
     for (const { value, decimal } of candidates) {
-        const scale = Math.max(decimal.scale, thresholds.scale);
+        const scale = Math.max(decimal.scale, thresholdsArg.scale);
         const units = atScale(decimal, scale);
-        const upper = atScale({ units: thresholds.upper, scale: thresholds.scale }, scale);
-        const lower = atScale({ units: thresholds.lower, scale: thresholds.scale }, scale);
+        const upper = thresholdsArg.upper * powerOfTen(scale - thresholdsArg.scale);
+        const lower = thresholdsArg.lower * powerOfTen(scale - thresholdsArg.scale);
         const up = exceeding ? units > upper : units >= upper;
         const down = exceeding ? units < lower : units <= lower;
         if ((optionsArg.direction !== 'down' && up) || (optionsArg.direction !== 'up' && down)) {
@@ -127,6 +128,40 @@ export const cpiFirstReaching = (valuesArg, referenceArg, percentArg, optionsArg
     }
     return undefined;
 };
+/**
+ * The first value after the reference period that reaches a threshold of a percent rule
+ * (`cpiThresholds`), or `undefined` while none does. Whether the threshold itself counts (`reached`) or
+ * only a value beyond it (`exceeded`), and which direction, is the clause's to say. All values must be
+ * published values of the reference value's series and base; their order does not matter, a period
+ * given twice is refused.
+ */
+export const cpiFirstReaching = (valuesArg, referenceArg, percentArg, optionsArg) => {
+    requireReachOptions(optionsArg);
+    return firstReachingUnits(valuesArg, referenceArg, thresholdUnitsOf(referenceArg, percentArg), optionsArg);
+};
+/**
+ * The first value after the reference period whose change from the reference in index points
+ * (`cpiChangePoints`) reaches a points rule's threshold, or `undefined` while none does: a value at or
+ * above reference + points (`up`), at or below reference − points (`down`), or whichever comes first
+ * (`either`). The points are a decimal written with digits and a point, from 0 upward, with any number
+ * of digits (`'5'`, `'2.5'`); nothing is rounded, so a threshold with more digits than the values is
+ * compared exactly. Whether the threshold itself counts (`reached`) or only a value beyond it
+ * (`exceeded`) is the clause's to say. Points depend on the base, so all values must be published
+ * values of the reference value's series and base (`base_mismatch` otherwise); their order does not
+ * matter, a period given twice is refused.
+ */
+export const cpiFirstReachingPoints = (valuesArg, referenceArg, pointsArg, optionsArg) => {
+    requireReachOptions(optionsArg);
+    const reference = publishedValueOf(referenceArg);
+    const points = parseDecimal(pointsArg);
+    if (!points) {
+        throw new CpiError('invalid_input', `${JSON.stringify(pointsArg)} is no number of index points from 0 upward, written with digits and a point.`);
+    }
+    const scale = Math.max(reference.scale, points.scale);
+    const referenceUnits = atScale(reference, scale);
+    const pointsUnits = atScale(points, scale);
+    return firstReachingUnits(valuesArg, referenceArg, { upper: referenceUnits + pointsUnits, lower: referenceUnits - pointsUnits, scale }, optionsArg);
+};
 /**
  * An amount in cents scaled from one index value to another, rounded half away from zero to whole cents:
  * by the index ratio (amount × new / old, the default, as the Statistisches Bundesamt writes it) or by
@@ -160,4 +195,4 @@ export const cpiScaleAmount = (amountCentsArg, oldArg, newArg, optionsArg = {})
     }
     return result;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indexmath.js","sourceRoot":"","sources":["../../ts/cpi/indexmath.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indexmath.js","sourceRoot":"","sources":["../../ts/cpi/indexmath.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fin.cx/opendata",
-  "version": "4.4.0",
+  "version": "4.5.0",
   "private": false,
   "description": "Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, the statutory public holidays of the German federal states, the base rate of § 247 BGB, the German consumer price index with the arithmetic of index clauses, and stock and crypto prices and fundamentals from several providers.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -116,6 +116,8 @@ Everything here comes from `@fin.cx/opendata/cpi`. That entry point imports noth
   The change in percent as the Statistisches Bundesamt computes it, ((new / old) × 100) − 100, rounded to one decimal; and the change in index points.
 - `cpiThresholds(reference, percent)`, `cpiFirstReaching(values, reference, percent, { direction, reach })`
   The thresholds of a percent rule (reference × (1 ± percent / 100), rounded to the reference's digits), and the first month after the reference month that reaches one. Whether the threshold itself counts (`reached`) or only a value beyond it (`exceeded`) is the clause's to say.
+- `cpiFirstReachingPoints(values, reference, points, { direction, reach })`
+  The same for a points rule: the first month after the reference month whose change in index points reaches the threshold, at or above reference + points (`up`), at or below reference − points (`down`), or whichever comes first (`either`). The points are a decimal from 0 upward (`'5'`, `'2.5'`); the comparison is exact and nothing is rounded.
 - `cpiScaleAmount(amountCents, old, new, { basis? })`
   An amount in cents scaled from one index value to another: by the index ratio (amount × new / old, the default) or, with `basis: 'rounded_percent'`, by the change in percent rounded to one decimal.
 - `CpiError` with the codes `invalid_input`, `before_first_period`, `not_published`, `base_mismatch`, `series_withdrawn`, `busy`, `unavailable`, `unreachable`, `timeout`, `aborted` and `unexpected_answer`
@@ -123,7 +125,7 @@ Everything here comes from `@fin.cx/opendata/cpi`. That entry point imports noth
 The client takes a `fetch` (for example `createPublicOnlyFetch` of `@push.rocks/smartrequest`), a `baseUrl` for a test server, a `timeoutMs` (30 seconds by default; its timer ends with the request), a `userAgent` and a caller's `signal`. Nothing is retried.
 
 ```typescript
-import { BundesbankCpiClient, CpiError, cpiChangePercent, cpiFirstReaching, cpiScaleAmount } from '@fin.cx/opendata/cpi';
+import { BundesbankCpiClient, CpiError, cpiChangePercent, cpiFirstReaching, cpiFirstReachingPoints, cpiScaleAmount } from '@fin.cx/opendata/cpi';
 
 const client = new BundesbankCpiClient();
 const series = await client.getMonthly({ from: '2020-01' });
@@ -140,6 +142,7 @@ cpiFirstReaching(series.values, series.values.find((value) => value.period === '
   direction: 'up',
   reach: 'reached',
 }); // the value of 2021-12 (104.7)
+cpiFirstReachingPoints(series.values, october2022, '5', { direction: 'up', reach: 'reached' }); // the value of 2024-03 (118.6); 5 % first in 2024-04
 
 try {
   await client.getMonth('2026-09');
@@ -160,7 +163,7 @@ The Statistisches Bundesamt moves the index to a new base year about every five
 
 - every value carries its base, and the calculations refuse values of different bases, indices or frequencies with `base_mismatch`; nothing is converted;
 - for a percent rule the Statistisches Bundesamt calculates with the values of the current base for both months, even where the contract names an earlier base, so read both again on the current base;
-- points depend on the base. `cpiChangePoints()` gives them within one base only; a points rule on an earlier base is the contract's matter;
+- points depend on the base. `cpiChangePoints()` and `cpiFirstReachingPoints()` give them within one base only; a points rule on an earlier base is the contract's matter;
 - the client leaves the base open in its request, and the Bundesbank answers with the series of the current base. The key of the former base 2015=100 answers 404 today; an answer of 404 ends in `series_withdrawn`, and an answer that holds two bases in `unexpected_answer`.
 
 #### Attribution
@@ -581,7 +584,7 @@ Four holidays apply only in part of a state:
 ### Consumer price index (`@fin.cx/opendata/cpi`)
 
 - `BundesbankCpiClient` with `getMonthly({ from, to? })`, `getAnnual({ from, to? })` and `getMonth(month)`
-- `cpiChangePercent(old, new)`, `cpiChangePoints(old, new)`, `cpiThresholds(reference, percent)`, `cpiFirstReaching(values, reference, percent, options)`, `cpiScaleAmount(amountCents, old, new, options?)`
+- `cpiChangePercent(old, new)`, `cpiChangePoints(old, new)`, `cpiThresholds(reference, percent)`, `cpiFirstReaching(values, reference, percent, options)`, `cpiFirstReachingPoints(values, reference, points, options)`, `cpiScaleAmount(amountCents, old, new, options?)`
 - `bundesbankCpiBaseUrl`, `bundesbankVpiMonthlyKey`, `bundesbankVpiAnnualKey`, `bundesbankVpiFirstMonth`, `bundesbankVpiFirstYear`, `destatisLicence`, `defaultCpiTimeoutMs`
 - `CpiError` with the codes `invalid_input`, `before_first_period`, `not_published`, `base_mismatch`, `series_withdrawn`, `busy`, `unavailable`, `unreachable`, `timeout`, `aborted` and `unexpected_answer`
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@fin.cx/opendata',
-  version: '4.4.0',
+  version: '4.5.0',
   description: 'Open business and financial data for TypeScript: register lookups on the German register portal (handelsregister.de) without storage, the statutory public holidays of the German federal states, the base rate of § 247 BGB, the German consumer price index with the arithmetic of index clauses, and stock and crypto prices and fundamentals from several providers.'
 }

package/ts/cpi/index.ts

@@ -12,5 +12,5 @@ export {
   defaultCpiTimeoutMs,
   destatisLicence,
 } from './constants.js';
-export { cpiChangePercent, cpiChangePoints, cpiFirstReaching, cpiScaleAmount, cpiThresholds } from './indexmath.js';
+export { cpiChangePercent, cpiChangePoints, cpiFirstReaching, cpiFirstReachingPoints, cpiScaleAmount, cpiThresholds } from './indexmath.js';
 export { BundesbankCpiClient } from './classes.bundesbankcpiclient.js';

package/ts/cpi/indexmath.ts

@@ -102,23 +102,25 @@ export const cpiThresholds = (referenceArg: ICpiValue, percentArg: string): ICpi
   };
 };
 
+/** The reach options as the clause gives them; anything else is refused. */
+const requireReachOptions = (optionsArg: ICpiReachOptions): void => {
+  if (!['up', 'down', 'either'].includes(optionsArg.direction) || !['reached', 'exceeded'].includes(optionsArg.reach)) {
+    throw new CpiError('invalid_input', 'the direction is up, down or either, and the reach is reached or exceeded.');
+  }
+};
+
 /**
- * The first value after the reference period that reaches a threshold of a percent rule
- * (`cpiThresholds`), or `undefined` while none does. Whether the threshold itself counts (`reached`) or
- * only a value beyond it (`exceeded`), and which direction, is the clause's to say. All values must be
- * published values of the reference value's series and base; their order does not matter, a period
- * given twice is refused.
+ * The first value after the reference period at or beyond the upper threshold or at or below the lower
+ * one, as the options say. The thresholds are units of 10^-scale; the lower one may be zero or less, which
+ * no index value reaches. All values must be published values of the reference value's series and base;
+ * their order does not matter, a period given twice is refused.
  */
-export const cpiFirstReaching = (
+const firstReachingUnits = (
   valuesArg: readonly ICpiValue[],
   referenceArg: ICpiValue,
-  percentArg: string,
+  thresholdsArg: { upper: bigint; lower: bigint; scale: number },
   optionsArg: ICpiReachOptions,
 ): ICpiValue | undefined => {
-  if (!['up', 'down', 'either'].includes(optionsArg.direction) || !['reached', 'exceeded'].includes(optionsArg.reach)) {
-    throw new CpiError('invalid_input', 'the direction is up, down or either, and the reach is reached or exceeded.');
-  }
-  const thresholds = thresholdUnitsOf(referenceArg, percentArg);
   const periods = new Set<string>();
   const candidates: { value: ICpiValue; decimal: IScaledDecimal }[] = [];
   for (const value of valuesArg) {
@@ -135,10 +137,10 @@ export const cpiFirstReaching = (
   candidates.sort((leftArg, rightArg) => leftArg.value.period.localeCompare(rightArg.value.period));
   const exceeding = optionsArg.reach === 'exceeded';
   for (const { value, decimal } of candidates) {
-    const scale = Math.max(decimal.scale, thresholds.scale);
+    const scale = Math.max(decimal.scale, thresholdsArg.scale);
     const units = atScale(decimal, scale);
-    const upper = atScale({ units: thresholds.upper, scale: thresholds.scale }, scale);
-    const lower = atScale({ units: thresholds.lower, scale: thresholds.scale }, scale);
+    const upper = thresholdsArg.upper * powerOfTen(scale - thresholdsArg.scale);
+    const lower = thresholdsArg.lower * powerOfTen(scale - thresholdsArg.scale);
     const up = exceeding ? units > upper : units >= upper;
     const down = exceeding ? units < lower : units <= lower;
     if ((optionsArg.direction !== 'down' && up) || (optionsArg.direction !== 'up' && down)) {
@@ -148,6 +150,52 @@ export const cpiFirstReaching = (
   return undefined;
 };
 
+/**
+ * The first value after the reference period that reaches a threshold of a percent rule
+ * (`cpiThresholds`), or `undefined` while none does. Whether the threshold itself counts (`reached`) or
+ * only a value beyond it (`exceeded`), and which direction, is the clause's to say. All values must be
+ * published values of the reference value's series and base; their order does not matter, a period
+ * given twice is refused.
+ */
+export const cpiFirstReaching = (
+  valuesArg: readonly ICpiValue[],
+  referenceArg: ICpiValue,
+  percentArg: string,
+  optionsArg: ICpiReachOptions,
+): ICpiValue | undefined => {
+  requireReachOptions(optionsArg);
+  return firstReachingUnits(valuesArg, referenceArg, thresholdUnitsOf(referenceArg, percentArg), optionsArg);
+};
+
+/**
+ * The first value after the reference period whose change from the reference in index points
+ * (`cpiChangePoints`) reaches a points rule's threshold, or `undefined` while none does: a value at or
+ * above reference + points (`up`), at or below reference − points (`down`), or whichever comes first
+ * (`either`). The points are a decimal written with digits and a point, from 0 upward, with any number
+ * of digits (`'5'`, `'2.5'`); nothing is rounded, so a threshold with more digits than the values is
+ * compared exactly. Whether the threshold itself counts (`reached`) or only a value beyond it
+ * (`exceeded`) is the clause's to say. Points depend on the base, so all values must be published
+ * values of the reference value's series and base (`base_mismatch` otherwise); their order does not
+ * matter, a period given twice is refused.
+ */
+export const cpiFirstReachingPoints = (
+  valuesArg: readonly ICpiValue[],
+  referenceArg: ICpiValue,
+  pointsArg: string,
+  optionsArg: ICpiReachOptions,
+): ICpiValue | undefined => {
+  requireReachOptions(optionsArg);
+  const reference = publishedValueOf(referenceArg);
+  const points = parseDecimal(pointsArg);
+  if (!points) {
+    throw new CpiError('invalid_input', `${JSON.stringify(pointsArg)} is no number of index points from 0 upward, written with digits and a point.`);
+  }
+  const scale = Math.max(reference.scale, points.scale);
+  const referenceUnits = atScale(reference, scale);
+  const pointsUnits = atScale(points, scale);
+  return firstReachingUnits(valuesArg, referenceArg, { upper: referenceUnits + pointsUnits, lower: referenceUnits - pointsUnits, scale }, optionsArg);
+};
+
 /**
  * An amount in cents scaled from one index value to another, rounded half away from zero to whole cents:
  * by the index ratio (amount × new / old, the default, as the Statistisches Bundesamt writes it) or by