lambda-live-debugger 1.12.6 → 1.12.8

package/node_modules/@inquirer/search/dist/index.d.ts

@@ -19,6 +19,17 @@ type Choice<Value> = {
     disabled?: boolean | string;
     type?: never;
 };
+type SearchConfig<Value = string> = {
+    message: string;
+    source: (term: string | undefined, opt: {
+        signal: AbortSignal;
+    }) => ReadonlyArray<Value | Choice<Value> | Separator> | Promise<ReadonlyArray<Value | Choice<Value> | Separator>>;
+    validate?: (value: Value) => boolean | string | Promise<string | boolean>;
+    pageSize?: number;
+    default?: NoInfer<Value>;
+    initialValue?: string;
+    theme?: PartialDeep<Theme<SearchTheme>>;
+};
 declare const _default: <const Value>(config: {
     message: string;
     source: (term: string | undefined, opt: {
@@ -27,7 +38,8 @@ declare const _default: <const Value>(config: {
     validate?: ((value: Value) => boolean | string | Promise<string | boolean>) | undefined;
     pageSize?: number | undefined;
     default?: NoInfer<Value> | undefined;
+    initialValue?: string | undefined;
     theme?: PartialDeep<Theme<SearchTheme>> | undefined;
-}, context?: import("@inquirer/type").Context) => Promise<Value>;
+} & SearchConfig<Value>, context?: import("@inquirer/type").Context) => Promise<Value>;
 export default _default;
 export { Separator } from '@inquirer/core';

package/node_modules/@inquirer/search/dist/index.js

@@ -45,7 +45,7 @@ export default createPrompt((config, done) => {
     const { pageSize = 7, validate = () => true } = config;
     const theme = makeTheme(searchTheme, config.theme);
     const [status, setStatus] = useState('loading');
-    const [searchTerm, setSearchTerm] = useState('');
+    const [searchTerm, setSearchTerm] = useState(config.initialValue ?? '');
     const [searchResults, setSearchResults] = useState([]);
     const [searchError, setSearchError] = useState();
     const defaultApplied = useRef(false);
@@ -56,6 +56,11 @@ export default createPrompt((config, done) => {
         return { first, last };
     }, [searchResults]);
     const [active = bounds.first, setActive] = useState();
+    useEffect((rl) => {
+        if (config.initialValue) {
+            rl.write(config.initialValue);
+        }
+    }, []);
     useEffect(() => {
         const controller = new AbortController();
         setStatus('loading');

package/node_modules/@inquirer/search/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inquirer/search",
-  "version": "4.2.1",
+  "version": "4.3.2",
   "description": "Inquirer search prompt",
   "keywords": [
     "answer",
@@ -67,11 +67,12 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@inquirer/core": "^11.2.1",
-    "@inquirer/figures": "^2.0.7",
-    "@inquirer/type": "^4.0.7"
+    "@inquirer/core": "^12.0.2",
+    "@inquirer/figures": "^2.0.9",
+    "@inquirer/type": "4.1.1"
   },
   "devDependencies": {
+    "@repo/tsconfig": "0.0.0",
     "typescript": "^6.0.2"
   },
   "peerDependencies": {
@@ -87,5 +88,5 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "gitHead": "b43359d803733b1a7c4638addcc270987fb894c3"
+  "gitHead": "5748bd9966b5e175ddf5995ee4cdce6f60c4272e"
 }

package/node_modules/@inquirer/select/dist/index.d.ts

@@ -22,6 +22,14 @@ type Choice<Value> = {
     disabled?: boolean | string;
     type?: never;
 };
+type SelectConfig<Value> = {
+    message: string;
+    choices: ReadonlyArray<Value | Choice<Value> | Separator>;
+    pageSize?: number;
+    loop?: boolean;
+    default?: NoInfer<Value>;
+    theme?: PartialDeep<Theme<SelectTheme>>;
+};
 declare const _default: <const Value>(config: {
     message: string;
     choices: readonly (Separator | Value | Choice<Value>)[];
@@ -29,6 +37,6 @@ declare const _default: <const Value>(config: {
     loop?: boolean | undefined;
     default?: NoInfer<Value> | undefined;
     theme?: PartialDeep<Theme<SelectTheme>> | undefined;
-}, context?: import("@inquirer/type").Context) => Promise<Value>;
+} & SelectConfig<Value>, context?: import("@inquirer/type").Context) => Promise<Value>;
 export default _default;
 export { Separator } from '@inquirer/core';

package/node_modules/@inquirer/select/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inquirer/select",
-  "version": "5.2.1",
+  "version": "5.2.4",
   "description": "Inquirer select/list prompt",
   "keywords": [
     "answer",
@@ -67,12 +67,13 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@inquirer/ansi": "^2.0.7",
-    "@inquirer/core": "^11.2.1",
-    "@inquirer/figures": "^2.0.7",
-    "@inquirer/type": "^4.0.7"
+    "@inquirer/ansi": "^2.0.8",
+    "@inquirer/core": "^12.0.2",
+    "@inquirer/figures": "^2.0.9",
+    "@inquirer/type": "4.1.1"
   },
   "devDependencies": {
+    "@repo/tsconfig": "0.0.0",
     "typescript": "^6.0.2"
   },
   "peerDependencies": {
@@ -88,5 +89,5 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "gitHead": "b43359d803733b1a7c4638addcc270987fb894c3"
+  "gitHead": "5748bd9966b5e175ddf5995ee4cdce6f60c4272e"
 }

package/node_modules/@inquirer/type/dist/utils.d.ts

@@ -1,7 +1,12 @@
 type Key = string | number | symbol;
-export type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
+/**
+ * Recursively expand intersections and mapped types for better IDE display,
+ * while preserving functions, arrays, primitives, and types with a string
+ * index signature (e.g. `Record<string, ...>`) as-is.
+ */
+export type Prettify<T> = T extends (...args: never[]) => unknown ? T : T extends ReadonlyArray<unknown> ? T : T extends string | number | boolean | symbol | bigint | null | undefined ? T : T extends object ? string extends keyof T ? T : {
+    [K in keyof T]: Prettify<T[K]>;
+} & {} : T;
 export type PartialDeep<T> = T extends object ? {
     [P in keyof T]?: PartialDeep<T[P]>;
 } : T;

package/node_modules/@inquirer/type/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inquirer/type",
-  "version": "4.0.7",
+  "version": "4.1.1",
   "description": "Inquirer core TS types",
   "keywords": [
     "answer",
@@ -68,6 +68,7 @@
     "tsc": "tsc"
   },
   "devDependencies": {
+    "@repo/tsconfig": "0.0.0",
     "typescript": "^6.0.2"
   },
   "peerDependencies": {
@@ -83,5 +84,5 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "gitHead": "b43359d803733b1a7c4638addcc270987fb894c3"
+  "gitHead": "5748bd9966b5e175ddf5995ee4cdce6f60c4272e"
 }

package/node_modules/@nodable/entities/README.md

@@ -14,7 +14,8 @@ npm install @nodable/entities
 import { EntityEncoder, EntityDecoder, ALL_ENTITIES } from '@nodable/entities';
 
 // Encode: plain text → entity references
-const enc = new EntityEncoder();
+// v3 requires an explicit entity set when encoding named (non‑ASCII) characters
+const enc = new EntityEncoder({ namedEntities: ALL_ENTITIES });
 enc.encode('Hello © 2024 & <stuff>');
 // → 'Hello &copy; 2024 &amp; &lt;stuff&gt;'
 
@@ -24,6 +25,56 @@ dec.decode('Hello &copy; 2024 &amp; &lt;stuff&gt;');
 // → 'Hello © 2024 & <stuff>'
 ```
 
+If you only need to encode XML‑unsafe characters (`&`, `<`, `>`, `"`, `'`), you can disable named‑entity encoding entirely and avoid importing any entity set:
+
+```js
+const enc = new EntityEncoder({ encodeAllNamed: false });
+enc.encode('© <stuff>'); // → '© &lt;stuff&gt;'  (copyright stays literal)
+```
+
+To encode only a specific subset of characters (e.g. common HTML entities), pass a custom map:
+
+```js
+import { EntityEncoder, COMMON_HTML, CURRENCY } from '@nodable/entities';
+
+const enc = new EntityEncoder({ namedEntities: { ...COMMON_HTML, ...CURRENCY } });
+enc.encode('Price: 10 © 2024'); // only COMMON_HTML/CURRENCY entities are recognized
+```
+
+---
+
+## Migration from v2 to v3
+
+**Breaking change:**  
+In v2, `new EntityEncoder()` automatically used the full built‑in entity set to encode non‑ASCII characters (like `©` → `&copy;`). This caused poor tree‑shaking: every consumer paid the cost of the entire entity table, even if they never used it.
+
+In v3, **`EntityEncoder` no longer includes a default entity set**.  
+If you pass no options and `encodeAllNamed` is `true` (the default), the constructor will **throw an error**:
+
+```js
+const enc = new EntityEncoder(); // throws: "encodeAllNamed is true but no `namedEntities` was provided"
+```
+
+### How to update
+
+| What you need | v2 code | v3 code |
+|---------------|---------|---------|
+| **Full built‑in set** (same as v2) | `new EntityEncoder()` | `import { ALL_ENTITIES } from '@nodable/entities';`<br>`new EntityEncoder({ namedEntities: ALL_ENTITIES })` |
+| **Only XML‑unsafe chars** (no named entities) | `new EntityEncoder({ encodeAllNamed: false })` | **Same** – no change |
+| **Custom subset** | `new EntityEncoder({ namedEntities: myMap })` | **Same** – but now your map is required for named‑entity encoding |
+
+This change allows bundlers to tree‑shake unused entity categories – you only pay for the characters you actually encode.
+
+### Upgrading step‑by‑step
+
+1. Update to `@nodable/entities@3.0.0`.
+2. Find all `new EntityEncoder()` calls in your project.
+3. Decide:
+   - If you need the full set: import `ALL_ENTITIES` and pass it as `namedEntities`.
+   - If you only need XML‑unsafe escaping: add `{ encodeAllNamed: false }`.
+   - If you used a custom set: keep it as‑is – it already worked.
+4. Run your tests – the encoder should now behave as before, but with better bundle size.
+
 ## Performance
 
 |  | encode | decode |

package/node_modules/@nodable/entities/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodable/entities",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "Entity parser for XML, HTML, External entites with security and NCR control",
   "main": "./src/index.js",
   "type": "module",

package/node_modules/@nodable/entities/src/EntityEncoder.js

@@ -1,5 +1,7 @@
-// EntityDecoder.js
-import { trie1, trie2, trie3 } from './entityTries.js';
+// EntityEncoder.js
+import { buildTries } from './entityTries.js';
+// NOTE: no static import of ALL_ENTITIES / entities.js here — that import
+// was the actual tree-shaking leak (see constructor comment below).
 
 // Replacement strings indexed by char code — direct array access, no hashing
 const XML_UNSAFE_REPLACEMENT = new Array(128);
@@ -26,6 +28,42 @@ export default class EntityEncoder {
     this.encodeAllNamed = options.encodeAllNamed !== false;
     this.maxReplacements = options.maxReplacements || 0;
     this.replacementsCount = 0;
+
+    // Tries are only built when named-entity encoding is actually requested,
+    // and only from what the caller explicitly hands in. There is no
+    // built-in default entity set imported here — that static import was
+    // exactly what pinned the entire ALL_ENTITIES data (all categories) into
+    // every consumer's bundle regardless of what they actually used. A `||`
+    // fallback to a statically-imported default does NOT tree-shake: the
+    // import is still "used" from the bundler's point of view even if the
+    // runtime branch never executes.
+    //
+    // BREAKING CHANGE from earlier versions: `new EntityEncoder()` with no
+    // `namedEntities` and `encodeAllNamed !== false` now throws instead of
+    // silently encoding the full built-in set. Callers who want the old
+    // "encode everything" behavior must opt in explicitly:
+    //   import { ALL_ENTITIES } from '@nodable/entities';
+    //   new EntityEncoder({ namedEntities: ALL_ENTITIES });
+    if (this.encodeAllNamed) {
+      if (!options.namedEntities) {
+        throw new Error(
+          '[EntityEncoder] encodeAllNamed is true but no `namedEntities` was ' +
+          'provided. Pass a specific set (e.g. { ...COMMON_HTML, ...CURRENCY }) ' +
+          'or the full built-in set via `namedEntities: ALL_ENTITIES` imported ' +
+          'from \'@nodable/entities\'. This is required so bundlers can ' +
+          'tree-shake unused entity categories out of your build; set ' +
+          '`encodeAllNamed: false` if you don\'t need named-entity encoding at all.'
+        );
+      }
+      const tries = buildTries(options.namedEntities);
+      this.trie1 = tries.trie1;
+      this.trie2 = tries.trie2;
+      this.trie3 = tries.trie3;
+    } else {
+      this.trie1 = null;
+      this.trie2 = null;
+      this.trie3 = null;
+    }
   }
 
   encode(str) {
@@ -38,6 +76,9 @@ export default class EntityEncoder {
     // Hoist to locals — avoids `this` property lookup inside the hot loop
     const encodeXmlSafe = this.encodeXmlSafe;
     const encodeAllNamed = this.encodeAllNamed;
+    const trie1 = this.trie1;
+    const trie2 = this.trie2;
+    const trie3 = this.trie3;
 
     const len = str.length;
 
@@ -84,32 +125,34 @@ export default class EntityEncoder {
       let matchedEntity = null;
       let advance = 1;
 
-      // Try 3-char match first (longest wins)
-      const mid3 = trie3.get(c0);
-      if (mid3 !== undefined) {
-        const c1 = str.charCodeAt(i + 1);
-        const inner3 = mid3.get(c1);
-        if (inner3 !== undefined) {
-          const c2 = str.charCodeAt(i + 2);
-          const candidate = inner3.get(c2);
-          if (candidate !== undefined) { matchedEntity = candidate; advance = 3; }
+      if (encodeAllNamed) {
+        // Try 3-char match first (longest wins)
+        const mid3 = trie3.get(c0);
+        if (mid3 !== undefined) {
+          const c1 = str.charCodeAt(i + 1);
+          const inner3 = mid3.get(c1);
+          if (inner3 !== undefined) {
+            const c2 = str.charCodeAt(i + 2);
+            const candidate = inner3.get(c2);
+            if (candidate !== undefined) { matchedEntity = candidate; advance = 3; }
+          }
         }
-      }
 
-      // Try 2-char match
-      if (matchedEntity === null) {
-        const inner2 = trie2.get(c0);
-        if (inner2 !== undefined) {
-          const c1 = str.charCodeAt(i + 1);
-          const candidate = inner2.get(c1);
-          if (candidate !== undefined) { matchedEntity = candidate; advance = 2; }
+        // Try 2-char match
+        if (matchedEntity === null) {
+          const inner2 = trie2.get(c0);
+          if (inner2 !== undefined) {
+            const c1 = str.charCodeAt(i + 1);
+            const candidate = inner2.get(c1);
+            if (candidate !== undefined) { matchedEntity = candidate; advance = 2; }
+          }
         }
-      }
 
-      // Try 1-char match
-      if (matchedEntity === null && encodeAllNamed) {
-        const candidate = trie1.get(c0);
-        if (candidate !== undefined) { matchedEntity = candidate; }
+        // Try 1-char match
+        if (matchedEntity === null) {
+          const candidate = trie1.get(c0);
+          if (candidate !== undefined) { matchedEntity = candidate; }
+        }
       }
 
       if (matchedEntity !== null) {
@@ -153,18 +196,20 @@ export default class EntityEncoder {
       let matchedEntity = null;
       let advance = 1;
 
-      if (i + 1 < len) {
-        const inner2 = trie2.get(c0);
-        if (inner2 !== undefined) {
-          const c1 = str.charCodeAt(i + 1);
-          const candidate = inner2.get(c1);
-          if (candidate !== undefined) { matchedEntity = candidate; advance = 2; }
+      if (encodeAllNamed) {
+        if (i + 1 < len) {
+          const inner2 = trie2.get(c0);
+          if (inner2 !== undefined) {
+            const c1 = str.charCodeAt(i + 1);
+            const candidate = inner2.get(c1);
+            if (candidate !== undefined) { matchedEntity = candidate; advance = 2; }
+          }
         }
-      }
 
-      if (matchedEntity === null && encodeAllNamed) {
-        const candidate = trie1.get(c0);
-        if (candidate !== undefined) { matchedEntity = candidate; }
+        if (matchedEntity === null) {
+          const candidate = trie1.get(c0);
+          if (candidate !== undefined) { matchedEntity = candidate; }
+        }
       }
 
       if (matchedEntity !== null) {

package/node_modules/@nodable/entities/src/all-entities.js

@@ -0,0 +1,53 @@
+// all-entities.js
+//
+// ALL_ENTITIES lives in its OWN module, deliberately separate from
+// entities.js. An object spread like `{ ...GREEK, ...CYRILLIC, ... }` is
+// treated conservatively by bundlers (esbuild, Rollup, webpack) as a
+// potential side effect — spreading can invoke getters or Symbol.iterator —
+// so a module containing such a spread cannot be safely tree-shaken. If that
+// spread lived inside entities.js alongside the individual category exports,
+// its mere presence would pin every category into any bundle that imports
+// even one of them, regardless of whether ALL_ENTITIES itself is ever used.
+//
+// Keeping it isolated here means:
+//   - `import { COMMON_HTML } from './entities.js'` tree-shakes cleanly —
+//     no other category is dragged in.
+//   - Only consumers who explicitly `import { ALL_ENTITIES } from
+//     './all-entities.js'` (re-exported from index.js for convenience) pay
+//     for the full merged set.
+
+import {
+  BASIC_LATIN,
+  LATIN_ACCENTS,
+  LATIN_EXTENDED,
+  GREEK,
+  CYRILLIC,
+  MATH,
+  MATH_ADVANCED,
+  ARROWS,
+  SHAPES,
+  PUNCTUATION,
+  CURRENCY,
+  FRACTIONS,
+  MISC_SYMBOLS,
+} from './entities.js';
+
+/**
+ * All entities combined (if you need everything).
+ * @type {Record<string, string>}
+ */
+export const ALL_ENTITIES = {
+  ...BASIC_LATIN,
+  ...LATIN_ACCENTS,
+  ...LATIN_EXTENDED,
+  ...GREEK,
+  ...CYRILLIC,
+  ...MATH,
+  ...MATH_ADVANCED,
+  ...ARROWS,
+  ...SHAPES,
+  ...PUNCTUATION,
+  ...CURRENCY,
+  ...FRACTIONS,
+  ...MISC_SYMBOLS,
+};

package/node_modules/@nodable/entities/src/entities.js

@@ -1104,26 +1104,6 @@ export const MISC_SYMBOLS = {
   nVDash: '⊯',
 };
 
-/**
- * All entities combined (if you need everything)
- * @type {Record<string, string>}
- */
-export const ALL_ENTITIES = {
-  ...BASIC_LATIN,
-  ...LATIN_ACCENTS,
-  ...LATIN_EXTENDED,
-  ...GREEK,
-  ...CYRILLIC,
-  ...MATH,
-  ...MATH_ADVANCED,
-  ...ARROWS,
-  ...SHAPES,
-  ...PUNCTUATION,
-  ...CURRENCY,
-  ...FRACTIONS,
-  ...MISC_SYMBOLS,
-};
-
 export const XML = {
   amp: "&",
   apos: "'",

package/node_modules/@nodable/entities/src/entityTries.js

@@ -1,49 +1,60 @@
 // entityTries.js
-// Builds integer-keyed tries so the decoder never allocates a string object
+// Builds integer-keyed tries so the encoder never allocates a string object
 // during lookup — every key is a plain charCode number.
 //
 // trie1: Map<code0, entity>
 // trie2: Map<code0, Map<code1, entity>>
 // trie3: Map<code0, Map<code1, Map<code2, entity>>>
+//
+// Trie construction is now a pure function, called on-demand by whoever
+// needs it (EntityEncoder, at instantiation time) instead of running
+// eagerly at module-import time against the full ALL_ENTITIES set. This
+// keeps the cost — and the entity data itself — out of any bundle/consumer
+// that never actually asks for it.
 
-import { ALL_ENTITIES } from './entities.js';
-
-// Reverse map: character sequence → "&name;"
-const CHAR_TO_ENTITY = new Map();
-for (const [name, chars] of Object.entries(ALL_ENTITIES)) {
-  CHAR_TO_ENTITY.set(chars, `&${name};`);
-}
-
-export const trie1 = new Map();   // code0          → entity string
-export const trie2 = new Map();   // code0 → Map    → entity string
-export const trie3 = new Map();   // code0 → Map → Map → entity string
+/**
+ * Build integer-keyed tries from a name → chars entity map.
+ * @param {Record<string, string>} entityMap
+ * @returns {{ trie1: Map, trie2: Map, trie3: Map }}
+ */
+export function buildTries(entityMap) {
+  const trie1 = new Map();   // code0          → entity string
+  const trie2 = new Map();   // code0 → Map    → entity string
+  const trie3 = new Map();   // code0 → Map → Map → entity string
 
-for (const [chars, entity] of CHAR_TO_ENTITY) {
-  const len = chars.length;
+  // Reverse map: character sequence → "&name;"
+  // (built inline, not kept around — only the tries need to survive)
+  for (const name in entityMap) {
+    const chars = entityMap[name];
+    const entity = `&${name};`;
+    const len = chars.length;
 
-  if (len === 1) {
-    const c0 = chars.charCodeAt(0);
-    // Keep shortest match only if no longer match already claimed this code
-    // (longer matches are inserted in the same pass so we just overwrite —
-    //  trie1 is only consulted after trie2/trie3 both miss, so no conflict)
-    trie1.set(c0, entity);
+    if (len === 1) {
+      const c0 = chars.charCodeAt(0);
+      // Keep shortest match only if no longer match already claimed this code
+      // (longer matches are inserted in the same pass so we just overwrite —
+      //  trie1 is only consulted after trie2/trie3 both miss, so no conflict)
+      trie1.set(c0, entity);
 
-  } else if (len === 2) {
-    const c0 = chars.charCodeAt(0);
-    const c1 = chars.charCodeAt(1);
-    let inner = trie2.get(c0);
-    if (inner === undefined) { inner = new Map(); trie2.set(c0, inner); }
-    inner.set(c1, entity);
+    } else if (len === 2) {
+      const c0 = chars.charCodeAt(0);
+      const c1 = chars.charCodeAt(1);
+      let inner = trie2.get(c0);
+      if (inner === undefined) { inner = new Map(); trie2.set(c0, inner); }
+      inner.set(c1, entity);
 
-  } else if (len === 3) {
-    const c0 = chars.charCodeAt(0);
-    const c1 = chars.charCodeAt(1);
-    const c2 = chars.charCodeAt(2);
-    let mid = trie3.get(c0);
-    if (mid === undefined) { mid = new Map(); trie3.set(c0, mid); }
-    let inner = mid.get(c1);
-    if (inner === undefined) { inner = new Map(); mid.set(c1, inner); }
-    inner.set(c2, entity);
+    } else if (len === 3) {
+      const c0 = chars.charCodeAt(0);
+      const c1 = chars.charCodeAt(1);
+      const c2 = chars.charCodeAt(2);
+      let mid = trie3.get(c0);
+      if (mid === undefined) { mid = new Map(); trie3.set(c0, mid); }
+      let inner = mid.get(c1);
+      if (inner === undefined) { inner = new Map(); mid.set(c1, inner); }
+      inner.set(c2, entity);
+    }
+    // HTML5 has no named entity whose character sequence is longer than 3 chars
   }
-  // HTML5 has no named entity whose character sequence is longer than 3 chars
-}
+
+  return { trie1, trie2, trie3 };
+}

package/node_modules/@nodable/entities/src/index.d.ts

@@ -61,12 +61,26 @@ export interface EntityEncoderOptions {
   encodeXmlSafe?: boolean;
 
   /**
-   * Whether to encode non‑ASCII characters (e.g. `é` → `é`) using the
-   * built‑in named entity trie.
+   * Whether to encode non‑ASCII characters (e.g. `é` → `é`) using a
+   * named entity trie. When `false`, no trie is built at all — cheapest option
+   * if you only need `encodeXmlSafe`.
    * @default true
    */
   encodeAllNamed?: boolean;
 
+  /**
+   * Restrict named-entity encoding to a specific set of entities instead of
+   * the full built-in `ALL_ENTITIES` table. Only meaningful when
+   * `encodeAllNamed` is `true` (the default). Passing a smaller set (e.g.
+   * `{ ...COMMON_HTML, ...CURRENCY }`) avoids building a trie for entity
+   * categories you never use.
+   *
+   * @default ALL_ENTITIES
+   * @example
+   * new EntityEncoder({ namedEntities: { ...COMMON_HTML, ...CURRENCY } });
+   */
+  namedEntities?: Record<string, string> | null;
+
   /**
    * Maximum number of replacements performed **cumulatively** across all
    * `encode()` calls. `0` means unlimited.

package/node_modules/@nodable/entities/src/index.js

@@ -10,7 +10,6 @@ export { default as EntityDecoder, ENTITY_ACTION } from './EntityDecoder.js';
 export {
   COMMON_HTML,
   XML,
-  ALL_ENTITIES,
   ARROWS,
   BASIC_LATIN,
   CURRENCY,
@@ -25,5 +24,6 @@ export {
   PUNCTUATION,
   SHAPES,
 } from './entities.js';
+export { ALL_ENTITIES } from './all-entities.js';
 
 export { default as EntityEncoder } from './EntityEncoder.js';