@lde/search 0.38.0 → 0.39.0

package/dist/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAwBL,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAGhB,MAAM,aAAa,CAAC;AAGrB;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAChD,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAC1C;IACC,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/D;AAED,qFAAqF;AACrF,MAAM,WAAW,eAAe;IAC9B;0CACsC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,EACrB,OAAO,GAAE,iBAAyC,GACjD,cAAc,CAkBhB;AAgMD;;;;;;;;;;;;GAYG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,QAAQ,EACpB,OAAO,GAAE,iBAAyC,GACjD,aAAa,CAAC,cAAc,CAAC,CAc/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,GACpB,SAAS,MAAM,EAAE,CAmCnB"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAsBL,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAGhB,MAAM,aAAa,CAAC;AAUrB;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAChD,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAC1C;IACC,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/D;AAED,qFAAqF;AACrF,MAAM,WAAW,eAAe;IAC9B;0CACsC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,EACrB,OAAO,GAAE,iBAAyC,GACjD,cAAc,CAkBhB;AAgMD;;;;;;;;;;;;GAYG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,QAAQ,EACpB,OAAO,GAAE,iBAAyC,GACjD,aAAa,CAAC,cAAc,CAAC,CAc/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,GACpB,SAAS,MAAM,EAAE,CAmCnB"}

package/dist/project.js

@@ -1,8 +1,9 @@
 import { fold } from '@lde/text-normalization';
 import { matchLanguage } from './language.js';
 import { buildSubjectIndex, frameSubjects, } from './frame-by-type.js';
-import { companionNames, assertTypeInSchema, displayFieldName, displayLangOf, documentKeyOf, endpointFieldOf, fieldNamed, identityFieldOf, inheritedFacetPolicies, inlineFramingDepth, irAlias, isAbsoluteIri, isInternalField, isInlineReference, isoToUnixSeconds, localLookupTargetsOf, physicalFields, referencedTargetsOf, referenceTypeNamed, storableUnixSeconds, storedTargetOf, TARGET_FIELD, } from './schema.js';
+import { companionNames, assertTypeInSchema, displayFieldName, displayLangOf, documentKeyOf, endpointFieldOf, fieldNamed, identityFieldOf, inheritedFacetPolicies, inlineFramingDepth, irAlias, isAbsoluteIri, isInternalField, isInlineReference, localLookupTargetsOf, physicalFields, referencedTargetsOf, referenceTypeNamed, storedTargetOf, TARGET_FIELD, } from './schema.js';
 import { periodCovering, periodOf } from './period.js';
