@o3co/ts.hocon 1.12.0 → 1.14.0

package/dist/chunk-GBNQADHT.cjs

@@ -0,0 +1,83 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkRO4D6BH7cjs = require('./chunk-RO4D6BH7.cjs');
+
+// src/value-factory.ts
+function fromMap(values, originDescription) {
+  const fields = _chunkRO4D6BH7cjs.guardStackDepth.call(void 0, 
+    () => coerceObject(values, ""),
+    (msg) => _chunkRO4D6BH7cjs.depthError.call(void 0, `fromMap: ${msg}`)
+  );
+  const root = { kind: "object", fields };
+  return _chunkRO4D6BH7cjs.Config._fromResolvedValue(root, { originDescription });
+}
+function empty(originDescription) {
+  const root = { kind: "object", fields: /* @__PURE__ */ new Map() };
+  return _chunkRO4D6BH7cjs.Config._fromResolvedValue(root, { originDescription });
+}
+var INT64_MAX = 9223372036854775807n;
+var INT64_MIN = -9223372036854775808n;
+function coerceObject(obj, atPath) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(obj)) {
+    const childPath = atPath ? `${atPath}.${k}` : k;
+    fields.set(k, coerceValue(v, childPath));
+  }
+  return fields;
+}
+function coerceValue(v, atPath) {
+  if (v === null) {
+    return { kind: "scalar", raw: "null", valueType: "null" };
+  }
+  if (v === void 0) {
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
+      `fromMap: undefined is not a valid HOCON value at path "${atPath}"`,
+      atPath
+    );
+  }
+  switch (typeof v) {
+    case "string":
+      return { kind: "scalar", raw: v, valueType: "string" };
+    case "number": {
+      if (Number.isNaN(v) || !Number.isFinite(v)) {
+        throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
+          `fromMap: ${v} is not representable in HOCON (NaN/Infinity not allowed) at path "${atPath}"`,
+          atPath
+        );
+      }
+      return { kind: "scalar", raw: Object.is(v, -0) ? "-0" : String(v), valueType: "number" };
+    }
+    case "boolean":
+      return { kind: "scalar", raw: v ? "true" : "false", valueType: "boolean" };
+    case "bigint": {
+      if (v > INT64_MAX || v < INT64_MIN) {
+        throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
+          `fromMap: integer ${v} is out of int64 range (HOCON integers are int64; spec F0.5) at path "${atPath}"`,
+          atPath
+        );
+      }
+      return { kind: "scalar", raw: String(v), valueType: "number" };
+    }
+    case "object": {
+      if (Array.isArray(v)) {
+        const items = v.map((item, i) => coerceValue(item, `${atPath}[${i}]`));
+        return { kind: "array", items };
+      }
+      const fields = coerceObject(v, atPath);
+      return { kind: "object", fields };
+    }
+    default:
+      throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
+        `fromMap: unsupported value type "${typeof v}" at path "${atPath}"`,
+        atPath
+      );
+  }
+}
+
+
+
+
+exports.fromMap = fromMap; exports.empty = empty;

package/dist/chunk-IMJ7QHIK.cjs

