@cimplify/cli 0.15.3 → 0.17.0

package/dist/chunk-JNCEKW2Y.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { parseManifest, MANIFEST_FILE } from './chunk-HQPZQIWW.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-I7GEHLDD.mjs';
+import { promises } from 'fs';
+import path from 'path';
+
+// src/interactives/remote/port.ts
+var CHANNELS = ["live", "test"];
+var RemoteError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RemoteError";
+    this.code = code;
+  }
+};
+async function readInteractiveId(root) {
+  const parsed = parseManifest(await promises.readFile(path.join(root, MANIFEST_FILE), "utf8"));
+  if (parsed.manifest === null) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${MANIFEST_FILE} is invalid:
+${parsed.diagnostics.map(formatDiagnostic).join("\n")}`);
+  }
+  if (parsed.manifest.identity.id === null) {
+    throw new CliError(CLI_ERROR_CODE.NOT_LINKED, "this Interactive has not been published yet", {
+      remediation: "Run `cimplify publish --channel test` to publish it."
+    });
+  }
+  return parsed.manifest.identity.id;
+}
+async function remoteCall(call) {
+  try {
+    return await call();
+  } catch (err) {
+    if (!(err instanceof RemoteError)) throw err;
+    const code = err.code === "not_found" ? CLI_ERROR_CODE.NOT_FOUND : err.code === "unauthorized" ? CLI_ERROR_CODE.UNAUTHORIZED : CLI_ERROR_CODE.INVALID_INPUT;
+    throw new CliError(code, err.message);
+  }
+}
+
+export { CHANNELS, RemoteError, readInteractiveId, remoteCall };

package/dist/chunk-JTYVGORV.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { SessionError, CaptureSession, FRAME_MS, DEFAULT_EPOCH_MS } from './chunk-SZXO6YSX.mjs';
+import { buildLocal, workPath } from './chunk-BTNVYAC4.mjs';
+import { writeLoopProfile, LOOP_PROFILE_FILE } from './chunk-454RQ6NR.mjs';
+import { locateToolchain } from './chunk-N2WZJX5P.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import { createHash } from 'crypto';
+import { promises } from 'fs';
+import path from 'path';
+
+var CAPTURE_SCHEMA = "cimplify.capture/1";
+var FINAL_CAPTURE = "final";
+async function prepareSession(root) {
+  const toolchain = locateToolchain(root);
+  if (toolchain === null) throw new SessionError("the pinned SDK is not installed, so the game cannot be served; run your package manager's install");
+  const build = await buildLocal(root, { uiSites: true, loops: { probe: true } });
+  const errors = build.result.diagnostics.filter((d) => d.severity === "error");
+  if (errors.length > 0) throw new SessionError(`the build failed:
+${errors.map(formatDiagnostic).join("\n")}`);
+  return { root, build, toolchain };
+}
+function digest(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+async function runSession(setup, request) {
+  const session = await CaptureSession.open(setup, { device: request.device, backend: request.backend, seed: request.seed, scene: request.scene });
+  const out = [];
+  const take = async (name) => {
+    const png = request.screenshots || request.inspect ? await session.screenshot() : new Uint8Array(0);
+    const inspection = request.inspect ? await session.inspect(png) : null;
+    const snapshot = inspection === null ? await session.snapshot() : null;
+    const report = inspection?.report ?? null;
+    const readiness = await session.readiness();
+    const device = request.device;
+    out.push({
+      png,
+      inspect: report,
+      sidecar: {
+        schema: CAPTURE_SCHEMA,
+        name,
+        png: "",
+        sha256: png.length === 0 ? "" : digest(png),
+        frame: session.frame,
+        time_ms: Math.round(session.frame * FRAME_MS * 1e3) / 1e3,
+        seed: request.seed,
+        epoch_ms: DEFAULT_EPOCH_MS,
+        device: { name: device.name, width: device.width, height: device.height, scale: device.scale, insets: device.insets },
+        backend: request.backend,
+        css_safe_area: session.cssSafeArea,
+        scene: report?.scene ?? snapshot?.scene ?? { requested: request.scene, applied: null, current: null },
+        script: request.scriptPath,
+        ui: report === null ? null : { nodes: report.nodes.length, findings: report.checks.findings.length },
+        readiness
+      }
+    });
+  };
+  try {
+    if (request.script !== null) await session.run(request.script, take);
+    await session.advanceTo(request.frame);
+    await take(FINAL_CAPTURE);
+    await recordLoopProfile(setup.root, session);
+    return out;
+  } finally {
+    await session.close();
+  }
+}
+async function recordLoopProfile(root, session) {
+  const samples = await session.loopSamples();
+  const keys = Object.keys(samples);
+  if (keys.length === 0 || session.frame <= 0) return null;
+  const loops = {};
+  for (const key of keys) {
+    const [ms, calls, rows] = samples[key];
+    loops[key] = { ms, calls, rows };
+  }
+  return writeLoopProfile(workPath(root, LOOP_PROFILE_FILE), session.frame, loops);
+}
+async function writeCapture(frame, pngPath) {
+  await promises.mkdir(path.dirname(pngPath), { recursive: true });
+  await promises.writeFile(pngPath, frame.png);
+  const sidecar = { ...frame.sidecar, png: path.basename(pngPath) };
+  await promises.writeFile(`${pngPath.slice(0, -path.extname(pngPath).length)}.json`, `${JSON.stringify({ ...sidecar, inspect: frame.inspect }, null, 2)}
+`);
+  return sidecar;
+}
+function framesFor(time, frame, fallback) {
+  if (time !== void 0 && frame !== void 0) return "pass --frame or --time, not both";
+  if (frame !== void 0) {
+    const n = Number(frame);
+    return Number.isInteger(n) && n >= 0 ? n : `--frame takes a whole number; got "${frame}"`;
+  }
+  if (time !== void 0) {
+    const match = /^(\d+(?:\.\d+)?)(ms|s)?$/.exec(time);
+    if (match === null) return `--time takes seconds or milliseconds, such as 2.5s or 2500ms; got "${time}"`;
+    const ms = Number(match[1]) * (match[2] === "ms" ? 1 : 1e3);
+    return Math.round(ms / FRAME_MS);
+  }
+  return fallback;
+}
+
+export { CAPTURE_SCHEMA, FINAL_CAPTURE, framesFor, prepareSession, runSession, writeCapture };

package/dist/chunk-KQNZKV6E.mjs

@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+// src/interactives/toml.ts
+var TomlSyntaxError = class extends Error {
+  line;
+  column;
+  reason;
+  constructor(reason, at) {
+    super(`${at.line}:${at.column}: ${reason}`);
+    this.name = "TomlSyntaxError";
+    this.reason = reason;
+    this.line = at.line;
+    this.column = at.column;
+  }
+};
+var CH_TAB = 9;
+var CH_LF = 10;
+var CH_CR = 13;
+var CH_SPACE = 32;
+var CH_QUOTE = 34;
+var CH_HASH = 35;
+var CH_APOS = 39;
+var CH_PLUS = 43;
+var CH_COMMA = 44;
+var CH_MINUS = 45;
+var CH_DOT = 46;
+var CH_0 = 48;
+var CH_9 = 57;
+var CH_EQUALS = 61;
+var CH_A = 65;
+var CH_Z = 90;
+var CH_LBRACKET = 91;
+var CH_BACKSLASH = 92;
+var CH_RBRACKET = 93;
+var CH_UNDERSCORE = 95;
+var CH_LOWER_A = 97;
+var CH_LOWER_Z = 122;
+var CH_LBRACE = 123;
+var CH_RBRACE = 125;
+var CH_DEL = 127;
+var DATE_SEPARATOR_INDEX = 4;
+var MAX_CODE_POINT = 1114111;
+var SURROGATE_LOW = 55296;
+var SURROGATE_HIGH = 57343;
+function isBare(c) {
+  return c >= CH_A && c <= CH_Z || c >= CH_LOWER_A && c <= CH_LOWER_Z || c >= CH_0 && c <= CH_9 || c === CH_UNDERSCORE || c === CH_MINUS;
+}
+function isDigit(c) {
+  return c >= CH_0 && c <= CH_9;
+}
+function isControl(c) {
+  return c < CH_SPACE && c !== CH_TAB || c === CH_DEL;
+}
+var Cursor = class {
+  src;
+  pos = 0;
+  line = 1;
+  lineStart = 0;
+  constructor(src) {
+    this.src = src;
+  }
+  at() {
+    return { line: this.line, column: this.pos - this.lineStart + 1 };
+  }
+  peek(offset = 0) {
+    const i = this.pos + offset;
+    return i < this.src.length ? this.src.charCodeAt(i) : -1;
+  }
+  done() {
+    return this.pos >= this.src.length;
+  }
+  fail(reason, at = this.at()) {
+    throw new TomlSyntaxError(reason, at);
+  }
+  advance() {
+    this.pos++;
+  }
+  newline() {
+    if (this.peek() === CH_CR) {
+      if (this.peek(1) !== CH_LF) this.fail("carriage return must be followed by a line feed");
+      this.pos++;
+    }
+    this.pos++;
+    this.line++;
+    this.lineStart = this.pos;
+  }
+  isNewline() {
+    const c = this.peek();
+    return c === CH_LF || c === CH_CR && this.peek(1) === CH_LF;
+  }
+  skipSpaces() {
+    for (; ; ) {
+      const c = this.peek();
+      if (c !== CH_SPACE && c !== CH_TAB) return;
+      this.pos++;
+    }
+  }
+  skipComment() {
+    if (this.peek() !== CH_HASH) return;
+    while (!this.done() && !this.isNewline()) {
+      if (isControl(this.peek())) this.fail("control characters are not allowed in comments");
+      this.pos++;
+    }
+  }
+  skipBlank() {
+    for (; ; ) {
+      this.skipSpaces();
+      this.skipComment();
+      if (!this.isNewline()) return;
+      this.newline();
+    }
+  }
+  endOfLine() {
+    this.skipSpaces();
+    this.skipComment();
+    if (this.done()) return;
+    if (!this.isNewline()) this.fail(`unexpected ${describe(this.peek())} after value`);
+    this.newline();
+  }
+};
+function describe(c) {
+  if (c < 0) return "end of input";
+  if (c === CH_LF || c === CH_CR) return "end of line";
+  return `character '${String.fromCharCode(c)}'`;
+}
+function define(table, part, value) {
+  table.entries.set(part.name, value);
+  table.keyAt.set(part.name, part.at);
+}
+function newTable(at, origin) {
+  return { kind: "table", entries: /* @__PURE__ */ new Map(), keyAt: /* @__PURE__ */ new Map(), at, origin };
+}
+function parseKey(cur) {
+  const parts = [];
+  for (; ; ) {
+    cur.skipSpaces();
+    const at = cur.at();
+    const c = cur.peek();
+    let name;
+    if (c === CH_QUOTE) {
+      if (cur.peek(1) === CH_QUOTE && cur.peek(2) === CH_QUOTE) cur.fail("multi-line strings cannot be keys");
+      name = parseBasicString(cur);
+    } else if (c === CH_APOS) {
+      if (cur.peek(1) === CH_APOS && cur.peek(2) === CH_APOS) cur.fail("multi-line strings cannot be keys");
+      name = parseLiteralString(cur);
+    } else if (isBare(c)) {
+      const start = cur.pos;
+      while (isBare(cur.peek())) cur.advance();
+      name = cur.src.slice(start, cur.pos);
+    } else {
+      cur.fail(`expected a key, found ${describe(c)}`);
+    }
+    parts.push({ name, at });
+    cur.skipSpaces();
+    if (cur.peek() !== CH_DOT) return parts;
+    cur.advance();
+  }
+}
+function parseBasicString(cur) {
+  cur.advance();
+  let out = "";
+  let runStart = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (c < 0 || c === CH_LF || c === CH_CR) cur.fail("unterminated string");
+    if (c === CH_QUOTE) {
+      out += cur.src.slice(runStart, cur.pos);
+      cur.advance();
+      return out;
+    }
+    if (c === CH_BACKSLASH) {
+      out += cur.src.slice(runStart, cur.pos);
+      out += parseEscape(cur);
+      runStart = cur.pos;
+      continue;
+    }
+    if (isControl(c)) cur.fail("control characters must be escaped in strings");
+    cur.advance();
+  }
+}
+function parseMultilineBasicString(cur) {
+  cur.pos += 3;
+  if (cur.isNewline()) cur.newline();
+  let out = "";
+  let runStart = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (c < 0) cur.fail("unterminated multi-line string");
+    if (c === CH_QUOTE && cur.peek(1) === CH_QUOTE && cur.peek(2) === CH_QUOTE) {
+      let extra = 0;
+      while (extra < 2 && cur.peek(3 + extra) === CH_QUOTE) extra++;
+      out += cur.src.slice(runStart, cur.pos + extra);
+      cur.pos += 3 + extra;
+      return out;
+    }
+    if (c === CH_BACKSLASH) {
+      out += cur.src.slice(runStart, cur.pos);
+      const save = cur.pos;
+      cur.advance();
+      cur.skipSpaces();
+      if (cur.isNewline()) {
+        cur.skipBlank();
+        runStart = cur.pos;
+        continue;
+      }
+      cur.pos = save;
+      out += parseEscape(cur);
+      runStart = cur.pos;
+      continue;
+    }
+    if (cur.isNewline()) {
+      out += cur.src.slice(runStart, cur.pos);
+      out += "\n";
+      cur.newline();
+      runStart = cur.pos;
+      continue;
+    }
+    if (isControl(c)) cur.fail("control characters must be escaped in strings");
+    cur.advance();
+  }
+}
+function parseEscape(cur) {
+  const at = cur.at();
+  cur.advance();
+  const e = cur.peek();
+  cur.advance();
+  switch (e) {
+    case 98:
+      return "\b";
+    case 116:
+      return "	";
+    case 110:
+      return "\n";
+    case 102:
+      return "\f";
+    case 114:
+      return "\r";
+    case 101:
+      return "\x1B";
+    case CH_QUOTE:
+      return '"';
+    case CH_BACKSLASH:
+      return "\\";
+    case 120:
+      return unicodeEscape(cur, 2, at);
+    case 117:
+      return unicodeEscape(cur, 4, at);
+    case 85:
+      return unicodeEscape(cur, 8, at);
+    default:
+      return cur.fail(`invalid escape sequence \\${e < 0 ? "" : String.fromCharCode(e)}`, at);
+  }
+}
+function unicodeEscape(cur, digits, at) {
+  const hex = cur.src.slice(cur.pos, cur.pos + digits);
+  if (hex.length !== digits || !/^[0-9A-Fa-f]+$/.test(hex)) cur.fail(`escape needs ${digits} hex digits`, at);
+  const code = Number.parseInt(hex, 16);
+  if (code > MAX_CODE_POINT || code >= SURROGATE_LOW && code <= SURROGATE_HIGH) {
+    cur.fail("escape is not a Unicode scalar value", at);
+  }
+  cur.pos += digits;
+  return String.fromCodePoint(code);
+}
+function parseLiteralString(cur) {
+  cur.advance();
+  const start = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (c < 0 || c === CH_LF || c === CH_CR) cur.fail("unterminated string");
+    if (c === CH_APOS) {
+      const value = cur.src.slice(start, cur.pos);
+      cur.advance();
+      return value;
+    }
+    if (isControl(c)) cur.fail("control characters are not allowed in literal strings");
+    cur.advance();
+  }
+}
+function parseMultilineLiteralString(cur) {
+  cur.pos += 3;
+  if (cur.isNewline()) cur.newline();
+  let out = "";
+  let runStart = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (c < 0) cur.fail("unterminated multi-line string");
+    if (c === CH_APOS && cur.peek(1) === CH_APOS && cur.peek(2) === CH_APOS) {
+      let extra = 0;
+      while (extra < 2 && cur.peek(3 + extra) === CH_APOS) extra++;
+      out += cur.src.slice(runStart, cur.pos + extra);
+      cur.pos += 3 + extra;
+      return out;
+    }
+    if (cur.isNewline()) {
+      out += cur.src.slice(runStart, cur.pos);
+      out += "\n";
+      cur.newline();
+      runStart = cur.pos;
+      continue;
+    }
+    if (isControl(c)) cur.fail("control characters are not allowed in literal strings");
+    cur.advance();
+  }
+}
+var INTEGER_DEC = /^[+-]?(0|[1-9](_?[0-9])*)$/;
+var INTEGER_HEX = /^0x[0-9A-Fa-f](_?[0-9A-Fa-f])*$/;
+var INTEGER_OCT = /^0o[0-7](_?[0-7])*$/;
+var INTEGER_BIN = /^0b[01](_?[01])*$/;
+var FLOAT = /^[+-]?(0|[1-9](_?[0-9])*)(\.[0-9](_?[0-9])*)?([eE][+-]?[0-9](_?[0-9])*)?$/;
+var FLOAT_SPECIAL = /^[+-]?(inf|nan)$/;
+function parseNumberOrBool(cur) {
+  const at = cur.at();
+  const start = cur.pos;
+  for (; ; ) {
+    const c = cur.peek();
+    if (isBare(c) || c === CH_PLUS || c === CH_DOT) {
+      cur.advance();
+      continue;
+    }
+    break;
+  }
+  const raw = cur.src.slice(start, cur.pos);
+  if (raw.length === 0) cur.fail(`expected a value, found ${describe(cur.peek())}`, at);
+  if (raw === "true") return { kind: "boolean", value: true, at };
+  if (raw === "false") return { kind: "boolean", value: false, at };
+  if (raw.length > DATE_SEPARATOR_INDEX && isDigit(raw.charCodeAt(0)) && raw.charCodeAt(DATE_SEPARATOR_INDEX) === CH_MINUS) {
+    cur.fail("dates and times are not supported in this file", at);
+  }
+  if (cur.peek() === 58) cur.fail("dates and times are not supported in this file", at);
+  if (INTEGER_DEC.test(raw)) return integer(cur, Number(raw.replaceAll("_", "")), at);
+  if (INTEGER_HEX.test(raw) || INTEGER_OCT.test(raw) || INTEGER_BIN.test(raw)) {
+    return integer(cur, Number(raw.replaceAll("_", "")), at);
+  }
+  if (FLOAT_SPECIAL.test(raw)) {
+    const negative = raw.charCodeAt(0) === CH_MINUS;
+    const value = raw.endsWith("nan") ? Number.NaN : negative ? -Infinity : Infinity;
+    return { kind: "float", value, at };
+  }
+  if (FLOAT.test(raw)) return { kind: "float", value: Number(raw.replaceAll("_", "")), at };
+  return cur.fail(`invalid value '${raw}'`, at);
+}
+function integer(cur, value, at) {
+  if (!Number.isSafeInteger(value)) cur.fail("integer is outside the safe range", at);
+  return { kind: "integer", value, at };
+}
+function parseValue(cur) {
+  const at = cur.at();
+  const c = cur.peek();
+  if (c === CH_QUOTE) {
+    if (cur.peek(1) === CH_QUOTE && cur.peek(2) === CH_QUOTE) {
+      return { kind: "string", value: parseMultilineBasicString(cur), at };
+    }
+    return { kind: "string", value: parseBasicString(cur), at };
+  }
+  if (c === CH_APOS) {
+    if (cur.peek(1) === CH_APOS && cur.peek(2) === CH_APOS) {
+      return { kind: "string", value: parseMultilineLiteralString(cur), at };
+    }
+    return { kind: "string", value: parseLiteralString(cur), at };
+  }
+  if (c === CH_LBRACKET) return parseArray(cur);
+  if (c === CH_LBRACE) return parseInlineTable(cur);
+  return parseNumberOrBool(cur);
+}
+function parseArray(cur) {
+  const at = cur.at();
+  cur.advance();
+  const items = [];
+  for (; ; ) {
+    cur.skipBlank();
+    if (cur.peek() === CH_RBRACKET) {
+      cur.advance();
+      return { kind: "array", items, at, ofTables: false };
+    }
+    items.push(parseValue(cur));
+    cur.skipBlank();
+    const c = cur.peek();
+    if (c === CH_COMMA) {
+      cur.advance();
+      continue;
+    }
+    if (c === CH_RBRACKET) {
+      cur.advance();
+      return { kind: "array", items, at, ofTables: false };
+    }
+    cur.fail(`expected ',' or ']' in array, found ${describe(c)}`);
+  }
+}
+function parseInlineTable(cur) {
+  const table = newTable(cur.at(), "inline");
+  cur.advance();
+  cur.skipSpaces();
+  if (cur.peek() === CH_RBRACE) {
+    cur.advance();
+    return table;
+  }
+  for (; ; ) {
+    const key = parseKey(cur);
+    if (cur.peek() !== CH_EQUALS) cur.fail(`expected '=' after key, found ${describe(cur.peek())}`);
+    cur.advance();
+    cur.skipSpaces();
+    const value = parseValue(cur);
+    assignDotted(cur, table, key, value, "inline");
+    cur.skipSpaces();
+    const c = cur.peek();
+    if (c === CH_COMMA) {
+      cur.advance();
+      cur.skipSpaces();
+      if (cur.peek() === CH_RBRACE) cur.fail("trailing comma is not allowed in an inline table");
+      continue;
+    }
+    if (c === CH_RBRACE) {
+      cur.advance();
+      return table;
+    }
+    cur.fail(`expected ',' or '}' in inline table, found ${describe(c)}`);
+  }
+}
+function joinKey(parts, upTo) {
+  let out = "";
+  for (let i = 0; i <= upTo; i++) out += i === 0 ? parts[i].name : `.${parts[i].name}`;
+  return out;
+}
+function assignDotted(cur, root, key, value, scope) {
+  let table = root;
+  for (let i = 0; i < key.length - 1; i++) {
+    const part = key[i];
+    const existing = table.entries.get(part.name);
+    if (existing === void 0) {
+      const child = newTable(part.at, "dotted");
+      define(table, part, child);
+      table = child;
+      continue;
+    }
+    if (existing.kind !== "table" || existing.origin === "inline" || scope === "body" && existing.origin === "header") {
+      cur.fail(`key '${joinKey(key, i)}' is already defined`, part.at);
+    }
+    if (scope === "body" && existing.origin === "implicit") {
+      cur.fail(`key '${joinKey(key, i)}' is already defined as a table`, part.at);
+    }
+    table = existing;
+  }
+  const last = key[key.length - 1];
+  if (table.entries.has(last.name)) cur.fail(`key '${joinKey(key, key.length - 1)}' is already defined`, last.at);
+  define(table, last, value);
+}
+function openHeader(cur, root, key, arrayOfTables) {
+  let table = root;
+  for (let i = 0; i < key.length - 1; i++) {
+    const part = key[i];
+    const existing2 = table.entries.get(part.name);
+    if (existing2 === void 0) {
+      const child = newTable(part.at, "implicit");
+      define(table, part, child);
+      table = child;
+      continue;
+    }
+    if (existing2.kind === "array" && existing2.ofTables) {
+      table = existing2.items[existing2.items.length - 1];
+      continue;
+    }
+    if (existing2.kind !== "table" || existing2.origin === "inline") {
+      cur.fail(`key '${joinKey(key, i)}' is already defined as a value`, part.at);
+    }
+    table = existing2;
+  }
+  const last = key[key.length - 1];
+  const existing = table.entries.get(last.name);
+  if (arrayOfTables) {
+    const element = newTable(last.at, "array_element");
+    if (existing === void 0) {
+      define(table, last, { kind: "array", items: [element], at: last.at, ofTables: true });
+      return element;
+    }
+    if (existing.kind !== "array" || !existing.ofTables) {
+      cur.fail(`key '${joinKey(key, key.length - 1)}' is already defined and is not an array of tables`, last.at);
+    }
+    existing.items.push(element);
+    return element;
+  }
+  if (existing === void 0) {
+    const child = newTable(last.at, "header");
+    define(table, last, child);
+    return child;
+  }
+  if (existing.kind === "table" && existing.origin === "implicit") {
+    existing.origin = "header";
+    return existing;
+  }
+  return cur.fail(`table '${joinKey(key, key.length - 1)}' is already defined`, last.at);
+}
+function parseToml(source) {
+  const cur = new Cursor(source.charCodeAt(0) === 65279 ? source.slice(1) : source);
+  const root = newTable({ line: 1, column: 1 }, "root");
+  let current = root;
+  for (; ; ) {
+    cur.skipBlank();
+    if (cur.done()) return root;
+    if (cur.peek() === CH_LBRACKET) {
+      const arrayOfTables = cur.peek(1) === CH_LBRACKET;
+      cur.pos += arrayOfTables ? 2 : 1;
+      const key2 = parseKey(cur);
+      if (cur.peek() !== CH_RBRACKET || arrayOfTables && cur.peek(1) !== CH_RBRACKET) {
+        cur.fail(arrayOfTables ? "expected ']]' to close the table header" : "expected ']' to close the table header");
+      }
+      cur.pos += arrayOfTables ? 2 : 1;
+      current = openHeader(cur, root, key2, arrayOfTables);
+      cur.endOfLine();
+      continue;
+    }
+    const key = parseKey(cur);
+    if (cur.peek() !== CH_EQUALS) cur.fail(`expected '=' after key, found ${describe(cur.peek())}`);
+    cur.advance();
+    cur.skipSpaces();
+    if (cur.done() || cur.isNewline()) cur.fail("expected a value after '='");
+    const value = parseValue(cur);
+    assignDotted(cur, current, key, value, "body");
+    cur.endOfLine();
+  }
+}
+function quoteTomlString(value) {
+  let out = '"';
+  for (let i = 0; i < value.length; i++) {
+    const c = value.charCodeAt(i);
+    if (c === CH_QUOTE) out += '\\"';
+    else if (c === CH_BACKSLASH) out += "\\\\";
+    else if (c === CH_LF) out += "\\n";
+    else if (c === CH_TAB) out += "\\t";
+    else if (c === CH_CR) out += "\\r";
+    else if (c < CH_SPACE || c === CH_DEL) out += `\\u${c.toString(16).padStart(4, "0")}`;
+    else out += value[i];
+  }
+  return `${out}"`;
+}
+
+export { TomlSyntaxError, parseToml, quoteTomlString };