edfcore 0.6.268 → 0.6.269

package/dist/constants.d.ts

@@ -109,5 +109,5 @@ export declare const SIGNAL_FIELD_BLOCK_OFFSETS: {
     readonly reserved: 224;
 };
 /** Published package version. Kept in sync with package.json by a test. */
-export declare const VERSION = "0.6.268";
+export declare const VERSION = "0.6.269";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -79,5 +79,5 @@ export const SIGNAL_FIELD_BLOCK_OFFSETS = {
     reserved: 224,
 };
 /** Published package version. Kept in sync with package.json by a test. */
-export const VERSION = '0.6.268';
+export const VERSION = '0.6.269';
 //# sourceMappingURL=constants.js.map

package/dist/text/describe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"describe.d.ts","sourceRoot":"","sources":["../../src/text/describe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iGAAiG;AACjG,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAwCpD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GAC/E,MAAM,CAER"}
+{"version":3,"file":"describe.d.ts","sourceRoot":"","sources":["../../src/text/describe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iGAAiG;AACjG,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CA2DpD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE;IAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GAC/E,MAAM,CAER"}

package/dist/text/describe.js

@@ -38,6 +38,25 @@ export function describeValue(value) {
     if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
         return Object.prototype.toString.call(value).slice(8, -1);
     }
+    /*
+     * A REGEXP, by the same tag, for the same reason, in the place it is likeliest to turn up.
+     *
+     * `a-pattern-where-a-label-belongs.test.ts` makes the argument: `matchSignals` takes a pattern and
+     * `findSignals` takes a label, and "a montage selector is more often a pattern than an exact
+     * label" — so a RegExp handed to the label-matching half is the commoner of the two spellings of
+     * that confusion. The guard's advice already names the kind, "matchSignals(header, pattern) for a
+     * RegExp or a predicate", while the subject called it "an object" and left the reader to work out
+     * that the object they passed was one.
+     *
+     * A predicate needs nothing here: `typeof` answers `function` and the message says so. A RegExp is
+     * the only matcher `typeof` flattens into `object`.
+     *
+     * `String(value)` is the source as written — `/EEG/i` — which is the whole of what a reader needs
+     * to recognise it, and it is a pattern they typed rather than data read out of a file.
+     */
+    if (Object.prototype.toString.call(value) === '[object RegExp]') {
+        return `the RegExp ${String(value)}`;
+    }
     /*
      * A PENDING PROMISE, which is the one object worth naming.
      *

package/dist/text/describe.js.map

@@ -1 +1 @@
-{"version":3,"file":"describe.js","sourceRoot":"","sources":["../../src/text/describe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iGAAiG;AACjG,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACpD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,cAAc,KAAK,GAAG,CAAC;IAC7D,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,cAAc,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;IAC5E,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IAClC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IAC5C;;;;;;OAMG;IACH,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;QAC9D,OAAO,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;IACD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,IAAI,OAAQ,KAA4B,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,mBAAmB,CAAC;IACzF,iGAAiG;IACjG,qFAAqF;IACrF,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK,EAAE,CAAC;AACvE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAgF;IAEhF,OAAO,YAAY,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC;AAC5F,CAAC"}
+{"version":3,"file":"describe.js","sourceRoot":"","sources":["../../src/text/describe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iGAAiG;AACjG,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACpD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,cAAc,KAAK,GAAG,CAAC;IAC7D,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,cAAc,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;IAC5E,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IAClC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IAC5C;;;;;;OAMG;IACH,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,KAAK,YAAY,WAAW,EAAE,CAAC;QAC9D,OAAO,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5D,CAAC;IACD;;;;;;;;;;;;;;;OAeG;IACH,IAAI,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,iBAAiB,EAAE,CAAC;QAChE,OAAO,cAAc,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IACvC,CAAC;IACD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,IAAI,OAAQ,KAA4B,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,mBAAmB,CAAC;IACzF,iGAAiG;IACjG,qFAAqF;IACrF,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK,EAAE,CAAC;AACvE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAgF;IAEhF,OAAO,YAAY,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC;AAC5F,CAAC"}

package/docs/CHANGELOG.md

@@ -6,6 +6,24 @@ alone does not tell you whether you were affected.
 edfcore is pre-1.0. Patch releases have carried behaviour changes where the old behaviour was a
 defect; those are called out below.
 
+## 0.6.269
+
+- **Fixed** a RegExp being described as "an object" by the guards that refuse one. `typeof` answers
+  `object` for a RegExp and `function` for a predicate, so of the two kinds of matcher this package
+  accepts, exactly one was flattened into the word every wrong value shares — while the same
+  sentence's advice already named the kind: "matchSignals(header, pattern) for a RegExp or a
+  predicate".
+- It is the spelling worth naming. `a-pattern-where-a-label-belongs.test.ts` states why: `matchSignals`
+  takes a pattern and `findSignals` takes a label, and "a montage selector is more often a pattern
+  than an exact label" — so the RegExp handed to the label-matching half is the commoner of the two,
+  and it was the one whose message could not say what had arrived.
+- Named by its built-in tag, which `describe.ts` already uses for a binary value "because that IS the
+  mistake wherever one turns up", and 0.6.256 applied to a typed array. The tag rather than
+  `instanceof`, because it is the same across realms.
+- The pattern is printed as written, flags and all — `the RegExp /EEG Fp1/i` — which is what a reader
+  needs to recognise something they typed. Every other spelling is unchanged, including a plain
+  object, an array and a `Map`, and the calls that genuinely take a pattern still take one.
+
 ## 0.6.268
 
 - **Fixed** an array of Promises where a diagnostics array belongs being refused as a by-code summary.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edfcore",
-  "version": "0.6.268",
+  "version": "0.6.269",
   "description": "Modern, typed, zero-dependency reader for EDF, EDF+, BDF and BDF+ biosignal files. Works in browsers and Node with true random access.",
   "keywords": [
     "edf",

package/src/constants.ts

@@ -93,4 +93,4 @@ export const SIGNAL_FIELD_BLOCK_OFFSETS = {
 } as const;
 
 /** Published package version. Kept in sync with package.json by a test. */
-export const VERSION = '0.6.268';
+export const VERSION = '0.6.269';

package/src/text/describe.ts

@@ -34,6 +34,25 @@ export function describeValue(value: unknown): string {
   if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
     return Object.prototype.toString.call(value).slice(8, -1);
   }
+  /*
+   * A REGEXP, by the same tag, for the same reason, in the place it is likeliest to turn up.
+   *
+   * `a-pattern-where-a-label-belongs.test.ts` makes the argument: `matchSignals` takes a pattern and
+   * `findSignals` takes a label, and "a montage selector is more often a pattern than an exact
+   * label" — so a RegExp handed to the label-matching half is the commoner of the two spellings of
+   * that confusion. The guard's advice already names the kind, "matchSignals(header, pattern) for a
+   * RegExp or a predicate", while the subject called it "an object" and left the reader to work out
+   * that the object they passed was one.
+   *
+   * A predicate needs nothing here: `typeof` answers `function` and the message says so. A RegExp is
+   * the only matcher `typeof` flattens into `object`.
+   *
+   * `String(value)` is the source as written — `/EEG/i` — which is the whole of what a reader needs
+   * to recognise it, and it is a pattern they typed rather than data read out of a file.
+   */
+  if (Object.prototype.toString.call(value) === '[object RegExp]') {
+    return `the RegExp ${String(value)}`;
+  }
   /*
    * A PENDING PROMISE, which is the one object worth naming.
    *