kimi-plugin-cc 2.4.4 → 2.5.1

package/plugins/kimi-dsh/dist/swarm-recovery.js

@@ -0,0 +1,134 @@
+import { RuntimeError } from "./errors.js";
+import { collectDescendantIdentities, collectProcessGroupsIdentities, probeProcessIdentity, revalidateProcessIdentities } from "./process-tree.js";
+export function recordRecoveryEvent(store, record, event) {
+    record.complete = false;
+    if (event.kind === "session") {
+        record.session = { sessionId: event.sessionId, workspaceId: event.workspaceId };
+        // Write-ahead: this must commit before the profile mutation is attempted.
+        record.sessionDirty = true;
+    }
+    else if (event.kind === "disabled") {
+        record.sessionDirty = false;
+    }
+    else if (event.kind.endsWith("-spawn")) {
+        record.launches.push({ kind: event.kind === "web-spawn" ? "web" : "print", pending: true, identities: [], quiescent: false, uncertain: false });
+    }
+    else {
+        const kind = event.kind.startsWith("web-") ? "web" : "print";
+        const launch = [...record.launches].reverse().find((entry) => entry.kind === kind);
+        if (!launch)
+            throw recoveryError("Missing durable launch intent.");
+        if (event.kind === "web-exit" || event.kind === "print-exit") {
+            launch.quiescent = true;
+            launch.pending = false;
+        }
+        else if ("identities" in event) {
+            const all = [...launch.identities, ...event.identities];
+            launch.identities = [...new Map(all.map((identity) => [`${identity.pid}:${identity.startToken}:${identity.processGroupId}`, identity])).values()];
+            launch.pending = launch.identities.length === 0;
+            launch.uncertain ||= !event.complete;
+        }
+    }
+    store.saveSwarmRecovery(record.jobId, record);
+}
+export function finishRecoveryRecord(store, record) {
+    record.complete = !record.sessionDirty && record.launches.every((entry) => entry.quiescent)
+        && (record.workspaceRoot === null || record.patchPath !== null);
+    store.saveSwarmRecovery(record.jobId, record);
+}
+export function recoveryError(message) {
+    return new RuntimeError("SWARM_RECOVERY_REQUIRED", message, "swarm.recovery");
+}
+export async function assertRecoveryOwnerGone(record) {
+    if (!record.owner || process.platform === "win32")
+        throw recoveryError("No durable, verifiable owner identity; recovery requires manual inspection on this host.");
+    const probe = await probeProcessIdentity(record.ownerPid);
+    if (!probe.complete)
+        throw recoveryError("Cannot verify the original companion's identity.");
+    if (probe.identity?.startToken === record.owner.startToken && !/^[ZX]/i.test(probe.identity.state)) {
+        throw recoveryError("The original companion is still alive. Use cancel for a running job, not recovery.");
+    }
+}
+/**
+ * Linux may fall back from /proc to ps for a whole-group snapshot while targeted
+ * identity reads still use /proc. Those start tokens are different namespaces,
+ * not different processes. Prove both representations current around the known
+ * identity read; never accept a member based on PID/PGID equality alone.
+ */
+export async function validateRecoveryGroupMembers(known, members, validate = revalidateProcessIdentities) {
+    const membership = await validate(members);
+    const ownership = await validate(known);
+    const membershipAfter = await validate(membership.identities);
+    for (const proof of [membership, ownership, membershipAfter]) {
+        if (!proof.complete || proof.groupChanged?.length)
+            throw recoveryError("Process ownership or group membership is uncertain.");
+    }
+    for (const member of membershipAfter.identities) {
+        const owner = ownership.identities.find((id) => id.pid === member.pid && id.processGroupId === member.processGroupId);
+        const crossNamespace = owner && ((owner.startToken.startsWith("proc:") && member.startToken.startsWith("ps:")) ||
+            (owner.startToken.startsWith("ps:") && member.startToken.startsWith("proc:")));
+        if (!owner || (owner.startToken !== member.startToken && !crossNamespace)) {
+            throw recoveryError("An unrecorded process survives in the recorded group; refusing group cleanup.");
+        }
+    }
+    return ownership.identities;
+}
+/** Never signal an unproven group, PID replacement, or changed-PGID process. */
+export async function recoverLaunch(launch, persist, signal) {
+    if (launch.quiescent)
+        return;
+    if (launch.pending || launch.uncertain || launch.identities.length === 0) {
+        throw recoveryError("Launch ownership was not fully recorded before interruption; manual inspection is required. No process was signalled.");
+    }
+    const root = launch.identities[0];
+    const rootProbe = await probeProcessIdentity(root.pid);
+    if (!rootProbe.complete)
+        throw recoveryError("Process identity probe is incomplete.");
+    if (rootProbe.identity?.startToken === root.startToken) {
+        if (rootProbe.identity.processGroupId !== root.processGroupId)
+            throw recoveryError("The recorded root changed process groups; refusing to signal it.");
+        const descendants = await collectDescendantIdentities(root.pid);
+        // Revalidate the ancestry anchor after collection before retaining new identities.
+        const after = await probeProcessIdentity(root.pid);
+        if (!after.complete || after.identity?.startToken !== root.startToken || after.identity.processGroupId !== root.processGroupId) {
+            throw recoveryError("Process ownership changed during recovery inspection.");
+        }
+        launch.identities = [...new Map([...launch.identities, ...descendants].map((id) => [`${id.pid}:${id.startToken}:${id.processGroupId}`, id])).values()];
+        persist();
+    }
+    const inspect = async () => {
+        const members = await collectProcessGroupsIdentities(launch.identities.map((id) => id.processGroupId));
+        if (members === undefined)
+            throw recoveryError("Process group membership is unreadable.");
+        return validateRecoveryGroupMembers(launch.identities, members);
+    };
+    for (const [killSignal, waitMs] of [["SIGTERM", 1500], ["SIGKILL", 500]]) {
+        signal?.throwIfAborted();
+        for (const identity of await inspect()) {
+            signal?.throwIfAborted();
+            const current = await revalidateProcessIdentities([identity]);
+            if (!current.complete || current.groupChanged?.length)
+                throw recoveryError("Process identity changed before signalling.");
+            if (current.identities.length) {
+                try {
+                    process.kill(identity.pid, killSignal);
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        throw recoveryError("Unable to stop the recorded process.");
+                }
+            }
+        }
+        const deadline = Date.now() + waitMs;
+        do {
+            signal?.throwIfAborted();
+            if ((await inspect()).length === 0) {
+                launch.quiescent = true;
+                persist();
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        } while (Date.now() < deadline);
+    }
+    throw recoveryError("Recorded processes did not become quiescent; recovery remains pending.");
+}

package/plugins/kimi-dsh/dist/types.js

@@ -0,0 +1 @@
+export {};

package/plugins/kimi-dsh/dist/vendor/shell-quote/LICENSE

@@ -0,0 +1,24 @@
+The MIT License
+
+Copyright (c) 2013 James Halliday (mail@substack.net)
+
+Permission is hereby granted, free of charge,
+to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to
+deal in the Software without restriction, including
+without limitation the rights to use, copy, modify,
+merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom
+the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/plugins/kimi-dsh/dist/vendor/shell-quote/index.js

@@ -0,0 +1 @@
+export { parse } from "./parse.js";

package/plugins/kimi-dsh/dist/vendor/shell-quote/parse.js

@@ -0,0 +1,229 @@
+// @ts-nocheck
+// Vendored from shell-quote 1.8.3 with the upstream 1.9.0 linear-finalization fix.
+// MIT, James Halliday. See ./LICENSE and ./README.md for provenance.
+'use strict';
+// '<(' is process substitution operator and
+// can be parsed the same as control operator
+var CONTROL = '(?:' + [
+    '\\|\\|',
+    '\\&\\&',
+    ';;',
+    '\\|\\&',
+    '\\<\\(',
+    '\\<\\<\\<',
+    '>>',
+    '>\\&',
+    '<\\&',
+    '[&;()|<>]'
+].join('|') + ')';
+var controlRE = new RegExp('^' + CONTROL + '$');
+var META = '|&;()<> \\t';
+var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
+var DOUBLE_QUOTE = '\'((\\\\\'|[^\'])*?)\'';
+var hash = /^#$/;
+var SQ = "'";
+var DQ = '"';
+var DS = '$';
+var TOKEN = '';
+var mult = 0x100000000; // Math.pow(16, 8);
+for (var i = 0; i < 4; i++) {
+    TOKEN += (mult * Math.random()).toString(16);
+}
+var startsWithToken = new RegExp('^' + TOKEN);
+function matchAll(s, r) {
+    var origIndex = r.lastIndex;
+    var matches = [];
+    var matchObj;
+    while ((matchObj = r.exec(s))) {
+        matches.push(matchObj);
+        if (r.lastIndex === matchObj.index) {
+            r.lastIndex += 1;
+        }
+    }
+    r.lastIndex = origIndex;
+    return matches;
+}
+function getVar(env, pre, key) {
+    var r = typeof env === 'function' ? env(key) : env[key];
+    if (typeof r === 'undefined' && key != '') {
+        r = '';
+    }
+    else if (typeof r === 'undefined') {
+        r = '$';
+    }
+    if (typeof r === 'object') {
+        return pre + TOKEN + JSON.stringify(r) + TOKEN;
+    }
+    return pre + r;
+}
+function parseInternal(string, env, opts) {
+    if (!opts) {
+        opts = {};
+    }
+    var BS = opts.escape || '\\';
+    var BAREWORD = '(\\' + BS + '[\'"' + META + ']|[^\\s\'"' + META + '])+';
+    var chunker = new RegExp([
+        '(' + CONTROL + ')', // control chars
+        '(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')+'
+    ].join('|'), 'g');
+    var matches = matchAll(string, chunker);
+    if (matches.length === 0) {
+        return [];
+    }
+    if (!env) {
+        env = {};
+    }
+    var commented = false;
+    return matches.map(function (match) {
+        var s = match[0];
+        if (!s || commented) {
+            return void undefined;
+        }
+        if (controlRE.test(s)) {
+            return { op: s };
+        }
+        // Hand-written scanner/parser for Bash quoting rules:
+        //
+        // 1. inside single quotes, all characters are printed literally.
+        // 2. inside double quotes, all characters are printed literally
+        //    except variables prefixed by '$' and backslashes followed by
+        //    either a double quote or another backslash.
+        // 3. outside of any quotes, backslashes are treated as escape
+        //    characters and not printed (unless they are themselves escaped)
+        // 4. quote context can switch mid-token if there is no whitespace
+        //     between the two quote contexts (e.g. all'one'"token" parses as
+        //     "allonetoken")
+        var quote = false;
+        var esc = false;
+        var out = '';
+        var isGlob = false;
+        var i;
+        function parseEnvVar() {
+            i += 1;
+            var varend;
+            var varname;
+            var char = s.charAt(i);
+            if (char === '{') {
+                i += 1;
+                if (s.charAt(i) === '}') {
+                    throw new Error('Bad substitution: ' + s.slice(i - 2, i + 1));
+                }
+                varend = s.indexOf('}', i);
+                if (varend < 0) {
+                    throw new Error('Bad substitution: ' + s.slice(i));
+                }
+                varname = s.slice(i, varend);
+                i = varend;
+            }
+            else if ((/[*@#?$!_-]/).test(char)) {
+                varname = char;
+                i += 1;
+            }
+            else {
+                var slicedFromI = s.slice(i);
+                varend = slicedFromI.match(/[^\w\d_]/);
+                if (!varend) {
+                    varname = slicedFromI;
+                    i = s.length;
+                }
+                else {
+                    varname = slicedFromI.slice(0, varend.index);
+                    i += varend.index - 1;
+                }
+            }
+            return getVar(env, '', varname);
+        }
+        for (i = 0; i < s.length; i++) {
+            var c = s.charAt(i);
+            isGlob = isGlob || (!quote && (c === '*' || c === '?'));
+            if (esc) {
+                out += c;
+                esc = false;
+            }
+            else if (quote) {
+                if (c === quote) {
+                    quote = false;
+                }
+                else if (quote == SQ) {
+                    out += c;
+                }
+                else { // Double quote
+                    if (c === BS) {
+                        i += 1;
+                        c = s.charAt(i);
+                        if (c === DQ || c === BS || c === DS) {
+                            out += c;
+                        }
+                        else {
+                            out += BS + c;
+                        }
+                    }
+                    else if (c === DS) {
+                        out += parseEnvVar();
+                    }
+                    else {
+                        out += c;
+                    }
+                }
+            }
+            else if (c === DQ || c === SQ) {
+                quote = c;
+            }
+            else if (controlRE.test(c)) {
+                return { op: s };
+            }
+            else if (hash.test(c)) {
+                commented = true;
+                var commentObj = { comment: string.slice(match.index + i + 1) };
+                if (out.length) {
+                    return [out, commentObj];
+                }
+                return [commentObj];
+            }
+            else if (c === BS) {
+                esc = true;
+            }
+            else if (c === DS) {
+                out += parseEnvVar();
+            }
+            else {
+                out += c;
+            }
+        }
+        if (isGlob) {
+            return { op: 'glob', pattern: out };
+        }
+        return out;
+    }).reduce(function (prev, arg) {
+        if (typeof arg === 'undefined') {
+            return prev;
+        }
+        [].concat(arg).forEach(function (entry) {
+            prev[prev.length] = entry;
+        });
+        return prev;
+    }, []);
+}
+export function parse(s, env, opts) {
+    var mapped = parseInternal(s, env, opts);
+    if (typeof env !== 'function') {
+        return mapped;
+    }
+    return mapped.reduce(function (acc, value) {
+        if (typeof value === 'object') {
+            acc[acc.length] = value;
+            return acc;
+        }
+        var xs = value.split(RegExp('(' + TOKEN + '.*?' + TOKEN + ')', 'g'));
+        if (xs.length === 1) {
+            acc[acc.length] = xs[0];
+            return acc;
+        }
+        xs.filter(Boolean).forEach(function (x) {
+            acc[acc.length] = startsWithToken.test(x)
+                ? JSON.parse(x.split(TOKEN)[1])
+                : x;
+        });
+        return acc;
+    }, []);
+}

package/plugins/kimi-dsh/dist/vendor/smol-toml/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) Squirrel Chat et al., All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/plugins/kimi-dsh/dist/vendor/smol-toml/date.js

@@ -0,0 +1,156 @@
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[Tt ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|z|[-+]\d{2}:\d{2})?$/i;
+export class TomlDate extends Date {
+    #hasDate = false;
+    #hasTime = false;
+    #offset = null;
+    constructor(date, fasttype, unsafeDelim) {
+        let hasDate = true;
+        let hasTime = true;
+        let offset = 'Z';
+        let c;
+        if (typeof date === 'string') {
+            if (fasttype)
+                prep: {
+                    // Date-time
+                    if (fasttype < 3) {
+                        if (+date.slice(11, 13) > 23) {
+                            date = '';
+                            break prep;
+                        }
+                        // Local
+                        if (fasttype === 2) {
+                            offset = null;
+                            date += 'Z';
+                        }
+                        // Offset; keep track of offset if not Z
+                        else if ((c = date.charCodeAt(date.length - 1)) !== 0x5a /* Z */ && c !== 0x7a /* z */) {
+                            offset = date.slice(date.length - 6);
+                        }
+                        if (unsafeDelim)
+                            date = date.slice(0, 10) + 'T' + date.slice(11);
+                    }
+                    // Time
+                    else if (fasttype === 4) {
+                        date = +date.slice(0, 2) > 23 ? '' : `0000-01-01T${date}Z`;
+                    }
+                    hasDate = fasttype !== 4;
+                    hasTime = fasttype !== 3;
+                }
+            else {
+                let match = date.match(DATE_TIME_RE);
+                if (match) {
+                    if (!match[1]) {
+                        hasDate = false;
+                        date = `0000-01-01T${date}`;
+                    }
+                    hasTime = !!match[2];
+                    // Make sure to use T instead of a space. Breaks in case of extreme values otherwise.
+                    hasTime && date[10] === ' ' && (date = date.replace(' ', 'T'));
+                    // Do not allow rollover hours.
+                    if (match[2] && +match[2] > 23) {
+                        date = '';
+                    }
+                    else {
+                        offset = match[3] || null;
+                        if (!offset && hasTime)
+                            date += 'Z';
+                    }
+                }
+                else {
+                    date = '';
+                }
+            }
+        }
+        super(date);
+        if (!isNaN(this.getTime())) {
+            this.#hasDate = hasDate;
+            this.#hasTime = hasTime;
+            this.#offset = offset;
+        }
+    }
+    isDateTime() {
+        return this.#hasDate && this.#hasTime;
+    }
+    isLocal() {
+        return !this.#hasDate || !this.#hasTime || !this.#offset;
+    }
+    isDate() {
+        return this.#hasDate && !this.#hasTime;
+    }
+    isTime() {
+        return this.#hasTime && !this.#hasDate;
+    }
+    isValid() {
+        return this.#hasDate || this.#hasTime;
+    }
+    toISOString() {
+        let iso = super.toISOString();
+        // Local Date
+        if (this.isDate())
+            return iso.slice(0, 10);
+        // Local Time
+        if (this.isTime())
+            return iso.slice(11, 23);
+        // Local DateTime
+        if (this.#offset === null)
+            return iso.slice(0, -1);
+        // Offset DateTime
+        if (this.#offset === 'Z' || this.#offset === 'z')
+            return iso;
+        // This part is quite annoying: JS strips the original timezone from the ISO string representation
+        // Instead of using a "modified" date and "Z", we restore the representation "as authored"
+        let offset = (+(this.#offset.slice(1, 3)) * 60) + +(this.#offset.slice(4, 6));
+        offset = this.#offset[0] === '-' ? offset : -offset;
+        let offsetDate = new Date(this.getTime() - (offset * 60e3));
+        return offsetDate.toISOString().slice(0, -1) + this.#offset;
+    }
+    static wrapAsOffsetDateTime(jsDate, offset = 'Z') {
+        let date = new TomlDate(jsDate);
+        date.#offset = offset;
+        return date;
+    }
+    static wrapAsLocalDateTime(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#offset = null;
+        return date;
+    }
+    static wrapAsLocalDate(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#hasTime = false;
+        date.#offset = null;
+        return date;
+    }
+    static wrapAsLocalTime(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#hasDate = false;
+        date.#offset = null;
+        return date;
+    }
+}

package/plugins/kimi-dsh/dist/vendor/smol-toml/error.js

@@ -0,0 +1,67 @@
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+function getLineColFromPtr(string, ptr) {
+    let lines = string.slice(0, ptr).split(/\r?\n/);
+    return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+    let lines = string.split(/\r?\n/);
+    let codeblock = '';
+    let numberLen = (Math.log10(line + 1) | 0) + 1;
+    for (let i = line - 1; i <= line + 1; i++) {
+        let l = lines[i - 1];
+        if (!l)
+            continue;
+        codeblock += i.toString().padEnd(numberLen, ' ');
+        codeblock += ':  ';
+        codeblock += l;
+        codeblock += '\n';
+        if (i === line) {
+            codeblock += ' '.repeat(numberLen + column + 2);
+            codeblock += '^\n';
+        }
+    }
+    return codeblock;
+}
+export class TomlError extends Error {
+    line;
+    column;
+    codeblock;
+    constructor(message, options) {
+        const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+        const codeblock = makeCodeBlock(options.toml, line, column);
+        super(`Invalid TOML document: ${message}\n\n${codeblock}`, options);
+        this.line = line;
+        this.column = column;
+        this.codeblock = codeblock;
+    }
+    /** @internal */
+    static x(message, ctx, ptr) {
+        throw new TomlError(message, { toml: ctx.s, ptr: ptr ?? ctx.p });
+    }
+}