@@ -0,0 +1,158 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkRO4D6BH7cjs = require('./chunk-RO4D6BH7.cjs');
+
+// src/parse.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+function defaultParseOptions() {
+  return { resolveSubstitutions: true };
+}
+function defaultResolveOptions() {
+  return { useSystemEnvironment: true, allowUnresolved: false };
+}
+function getEnv(opts) {
+  if (opts.env !== void 0) return opts.env;
+  if (typeof process !== "undefined" && process.env) return process.env;
+  return {};
+}
+function defaultReadFileSync(filePath) {
+  return fs.readFileSync(filePath, "utf-8");
+}
+async function defaultReadFile(filePath) {
+  return fs.promises.readFile(filePath, "utf-8");
+}
+function buildResolveContext(input, opts) {
+  const tokens = _chunkRO4D6BH7cjs.tokenize.call(void 0, input);
+  const ast = _chunkRO4D6BH7cjs.parseTokens.call(void 0, tokens);
+  if (ast.kind === "array") {
+    const origin = _nullishCoalesce(opts.originDescription, () => ( "input"));
+    throw new (0, _chunkRO4D6BH7cjs.ConfigError)(
+      `${origin}: ${ast.pos.line}:${ast.pos.col}: document has type array rather than object at file root (HOCON.md L989-991); the Config API requires an object root`,
+      ""
+    );
+  }
+  const resolveOpts = {
+    env: getEnv(opts),
+    baseDir: opts.baseDir,
+    readFileSync: _nullishCoalesce(opts.readFileSync, () => ( defaultReadFileSync)),
+    readFile: opts.readFile,
+    originDescription: opts.originDescription,
+    resolveFrom: opts.resolveFrom,
+    packageResolver: opts.packageResolver
+  };
+  return { ast, resolveOpts };
+}
+function parse(input, opts = {}) {
+  return parseStringWithOptions(input, opts);
+}
+var parseString = parse;
+function parseStringWithOptions(input, opts = {}) {
+  return _chunkRO4D6BH7cjs.guardStackDepth.call(void 0, 
+    () => parseStringInner(input, opts),
+    (msg) => new (0, _chunkRO4D6BH7cjs.ParseError)(msg, 1, 1, opts.originDescription)
+  );
+}
+function parseStringInner(input, opts) {
+  const resolveSubstitutions = _nullishCoalesce(opts.resolveSubstitutions, () => ( true));
+  const { ast, resolveOpts } = buildResolveContext(input, opts);
+  if (resolveSubstitutions) {
+    const value = _chunkRO4D6BH7cjs.resolve.call(void 0, ast, resolveOpts);
+    if (value.kind !== "object") throw new Error("resolved value is not an object");
+    return new (0, _chunkRO4D6BH7cjs.Config)(value, { resolved: true, originDescription: opts.originDescription });
+  }
+  const tree = _chunkRO4D6BH7cjs.buildTree.call(void 0, ast, resolveOpts);
+  const hasPlaceholders = _chunkRO4D6BH7cjs.containsPlaceholders.call(void 0, tree);
+  return _chunkRO4D6BH7cjs.Config._fromUnresolvedResObj(tree, {
+    parseBaseDir: opts.baseDir,
+    originDescription: opts.originDescription,
+    resolved: !hasPlaceholders,
+    resolveOpts
+  });
+}
+function parseFileWithOptions(filePath, opts = {}) {
+  if (typeof process === "undefined" && !opts.readFileSync) {
+    throw new Error("parseFileWithOptions is not supported in browser environments without opts.readFileSync.");
+  }
+  const resolvedPath = path.resolve(filePath);
+  const readFileSync2 = _nullishCoalesce(opts.readFileSync, () => ( defaultReadFileSync));
+  const input = readFileSync2(resolvedPath);
+  return parseStringWithOptions(input, {
+    ...opts,
+    baseDir: _nullishCoalesce(opts.baseDir, () => ( path.dirname(resolvedPath))),
+    readFileSync: readFileSync2
+  });
+}
+async function parseAsync(input, opts = {}) {
+  return _chunkRO4D6BH7cjs.guardStackDepthAsync.call(void 0, 
+    () => parseStringInnerAsync(input, opts),
+    (msg) => new (0, _chunkRO4D6BH7cjs.ParseError)(msg, 1, 1, opts.originDescription)
+  );
+}
+async function parseStringInnerAsync(input, opts) {
+  const resolveSubstitutions = _nullishCoalesce(opts.resolveSubstitutions, () => ( true));
+  const { ast, resolveOpts } = buildResolveContext(input, opts);
+  if (resolveSubstitutions) {
+    const value = await _chunkRO4D6BH7cjs.resolveAsync.call(void 0, ast, resolveOpts);
+    if (value.kind !== "object") throw new Error("resolved value is not an object");
+    return new (0, _chunkRO4D6BH7cjs.Config)(value, { resolved: true, originDescription: opts.originDescription });
+  }
+  const tree = await _chunkRO4D6BH7cjs.buildTreeAsync.call(void 0, ast, resolveOpts);
+  const hasPlaceholders = _chunkRO4D6BH7cjs.containsPlaceholders.call(void 0, tree);
+  return _chunkRO4D6BH7cjs.Config._fromUnresolvedResObj(tree, {
+    parseBaseDir: opts.baseDir,
+    originDescription: opts.originDescription,
+    resolved: !hasPlaceholders,
+    resolveOpts
+  });
+}
+function parseFile(filePath, opts = {}) {
+  if (typeof process === "undefined" && !opts.readFileSync) {
+    throw new Error("parseFile is not supported in browser environments. Provide opts.readFileSync or use parse() instead.");
+  }
+  const resolvedPath = path.resolve(filePath);
+  const readFileSync2 = _nullishCoalesce(opts.readFileSync, () => ( defaultReadFileSync));
+  const input = readFileSync2(resolvedPath);
+  return parse(input, {
+    ...opts,
+    baseDir: _nullishCoalesce(opts.baseDir, () => ( path.dirname(resolvedPath))),
+    readFileSync: readFileSync2
+  });
+}
+async function parseFileAsync(filePath, opts = {}) {
+  if (typeof process === "undefined" && !opts.readFile) {
+    throw new Error("parseFileAsync is not supported in browser environments. Provide opts.readFile or use parseAsync() instead.");
+  }
+  const resolvedPath = path.resolve(filePath);
+  const readFile = _nullishCoalesce(opts.readFile, () => ( defaultReadFile));
+  const input = await readFile(resolvedPath);
+  return parseAsync(input, {
+    ...opts,
+    baseDir: _nullishCoalesce(opts.baseDir, () => ( path.dirname(resolvedPath))),
+    readFile,
+    readFileSync: _nullishCoalesce(opts.readFileSync, () => ( defaultReadFileSync))
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.defaultParseOptions = defaultParseOptions; exports.defaultResolveOptions = defaultResolveOptions; exports.parse = parse; exports.parseString = parseString; exports.parseStringWithOptions = parseStringWithOptions; exports.parseFileWithOptions = parseFileWithOptions; exports.parseAsync = parseAsync; exports.parseFile = parseFile; exports.parseFileAsync = parseFileAsync;

package/dist/chunk-QY7ECGS6.js

@@ -0,0 +1,83 @@
+import {
+  Config,
+  ConfigError,
+  depthError,
+  guardStackDepth
+} from "./chunk-WTXULUZS.js";
+
+// src/value-factory.ts
+function fromMap(values, originDescription) {
+  const fields = guardStackDepth(
+    () => coerceObject(values, ""),
+    (msg) => depthError(`fromMap: ${msg}`)
+  );
+  const root = { kind: "object", fields };
+  return Config._fromResolvedValue(root, { originDescription });
+}
+function empty(originDescription) {
+  const root = { kind: "object", fields: /* @__PURE__ */ new Map() };
+  return Config._fromResolvedValue(root, { originDescription });
+}
+var INT64_MAX = 9223372036854775807n;
+var INT64_MIN = -9223372036854775808n;
+function coerceObject(obj, atPath) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(obj)) {
+    const childPath = atPath ? `${atPath}.${k}` : k;
+    fields.set(k, coerceValue(v, childPath));
+  }
+  return fields;
+}
+function coerceValue(v, atPath) {
+  if (v === null) {
+    return { kind: "scalar", raw: "null", valueType: "null" };
+  }
+  if (v === void 0) {
+    throw new ConfigError(
+      `fromMap: undefined is not a valid HOCON value at path "${atPath}"`,
+      atPath
+    );
+  }
+  switch (typeof v) {
+    case "string":
+      return { kind: "scalar", raw: v, valueType: "string" };
+    case "number": {
+      if (Number.isNaN(v) || !Number.isFinite(v)) {
+        throw new ConfigError(
+          `fromMap: ${v} is not representable in HOCON (NaN/Infinity not allowed) at path "${atPath}"`,
+          atPath
+        );
+      }
+      return { kind: "scalar", raw: Object.is(v, -0) ? "-0" : String(v), valueType: "number" };
+    }
+    case "boolean":
+      return { kind: "scalar", raw: v ? "true" : "false", valueType: "boolean" };
+    case "bigint": {
+      if (v > INT64_MAX || v < INT64_MIN) {
+        throw new ConfigError(
+          `fromMap: integer ${v} is out of int64 range (HOCON integers are int64; spec F0.5) at path "${atPath}"`,
+          atPath
+        );
+      }
+      return { kind: "scalar", raw: String(v), valueType: "number" };
+    }
+    case "object": {
+      if (Array.isArray(v)) {
+        const items = v.map((item, i) => coerceValue(item, `${atPath}[${i}]`));
+        return { kind: "array", items };
+      }
+      const fields = coerceObject(v, atPath);
+      return { kind: "object", fields };
+    }
+    default:
+      throw new ConfigError(
+        `fromMap: unsupported value type "${typeof v}" at path "${atPath}"`,
+        atPath
+      );
+  }
+}
+
+export {
+  fromMap,
+  empty
+};