@bolt-foundry/gambit 0.8.3 → 0.8.5-rc.5

package/esm/deps/jsr.io/@std/toml/1.0.11/mod.d.ts

@@ -0,0 +1,109 @@
+/**
+ * {@linkcode parse} and {@linkcode stringify} for handling
+ * {@link https://toml.io | TOML} encoded data.
+ *
+ * Be sure to read the supported types as not every spec is supported at the
+ * moment and the handling in TypeScript side is a bit different.
+ *
+ * ## Supported types and handling
+ *
+ * - [x] [Keys](https://toml.io/en/latest#keys)
+ * - [ ] [String](https://toml.io/en/latest#string)
+ * - [x] [Multiline String](https://toml.io/en/latest#string)
+ * - [x] [Literal String](https://toml.io/en/latest#string)
+ * - [ ] [Integer](https://toml.io/en/latest#integer)
+ * - [x] [Float](https://toml.io/en/latest#float)
+ * - [x] [Boolean](https://toml.io/en/latest#boolean)
+ * - [x] [Offset Date-time](https://toml.io/en/latest#offset-date-time)
+ * - [x] [Local Date-time](https://toml.io/en/latest#local-date-time)
+ * - [x] [Local Date](https://toml.io/en/latest#local-date)
+ * - [ ] [Local Time](https://toml.io/en/latest#local-time)
+ * - [x] [Table](https://toml.io/en/latest#table)
+ * - [x] [Inline Table](https://toml.io/en/latest#inline-table)
+ * - [ ] [Array of Tables](https://toml.io/en/latest#array-of-tables)
+ *
+ * _Supported with warnings see [Warning](#Warning)._
+ *
+ * ### Warning
+ *
+ * #### String
+ *
+ * Due to the spec, there is no flag to detect regex properly in a TOML
+ * declaration. So the regex is stored as string.
+ *
+ * #### Integer
+ *
+ * For **Binary** / **Octal** / **Hexadecimal** numbers, they are stored as string
+ * to be not interpreted as Decimal.
+ *
+ * #### Local Time
+ *
+ * Because local time does not exist in JavaScript, the local time is stored as a
+ * string.
+ *
+ * #### Array of Tables
+ *
+ * At the moment only simple declarations like below are supported:
+ *
+ * ```toml
+ * [[bin]]
+ * name = "deno"
+ * path = "cli/main.rs"
+ *
+ * [[bin]]
+ * name = "deno_core"
+ * path = "src/foo.rs"
+ *
+ * [[nib]]
+ * name = "node"
+ * path = "not_found"
+ * ```
+ *
+ * will output:
+ *
+ * ```json
+ * {
+ *   "bin": [
+ *     { "name": "deno", "path": "cli/main.rs" },
+ *     { "name": "deno_core", "path": "src/foo.rs" }
+ *   ],
+ *   "nib": [{ "name": "node", "path": "not_found" }]
+ * }
+ * ```
+ *
+ * ```ts
+ * import { parse, stringify } from "@std/toml";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   bin: [
+ *     { name: "deno", path: "cli/main.rs" },
+ *     { name: "deno_core", path: "src/foo.rs" },
+ *   ],
+ *   nib: [{ name: "node", path: "not_found" }],
+ * };
+ *
+ * const tomlString = stringify(obj);
+ * assertEquals(tomlString, `
+ * [[bin]]
+ * name = "deno"
+ * path = "cli/main.rs"
+ *
+ * [[bin]]
+ * name = "deno_core"
+ * path = "src/foo.rs"
+ *
+ * [[nib]]
+ * name = "node"
+ * path = "not_found"
+ * `);
+ *
+ * const tomlObject = parse(tomlString);
+ * assertEquals(tomlObject, obj);
+ * ```
+ *
+ * @module
+ */
+export * from "./stringify.js";
+export * from "./parse.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/toml/1.0.11/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/toml/1.0.11/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC"}

package/esm/deps/jsr.io/@std/toml/1.0.11/mod.js

