eyeling 1.25.3 → 1.25.4

package/HANDBOOK.md

@@ -559,21 +559,25 @@ Facts live in an array `facts: Triple[]`.
 Eyeling attaches hidden (non-enumerable) index fields:
 
 - `facts.__byPred: Map<predicateId, number[]>` where each entry is an index into `facts` (and `predicateId` is `predicate.__tid`)
-- `facts.__byPS: Map<predicateId, Map<termId, number[]>>` where each entry is an index into `facts` (and `termId` is `term.__tid`)
-- `facts.__byPO: Map<predicateId, Map<termId, number[]>>` where each entry is an index into `facts` (and `termId` is `term.__tid`)
+- `facts.__byPS: Map<predicateId, Map<lookupKey, number[]>>` where each entry is an index into `facts`
+- `facts.__byPO: Map<predicateId, Map<lookupKey, number[]>>` where each entry is an index into `facts`
+- `facts.__byPNonFastS` / `facts.__byPNonFastO` for the small fallback set of IRI-predicate facts whose subject/object cannot be fast-keyed (for example variables or quoted formulas)
+- `facts.__varPred*` for top-level facts whose predicate is a variable; these are the only non-IRI-predicate facts that can match a ground IRI predicate goal
 - `facts.__keySet: Set<string>` for a fast-path `"sid	pid	oid"` key (all three are `__tid` values)
 
-`termFastKey(term)` returns a `termId` (`term.__tid`) for **Iri**, **Literal**, and **Blank** terms, and `null` for structured terms (lists, quoted graphs) and variables.
+`termFastKey(term)` returns a `termId` (`term.__tid`) for **Iri**, **Literal**, **Blank**, and strict-ground list terms, and `null` for quoted graphs, open lists, and variables. Proving-time lookup uses `termLookupKey(term)`, which is aligned with `unifyTerm`: it keeps exact ids for IRIs/blanks/strings, but canonicalizes value-equivalent booleans and numerics such as `true` / `"1"^^xsd:boolean` and `1.0` / `1.00`.
 
-The “fast key” only exists when `termFastKey` succeeds for all three terms.
+The duplicate-check “fast key” only exists when `termFastKey` succeeds for all three terms; the proof indexes use the broader `termLookupKey`.
 
 ### 7.2 Candidate selection: pick the smallest bucket
 
 When proving a goal with IRI predicate, Eyeling computes candidate facts by:
 
-1. restricting to predicate bucket
-2. optionally narrowing further by subject or object fast key
-3. choosing the smaller of (p,s) vs (p,o) when both exist
+1. restricting to the IRI predicate bucket
+2. if subject or object has a lookup key, using the matching `(p,s)` or `(p,o)` bucket plus only the non-fast fallback facts for that same position
+3. choosing the smaller of the subject-constrained and object-constrained candidate sets when both exist
+
+Variable-predicate facts are kept in a separate tiny fallback index. Blank/list/formula predicates are not scanned for an IRI predicate goal because they cannot unify with an IRI predicate.
 
 This is a cheap selectivity heuristic. In type-heavy RDF, `(p,o)` is often extremely selective (e.g., `rdf:type` + a class IRI), so the PO index can be a major speed win.
 
@@ -583,7 +587,7 @@ The same selectivity idea is also reused by the single-premise forward-rule agen
 
 When adding derived facts, Eyeling uses a fast-path duplicate check when possible:
 
-- If all three terms have a fast key (Iri/Literal/Blank → `__tid`), it checks membership in `facts.__keySet` using the `"sid	pid	oid"` key.
+- If all three terms have a duplicate-check fast key, it checks membership in `facts.__keySet` using the `"sid	pid	oid"` key.
 - Otherwise (lists, quoted graphs, variables), it falls back to structural triple equality.
 
 This still treats blanks correctly: blanks are _not_ interchangeable; the blank **label** (and thus its `__tid`) is part of the key.

package/dist/browser/eyeling.browser.js

