@o3co/ts.hocon 1.12.0 → 1.14.0

package/dist/adapters/json5.cjs

@@ -0,0 +1,496 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkGBNQADHTcjs = require('../chunk-GBNQADHT.cjs');
+
+
+
+
+
+var _chunkRO4D6BH7cjs = require('../chunk-RO4D6BH7.cjs');
+
+// src/adapters/json5.ts
+function parseJson5(input, originDescription) {
+  const p = new Parser(_chunkRO4D6BH7cjs.stripBom.call(void 0, input), originDescription);
+  const doc = _chunkRO4D6BH7cjs.guardStackDepth.call(void 0, 
+    () => p.parseDocument(),
+    (msg) => _chunkRO4D6BH7cjs.depthError.call(void 0, `json5: ${describe(originDescription)}: ${msg}`)
+  );
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
+      `json5: ${describe(originDescription)}: document root is ${rootKind(doc)}, but a config root must be an object (spec F0.3)`,
+      ""
+    );
+  }
+  return _chunkGBNQADHTcjs.fromMap.call(void 0, doc, originDescription);
+}
+function describe(origin) {
+  return origin === void 0 || origin === "" ? "document" : origin;
+}
+function rootKind(doc) {
+  if (doc === null) return "null";
+  if (Array.isArray(doc)) return "an array";
+  return typeof doc;
+}
+var INT64_MAX = 9223372036854775807n;
+var INT64_MIN = -9223372036854775808n;
+function isLineTerminator(cp) {
+  return cp === 10 || cp === 13 || cp === 8232 || cp === 8233;
+}
+var ZS_RE = /^\p{Zs}$/u;
+function isJson5Space(cp) {
+  switch (cp) {
+    case 9:
+    case 11:
+    case 12:
+    case 32:
+    case 160:
+    case 65279:
+      return true;
+    default:
+      return ZS_RE.test(String.fromCodePoint(cp));
+  }
+}
+var IDENT_START_RE = /^[\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Lo}\p{Nl}]$/u;
+var IDENT_PART_EXTRA_RE = /^[\p{Mn}\p{Mc}\p{Nd}\p{Pc}]$/u;
+function isIdentStart(cp) {
+  return cp === 36 || cp === 95 || IDENT_START_RE.test(String.fromCodePoint(cp));
+}
+function isIdentPart(cp) {
+  return isIdentStart(cp) || cp === 8204 || cp === 8205 || IDENT_PART_EXTRA_RE.test(String.fromCodePoint(cp));
+}
+function continuesIdentifier(s, i) {
+  if (i >= s.length) return false;
+  return isIdentPart(s.codePointAt(i));
+}
+function isHexDigit(c) {
+  return c >= "0" && c <= "9" || c >= "a" && c <= "f" || c >= "A" && c <= "F";
+}
+var hex4 = (cp) => cp.toString(16).toUpperCase().padStart(4, "0");
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeObjects(dst, src) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [k, v] of Object.entries(dst)) out[k] = v;
+  for (const [k, v] of Object.entries(src)) {
+    const prev = k in out ? out[k] : void 0;
+    if (prev !== void 0 && isPlainObject(prev) && isPlainObject(v)) {
+      out[k] = mergeObjects(prev, v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var Parser = class {
+  // code unit offset where the current line starts
+  constructor(src, origin) {
+    this.src = src;
+    this.origin = origin;
+    this.pos = 0;
+    // UTF-16 code unit offset
+    this.line = 0;
+    // 0-based; reported 1-based
+    this.lineAt = 0;
+  }
+  errf(msg) {
+    const col = [...this.src.slice(this.lineAt, this.pos)].length + 1;
+    return new (0, _chunkRO4D6BH7cjs.ConfigError)(
+      `json5: ${describe(this.origin)}: line ${this.line + 1} col ${col}: ${msg}`,
+      ""
+    );
+  }
+  /** The code point at `pos` (caller guarantees `pos < src.length`). */
+  rune() {
+    const cp = this.src.codePointAt(this.pos);
+    return { cp, size: cp > 65535 ? 2 : 1 };
+  }
+  advance(cp, size) {
+    this.pos += size;
+    if (isLineTerminator(cp)) {
+      if (cp === 13 && this.src[this.pos] === "\n") this.pos++;
+      this.line++;
+      this.lineAt = this.pos;
+    }
+  }
+  /**
+   * Parse exactly one JSON5 value, allowing only whitespace and comments after
+   * it (the F3.2 strictness rule).
+   */
+  parseDocument() {
+    this.skipSpace();
+    const v = this.parseValue();
+    this.skipSpace();
+    if (this.pos < this.src.length) {
+      throw this.errf("unexpected content after top-level value");
+    }
+    return v;
+  }
+  /** Consume whitespace, line terminators, and both comment forms. */
+  skipSpace() {
+    while (this.pos < this.src.length) {
+      const { cp, size } = this.rune();
+      if (isJson5Space(cp) || isLineTerminator(cp)) {
+        this.advance(cp, size);
+        continue;
+      }
+      if (cp === 47 && this.src[this.pos + 1] === "/") {
+        this.pos += 2;
+        while (this.pos < this.src.length) {
+          const cp2 = this.src.codePointAt(this.pos);
+          if (isLineTerminator(cp2)) break;
+          this.pos += cp2 > 65535 ? 2 : 1;
+        }
+        continue;
+      }
+      if (cp === 47 && this.src[this.pos + 1] === "*") {
+        this.pos += 2;
+        let closed = false;
+        while (this.pos < this.src.length) {
+          const r2 = this.rune();
+          if (r2.cp === 42 && this.src[this.pos + 1] === "/") {
+            this.pos += 2;
+            closed = true;
+            break;
+          }
+          this.advance(r2.cp, r2.size);
+        }
+        if (!closed) throw this.errf("unterminated /* comment");
+        continue;
+      }
+      return;
+    }
+  }
+  parseValue() {
+    if (this.pos >= this.src.length) {
+      throw this.errf("unexpected end of input, expected a value");
+    }
+    const c = this.src[this.pos];
+    if (c === "{") return this.parseObject();
+    if (c === "[") return this.parseArray();
+    if (c === '"' || c === "'") return this.parseString(c);
+    if (c === "+" || c === "-" || c === "." || c >= "0" && c <= "9") return this.parseNumber();
+    return this.parseKeyword();
+  }
+  /**
+   * Handle true/false/null, and reject Infinity/NaN by name so the error
+   * explains itself (spec F0.6).
+   */
+  parseKeyword() {
+    const rest = this.src.slice(this.pos);
+    for (const [kw, v] of [
+      ["true", true],
+      ["false", false],
+      ["null", null]
+    ]) {
+      if (rest.startsWith(kw) && !continuesIdentifier(rest, kw.length)) {
+        this.pos += kw.length;
+        return v;
+      }
+    }
+    for (const kw of ["Infinity", "NaN"]) {
+      if (rest.startsWith(kw) && !continuesIdentifier(rest, kw.length)) {
+        throw this.errf(`${kw} is not representable in the HOCON number model (spec F0.6)`);
+      }
+    }
+    const first = String.fromCodePoint(rest.codePointAt(0));
+    throw this.errf(`unexpected character ${JSON.stringify(first)}`);
+  }
+  // ── Objects and arrays ──────────────────────────────────────────────────────
+  parseObject() {
+    this.pos++;
+    const obj = /* @__PURE__ */ Object.create(null);
+    for (; ; ) {
+      this.skipSpace();
+      if (this.pos >= this.src.length) throw this.errf("unterminated object, expected '}'");
+      if (this.src[this.pos] === "}") {
+        this.pos++;
+        return obj;
+      }
+      const key = this.parseMemberName();
+      this.skipSpace();
+      if (this.pos >= this.src.length || this.src[this.pos] !== ":") {
+        throw this.errf(`expected ':' after object key ${JSON.stringify(key)}`);
+      }
+      this.pos++;
+      this.skipSpace();
+      let val = this.parseValue();
+      if (key in obj) {
+        const prev = obj[key];
+        if (isPlainObject(prev) && isPlainObject(val)) val = mergeObjects(prev, val);
+      }
+      obj[key] = val;
+      this.skipSpace();
+      if (this.pos >= this.src.length) throw this.errf("unterminated object, expected ',' or '}'");
+      const c = this.src[this.pos];
+      if (c === ",") {
+        this.pos++;
+      } else if (c === "}") {
+        this.pos++;
+        return obj;
+      } else {
+        throw this.errf("expected ',' or '}' in object");
+      }
+    }
+  }
+  parseArray() {
+    this.pos++;
+    const arr = [];
+    for (; ; ) {
+      this.skipSpace();
+      if (this.pos >= this.src.length) throw this.errf("unterminated array, expected ']'");
+      if (this.src[this.pos] === "]") {
+        this.pos++;
+        return arr;
+      }
+      arr.push(this.parseValue());
+      this.skipSpace();
+      if (this.pos >= this.src.length) throw this.errf("unterminated array, expected ',' or ']'");
+      const c = this.src[this.pos];
+      if (c === ",") {
+        this.pos++;
+      } else if (c === "]") {
+        this.pos++;
+        return arr;
+      } else {
+        throw this.errf("expected ',' or ']' in array");
+      }
+    }
+  }
+  // ── Member names (quoted or ES5 IdentifierName) ─────────────────────────────
+  parseMemberName() {
+    const c = this.src[this.pos];
+    if (c === '"' || c === "'") return this.parseString(c);
+    return this.parseIdentifier();
+  }
+  /**
+   * Scan an ES5 IdentifierName, honouring `\uXXXX` escapes in the name (the
+   * escaped codepoint must itself be a legal identifier character for its
+   * position, per ES5 — `1` cannot start a key).
+   */
+  parseIdentifier() {
+    let name = "";
+    let first = true;
+    while (this.pos < this.src.length) {
+      const r = this.rune();
+      let cp = r.cp;
+      let escaped = false;
+      if (cp === 92) {
+        if (this.src[this.pos + 1] !== "u") {
+          throw this.errf("only \\uXXXX escapes are allowed in identifiers");
+        }
+        this.pos += 2;
+        cp = this.readHex4();
+        escaped = true;
+      }
+      const legal = first ? isIdentStart(cp) : isIdentPart(cp);
+      if (!legal) {
+        if (escaped) {
+          throw this.errf(`escape \\u${hex4(cp)} is not a valid identifier character here`);
+        }
+        if (first) {
+          throw this.errf(`expected an object key, got ${JSON.stringify(String.fromCodePoint(cp))}`);
+        }
+        break;
+      }
+      name += String.fromCodePoint(cp);
+      if (!escaped) this.pos += r.size;
+      first = false;
+    }
+    if (name.length === 0) throw this.errf("expected an object key");
+    return name;
+  }
+  /** Read exactly four hex digits at `pos` and return the code point. */
+  readHex4() {
+    if (this.pos + 4 > this.src.length) throw this.errf("truncated \\u escape");
+    const quad = this.src.slice(this.pos, this.pos + 4);
+    if (!/^[0-9a-fA-F]{4}$/.test(quad)) {
+      throw this.errf(`invalid \\u escape ${JSON.stringify("\\u" + quad)}`);
+    }
+    this.pos += 4;
+    return parseInt(quad, 16);
+  }
+  // ── Strings ─────────────────────────────────────────────────────────────────
+  /**
+   * Scan a single- or double-quoted JSON5 string. `quote` is the opening quote
+   * character. JSON5 differences from JSON: either quote character, `\xHH`
+   * escapes, `\v`, `\0`, line continuations (backslash before a line
+   * terminator, including CRLF as one), any other non-digit character escaping
+   * to itself, and unescaped LS/PS allowed inside the string.
+   */
+  parseString(quote) {
+    this.pos++;
+    let out = "";
+    for (; ; ) {
+      if (this.pos >= this.src.length) throw this.errf("unterminated string");
+      const { cp, size } = this.rune();
+      if (this.src[this.pos] === quote) {
+        this.pos++;
+        return out;
+      }
+      if (cp === 10 || cp === 13) {
+        throw this.errf("unescaped line terminator in string");
+      }
+      if (cp === 92) {
+        this.pos++;
+        out += this.readEscape();
+        continue;
+      }
+      out += this.src.slice(this.pos, this.pos + size);
+      this.advance(cp, size);
+    }
+  }
+  /**
+   * Consume one escape sequence (the backslash is already consumed) and return
+   * its value.
+   */
+  readEscape() {
+    if (this.pos >= this.src.length) throw this.errf("unterminated escape sequence");
+    const { cp, size } = this.rune();
+    if (isLineTerminator(cp)) {
+      this.advance(cp, size);
+      return "";
+    }
+    const ch = String.fromCodePoint(cp);
+    switch (ch) {
+      case "n":
+        this.pos++;
+        return "\n";
+      case "t":
+        this.pos++;
+        return "	";
+      case "r":
+        this.pos++;
+        return "\r";
+      case "b":
+        this.pos++;
+        return "\b";
+      case "f":
+        this.pos++;
+        return "\f";
+      case "v":
+        this.pos++;
+        return "\v";
+      case "0": {
+        const next = this.src[this.pos + 1];
+        if (next !== void 0 && next >= "0" && next <= "9") {
+          throw this.errf("octal escape sequences are not allowed");
+        }
+        this.pos++;
+        return "\0";
+      }
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9":
+        throw this.errf(`escape \\${ch} is not allowed (digits cannot be escaped)`);
+      case "x": {
+        this.pos++;
+        if (this.pos + 2 > this.src.length) throw this.errf("truncated \\x escape");
+        const hh = this.src.slice(this.pos, this.pos + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(hh)) throw this.errf("invalid \\x escape");
+        this.pos += 2;
+        return String.fromCharCode(parseInt(hh, 16));
+      }
+      case "u": {
+        this.pos++;
+        const hi = this.readHex4();
+        if (hi >= 55296 && hi <= 57343) {
+          if (this.pos + 6 <= this.src.length && this.src[this.pos] === "\\" && this.src[this.pos + 1] === "u") {
+            this.pos += 2;
+            const lo = this.readHex4();
+            if (hi <= 56319 && lo >= 56320 && lo <= 57343) {
+              return String.fromCodePoint(65536 + (hi - 55296 << 10) + (lo - 56320));
+            }
+            throw this.errf(`unpaired \\u${hex4(hi)} surrogate (spec F3.5)`);
+          }
+          throw this.errf(`unpaired \\u${hex4(hi)} surrogate (spec F3.5)`);
+        }
+        return String.fromCharCode(hi);
+      }
+      default:
+        this.advance(cp, size);
+        return ch;
+    }
+  }
+  // ── Numbers ─────────────────────────────────────────────────────────────────
+  /**
+   * Scan a JSON5 numeric literal: optional sign, then a hex integer or a
+   * decimal with optional leading/trailing point and exponent. Signed
+   * Infinity/NaN are routed to the F0.6 error here.
+   */
+  parseNumber() {
+    const start = this.pos;
+    let neg = false;
+    const sign = this.src[this.pos];
+    if (sign === "+" || sign === "-") {
+      neg = sign === "-";
+      this.pos++;
+    }
+    const rest = this.src.slice(this.pos);
+    for (const kw of ["Infinity", "NaN"]) {
+      if (rest.startsWith(kw) && !continuesIdentifier(rest, kw.length)) {
+        throw this.errf(`${kw} is not representable in the HOCON number model (spec F0.6)`);
+      }
+    }
+    if (rest.startsWith("0x") || rest.startsWith("0X")) {
+      this.pos += 2;
+      const ds = this.pos;
+      while (this.pos < this.src.length && isHexDigit(this.src[this.pos])) this.pos++;
+      if (this.pos === ds) throw this.errf("hex literal needs at least one digit");
+      const mag = BigInt("0x" + this.src.slice(ds, this.pos));
+      const limit = neg ? 1n << 63n : (1n << 63n) - 1n;
+      if (mag > limit) {
+        throw this.errf(`integer ${this.src.slice(start, this.pos)} does not fit in int64 (spec F0.5)`);
+      }
+      if (neg && mag === 0n) return -0;
+      return integerValue(neg ? -mag : mag);
+    }
+    let sawDigit = false;
+    let sawDot = false;
+    let sawExp = false;
+    while (this.pos < this.src.length) {
+      const c = this.src[this.pos];
+      if (c >= "0" && c <= "9") {
+        sawDigit = true;
+      } else if (c === "." && !sawDot && !sawExp) {
+        sawDot = true;
+      } else if ((c === "e" || c === "E") && sawDigit && !sawExp) {
+        sawExp = true;
+        const n = this.src[this.pos + 1];
+        if (n === "+" || n === "-") this.pos++;
+      } else {
+        break;
+      }
+      this.pos++;
+    }
+    const text = this.src.slice(start, this.pos);
+    if (!sawDigit) throw this.errf(`malformed number ${JSON.stringify(text)}`);
+    if (sawDot || sawExp) {
+      const f = Number(text);
+      if (Number.isNaN(f) || !Number.isFinite(f)) {
+        throw this.errf(`malformed number ${JSON.stringify(text)}`);
+      }
+      return f;
+    }
+    const digits = text.startsWith("+") ? text.slice(1) : text;
+    const i = BigInt(digits);
+    if (i > INT64_MAX || i < INT64_MIN) {
+      throw this.errf(`integer ${text} does not fit in int64 (spec F0.5)`);
+    }
+    if (i >= -9007199254740991n && i <= 9007199254740991n) return Number(digits);
+    return i;
+  }
+};
+function integerValue(v) {
+  if (v >= -9007199254740991n && v <= 9007199254740991n) return Number(v);
+  return v;
+}
+
+
+exports.parseJson5 = parseJson5;

package/dist/adapters/json5.d.cts

@@ -0,0 +1,47 @@
+import { C as Config } from '../config-OccaKqXu.cjs';
+
+/**
+ * Read JSON5 (https://json5.org, spec 1.0.0) as HOCON config.
+ *
+ * Unlike the jsonc adapter — which strips comments and hands the rest to
+ * `JSON.parse` — JSON5 changes the token grammar itself (unquoted identifier
+ * keys, single-quoted strings with line continuations, hex integers, leading
+ * and trailing decimal points, an explicit plus sign), so this adapter is a
+ * hand-rolled scanner and recursive-descent parser. Zero dependencies, like
+ * every adapter in this package; it is a port of go.hocon's `adapters/json5`.
+ *
+ * The accepted grammar is JSON5 1.0.0 as defined by the reference
+ * implementation (the json5 npm package), the dialect owner this spec item
+ * tracks — the same ownership rule F3.2 applies to JSONC. That is why a `//`
+ * comment here ends at LS/PS as well as LF/CR, while the jsonc adapter's runs
+ * through them: each dialect's owner decides. Where the mapping spec is
+ * stricter than JSON5, the spec wins:
+ *
+ *   - `Infinity` and `NaN` (signed or bare) are errors, not values (spec F0.6).
+ *   - Integers — decimal or hex — must fit in int64 (spec F0.5); a number
+ *     written with `.`, `e` or `E` is a float, all other decimal forms and
+ *     every hex form are integers. An integer past 2^53 is carried as a
+ *     `bigint` so its digits survive verbatim (`getString` returns them
+ *     exactly); `getNumber` and `toObject` still apply the JS number model,
+ *     as they do for HOCON's own literals.
+ *   - An unpaired `\uXXXX` surrogate **escape** is an error, and a valid pair
+ *     combines into the astral codepoint (spec F3.5). This deliberately
+ *     differs from the jsonc adapter, which accepts one: there `JSON.parse` —
+ *     the host language's own decoder — owns the escape, and refusing would be
+ *     the spec overriding the platform (the S1.2.6 class). Here the scanner is
+ *     ours, so the four implementations can and do agree. A lone surrogate
+ *     *code unit* sitting raw in the source string is still accepted as data —
+ *     a JavaScript string is UTF-16 and holds it natively; go.hocon's
+ *     equivalent check rejects invalid UTF-8 bytes, a case that cannot arise
+ *     in a JS string.
+ *   - Duplicate keys follow HOCON semantics: objects merge, otherwise the
+ *     later value wins (spec F0.7).
+ *   - The document holds exactly one value; whitespace and comments may follow
+ *     it, anything else is an error (the F3.2 strictness rule).
+ *
+ * See the F3.x items in the format-ingestion mapping spec:
+ * https://github.com/o3co/xx.hocon/blob/main/docs/format-ingestion-mapping.md
+ */
+declare function parseJson5(input: string, originDescription?: string): Config;
+
+export { parseJson5 };

package/dist/adapters/json5.d.ts

@@ -0,0 +1,47 @@
+import { C as Config } from '../config-OccaKqXu.js';
+
+/**
+ * Read JSON5 (https://json5.org, spec 1.0.0) as HOCON config.
+ *
+ * Unlike the jsonc adapter — which strips comments and hands the rest to
+ * `JSON.parse` — JSON5 changes the token grammar itself (unquoted identifier
+ * keys, single-quoted strings with line continuations, hex integers, leading
+ * and trailing decimal points, an explicit plus sign), so this adapter is a
+ * hand-rolled scanner and recursive-descent parser. Zero dependencies, like
+ * every adapter in this package; it is a port of go.hocon's `adapters/json5`.
+ *
+ * The accepted grammar is JSON5 1.0.0 as defined by the reference
+ * implementation (the json5 npm package), the dialect owner this spec item
+ * tracks — the same ownership rule F3.2 applies to JSONC. That is why a `//`
+ * comment here ends at LS/PS as well as LF/CR, while the jsonc adapter's runs
+ * through them: each dialect's owner decides. Where the mapping spec is
+ * stricter than JSON5, the spec wins:
+ *
+ *   - `Infinity` and `NaN` (signed or bare) are errors, not values (spec F0.6).
+ *   - Integers — decimal or hex — must fit in int64 (spec F0.5); a number
+ *     written with `.`, `e` or `E` is a float, all other decimal forms and
+ *     every hex form are integers. An integer past 2^53 is carried as a
+ *     `bigint` so its digits survive verbatim (`getString` returns them
+ *     exactly); `getNumber` and `toObject` still apply the JS number model,
+ *     as they do for HOCON's own literals.
+ *   - An unpaired `\uXXXX` surrogate **escape** is an error, and a valid pair
+ *     combines into the astral codepoint (spec F3.5). This deliberately
+ *     differs from the jsonc adapter, which accepts one: there `JSON.parse` —
+ *     the host language's own decoder — owns the escape, and refusing would be
+ *     the spec overriding the platform (the S1.2.6 class). Here the scanner is
+ *     ours, so the four implementations can and do agree. A lone surrogate
+ *     *code unit* sitting raw in the source string is still accepted as data —
+ *     a JavaScript string is UTF-16 and holds it natively; go.hocon's
+ *     equivalent check rejects invalid UTF-8 bytes, a case that cannot arise
+ *     in a JS string.
+ *   - Duplicate keys follow HOCON semantics: objects merge, otherwise the
+ *     later value wins (spec F0.7).
+ *   - The document holds exactly one value; whitespace and comments may follow
+ *     it, anything else is an error (the F3.2 strictness rule).
+ *
+ * See the F3.x items in the format-ingestion mapping spec:
+ * https://github.com/o3co/xx.hocon/blob/main/docs/format-ingestion-mapping.md
+ */
+declare function parseJson5(input: string, originDescription?: string): Config;
+
+export { parseJson5 };