+import { describeValue, isReadKind, readValue, UNREADABLE, } from './read-value.js';
 /** The context a projection runs with when its caller supplied none. */
 const NO_PROJECTION_CONTEXT = {};
 /**
@@ -257,12 +258,7 @@ function hasValue(document, field, searchType) {
                 fieldNamed(searchType, key) === undefined)));
 }
 function applyField(document, node, field, searchType, schema, context, sink, nested) {
-    // A blank value states nothing, so there is nothing to correct at the source.
-    const unread = (value) => {
-        if (value.trim() !== '') {
-            sink(field.name, value);
-        }
-    };
+    const unread = (value) => sink(field.name, value);
     // The three value sources, mutually exclusive by declaration
     // (`validateSearchType`): a projection value, a computed value, a graph path.
     if ((field.kind === 'keyword' || field.kind === 'reference') &&
@@ -271,30 +267,24 @@ function applyField(document, node, field, searchType, schema, context, sink, ne
     }
     if (field.derive !== undefined) {
         const derived = field.derive(document, context);
-        // A derived `reference` is held to the same rule as a read one: what it
-        // stores is a selection key, and the surface types it `IRI`. ADR 21 sends
-        // an IRI-valued `keyword` derive here by converting it to `reference`, so
-        // this is the busiest way a non-IRI could otherwise reach the index. A
-        // value that survives nothing leaves the field absent, exactly as a derive
-        // returning `undefined` does.
-        if (field.kind === 'date') {
-            return applyDerivedDate(document, field, derived, unread);
-        }
         if (field.kind === 'period') {
             return setPeriod(document, field, derivedStrings(derived, unread), unread);
         }
-        const value = field.kind === 'reference' && derived !== undefined
-            ? derivedIris(derived, unread)
-            : derived;
-        // NaN is not a value any kind stores, and a derive is the only route that
-        // can produce one (`setNumber` guards the read route). It serializes as
-        // `null`, which an engine rejects for a numeric field – so drop it, leaving
-        // the field absent as an unparseable string already does.
-        if (value !== undefined && !Number.isNaN(value)) {
-            document[field.name] = value;
+        // A derived value is held to the same rule as a read one, through the same
+        // reader: a derived `reference` stores a selection key the surface types
+        // `IRI` – ADR 21 sends an IRI-valued `keyword` derive here by converting it
+        // to `reference`, so this is the busiest way a non-IRI could otherwise
+        // reach the index – and a derived `integer` an int64.
+        if (isReadKind(field.kind)) {
+            return applyRead(document, field, field.kind, Array.isArray(derived) ? derived : [derived], unread);
+        }
+        // A `keyword` or `text` field reads any value but NaN, which serializes as
+        // `null` – stored by an engine as no value, or refused with the document.
+        if (Number.isNaN(derived)) {
+            unread('NaN');
         }
-        else if (value !== undefined) {
-            unread(String(value));
+        else if (derived !== undefined) {
+            document[field.name] = derived;
         }
         return;
     }
@@ -350,38 +340,37 @@ function applyField(document, node, field, searchType, schema, context, sink, ne
             return applyFacet(document, values, field, schema, targetsById);
         }
         case 'integer':
-        case 'number': {
-            const literal = firstLiteralOf(node, alias);
-            const value = field.kind === 'integer' ? toInteger(literal) : toNumber(literal);
-            if (literal !== undefined && Number.isNaN(value)) {
-                unread(literal);
-            }
-            return setNumber(document, field.name, value);
-        }
-        case 'date': {
-            const literal = firstLiteralOf(node, alias);
-            const stored = literal === undefined ? undefined : isoToUnixSeconds(literal);
-            if (literal !== undefined && stored === undefined) {
-                unread(literal);
-            }
-            return setDate(document, field, stored);
-        }
+        case 'number':
+        case 'date':
+        case 'boolean':
+            return applyRead(document, field, field.kind, literalsOf(node, alias), unread);
         case 'period':
             return setPeriod(document, field, literalsOf(node, alias), unread);
-        case 'boolean': {
-            // The xsd:boolean lexical space: true/false/1/0. Anything else – `ja`,
-            // `yes` – states neither, so it is left out rather than stored as false.
-            // Surrounding whitespace is collapsed, as xsd:boolean’s facet says.
-            const literal = firstLiteralOf(node, alias)?.trim();
-            if (literal === undefined) {
-                return;
-            }
-            if (!BOOLEAN_LEXICAL_SPACE.has(literal)) {
-                return unread(literal);
-            }
-            document[field.name] = literal === 'true' || literal === '1';
-            return;
+    }
+}
+/**
+ * Store what {@link readValue} reads of `values` as `kind`, reporting every
+ * value it cannot. An `array` reference stores the list; every other kind is a
+ * scalar in the engine, so it stores the first value read – and an unreadable
+ * or blank value cannot cost the field a readable one behind it.
+ */
+function applyRead(document, field, kind, values, unread) {
+    const read = values.flatMap((value) => {
+        const reading = readValue(kind, value);
+        if (reading === UNREADABLE) {
+            unread(describeValue(value));
+            return [];
         }
+        return reading === undefined ? [] : [reading];
+    });
+    if (kind === 'date') {
+        return setDate(document, field, read[0]);
+    }
+    if (kind === 'reference' && field.array === true) {
+        document[field.name] = read;
+    }
+    else if (read.length > 0) {
+        document[field.name] = read[0];
     }
 }
 /**
@@ -413,10 +402,10 @@ function applyField(document, node, field, searchType, schema, context, sink, ne
 function referenceValues(node, alias, field, schema, targetsById, unread) {
     // A literal where a referent belongs states no IRI to store. A node without
     // one – a blank node – carries no value a publisher could look up, so only
-    // literals are reported.
+    // literals are reported, and a blank one states nothing to correct.
     for (const value of valuesOf(node, alias)) {
         const literal = iriString(value) === undefined ? literalString(value) : undefined;
-        if (literal !== undefined) {
+        if (literal !== undefined && literal.trim() !== '') {
             unread(literal);
         }
     }
@@ -1054,9 +1043,6 @@ function literalsOf(node, key) {
         .map(literalString)
         .filter((value) => value !== undefined);
 }
-function firstLiteralOf(node, key) {
-    return literalsOf(node, key)[0];
-}
 function irisOf(node, key) {
     return valuesOf(node, key)
         .map(iriString)
@@ -1119,57 +1105,6 @@ function iriString(value) {
     const iri = isObject(value) ? value['@id'] : value;
     return typeof iri === 'string' && isAbsoluteIri(iri) ? iri : undefined;
 }
-/** What a `derive` on a `reference` field is allowed to have produced: the
- *  absolute IRIs among its return value, keeping the shape the declaration
- *  promises (a list stays a list, a single value stays single) so `array` still
- *  decides the stored shape. A lone non-IRI becomes `undefined`, i.e. absent –
- *  the same outcome the graph path gives it. */
-function derivedIris(value, unread) {
-    const isIri = (entry) => {
-        const iri = typeof entry === 'string' && isAbsoluteIri(entry);
-        if (!iri && entry !== undefined) {
-            unread(String(entry));
-        }
-        return iri;
-    };
-    if (Array.isArray(value)) {
-        return value.filter(isIri);
-    }
-    return isIri(value) ? value : undefined;
-}
-function toInteger(literal) {
-    return literal === undefined ? undefined : Math.trunc(Number(literal));
-}
-function toNumber(literal) {
-    return literal === undefined ? undefined : Number(literal);
-}
-/**
- * A derived `date` goes through the same storage codec as a read one: the field
- * is stored as Unix seconds, so an ISO string returned here would otherwise
- * land as a string in an int64 field – and it is parsed like any literal, its
- * precision included. A derive that computed seconds itself returns a number,
- * which states no precision and so is stored as a date-time; the codec never
- * saw it and so never range-checked it, and seconds outside the int64 a `date`
- * field is stored in would be refused by the engine where an unparseable
- * string merely leaves the field absent – so drop those too.
- */
-function applyDerivedDate(document, field, derived, unread) {
-    let stored;
-    if (typeof derived === 'string') {
-        stored = isoToUnixSeconds(derived);
-    }
-    else if (typeof derived === 'number') {
-        // Truncated, as the codec truncates a string’s fractional seconds: the
-        // field is an int64. `storableUnixSeconds` drops NaN.
-        const seconds = storableUnixSeconds(Math.trunc(derived));
-        stored =
-            seconds === undefined ? undefined : { seconds, precision: 'dateTime' };
-    }
-    if (derived !== undefined && stored === undefined) {
-        unread(String(derived));
-    }
-    setDate(document, field, stored);
-}
 /** Store a `date` field’s seconds, and its precision in the companion beside
  *  them ({@link physicalFields}), so the surface can serve the value in the
  *  form its source gave. */
