ng-form-foundry-transformers 0.4.0 → 0.4.1

package/README.md

@@ -294,6 +294,15 @@ npm test        # node:test on the compiled output (no Python needed)
 
 ## Status
 
+`0.4.1` — libconfig hardening after a conformance battle test against the C
+library's own scanner, test corpus, and real srsRAN/OAI configs: `0q`/`0Q`
+octal, verbatim radix-prefix preservation on edits, sign accepted on decimal
+literals only, negative edits into hex/bin/oct slots emit decimal, exact
+round-trips for collections mixing safe and beyond-2^53 integers, `null`
+rejected instead of written as `true`, a 256-level nesting cap, strict `\x`
+escapes, `@include` legal in value positions, and modified read-only carries
+throw instead of corrupting.
+
 `0.4.0` — version-alignment release with the workspace (the paired
 `ng-form-foundry` 0.4.0 adds appearance-driven field layout); no transformer
 changes.

package/dist/transformers/libconfig/parser.d.ts

@@ -13,9 +13,13 @@
  * (https://hyperrealm.github.io/libconfig/libconfig_manual.html); the grammar
  * covers: groups `{}`, arrays `[]` (homogeneous scalars), lists `()`
  * (heterogeneous), settings `name = value;` / `name : value` with an optional
- * `;`/`,` terminator, int (decimal/hex/binary/octal), int64 (`L`/`LL`
+ * `;`/`,` terminator, int (decimal, `0x` hex, `0b` binary, `0o`/`0q` octal —
+ * a sign is legal on decimal only, as in the C scanner), int64 (`L`/`LL`
  * suffix), float, bool (case-insensitive), strings with escapes and adjacent
- * literal concatenation, `#`/`//`/`/* *​/` comments, and `@include` lines.
+ * literal concatenation, `#`/`//`/`/* *​/` comments, and `@include` lines
+ * (handled as trivia, so they are legal anywhere the C scanner accepts them).
+ * Nesting is capped at {@link MAX_DEPTH} levels so hostile documents fail
+ * with a parse error instead of exhausting the JS stack.
  */
 /** Half-open source range of a node, in code-unit offsets. */
 export interface Span {
@@ -29,6 +33,8 @@ export interface IntMeta {
     suffix: string;
     /** Hex/binary/octal digit count of the literal, for width-preserving edits. */
     digits: number;
+    /** Radix prefix verbatim (`0x`, `0B`, `0q`, …), empty for decimal. */
+    prefix: string;
 }
 export type CfgValue = CfgScalar | CfgGroup | CfgArray | CfgList;
 export interface CfgScalar {

package/dist/transformers/libconfig/parser.js

@@ -14,9 +14,13 @@
  * (https://hyperrealm.github.io/libconfig/libconfig_manual.html); the grammar
  * covers: groups `{}`, arrays `[]` (homogeneous scalars), lists `()`
  * (heterogeneous), settings `name = value;` / `name : value` with an optional
- * `;`/`,` terminator, int (decimal/hex/binary/octal), int64 (`L`/`LL`
+ * `;`/`,` terminator, int (decimal, `0x` hex, `0b` binary, `0o`/`0q` octal —
+ * a sign is legal on decimal only, as in the C scanner), int64 (`L`/`LL`
  * suffix), float, bool (case-insensitive), strings with escapes and adjacent
- * literal concatenation, `#`/`//`/`/* *​/` comments, and `@include` lines.
+ * literal concatenation, `#`/`//`/`/* *​/` comments, and `@include` lines
+ * (handled as trivia, so they are legal anywhere the C scanner accepts them).
+ * Nesting is capped at {@link MAX_DEPTH} levels so hostile documents fail
+ * with a parse error instead of exhausting the JS stack.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LibconfigParseError = void 0;
@@ -33,18 +37,22 @@ class LibconfigParseError extends Error {
 }
 exports.LibconfigParseError = LibconfigParseError;
 const NAME_RE = /^[A-Za-z*][-A-Za-z0-9_*.]*/;
-const INT_RE = /^[-+]?(0[xX][0-9A-Fa-f]+|0[bB][01]+|0[oO][0-7]+|[0-9]+)(LL?)?/;
+// Like the C scanner: octal is `0o` or `0q`, and only decimal takes a sign.
+const INT_RE = /^(0[xX][0-9A-Fa-f]+|0[bB][01]+|0[oOqQ][0-7]+|[-+]?[0-9]+)(LL?)?/;
 const FLOAT_RE = /^[-+]?(([0-9]*\.[0-9]+|[0-9]+\.[0-9]*)([eE][-+]?[0-9]+)?|[0-9]+[eE][-+]?[0-9]+)/;
 const BOOL_RE = /^(true|false)(?![-A-Za-z0-9_*.])/i;
 /** Parse a libconfig document into its root group (spans index into `source`). */
 function parseLibconfig(source, options) {
     return new Parser(source, options?.includes ?? 'reject').parseRoot();
 }
+/** Deepest legal value nesting — far past real configs, well inside JS stack. */
+const MAX_DEPTH = 256;
 class Parser {
     constructor(src, includes) {
         this.src = src;
         this.includes = includes;
         this.pos = 0;
+        this.depth = 0;
     }
     parseRoot() {
         const settings = this.parseSettings(undefined);
@@ -67,10 +75,6 @@ class Parser {
             }
             if (closer && this.src[this.pos] === closer)
                 return settings;
-            if (this.src[this.pos] === '@') {
-                this.handleInclude();
-                continue;
-            }
             settings.push(this.parseSetting(settings));
         }
     }
@@ -94,14 +98,21 @@ class Parser {
         return { name, span: { start, end: this.pos }, value };
     }
     parseValue() {
-        const c = this.src[this.pos];
-        if (c === '{')
-            return this.parseGroup();
-        if (c === '[')
-            return this.parseCollection('[', ']', 'array');
-        if (c === '(')
-            return this.parseCollection('(', ')', 'list');
-        return this.parseScalar();
+        if (++this.depth > MAX_DEPTH)
+            this.fail(`nesting deeper than ${MAX_DEPTH} levels`);
+        try {
+            const c = this.src[this.pos];
+            if (c === '{')
+                return this.parseGroup();
+            if (c === '[')
+                return this.parseCollection('[', ']', 'array');
+            if (c === '(')
+                return this.parseCollection('(', ')', 'list');
+            return this.parseScalar();
+        }
+        finally {
+            this.depth--;
+        }
     }
     parseGroup() {
         const start = this.pos++;
@@ -181,15 +192,16 @@ class Parser {
         return this.fail('expected a value');
     }
     intScalar(lexeme, span) {
-        const sign = lexeme[0] === '-' ? '-' : '';
-        const unsigned = lexeme.replace(/^[-+]/, '');
-        const suffix = /LL?$/i.exec(unsigned)?.[0] ?? '';
-        const body = suffix ? unsigned.slice(0, -suffix.length) : unsigned;
-        const prefix = body.slice(0, 2).toLowerCase();
-        const radix = prefix === '0x' ? 16 : prefix === '0b' ? 2 : prefix === '0o' ? 8 : 10;
-        const digits = radix === 10 ? body : body.slice(2);
-        const big = BigInt(sign + (radix === 10 ? digits : body.slice(0, 2) + digits));
-        const meta = { radix, suffix, digits: digits.length };
+        const suffix = /LL?$/i.exec(lexeme)?.[0] ?? '';
+        const body = suffix ? lexeme.slice(0, -suffix.length) : lexeme;
+        const prefix = /^0[xXbBoOqQ]/.test(body) ? body.slice(0, 2) : '';
+        const p = prefix.toLowerCase();
+        const radix = p === '0x' ? 16 : p === '0b' ? 2 : p === '' ? 10 : 8;
+        const digits = prefix ? body.slice(2) : body.replace(/^[-+]/, '');
+        const sign = body[0] === '-' ? '-' : '';
+        // `0q`/`0O` normalize to a prefix BigInt understands; decimal keeps its sign.
+        const big = prefix ? BigInt((radix === 8 ? '0o' : p) + digits) : BigInt(sign + digits);
+        const meta = { radix, suffix, digits: digits.length, prefix };
         // Values past 2^53 ride as exact decimal strings (the core bigint strategy);
         // the suffix and radix stay in the metadata for the write-back.
         const safe = big >= BigInt(Number.MIN_SAFE_INTEGER) && big <= BigInt(Number.MAX_SAFE_INTEGER);
@@ -228,8 +240,11 @@ class Parser {
             }
             if (c === '\\') {
                 const esc = this.src[this.pos + 1];
-                if (esc === 'x') {
-                    out += String.fromCharCode(parseInt(this.src.slice(this.pos + 2, this.pos + 4), 16));
+                if (esc === 'x' || esc === 'X') {
+                    const hex = this.src.slice(this.pos + 2, this.pos + 4);
+                    if (!/^[0-9A-Fa-f]{2}$/.test(hex))
+                        this.fail('\\x escape needs two hex digits');
+                    out += String.fromCharCode(parseInt(hex, 16));
                     this.pos += 4;
                     continue;
                 }
@@ -253,7 +268,7 @@ class Parser {
         }
         this.pos = lineEnd === -1 ? this.src.length : lineEnd + 1;
     }
-    /** Skip whitespace and all three comment forms. */
+    /** Skip whitespace, all three comment forms, and `@include` lines. */
     skipTrivia() {
         for (;;) {
             const c = this.src[this.pos];
@@ -261,6 +276,12 @@ class Parser {
                 this.pos++;
                 continue;
             }
+            // The C scanner handles `@include` at token level, so it is legal in any
+            // trivia position (even between list elements), not just between settings.
+            if (c === '@' && this.src.startsWith('@include', this.pos)) {
+                this.handleInclude();
+                continue;
+            }
             if (c === '#' || (c === '/' && this.src[this.pos + 1] === '/')) {
                 const nl = this.src.indexOf('\n', this.pos);
                 this.pos = nl === -1 ? this.src.length : nl;

package/dist/transformers/libconfig/revert.js

@@ -21,7 +21,8 @@ function patchGroup(src, group, value, edits) {
         patchValue(src, setting.value, value[setting.name], edits);
     }
     const known = new Set(group.settings.map((s) => s.name));
-    const added = Object.keys(value ?? {}).filter((k) => !known.has(k));
+    // null/undefined means "absent", never a value: such keys are not added.
+    const added = Object.keys(value ?? {}).filter((k) => !known.has(k) && value[k] != null);
     if (added.length) {
         edits.push(insertionEdit(src, group, added.map((k) => `${k} = ${serialize(value[k], '')};`)));
     }
@@ -31,6 +32,10 @@ function patchValue(src, node, value, edits) {
         case 'scalar': {
             if (node.value === value)
                 return;
+            // The collection-wide bigint carry hands safe elements back as digit
+            // strings; a string spelling the same value is not an edit.
+            if (typeof value === 'string' && typeof node.value === 'number' && value === String(node.value))
+                return;
             edits.push({ ...node.span, text: emitScalar(value, node) });
             return;
         }
@@ -43,9 +48,13 @@ function patchValue(src, node, value, edits) {
         case 'array': {
             if (Array.isArray(value))
                 return patchElements(src, node.elements, node, value, edits);
-            // The read-only raw carry of an untyped empty array: leave verbatim.
-            if (typeof value === 'string' && value === (0, schema_1.raw)(node, src))
-                return;
+            // A string here is the read-only raw carry of an untyped empty array:
+            // unchanged it stays verbatim, edited it is an error, never a splice.
+            if (typeof value === 'string') {
+                if (value === (0, schema_1.raw)(node, src))
+                    return;
+                throw new Error('this collection is read-only (no element type to edit by): the edited text was not applied');
+            }
             edits.push({ ...node.span, text: serialize(value, '') });
             return;
         }
@@ -64,11 +73,15 @@ function patchValue(src, node, value, edits) {
                 }
                 return;
             }
-            // Heterogeneous (read-only raw carry) or unchanged empty: only replace on
-            // a genuine mismatch with a non-raw value shape — otherwise leave verbatim.
-            if (typeof value === 'string' && value === (0, schema_1.raw)(node, src))
-                return;
-            if (value !== undefined && typeof value !== 'string') {
+            // Heterogeneous (read-only raw carry) or unchanged empty: the carry
+            // stays verbatim, an edited carry is an error, a non-string value is a
+            // genuine shape change and regenerates.
+            if (typeof value === 'string') {
+                if (value === (0, schema_1.raw)(node, src))
+                    return;
+                throw new Error('this list is read-only (heterogeneous): the edited text was not applied');
+            }
+            if (value !== undefined) {
                 edits.push({ ...node.span, text: serialize(value, '') });
             }
             return;
@@ -146,11 +159,17 @@ function emitScalar(value, node) {
     if (typeof value === 'boolean')
         return value ? 'true' : 'false';
     if (typeof value === 'string') {
-        // The int64 string carry: exact digits back, with the original suffix.
-        if (node.type === 'int64' && typeof node.value === 'string') {
+        if (node.type === 'int' || node.type === 'int64') {
             if (!/^[-+]?[0-9]+$/.test(value)) {
-                throw new Error(`'${value}' is not an integer: this setting carries a 64-bit integer as a string`);
+                throw new Error(`'${value}' is not an integer: this setting is integer-typed`);
             }
+            // The int64 string carry: exact digits back, with the original suffix.
+            if (typeof node.value === 'string')
+                return value + (node.int?.suffix ?? '');
+            // A safe element of a carried collection: back to its own literal style.
+            const n = Number(value);
+            if (Number.isSafeInteger(n))
+                return intLiteral(n, node.int);
             return value + (node.int?.suffix ?? '');
         }
         return quote(value);
@@ -165,13 +184,17 @@ function emitScalar(value, node) {
     }
     return serialize(value, '');
 }
-/** Integer in the source's radix and width, suffix preserved. */
+/**
+ * Integer in the source's radix, width, and prefix spelling, suffix preserved.
+ * Negatives always emit decimal: the C scanner accepts no sign on a
+ * hex/binary/octal literal, so `-0x1A` would not load.
+ */
 function intLiteral(value, meta) {
-    if (!meta || meta.radix === 10)
+    if (!meta || meta.radix === 10 || value < 0)
         return String(value) + (meta?.suffix ?? '');
-    const prefix = meta.radix === 16 ? '0x' : meta.radix === 2 ? '0b' : '0o';
-    const digits = Math.abs(value).toString(meta.radix).toUpperCase().padStart(meta.digits, '0');
-    return (value < 0 ? '-' : '') + prefix + digits + meta.suffix;
+    const prefix = meta.prefix || (meta.radix === 16 ? '0x' : meta.radix === 2 ? '0b' : '0o');
+    const digits = value.toString(meta.radix).toUpperCase().padStart(meta.digits, '0');
+    return prefix + digits + meta.suffix;
 }
 /** A float literal that stays a float: integral values gain `.0`. */
 function floatLiteral(value) {
@@ -206,9 +229,13 @@ function quote(value) {
  * grown collection). Typing is value-driven here: integral numbers emit as
  * ints, fractional as floats — a host that needs a float-typed `21.0` for a
  * fresh setting should send `21.0`-producing edits through an existing float
- * slot or accept the int typing (documented beta limitation).
+ * slot or accept the int typing. null/undefined have no libconfig literal
+ * and throw.
  */
 function serialize(value, indent) {
+    if (value == null) {
+        throw new Error('null/undefined has no libconfig representation: omit the setting instead');
+    }
     if (typeof value === 'boolean')
         return value ? 'true' : 'false';
     if (typeof value === 'number')
@@ -226,7 +253,7 @@ function serialize(value, indent) {
             .join(' ');
         return `{ ${body} }`;
     }
-    return 'true'; // null/undefined have no libconfig literal; unreachable via typed forms
+    throw new Error(`a ${typeof value} value has no libconfig representation`);
 }
 /** An integer string that exceeds the double-safe range (the bigint carry). */
 function isBigIntString(value) {

package/dist/transformers/libconfig/schema.js

@@ -149,12 +149,15 @@ function listShape(list) {
 }
 /** Read-only leaf carrying the collection's verbatim source text. */
 function rawLeaf(name, why) {
+    const hint = why === 'empty collection'
+        ? 'Provide a JSON Schema to type its elements and make it editable.'
+        : 'It stays read-only: no single element type exists to edit by.';
     return {
         kind: 'leaf',
         name,
         type: 'string',
         readOnly: true,
-        description: `Shown verbatim (${why}): libconfig gives no element type to edit by. Provide a JSON Schema to make it editable.`,
+        description: `Shown verbatim (${why}). ${hint}`,
     };
 }
 /** The verbatim source slice of a node. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-form-foundry-transformers",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Framework-agnostic Node + TypeScript catalog of source-format transformers: turn a YANG model (and more) into an ng-form-foundry schema and revert the edited form value back to the source format.",
   "keywords": [
     "ng-form-foundry",