@@ -6523,6 +6523,12 @@ function alphaEqGraphTriples(xs, ys, opts) {
 //   - __byPred: Map<predicateId, number[]>   (indices into facts array)
 //   - __byPS:   Map<predicateId, Map<subjectId, number[]>>
 //   - __byPO:   Map<predicateId, Map<objectId, number[]>>
+//   - __byPNonFastS / __byPNonFastO: Map<predicateId, number[]>
+//       IRI-predicate facts whose subject/object cannot be indexed by fast key.
+//       These are the fallback clauses for a constrained subject/object, just
+//       like a Prolog clause index keeps variable-headed clauses as fallback.
+//   - __varPred* indexes: facts whose predicate is a Var.  Only these non-IRI
+//       predicate facts can unify with a ground IRI predicate goal.
 //   - __keySet: Set<"S\tP\tO"> for Iri/Literal/Blank-only triples (fast dup check)
 //
 // Backward rules:
@@ -6538,6 +6544,8 @@ const __compoundKeyToTid = new Map();
 // Use a negative id space so we never collide with __tid (which is positive).
 let __nextCompoundTid = -1;
 
+const EMPTY_FACT_INDEX_BUCKET = Object.freeze([]);
+
 function __internCompoundTid(key) {
   const hit = __compoundKeyToTid.get(key);
   if (hit !== undefined) return hit;
@@ -6589,6 +6597,71 @@ function termFastKey(t) {
   return null;
 }
 
+function encodeLookupKeyPart(k) {
+  if (typeof k === 'number') return 'T' + k;
+  const s = String(k);
+  return 'K' + s.length + ':' + s;
+}
+
+function literalLookupKey(t) {
+  const boolInfo = parseBooleanLiteralInfo(t);
+  if (boolInfo) return '\u0000B' + (boolInfo.value ? '1' : '0');
+
+  const numInfo = parseNumericLiteralInfo(t);
+  if (numInfo) {
+    if (numInfo.kind === 'bigint') return '\u0000N' + numInfo.dt + '\u0000' + numInfo.value.toString();
+
+    const n = numInfo.value;
+    // Normal unification intentionally does not make NaN value-equal to NaN;
+    // only identical lexical literals match through the ordinary __tid path.
+    if (!Number.isNaN(n)) return '\u0000N' + numInfo.dt + '\u0000' + String(n);
+  }
+
+  // Covers exact literals plus plain string / xsd:string canonicalization, which
+  // Literal construction already normalizes into a shared __tid.
+  return termFastKey(t);
+}
+
+function termLookupKey(t) {
+  // Lookup keys summarize the equality accepted by ordinary unifyTerm(), not
+  // merely object identity.  This keeps literal-index pruning complete for
+  // value-equivalent booleans/numerics such as true/"1"^^xsd:boolean and
+  // 1.0/1.00, while preserving exact fast ids for IRIs, blanks, and strings.
+  if (t instanceof Iri) {
+    if (t.value === RDF_NIL_IRI) return '\u0000L0';
+    return t.__tid;
+  }
+  if (t instanceof Blank) return t.__tid;
+  if (t instanceof Literal) return literalLookupKey(t);
+
+  if (t instanceof ListTerm) {
+    const cached = t.__lookupKey;
+    if (cached !== undefined) return cached === false ? null : cached;
+
+    const xs = t.elems;
+    if (xs.length === 0) {
+      Object.defineProperty(t, '__lookupKey', { value: '\u0000L0', enumerable: false });
+      return '\u0000L0';
+    }
+
+    const parts = new Array(xs.length);
+    for (let i = 0; i < xs.length; i++) {
+      const k = termLookupKey(xs[i]);
+      if (k === null) {
+        Object.defineProperty(t, '__lookupKey', { value: false, enumerable: false });
+        return null;
+      }
+      parts[i] = encodeLookupKeyPart(k);
+    }
+
+    const key = '\u0000L' + xs.length + '\u0001' + parts.join('\u0001');
+    Object.defineProperty(t, '__lookupKey', { value: key, enumerable: false });
+    return key;
+  }
+
+  return null;
+}
+
 function tripleFastKey(tr) {
   const ks = termFastKey(tr.s);
   const kp = termFastKey(tr.p);
@@ -6602,9 +6675,13 @@ function ensureFactIndexes(facts) {
     facts.__byPred &&
     facts.__byPS &&
     facts.__byPO &&
-    facts.__wildPred &&
-    facts.__wildPS &&
-    facts.__wildPO &&
+    facts.__byPNonFastS &&
+    facts.__byPNonFastO &&
+    facts.__varPred &&
+    facts.__varPredPS &&
+    facts.__varPredPO &&
+    facts.__varPredNonFastS &&
+    facts.__varPredNonFastO &&
     facts.__keySet
   )
     return;
@@ -6624,21 +6701,41 @@ function ensureFactIndexes(facts) {
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPred', {
+  Object.defineProperty(facts, '__byPNonFastS', {
+    value: new Map(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__byPNonFastO', {
+    value: new Map(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__varPred', {
     value: [],
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPS', {
+  Object.defineProperty(facts, '__varPredPS', {
     value: new Map(),
     enumerable: false,
     writable: true,
   });
-  Object.defineProperty(facts, '__wildPO', {
+  Object.defineProperty(facts, '__varPredPO', {
     value: new Map(),
     enumerable: false,
     writable: true,
   });
+  Object.defineProperty(facts, '__varPredNonFastS', {
+    value: [],
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(facts, '__varPredNonFastO', {
+    value: [],
+    enumerable: false,
+    writable: true,
+  });
   Object.defineProperty(facts, '__keySet', {
     value: new Set(),
     enumerable: false,
@@ -6679,16 +6776,53 @@ function cloneFactIndexesForSnapshot(src, dest) {
   Object.defineProperty(dest, '__byPred', { value: cloneArrayMap(src.__byPred), enumerable: false, writable: true });
   Object.defineProperty(dest, '__byPS', { value: cloneNestedArrayMap(src.__byPS), enumerable: false, writable: true });
   Object.defineProperty(dest, '__byPO', { value: cloneNestedArrayMap(src.__byPO), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPred', { value: src.__wildPred.slice(), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPS', { value: cloneArrayMap(src.__wildPS), enumerable: false, writable: true });
-  Object.defineProperty(dest, '__wildPO', { value: cloneArrayMap(src.__wildPO), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__byPNonFastS', {
+    value: cloneArrayMap(src.__byPNonFastS),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__byPNonFastO', {
+    value: cloneArrayMap(src.__byPNonFastO),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPred', { value: src.__varPred.slice(), enumerable: false, writable: true });
+  Object.defineProperty(dest, '__varPredPS', {
+    value: cloneArrayMap(src.__varPredPS),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredPO', {
+    value: cloneArrayMap(src.__varPredPO),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredNonFastS', {
+    value: src.__varPredNonFastS.slice(),
+    enumerable: false,
+    writable: true,
+  });
+  Object.defineProperty(dest, '__varPredNonFastO', {
+    value: src.__varPredNonFastO.slice(),
+    enumerable: false,
+    writable: true,
+  });
   Object.defineProperty(dest, '__keySet', { value: new Set(src.__keySet), enumerable: false, writable: true });
   Object.defineProperty(dest, '__keySetComplete', { value: !!src.__keySetComplete, enumerable: false, writable: true });
 }
 
+function addToIndexArrayMap(map, key, value) {
+  let bucket = map.get(key);
+  if (!bucket) {
+    bucket = [];
+    map.set(key, bucket);
+  }
+  bucket.push(value);
+}
+
 function indexFact(facts, tr, idx, addKeySet = true) {
-  const sk = termFastKey(tr.s);
-  const ok = termFastKey(tr.o);
+  const sk = termLookupKey(tr.s);
+  const ok = termLookupKey(tr.o);
   let pkForKey = null;
 
   if (tr.p instanceof Iri) {
@@ -6709,12 +6843,9 @@ function indexFact(facts, tr, idx, addKeySet = true) {
         ps = new Map();
         facts.__byPS.set(pk, ps);
       }
-      let psb = ps.get(sk);
-      if (!psb) {
-        psb = [];
-        ps.set(sk, psb);
-      }
-      psb.push(idx);
+      addToIndexArrayMap(ps, sk, idx);
+    } else {
+      addToIndexArrayMap(facts.__byPNonFastS, pk, idx);
     }
 
     if (ok !== null) {
@@ -6723,32 +6854,23 @@ function indexFact(facts, tr, idx, addKeySet = true) {
         po = new Map();
         facts.__byPO.set(pk, po);
       }
-      let pob = po.get(ok);
-      if (!pob) {
-        pob = [];
-        po.set(ok, pob);
-      }
-      pob.push(idx);
+      addToIndexArrayMap(po, ok, idx);
+    } else {
+      addToIndexArrayMap(facts.__byPNonFastO, pk, idx);
     }
-  } else {
-    facts.__wildPred.push(idx);
+  } else if (tr.p instanceof Var) {
+    facts.__varPred.push(idx);
 
     if (sk !== null) {
-      let psb = facts.__wildPS.get(sk);
-      if (!psb) {
-        psb = [];
-        facts.__wildPS.set(sk, psb);
-      }
-      psb.push(idx);
+      addToIndexArrayMap(facts.__varPredPS, sk, idx);
+    } else {
+      facts.__varPredNonFastS.push(idx);
     }
 
     if (ok !== null) {
-      let pob = facts.__wildPO.get(ok);
-      if (!pob) {
-        pob = [];
-        facts.__wildPO.set(ok, pob);
-      }
-      pob.push(idx);
+      addToIndexArrayMap(facts.__varPredPO, ok, idx);
+    } else {
+      facts.__varPredNonFastO.push(idx);
     }
   }
 
@@ -6758,55 +6880,86 @@ function indexFact(facts, tr, idx, addKeySet = true) {
   }
 }
 
+function mergeIndexBuckets(primary, fallback) {
+  const a = primary && primary.length ? primary : null;
+  const b = fallback && fallback.length ? fallback : null;
+  if (!a && !b) return EMPTY_FACT_INDEX_BUCKET;
+  if (!a) return b;
+  if (!b) return a;
+  const out = new Array(a.length + b.length);
+  for (let i = 0; i < a.length; i++) out[i] = a[i];
+  for (let i = 0; i < b.length; i++) out[a.length + i] = b[i];
+  return out;
+}
+
+function selectPositionIndexedCandidates(all, exactByS, fallbackS, sk, exactByO, fallbackO, ok) {
+  if (sk === null && ok === null) return all && all.length ? all : EMPTY_FACT_INDEX_BUCKET;
+
+  let sBucket = null;
+  if (sk !== null) sBucket = mergeIndexBuckets(exactByS || null, fallbackS || null);
+
+  let oBucket = null;
+  if (ok !== null) oBucket = mergeIndexBuckets(exactByO || null, fallbackO || null);
+
+  if (sk !== null && ok !== null) return sBucket.length <= oBucket.length ? sBucket : oBucket;
+  return sk !== null ? sBucket : oBucket;
+}
+
 function candidateFacts(facts, goal) {
   ensureFactIndexes(facts);
 
   if (goal.p instanceof Iri) {
     const pk = goal.p.__tid;
 
-    const sk = termFastKey(goal.s);
-    const ok = termFastKey(goal.o);
+    const sk = termLookupKey(goal.s);
+    const ok = termLookupKey(goal.o);
 
-    /** @type {number[] | null} */
     let byPS = null;
     if (sk !== null) {
       const ps = facts.__byPS.get(pk);
       if (ps) byPS = ps.get(sk) || null;
     }
+    const byPNonFastS = sk !== null ? facts.__byPNonFastS.get(pk) || null : null;
 
-    /** @type {number[] | null} */
     let byPO = null;
     if (ok !== null) {
       const po = facts.__byPO.get(pk);
       if (po) byPO = po.get(ok) || null;
     }
+    const byPNonFastO = ok !== null ? facts.__byPNonFastO.get(pk) || null : null;
 
-    let exact = null;
-    if (byPS && byPO) exact = byPS.length <= byPO.length ? byPS : byPO;
-    else if (byPS) exact = byPS;
-    else if (byPO) exact = byPO;
-    else exact = facts.__byPred.get(pk) || null;
+    const exact = selectPositionIndexedCandidates(
+      facts.__byPred.get(pk) || null,
+      byPS,
+      byPNonFastS,
+      sk,
+      byPO,
+      byPNonFastO,
+      ok,
+    );
 
-    /** @type {number[] | null} */
-    let wildPS = null;
-    if (sk !== null) wildPS = facts.__wildPS.get(sk) || null;
+    let varPredPS = null;
+    if (sk !== null) varPredPS = facts.__varPredPS.get(sk) || null;
 
-    /** @type {number[] | null} */
-    let wildPO = null;
-    if (ok !== null) wildPO = facts.__wildPO.get(ok) || null;
+    let varPredPO = null;
+    if (ok !== null) varPredPO = facts.__varPredPO.get(ok) || null;
 
-    let wild = null;
-    if (wildPS && wildPO) wild = wildPS.length <= wildPO.length ? wildPS : wildPO;
-    else if (wildPS) wild = wildPS;
-    else if (wildPO) wild = wildPO;
-    else wild = facts.__wildPred.length ? facts.__wildPred : null;
+    const wild = selectPositionIndexedCandidates(
+      facts.__varPred,
+      varPredPS,
+      sk !== null ? facts.__varPredNonFastS : null,
+      sk,
+      varPredPO,
+      ok !== null ? facts.__varPredNonFastO : null,
+      ok,
+    );
 
     return {
-      exact: exact || null,
-      wild: wild || null,
-      exactLen: exact ? exact.length : 0,
-      wildLen: wild ? wild.length : 0,
-      totalLen: (exact ? exact.length : 0) + (wild ? wild.length : 0),
+      exact,
+      wild,
+      exactLen: exact.length,
+      wildLen: wild.length,
+      totalLen: exact.length + wild.length,
     };
   }
 
@@ -6824,20 +6977,28 @@ function hasFactIndexed(facts, tr) {
 
   if (tr.p instanceof Iri) {
     const pk = tr.p.__tid;
+    const sk = termLookupKey(tr.s);
+    let best = null;
 
-    const ok = termFastKey(tr.o);
+    if (sk !== null) {
+      const ps = facts.__byPS.get(pk);
+      if (!ps) return false;
+      const psb = ps.get(sk);
+      if (!psb || psb.length === 0) return false;
+      best = psb;
+    }
+
+    const ok = termLookupKey(tr.o);
     if (ok !== null) {
       const po = facts.__byPO.get(pk);
-      if (po) {
-        const pob = po.get(ok) || [];
-        // Facts are all in the same graph. Different blank node labels represent
-        // different existentials unless explicitly connected. Do NOT treat
-        // triples as duplicates modulo blank renaming, or you'll incorrectly
-        // drop facts like: _:sk_0 :x 8.0  (because _:b8 :x 8.0 exists).
-        return pob.some((i) => triplesEqual(facts[i], tr));
-      }
+      if (!po) return false;
+      const pob = po.get(ok);
+      if (!pob || pob.length === 0) return false;
+      if (!best || pob.length < best.length) best = pob;
     }
 
+    if (best) return best.some((i) => triplesEqual(facts[i], tr));
+
     const pb = facts.__byPred.get(pk) || [];
     return pb.some((i) => triplesEqual(facts[i], tr));
   }
@@ -6946,11 +7107,25 @@ function mergeSinglePremiseAgendaBuckets() {
   return out;
 }
 
+function termContainsVarForAgenda(t) {
+  if (t instanceof Var) return true;
+  if (t instanceof ListTerm) return t.elems.some(termContainsVarForAgenda);
+  if (t instanceof OpenListTerm) return true;
+  if (t instanceof GraphTerm)
+    return t.triples.some(
+      (tr) =>
+        termContainsVarForAgenda(tr.s) || termContainsVarForAgenda(tr.p) || termContainsVarForAgenda(tr.o),
+    );
+  return false;
+}
+
 function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
   const index = {
     byPred: new Map(),
+    byPredAll: new Map(),
     byPS: new Map(),
     byPO: new Map(),
+    allIriPred: [],
     wildPred: [],
     wildPS: new Map(),
     wildPO: new Map(),
@@ -6972,8 +7147,8 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     if (!isSinglePremiseAgendaRuleSafe(r, backRules)) continue;
 
     const goal = r.premise[0];
-    const goalSKey = termFastKey(goal.s);
-    const goalOKey = termFastKey(goal.o);
+    const goalSKey = termLookupKey(goal.s);
+    const goalOKey = termLookupKey(goal.o);
     const fastSubjectVar = goal.p instanceof Iri && goal.s instanceof Var && goalOKey !== null ? goal.s.name : null;
     const fastObjectVar = goal.p instanceof Iri && goal.o instanceof Var && goalSKey !== null ? goal.o.name : null;
     const entry = {
@@ -6992,6 +7167,8 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
     index.size += 1;
 
     if (entry.goalPredTid !== null) {
+      addToMapArray(index.byPredAll, entry.goalPredTid, entry);
+      index.allIriPred.push(entry);
       if (entry.goalSKey === null && entry.goalOKey === null) addToMapArray(index.byPred, entry.goalPredTid, entry);
       if (entry.goalSKey !== null) {
         let ps = index.byPS.get(entry.goalPredTid);
@@ -7022,25 +7199,37 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
 function getSinglePremiseAgendaCandidates(index, fact) {
   if (!index || index.size === 0) return null;
 
-  const sk = termFastKey(fact.s);
-  const ok = termFastKey(fact.o);
+  const sk = termLookupKey(fact.s);
+  const ok = termLookupKey(fact.o);
 
   let exact = null;
   if (fact.p instanceof Iri) {
     const pk = fact.p.__tid;
-    const byPred = index.byPred.get(pk) || null;
-    let byPS = null;
-    if (sk !== null) {
+    if ((sk === null && termContainsVarForAgenda(fact.s)) || (ok === null && termContainsVarForAgenda(fact.o))) {
+      // A fact with a variable-bearing subject/object (most importantly a
+      // top-level variable fact such as `?S :p ?O.`) can match rules whose
+      // premise is fixed in that position. The ordinary `(p,s)` / `(p,o)` lookup
+      // would miss those rules, so fall back to all agenda-indexed rules for
+      // this predicate. Do not do this merely for non-fast quoted formulas:
+      // they are not wildcards, and broad fallback would over-fire rules that
+      // rely on protected blank-node/formula unification semantics.
+      exact = index.byPredAll.get(pk) || null;
+    } else {
+      const byPred = index.byPred.get(pk) || null;
+      let byPS = null;
       const ps = index.byPS.get(pk);
       if (ps) byPS = ps.get(sk) || null;
-    }
-    let byPO = null;
-    if (ok !== null) {
+      let byPO = null;
       const po = index.byPO.get(pk);
       if (po) byPO = po.get(ok) || null;
-    }
 
-    exact = mergeSinglePremiseAgendaBuckets(byPred, byPS, byPO);
+      exact = mergeSinglePremiseAgendaBuckets(byPred, byPS, byPO);
+    }
+  } else if (fact.p instanceof Var) {
+    // A variable-predicate fact can match any IRI-predicate agenda rule.
+    // This is deliberately broad and relies on final unification below; such
+    // facts are uncommon and correctness matters more than over-indexing them.
+    exact = index.allIriPred.length ? index.allIriPred : null;
   }
 
   const wildPred = index.wildPred.length ? index.wildPred : null;
@@ -9647,15 +9836,6 @@ function isIdentChar(c) {
   return c === ':' || isPnChars(c);
 }
 
-function canContinueAfterDot(next) {
-  // PN_LOCAL allows '.' but it cannot appear at the end.
-  // We include '.' only if it is followed by something that could continue a name.
-  if (next === null) return false;
-  if (isIdentChar(next)) return true;
-  if (next === '%' || next === '\\') return true;
-  return false;
-}
-
 function isForbiddenNoncharacterCodePoint(cp) {
   return (cp & 0xffff) === 0xfffe || (cp & 0xffff) === 0xffff;
 }