@@ -0,0 +1,110 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * {@linkcode parse} and {@linkcode stringify} for handling
+ * {@link https://toml.io | TOML} encoded data.
+ *
+ * Be sure to read the supported types as not every spec is supported at the
+ * moment and the handling in TypeScript side is a bit different.
+ *
+ * ## Supported types and handling
+ *
+ * - [x] [Keys](https://toml.io/en/latest#keys)
+ * - [ ] [String](https://toml.io/en/latest#string)
+ * - [x] [Multiline String](https://toml.io/en/latest#string)
+ * - [x] [Literal String](https://toml.io/en/latest#string)
+ * - [ ] [Integer](https://toml.io/en/latest#integer)
+ * - [x] [Float](https://toml.io/en/latest#float)
+ * - [x] [Boolean](https://toml.io/en/latest#boolean)
+ * - [x] [Offset Date-time](https://toml.io/en/latest#offset-date-time)
+ * - [x] [Local Date-time](https://toml.io/en/latest#local-date-time)
+ * - [x] [Local Date](https://toml.io/en/latest#local-date)
+ * - [ ] [Local Time](https://toml.io/en/latest#local-time)
+ * - [x] [Table](https://toml.io/en/latest#table)
+ * - [x] [Inline Table](https://toml.io/en/latest#inline-table)
+ * - [ ] [Array of Tables](https://toml.io/en/latest#array-of-tables)
+ *
+ * _Supported with warnings see [Warning](#Warning)._
+ *
+ * ### Warning
+ *
+ * #### String
+ *
+ * Due to the spec, there is no flag to detect regex properly in a TOML
+ * declaration. So the regex is stored as string.
+ *
+ * #### Integer
+ *
+ * For **Binary** / **Octal** / **Hexadecimal** numbers, they are stored as string
+ * to be not interpreted as Decimal.
+ *
+ * #### Local Time
+ *
+ * Because local time does not exist in JavaScript, the local time is stored as a
+ * string.
+ *
+ * #### Array of Tables
+ *
+ * At the moment only simple declarations like below are supported:
+ *
+ * ```toml
+ * [[bin]]
+ * name = "deno"
+ * path = "cli/main.rs"
+ *
+ * [[bin]]
+ * name = "deno_core"
+ * path = "src/foo.rs"
+ *
+ * [[nib]]
+ * name = "node"
+ * path = "not_found"
+ * ```
+ *
+ * will output:
+ *
+ * ```json
+ * {
+ *   "bin": [
+ *     { "name": "deno", "path": "cli/main.rs" },
+ *     { "name": "deno_core", "path": "src/foo.rs" }
+ *   ],
+ *   "nib": [{ "name": "node", "path": "not_found" }]
+ * }
+ * ```
+ *
+ * ```ts
+ * import { parse, stringify } from "@std/toml";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   bin: [
+ *     { name: "deno", path: "cli/main.rs" },
+ *     { name: "deno_core", path: "src/foo.rs" },
+ *   ],
+ *   nib: [{ name: "node", path: "not_found" }],
+ * };
+ *
+ * const tomlString = stringify(obj);
+ * assertEquals(tomlString, `
+ * [[bin]]
+ * name = "deno"
+ * path = "cli/main.rs"
+ *
+ * [[bin]]
+ * name = "deno_core"
+ * path = "src/foo.rs"
+ *
+ * [[nib]]
+ * name = "node"
+ * path = "not_found"
+ * `);
+ *
+ * const tomlObject = parse(tomlString);
+ * assertEquals(tomlObject, obj);
+ * ```
+ *
+ * @module
+ */
+export * from "./stringify.js";
+export * from "./parse.js";

package/esm/deps/jsr.io/@std/toml/1.0.11/parse.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Parses a {@link https://toml.io | TOML} string into an object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/toml/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const tomlString = `title = "TOML Example"
+ * [owner]
+ * name = "Alice"
+ * bio = "Alice is a programmer."`;
+ *
+ * const obj = parse(tomlString);
+ * assertEquals(obj, { title: "TOML Example", owner: { name: "Alice", bio: "Alice is a programmer." } });
+ * ```
+ * @param tomlString TOML string to be parsed.
+ * @returns The parsed JS object.
+ */
+export declare function parse(tomlString: string): Record<string, unknown>;
+//# sourceMappingURL=parse.d.ts.map

package/esm/deps/jsr.io/@std/toml/1.0.11/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/toml/1.0.11/parse.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEjE"}

package/esm/deps/jsr.io/@std/toml/1.0.11/parse.js

@@ -0,0 +1,25 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { parserFactory, toml } from "./_parser.js";
+/**
+ * Parses a {@link https://toml.io | TOML} string into an object.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/toml/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const tomlString = `title = "TOML Example"
+ * [owner]
+ * name = "Alice"
+ * bio = "Alice is a programmer."`;
+ *
+ * const obj = parse(tomlString);
+ * assertEquals(obj, { title: "TOML Example", owner: { name: "Alice", bio: "Alice is a programmer." } });
+ * ```
+ * @param tomlString TOML string to be parsed.
+ * @returns The parsed JS object.
+ */
+export function parse(tomlString) {
+    return parserFactory(toml)(tomlString);
+}

package/esm/deps/jsr.io/@std/toml/1.0.11/stringify.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Options for {@linkcode stringify}.
+ */
+export interface StringifyOptions {
+    /**
+     * Define if the keys should be aligned or not.
+     *
+     * @default {false}
+     */
+    keyAlignment?: boolean;
+}
+/**
+ * Converts an object to a {@link https://toml.io | TOML} string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/toml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   title: "TOML Example",
+ *   owner: {
+ *     name: "Bob",
+ *     bio: "Bob is a cool guy",
+ *  }
+ * };
+ * const tomlString = stringify(obj);
+ * assertEquals(tomlString, `title = "TOML Example"\n\n[owner]\nname = "Bob"\nbio = "Bob is a cool guy"\n`);
+ * ```
+ * @param obj Source object
+ * @param options Options for stringifying.
+ * @returns TOML string
+ */
+export declare function stringify(obj: Record<string, unknown>, options?: StringifyOptions): string;
+//# sourceMappingURL=stringify.d.ts.map

package/esm/deps/jsr.io/@std/toml/1.0.11/stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringify.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/toml/1.0.11/stringify.ts"],"names":[],"mappings":"AAsBA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AA2OD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,OAAO,CAAC,EAAE,gBAAgB,GACzB,MAAM,CAER"}

package/esm/deps/jsr.io/@std/toml/1.0.11/stringify.js

@@ -0,0 +1,283 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Dumper_instances, _Dumper_arrayTypeCache, _Dumper_printObject, _Dumper_isPrimitive, _Dumper_getTypeOfArray, _Dumper_doGetTypeOfArray, _Dumper_printAsInlineValue, _Dumper_isSimplySerializable, _Dumper_header, _Dumper_headerGroup, _Dumper_declaration, _Dumper_arrayDeclaration, _Dumper_strDeclaration, _Dumper_numberDeclaration, _Dumper_boolDeclaration, _Dumper_printDate, _Dumper_dateDeclaration, _Dumper_format;
+// Bare keys may only contain ASCII letters,
+// ASCII digits, underscores, and dashes (A-Za-z0-9_-).
+function joinKeys(keys) {
+    // Dotted keys are a sequence of bare or quoted keys joined with a dot.
+    // This allows for grouping similar properties together:
+    return keys
+        .map((str) => {
+        return str.length === 0 || str.match(/[^A-Za-z0-9_-]/)
+            ? JSON.stringify(str)
+            : str;
+    })
+        .join(".");
+}
+class Dumper {
+    constructor(srcObjc) {
+        _Dumper_instances.add(this);
+        Object.defineProperty(this, "maxPad", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "srcObject", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        _Dumper_arrayTypeCache.set(this, new Map());
+        this.srcObject = srcObjc;
+    }
+    dump(fmtOptions = {}) {
+        // deno-lint-ignore no-explicit-any
+        this.output = __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_printObject).call(this, this.srcObject);
+        this.output = __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_format).call(this, fmtOptions);
+        return this.output;
+    }
+}
+_Dumper_arrayTypeCache = new WeakMap(), _Dumper_instances = new WeakSet(), _Dumper_printObject = function _Dumper_printObject(obj, keys = []) {
+    const out = [];
+    const props = Object.keys(obj);
+    const inlineProps = [];
+    const multilineProps = [];
+    for (const prop of props) {
+        if (__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_isSimplySerializable).call(this, obj[prop])) {
+            inlineProps.push(prop);
+        }
+        else {
+            multilineProps.push(prop);
+        }
+    }
+    const sortedProps = inlineProps.concat(multilineProps);
+    for (const prop of sortedProps) {
+        const value = obj[prop];
+        if (value instanceof Date) {
+            out.push(__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_dateDeclaration).call(this, [prop], value));
+        }
+        else if (typeof value === "string" || value instanceof RegExp) {
+            out.push(__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_strDeclaration).call(this, [prop], value.toString()));
+        }
+        else if (typeof value === "number") {
+            out.push(__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_numberDeclaration).call(this, [prop], value));
+        }
+        else if (typeof value === "boolean") {
+            out.push(__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_boolDeclaration).call(this, [prop], value));
+        }
+        else if (value instanceof Array) {
+            const arrayType = __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_getTypeOfArray).call(this, value);
+            if (arrayType === "ONLY_PRIMITIVE") {
+                out.push(__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_arrayDeclaration).call(this, [prop], value));
+            }
+            else if (arrayType === "ONLY_OBJECT_EXCLUDING_ARRAY") {
+                // array of objects
+                for (let i = 0; i < value.length; i++) {
+                    out.push("");
+                    out.push(__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_headerGroup).call(this, [...keys, prop]));
+                    out.push(...__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_printObject).call(this, value[i], [...keys, prop]));
+                }
+            }
+            else {
+                // this is a complex array, use the inline format.
+                const str = value.map((x) => __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_printAsInlineValue).call(this, x)).join(",");
+                out.push(`${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, [prop])}[${str}]`);
+            }
+        }
+        else if (typeof value === "object") {
+            out.push("");
+            out.push(__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_header).call(this, [...keys, prop]));
+            if (value) {
+                const toParse = value;
+                out.push(...__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_printObject).call(this, toParse, [...keys, prop]));
+            }
+            // out.push(...this._parse(value, `${path}${prop}.`));
+        }
+    }
+    out.push("");
+    return out;
+}, _Dumper_isPrimitive = function _Dumper_isPrimitive(value) {
+    return value instanceof Date ||
+        value instanceof RegExp ||
+        ["string", "number", "boolean"].includes(typeof value);
+}, _Dumper_getTypeOfArray = function _Dumper_getTypeOfArray(arr) {
+    if (__classPrivateFieldGet(this, _Dumper_arrayTypeCache, "f").has(arr)) {
+        return __classPrivateFieldGet(this, _Dumper_arrayTypeCache, "f").get(arr);
+    }
+    const type = __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_doGetTypeOfArray).call(this, arr);
+    __classPrivateFieldGet(this, _Dumper_arrayTypeCache, "f").set(arr, type);
+    return type;
+}, _Dumper_doGetTypeOfArray = function _Dumper_doGetTypeOfArray(arr) {
+    if (!arr.length) {
+        // any type should be fine
+        return "ONLY_PRIMITIVE";
+    }
+    const onlyPrimitive = __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_isPrimitive).call(this, arr[0]);
+    if (arr[0] instanceof Array) {
+        return "MIXED";
+    }
+    for (let i = 1; i < arr.length; i++) {
+        if (onlyPrimitive !== __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_isPrimitive).call(this, arr[i]) || arr[i] instanceof Array) {
+            return "MIXED";
+        }
+    }
+    return onlyPrimitive ? "ONLY_PRIMITIVE" : "ONLY_OBJECT_EXCLUDING_ARRAY";
+}, _Dumper_printAsInlineValue = function _Dumper_printAsInlineValue(value) {
+    if (value instanceof Date) {
+        return `"${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_printDate).call(this, value)}"`;
+    }
+    else if (typeof value === "string" || value instanceof RegExp) {
+        return JSON.stringify(value.toString());
+    }
+    else if (typeof value === "number") {
+        return value;
+    }
+    else if (typeof value === "boolean") {
+        return value.toString();
+    }
+    else if (value instanceof Array) {
+        const str = value.map((x) => __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_printAsInlineValue).call(this, x)).join(",");
+        return `[${str}]`;
+    }
+    else if (typeof value === "object") {
+        if (!value) {
+            throw new Error("Should never reach");
+        }
+        const str = Object.keys(value).map((key) => {
+            return `${joinKeys([key])} = ${
+            // deno-lint-ignore no-explicit-any
+            __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_printAsInlineValue).call(this, value[key])}`;
+        }).join(",");
+        return `{${str}}`;
+    }
+    throw new Error("Should never reach");
+}, _Dumper_isSimplySerializable = function _Dumper_isSimplySerializable(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean" ||
+        value instanceof RegExp ||
+        value instanceof Date ||
+        (value instanceof Array &&
+            __classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_getTypeOfArray).call(this, value) !== "ONLY_OBJECT_EXCLUDING_ARRAY"));
+}, _Dumper_header = function _Dumper_header(keys) {
+    return `[${joinKeys(keys)}]`;
+}, _Dumper_headerGroup = function _Dumper_headerGroup(keys) {
+    return `[[${joinKeys(keys)}]]`;
+}, _Dumper_declaration = function _Dumper_declaration(keys) {
+    const title = joinKeys(keys);
+    if (title.length > this.maxPad) {
+        this.maxPad = title.length;
+    }
+    return `${title} = `;
+}, _Dumper_arrayDeclaration = function _Dumper_arrayDeclaration(keys, value) {
+    return `${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, keys)}${JSON.stringify(value)}`;
+}, _Dumper_strDeclaration = function _Dumper_strDeclaration(keys, value) {
+    return `${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, keys)}${JSON.stringify(value)}`;
+}, _Dumper_numberDeclaration = function _Dumper_numberDeclaration(keys, value) {
+    if (Number.isNaN(value)) {
+        return `${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, keys)}nan`;
+    }
+    switch (value) {
+        case Infinity:
+            return `${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, keys)}inf`;
+        case -Infinity:
+            return `${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, keys)}-inf`;
+        default:
+            return `${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, keys)}${value}`;
+    }
+}, _Dumper_boolDeclaration = function _Dumper_boolDeclaration(keys, value) {
+    return `${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, keys)}${value}`;
+}, _Dumper_printDate = function _Dumper_printDate(value) {
+    function dtPad(v, lPad = 2) {
+        return v.padStart(lPad, "0");
+    }
+    const m = dtPad((value.getUTCMonth() + 1).toString());
+    const d = dtPad(value.getUTCDate().toString());
+    const h = dtPad(value.getUTCHours().toString());
+    const min = dtPad(value.getUTCMinutes().toString());
+    const s = dtPad(value.getUTCSeconds().toString());
+    const ms = dtPad(value.getUTCMilliseconds().toString(), 3);
+    // formatted date
+    const fData = `${value.getUTCFullYear()}-${m}-${d}T${h}:${min}:${s}.${ms}`;
+    return fData;
+}, _Dumper_dateDeclaration = function _Dumper_dateDeclaration(keys, value) {
+    return `${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_declaration).call(this, keys)}${__classPrivateFieldGet(this, _Dumper_instances, "m", _Dumper_printDate).call(this, value)}`;
+}, _Dumper_format = function _Dumper_format(options = {}) {
+    const { keyAlignment = false } = options;
+    const rDeclaration = /^(\".*\"|[^=]*)\s=/;
+    const out = [];
+    for (let i = 0; i < this.output.length; i++) {
+        const l = this.output[i];
+        // we keep empty entry for array of objects
+        if (l[0] === "[" && l[1] !== "[") {
+            // non-empty object with only subobjects as properties
+            if (this.output[i + 1] === "" &&
+                this.output[i + 2]?.slice(0, l.length) === l.slice(0, -1) + ".") {
+                i += 1;
+                continue;
+            }
+            out.push(l);
+        }
+        else {
+            if (keyAlignment) {
+                const m = rDeclaration.exec(l);
+                if (m && m[1]) {
+                    out.push(l.replace(m[1], m[1].padEnd(this.maxPad)));
+                }
+                else {
+                    out.push(l);
+                }
+            }
+            else {
+                out.push(l);
+            }
+        }
+    }
+    // Cleaning multiple spaces
+    const cleanedOutput = [];
+    for (let i = 0; i < out.length; i++) {
+        const l = out[i];
+        if (!(l === "" && out[i + 1] === "")) {
+            cleanedOutput.push(l);
+        }
+    }
+    return cleanedOutput;
+};
+/**
+ * Converts an object to a {@link https://toml.io | TOML} string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/toml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const obj = {
+ *   title: "TOML Example",
+ *   owner: {
+ *     name: "Bob",
+ *     bio: "Bob is a cool guy",
+ *  }
+ * };
+ * const tomlString = stringify(obj);
+ * assertEquals(tomlString, `title = "TOML Example"\n\n[owner]\nname = "Bob"\nbio = "Bob is a cool guy"\n`);
+ * ```
+ * @param obj Source object
+ * @param options Options for stringifying.
+ * @returns TOML string
+ */
+export function stringify(obj, options) {
+    return new Dumper(obj).dump(options).join("\n");
+}