@@ -1220,21 +1155,17 @@ function setPeriod(document, field, values, unread) {
     }
 }
 /** A derive’s value as the strings a `period` stores: one string, or the
- *  strings in a list; anything else states no value. */
+ *  strings in a list. `null` and `undefined` state no value; anything else
+ *  is reported. */
 function derivedStrings(derived, unread) {
     const values = Array.isArray(derived) ? derived : [derived];
     return values.filter((value) => {
-        if (typeof value !== 'string' && value !== undefined) {
-            unread(String(value));
+        if (typeof value !== 'string' && value !== undefined && value !== null) {
+            unread(describeValue(value));
         }
         return typeof value === 'string';
     });
 }
-function setNumber(document, field, value) {
-    if (value !== undefined && !Number.isNaN(value)) {
-        document[field] = value;
-    }
-}
 function dedupe(values) {
     return [...new Set(values)];
 }
@@ -1275,10 +1206,3 @@ function unreadableSink(context, id) {
 function ignoreUnreadable() {
     // Nobody asked for the report.
 }
-/** The xsd:boolean lexical space. */
-const BOOLEAN_LEXICAL_SPACE = new Set([
-    'true',
-    'false',
-    '1',
-    '0',
-]);

package/dist/read-value.d.ts

@@ -0,0 +1,44 @@
+import { type StoredDate } from './schema.js';
+/** What reading a value that is there, but not one its kind can store, gives:
+ *  `onbekend` for an integer, `ja` for a boolean. */
+export declare const UNREADABLE: unique symbol;
+/**
+ * One value read as a field’s kind: what the field stores, {@link UNREADABLE}
+ * for a value it cannot store, or `undefined` for no value at all – a missing
+ * or blank one, which states nothing to correct at the source.
+ */
+type Reading<T> = T | typeof UNREADABLE | undefined;
+/** The kinds that can refuse a value: the rest store any literal. */
+declare const READ_KINDS: readonly ["integer", "number", "boolean", "date", "reference"];
+/** One of {@link READ_KINDS}. */
+export type ReadKind = (typeof READ_KINDS)[number];
+/** Whether `kind` is one {@link readValue} reads. */
+export declare function isReadKind(kind: string): kind is ReadKind;
+/**
+ * Read one value – a literal from the graph, or whatever a `derive` returned –
+ * as `kind` stores it. Both value routes read through here, so a kind accepts
+ * and refuses the same values whichever route they came by.
+ *
+ * - `integer`: a finite number, or an `xsd:decimal` or `xsd:double` lexical
+ *   form, truncated, within ±2⁵³ – beyond that a double no longer holds every
+ *   integer, so the stored value would not be the stated one. `INF` and `NaN`
+ *   are refused: an engine cannot store them.
+ * - `number`: any finite one, untruncated.
+ * - `boolean`: `true` or `false`, or the `xsd:boolean` lexical space
+ *   (`true`/`false`/`1`/`0`).
+ * - `date`: anything the `date` codec reads ({@link isoToUnixSeconds}), or
+ *   Unix seconds as a number.
+ * - `reference`: an absolute IRI.
+ *
+ * A string is read with surrounding whitespace collapsed, as XSD does.
+ */
+export declare function readValue(kind: ReadKind, value: unknown): Reading<number | boolean | string | StoredDate>;
+/**
+ * A value as the report shows it: `String(value)`, or its `typeof` when it has
+ * no string form, as an object built without a prototype has not. Never
+ * throws, so a derive’s odd return is reported rather than crashing the
+ * projection.
+ */
+export declare function describeValue(value: unknown): string;
+export {};
+//# sourceMappingURL=read-value.d.ts.map

package/dist/read-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-value.d.ts","sourceRoot":"","sources":["../src/read-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAErB;qDACqD;AACrD,eAAO,MAAM,UAAU,eAAuB,CAAC;AAE/C;;;;GAIG;AACH,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,UAAU,GAAG,SAAS,CAAC;AAEpD,qEAAqE;AACrE,QAAA,MAAM,UAAU,gEAMN,CAAC;AAEX,iCAAiC;AACjC,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD,qDAAqD;AACrD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,QAAQ,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC,CA8CjD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMpD"}

package/dist/read-value.js

@@ -0,0 +1,96 @@
+import { isAbsoluteIri, isoToUnixSeconds, storableUnixSeconds, } from './schema.js';
+/** What reading a value that is there, but not one its kind can store, gives:
+ *  `onbekend` for an integer, `ja` for a boolean. */
+export const UNREADABLE = Symbol('unreadable');
+/** The kinds that can refuse a value: the rest store any literal. */
+const READ_KINDS = [
+    'integer',
+    'number',
+    'boolean',
+    'date',
+    'reference',
+];
+/** Whether `kind` is one {@link readValue} reads. */
+export function isReadKind(kind) {
+    return READ_KINDS.includes(kind);
+}
+/**
+ * Read one value – a literal from the graph, or whatever a `derive` returned –
+ * as `kind` stores it. Both value routes read through here, so a kind accepts
+ * and refuses the same values whichever route they came by.
+ *
+ * - `integer`: a finite number, or an `xsd:decimal` or `xsd:double` lexical
+ *   form, truncated, within ±2⁵³ – beyond that a double no longer holds every
+ *   integer, so the stored value would not be the stated one. `INF` and `NaN`
+ *   are refused: an engine cannot store them.
+ * - `number`: any finite one, untruncated.
+ * - `boolean`: `true` or `false`, or the `xsd:boolean` lexical space
+ *   (`true`/`false`/`1`/`0`).
+ * - `date`: anything the `date` codec reads ({@link isoToUnixSeconds}), or
+ *   Unix seconds as a number.
+ * - `reference`: an absolute IRI.
+ *
+ * A string is read with surrounding whitespace collapsed, as XSD does.
+ */
+export function readValue(kind, value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const text = typeof value === 'string' ? value.trim() : undefined;
+    if (text === '') {
+        return undefined;
+    }
+    switch (kind) {
+        case 'integer':
+        case 'number': {
+            const number = typeof value === 'number'
+                ? value
+                : text !== undefined && NUMERIC.test(text)
+                    ? Number(text)
+                    : Number.NaN;
+            if (kind === 'number') {
+                return Number.isFinite(number) ? number : UNREADABLE;
+            }
+            const integer = Math.trunc(number);
+            return Number.isSafeInteger(integer) ? integer : UNREADABLE;
+        }
+        case 'boolean':
+            if (typeof value === 'boolean') {
+                return value;
+            }
+            return text !== undefined && BOOLEAN.has(text)
+                ? text === 'true' || text === '1'
+                : UNREADABLE;
+        case 'date': {
+            if (typeof value === 'number') {
+                // Truncated, as the codec truncates a string’s fractional seconds: the
+                // field is an int64. `storableUnixSeconds` drops NaN.
+                const seconds = storableUnixSeconds(Math.trunc(value));
+                return seconds === undefined
+                    ? UNREADABLE
+                    : { seconds, precision: 'dateTime' };
+            }
+            return ((text === undefined ? undefined : isoToUnixSeconds(text)) ?? UNREADABLE);
+        }
+        case 'reference':
+            return text !== undefined && isAbsoluteIri(text) ? text : UNREADABLE;
+    }
+}
+/**
+ * A value as the report shows it: `String(value)`, or its `typeof` when it has
+ * no string form, as an object built without a prototype has not. Never
+ * throws, so a derive’s odd return is reported rather than crashing the
+ * projection.
+ */
+export function describeValue(value) {
+    try {
+        return String(value);
+    }
+    catch {
+        return typeof value;
+    }
+}
+/** The `xsd:decimal` and `xsd:double` lexical forms, `INF` and `NaN` aside. */
+const NUMERIC = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+/** The `xsd:boolean` lexical space. */
+const BOOLEAN = new Set(['true', 'false', '1', '0']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "description": "Engine- and domain-agnostic core for RDF-backed search: a unified declarative field model (SearchField/SearchType/SearchSchema), a neutral query IR, the SearchEngine port with logical result types, and a streaming CONSTRUCT-to-document projection. Bakes in no engine, protocol, or domain.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",