@aventara/prisma7-adapter 0.1.0-pilot.0

package/dist/discovery/schema.reader.js

@@ -0,0 +1,692 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+export class PrismaSchemaReaderError extends Error {
+    name = "PrismaSchemaReaderError";
+}
+/** Field attributes this reader models. Anything else is recorded, not dropped. */
+const FIELD_ATTRIBUTES = new Set([
+    "@id",
+    "@unique",
+    "@updatedAt",
+    "@default",
+    "@relation",
+    "@ignore",
+]);
+/** Block attributes this reader models. */
+const BLOCK_ATTRIBUTES = new Set(["@@id", "@@unique", "@@ignore"]);
+/** `@relation` arguments this reader models. A positional argument is the name. */
+const RELATION_ARGUMENTS = new Set([
+    "name",
+    "fields",
+    "references",
+    "onDelete",
+    "onUpdate",
+]);
+/**
+ * Bucket 2 at `@relation`'s argument level. `map:` names the foreign-key
+ * CONSTRAINT — measured at 7.10.0, `@relation(…, map: "beta_alpha_fk")` renders
+ * `ALTER TABLE "B" ADD CONSTRAINT "beta_alpha_fk" FOREIGN KEY …`, and that name
+ * appears nowhere else. It fails the surface test and the reason behind it
+ * alike, which is what separates it from `onDelete`/`onUpdate` on the same
+ * attribute.
+ */
+const DISCARDED_RELATION_ARGUMENTS = new Set(["map"]);
+/**
+ * PSL's referential-action spellings, renamed into Aventara's words. PSL writes
+ * the SQL-standard set in PascalCase, so this is a rename, not a translation,
+ * and no Prisma spelling travels with the fact.
+ *
+ * A sixth spelling is bucket 3 rather than a guess: an action this reader cannot
+ * name is an action a planner would silently mis-plan around.
+ */
+const REFERENTIAL_ACTIONS = {
+    Cascade: "cascade",
+    Restrict: "restrict",
+    NoAction: "no-action",
+    SetNull: "set-null",
+    SetDefault: "set-default",
+};
+/**
+ * **Bucket 2 — recognised and deliberately discarded.** DB-naming and
+ * physical-layout concerns with no Aventara vocabulary at all.
+ *
+ * The list is explicit on purpose: the discard is then a decision a reader can
+ * see and audit, not an omission. Bucket 1 is `FIELD_ATTRIBUTES`,
+ * `BLOCK_ATTRIBUTES`, `@db.*` and `RELATION_ARGUMENTS`; bucket 3 is everything
+ * on neither list, which is recorded in `unhandled` and stops the build.
+ */
+const DISCARDED_ATTRIBUTES = new Set(["@map", "@@map", "@@index"]);
+/**
+ * Bucket 2 at argument level: the named arguments of a **handled** block
+ * attribute that this reader discards. `map:`'s index name is the only one —
+ * measured at 7.10.0, it reaches nothing but the 🛑 `internal/class.ts`
+ * inline-schema blob, so no value of it can ever be observed through Aventara.
+ *
+ * `name:` was on this list and is **not** any more (2026-09-29): a custom name
+ * REPLACES the positional compound alias in `WhereUniqueInput` and in the
+ * `AtLeast` key union, so it is a public-API fact, it is modelled
+ * ({@link PrismaSchemaBlockIdentifier}), and this list is where discarding it
+ * silently broke addressing for every named identifier.
+ *
+ * An argument on neither this list nor `@@id`/`@@unique`'s modelled set is
+ * bucket 3.
+ */
+const DISCARDED_BLOCK_ATTRIBUTE_ARGUMENTS = new Set(["map"]);
+/** The named arguments of `@@id`/`@@unique` this reader models, besides the list. */
+const BLOCK_IDENTIFIER_ARGUMENTS = new Set(["name"]);
+/**
+ * The argument name under which `@@id`/`@@unique` may carry its member list.
+ *
+ * PSL accepts the SAME list positionally or named — `@@unique([b, a])` and
+ * `@@unique(fields: [b, a])` are one constraint, and a generated client keys both
+ * `b_a` (verified with `prisma validate` and a generated client at 7.10.0,
+ * 2026-09-29). Which spelling is used is therefore not a fact about the schema,
+ * and no argument here is located by POSITION.
+ */
+const BLOCK_IDENTIFIER_LIST_ARGUMENT = "fields";
+/** A member this reader can locate: a field name and nothing else. */
+const PLAIN_NAME = /^[A-Za-z_]\w*$/;
+const BLOCK_KEYWORDS = new Set([
+    "model",
+    "enum",
+    "generator",
+    "datasource",
+    "type",
+    "view",
+]);
+/**
+ * Reads a schema file, or a schema **folder** (Prisma 7 accepts either).
+ * A folder is read as readdir-plus-merge in filename order.
+ */
+export async function readPrismaSchema(location) {
+    const stats = await stat(location).catch((cause) => {
+        throw new PrismaSchemaReaderError(`the Prisma schema at ${location} could not be read`, { cause });
+    });
+    const files = stats.isDirectory()
+        ? (await readdir(location))
+            .filter((entry) => entry.endsWith(".prisma"))
+            .sort()
+            .map((entry) => path.join(location, entry))
+        : [location];
+    if (files.length === 0) {
+        throw new PrismaSchemaReaderError(`the Prisma schema folder at ${location} contains no .prisma file`);
+    }
+    const sources = [];
+    for (const file of files) {
+        sources.push({ file, text: await readFile(file, "utf8") });
+    }
+    return readPrismaSchemaSources(sources);
+}
+/**
+ * The reader proper, over text already in hand. Merging several sources is
+ * concatenation: blocks are file-local and references are by name.
+ */
+export function readPrismaSchemaSources(sources) {
+    const enums = [];
+    const models = [];
+    const unhandled = [];
+    for (const source of sources) {
+        readOneSource(source, enums, models, unhandled);
+    }
+    return { enums, models, unhandled };
+}
+function readOneSource(source, enums, models, unhandled) {
+    let open = null;
+    const lines = source.text.split("\n");
+    // Relations whose action argument this reader could not NAME. They are
+    // recorded in `unhandled` and must not then be handed a default: a resolved
+    // action is a claim about what a delete does, and the reader has just said it
+    // does not know. Kept beside the facts rather than on them, so the public
+    // shape carries no "unreadable" state that no consumer can ever observe (a
+    // non-empty `unhandled` fails the generate step first).
+    const unreadableActions = new Set();
+    for (const [index, raw] of lines.entries()) {
+        const site = { file: source.file, line: index + 1 };
+        // Comments go first, and go away string-aware: `"a, b // not a comment"`
+        // carries a `//` that is data, not a comment.
+        const line = stripComment(raw).trim();
+        if (line.length === 0) {
+            continue;
+        }
+        const record = (kind, spelling, text) => {
+            unhandled.push({
+                kind,
+                spelling,
+                text,
+                block: open === null ? null : open.name,
+                site,
+            });
+        };
+        if (open === null) {
+            open = openBlock(line, site, record);
+            continue;
+        }
+        if (line === "}") {
+            if (open.kind === "enum") {
+                enums.push({ name: open.name, values: open.values, site: open.site });
+            }
+            else if (open.kind === "model") {
+                models.push({
+                    name: open.name,
+                    // Defaults resolve HERE and not on the field line: the default
+                    // turns on the foreign key's optionality, and a `@relation` may
+                    // name a scalar declared below it.
+                    fields: resolvePrismaReferentialDefaults(open.fields, unreadableActions),
+                    blockId: open.blockId,
+                    blockUniques: open.blockUniques,
+                    ignored: open.ignored,
+                    site: open.site,
+                });
+            }
+            open = null;
+            continue;
+        }
+        if (open.kind === "skip") {
+            continue;
+        }
+        if (open.kind === "enum") {
+            // An enum body carries members and block attributes. `@@map` on the enum
+            // is bucket 2 like every other `@@map`; anything else `@@` is bucket 3.
+            if (line.startsWith("@@")) {
+                for (const attribute of splitAttributes(line)) {
+                    const name = attributeName(attribute);
+                    if (!DISCARDED_ATTRIBUTES.has(name)) {
+                        record("block-attribute", name, attribute);
+                    }
+                }
+                continue;
+            }
+            // A member is a name, optionally followed by attributes. A member-level
+            // `@map` falls into bucket 2 and is no longer a special case, so the
+            // attributes are located only far enough to find where the name ends.
+            const attributes = splitAttributes(line);
+            const name = line.slice(0, firstTopLevelAt(line) ?? line.length).trim();
+            if (!/^[A-Za-z_]\w*$/.test(name)) {
+                record("line", "enum-member", line);
+                continue;
+            }
+            for (const attribute of attributes) {
+                const attributeName_ = attributeName(attribute);
+                if (!DISCARDED_ATTRIBUTES.has(attributeName_)) {
+                    record("field-attribute", attributeName_, attribute);
+                }
+            }
+            open.values.push(name);
+            continue;
+        }
+        if (line.startsWith("@@")) {
+            readBlockAttributeLine(line, open, record);
+            continue;
+        }
+        const field = readFieldLine(line, site, record, unreadableActions);
+        if (field !== null) {
+            open.fields.push(field);
+        }
+    }
+    if (open !== null) {
+        throw new PrismaSchemaReaderError(`${source.file} ends inside the block "${open.name}"`);
+    }
+}
+function openBlock(line, site, record) {
+    const match = /^([A-Za-z_]\w*)\s+([A-Za-z_]\w*)\s*\{/.exec(line);
+    const keyword = match?.[1];
+    const name = match?.[2];
+    if (keyword === undefined || name === undefined) {
+        record("line", "top-level", line);
+        return null;
+    }
+    if (!BLOCK_KEYWORDS.has(keyword)) {
+        record("block", keyword, line);
+        return { kind: "skip", name };
+    }
+    if (keyword === "model") {
+        return {
+            kind: "model",
+            name,
+            site,
+            fields: [],
+            blockId: null,
+            blockUniques: [],
+            ignored: false,
+        };
+    }
+    if (keyword === "enum") {
+        return { kind: "enum", name, site, values: [] };
+    }
+    if (keyword === "type" || keyword === "view") {
+        // Modelling these would be evaluating, not locating (see the header).
+        record("block", keyword, line);
+    }
+    return { kind: "skip", name };
+}
+function readBlockAttributeLine(line, open, record) {
+    const attributes = splitAttributes(line);
+    if (attributes.length !== 1) {
+        // `prisma validate` rejects two block attributes on one line with P1012
+        // (case 3 in the header), so this is unreachable through the real tool.
+        // It is recorded rather than assumed away.
+        record("line", "block-attribute-line", line);
+        return;
+    }
+    const attribute = attributes[0];
+    const name = attributeName(attribute);
+    if (DISCARDED_ATTRIBUTES.has(name)) {
+        // Bucket 2. `@@map` and `@@index` are DB-naming and physical-layout only.
+        return;
+    }
+    if (!BLOCK_ATTRIBUTES.has(name)) {
+        record("block-attribute", name, attribute);
+        return;
+    }
+    if (name === "@@ignore") {
+        open.ignored = true;
+        return;
+    }
+    // Every argument is classified BY NAME, never by position. PSL writes the
+    // member list either positionally or as `fields:`, and lets the named
+    // arguments come in any order; all eight spellings of `@@unique` and all five
+    // of `@@id` are accepted by `prisma validate` 7.10.0 (measured 2026-09-29).
+    // Reading the list as "the first argument" is what made the reader take
+    // `@@unique(fields: [b, a])` as one member called `fields: [b, a]`, silently,
+    // and the generate step then refused a schema Prisma accepts.
+    //
+    // The other arguments are classified, not skipped: `name:` is modelled (its
+    // value is an `AtLeast` key), `map:` is bucket 2 (invisible on the 🟢
+    // surface), and an argument spelling this reader has never seen is bucket 3
+    // and stops the build.
+    //
+    // Member order follows THE ATTRIBUTE'S LIST, never the field declaration
+    // order: `@@unique([y, x])` is `["y", "x"]` even where `x` is declared first.
+    let members = null;
+    let unlocatable = false;
+    let alias = null;
+    for (const argument of splitTopLevel(argumentText(attribute) ?? "", ",")) {
+        const keyed = /^([A-Za-z_]\w*)\s*:\s*([\s\S]*)$/.exec(argument);
+        const key = keyed?.[1];
+        const value = keyed?.[2] ?? argument;
+        if (key === undefined || key === BLOCK_IDENTIFIER_LIST_ARGUMENT) {
+            // The positional argument IS the member list, and `fields:` is that
+            // same list named; PSL rejects a declaration carrying both.
+            const located = listMembers(value);
+            if (located === null) {
+                unlocatable = true;
+                continue;
+            }
+            members = located;
+            continue;
+        }
+        if (BLOCK_IDENTIFIER_ARGUMENTS.has(key)) {
+            // Located and unquoted, never evaluated: PSL writes it as a string
+            // literal and Prisma spells the key with exactly those characters.
+            alias = unquote(value);
+            continue;
+        }
+        if (!DISCARDED_BLOCK_ATTRIBUTE_ARGUMENTS.has(key)) {
+            record("attribute-argument", key, argument);
+        }
+    }
+    if (members === null || unlocatable) {
+        // Bucket 3, and deliberately not a guess: a member spelled `a(sort: Desc)`
+        // — valid PSL at 7.10.0 — cannot be reduced to a field name without
+        // EVALUATING it, which this reader does not do. Recorded, so the generate
+        // step stops loudly rather than emitting an identifier over a column no
+        // `AdapterFieldMap` carries.
+        record("block-attribute", name, attribute);
+        return;
+    }
+    const identifier = { members, name: alias };
+    if (name === "@@id") {
+        open.blockId = identifier;
+    }
+    else {
+        open.blockUniques.push(identifier);
+    }
+}
+function readFieldLine(line, site, record, unreadableActions) {
+    const attributeStart = firstTopLevelAt(line);
+    const declaration = (attributeStart === null ? line : line.slice(0, attributeStart)).trim();
+    const tokens = declaration.split(/\s+/).filter((t) => t.length > 0);
+    const name = tokens[0];
+    const written = tokens[1];
+    if (tokens.length !== 2 || name === undefined || written === undefined) {
+        // `prisma validate` rejects a split field declaration with P1012 (case 4 in
+        // the header), so this is unreachable through the real tool.
+        record("line", "field-declaration", line);
+        return null;
+    }
+    const list = written.endsWith("[]");
+    const optional = written.endsWith("?");
+    const type = written.replace(/(\[\]|\?)$/, "");
+    let id = false;
+    let unique = false;
+    let updatedAt = false;
+    let ignored = false;
+    let defaultArgument = null;
+    let relation = null;
+    const native = [];
+    for (const attribute of attributeStart === null
+        ? []
+        : splitAttributes(line.slice(attributeStart))) {
+        const attributeName_ = attributeName(attribute);
+        if (attributeName_.startsWith("@db.")) {
+            // A hint only, kept exactly as written.
+            native.push(attribute);
+            continue;
+        }
+        if (DISCARDED_ATTRIBUTES.has(attributeName_)) {
+            // Bucket 2. A field-level `@map` names a column; Aventara has no
+            // vocabulary for a column name, and recording it here would fail the
+            // generate step on most real Prisma schemas.
+            continue;
+        }
+        if (!FIELD_ATTRIBUTES.has(attributeName_)) {
+            record("field-attribute", attributeName_, attribute);
+            continue;
+        }
+        switch (attributeName_) {
+            case "@id":
+                id = true;
+                break;
+            case "@unique":
+                unique = true;
+                break;
+            case "@updatedAt":
+                updatedAt = true;
+                break;
+            case "@ignore":
+                ignored = true;
+                break;
+            case "@default":
+                // RAW TEXT. Matched against a table downstream, never parsed here.
+                defaultArgument = argumentText(attribute);
+                break;
+            default:
+                relation = readRelationAttribute(attribute, record, unreadableActions);
+                break;
+        }
+    }
+    return {
+        name,
+        type,
+        list,
+        optional,
+        id,
+        unique,
+        updatedAt,
+        defaultArgument,
+        relation,
+        native,
+        ignored,
+        site,
+    };
+}
+function readRelationAttribute(attribute, record, unreadableActions) {
+    let name = null;
+    let fields = null;
+    let references = null;
+    let onDelete = null;
+    let onUpdate = null;
+    let unreadableAction = false;
+    for (const argument of splitTopLevel(argumentText(attribute) ?? "", ",")) {
+        const keyed = /^([A-Za-z_]\w*)\s*:\s*([\s\S]*)$/.exec(argument);
+        if (keyed === null) {
+            // A positional argument is the relation name — the ONLY evidence
+            // pairing a back-reference with its forward reference.
+            name = unquote(argument);
+            continue;
+        }
+        const key = keyed[1];
+        const value = keyed[2].trim();
+        if (DISCARDED_RELATION_ARGUMENTS.has(key)) {
+            // Bucket 2: a foreign-key constraint name, and nothing else.
+            continue;
+        }
+        if (!RELATION_ARGUMENTS.has(key)) {
+            record("attribute-argument", key, argument);
+            continue;
+        }
+        if (key === "name") {
+            name = unquote(value);
+            continue;
+        }
+        if (key === "onDelete" || key === "onUpdate") {
+            // Located, then renamed through a closed table. An enum member is
+            // written bare in PSL, so this is a lookup and not an evaluation.
+            const action = REFERENTIAL_ACTIONS[value];
+            if (action === undefined) {
+                record("attribute-argument", key, argument);
+                unreadableAction = true;
+                continue;
+            }
+            if (key === "onDelete") {
+                onDelete = action;
+            }
+            else {
+                onUpdate = action;
+            }
+            continue;
+        }
+        // `fields:`/`references:` are located the same way the block attributes'
+        // list is, and by the same rule: a member this reader cannot reduce to a
+        // field name without evaluating it is bucket 3, not a guess.
+        const located = listMembers(value);
+        if (located === null) {
+            record("attribute-argument", key, argument);
+            continue;
+        }
+        if (key === "fields") {
+            fields = located;
+        }
+        else {
+            references = located;
+        }
+    }
+    const relation = {
+        name,
+        fields,
+        references,
+        onDelete,
+        onUpdate,
+    };
+    if (unreadableAction) {
+        unreadableActions.add(relation);
+    }
+    return relation;
+}
+/**
+ * Absent `onDelete`/`onUpdate` replaced by Prisma's **effective** default, on the
+ * owning edges of one model.
+ *
+ * An absent action and the explicitly-written default are one fact about what a
+ * delete does, so there is no third state to carry. What the default IS was
+ * measured at 7.10.0 with
+ * `prisma migrate diff --from-empty --to-schema <file> --script`, identical on
+ * `postgresql` and `sqlite` (2026-09-29):
+ *
+ * ```text
+ *   alphaId String   alpha Alpha   → ON DELETE RESTRICT ON UPDATE CASCADE
+ *   alphaId String?  alpha Alpha?  → ON DELETE SET NULL ON UPDATE CASCADE
+ *   aId String, aK String?  a A?   → ON DELETE RESTRICT ON UPDATE CASCADE
+ * ```
+ *
+ * The third line is why the discriminant is stated as it is. The plain reading —
+ * "a required relation restricts, an optional one nulls" — is wrong: the
+ * relation field's own `?` does not decide it. `SET NULL` appears exactly when
+ * **every** scalar in `fields:` is optional, which is the only case where the
+ * database can actually write the null. A compound key with one required member
+ * restricts, and so does an optional relation field over a required foreign key.
+ *
+ * A foreign key naming no sibling is left non-optional here, which resolves to
+ * `restrict`; `field.mapper.ts` throws on that schema before any consumer reads
+ * the action.
+ */
+function resolvePrismaReferentialDefaults(fields, unreadableActions) {
+    const optionalByName = new Map(fields.map((field) => [field.name, field.optional]));
+    return fields.map((field) => {
+        const relation = field.relation;
+        // `fields:` is what makes an edge the owning side, and PSL forbids the
+        // other side from carrying an action at all — so a back-reference keeps
+        // `null`, which reads as "ask the other edge".
+        if (relation === null || relation.fields === null) {
+            return field;
+        }
+        if (unreadableActions.has(relation)) {
+            return field;
+        }
+        const nullable = relation.fields.length > 0 &&
+            relation.fields.every((name) => optionalByName.get(name) === true);
+        return {
+            ...field,
+            relation: {
+                ...relation,
+                onDelete: relation.onDelete ?? (nullable ? "set-null" : "restrict"),
+                onUpdate: relation.onUpdate ?? "cascade",
+            },
+        };
+    });
+}
+/* ------------------------------------------------------------------ *
+ * Locating primitives. Every one of these finds where a token is; not *
+ * one of them decides what a token means.                            *
+ * ------------------------------------------------------------------ */
+/** Removes a `//` comment, string-aware: a `//` inside a string literal is data. */
+function stripComment(line) {
+    let inString = false;
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i];
+        if (inString) {
+            if (ch === "\\") {
+                i += 1;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === "/" && line[i + 1] === "/") {
+            return line.slice(0, i);
+        }
+    }
+    return line;
+}
+/** The index of the first attribute `@` outside strings and brackets, or null. */
+function firstTopLevelAt(text) {
+    for (const index of topLevelAtIndexes(text)) {
+        return index;
+    }
+    return null;
+}
+function* topLevelAtIndexes(text) {
+    let depth = 0;
+    let inString = false;
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === "\\") {
+                i += 1;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+        }
+        else if (ch === "(" || ch === "[") {
+            depth += 1;
+        }
+        else if (ch === ")" || ch === "]") {
+            depth -= 1;
+        }
+        else if (ch === "@" && depth === 0 && text[i - 1] !== "@") {
+            // `@@` is one marker, not two attributes.
+            yield i;
+        }
+    }
+}
+/** Splits `@a(1) @@b([x])` into whole attributes, strings and brackets respected. */
+function splitAttributes(text) {
+    const starts = [...topLevelAtIndexes(text)];
+    return starts
+        .map((start, position) => text.slice(start, starts[position + 1] ?? text.length).trim())
+        .filter((attribute) => attribute.length > 0);
+}
+/** `@db.Decimal(10, 2)` → `@db.Decimal`; `@@unique([y, x])` → `@@unique`. */
+function attributeName(attribute) {
+    return /^@@?[A-Za-z_][\w.]*/.exec(attribute)?.[0] ?? attribute;
+}
+/** The text between an attribute's outermost parentheses, or null when it has none. */
+function argumentText(attribute) {
+    const open = attribute.indexOf("(");
+    if (open < 0 || !attribute.trimEnd().endsWith(")")) {
+        return null;
+    }
+    return attribute
+        .trimEnd()
+        .slice(open + 1, -1)
+        .trim();
+}
+/**
+ * A `[…]` argument's members in written order, or **null** when the value is not
+ * a list of plain field names.
+ *
+ * Null is the locator's honest answer, and the caller turns it into an
+ * `unhandled` entry. Two shapes reach it, both valid PSL at 7.10.0: a member
+ * carrying an argument of its own (`@@unique([a(sort: Desc)])`), and a value that
+ * is not a list at all. Either one would have to be EVALUATED to yield a field
+ * name, and a reader that guesses here emits an identifier over a column that
+ * does not exist — which is exactly how the named-list defect stayed silent.
+ */
+function listMembers(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+        return null;
+    }
+    const members = splitTopLevel(trimmed.slice(1, -1), ",");
+    return members.every((member) => PLAIN_NAME.test(member)) ? members : null;
+}
+/** Splits on a separator at bracket depth 0, outside string literals. */
+function splitTopLevel(text, separator) {
+    const out = [];
+    let depth = 0;
+    let inString = false;
+    let start = 0;
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === "\\") {
+                i += 1;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+        }
+        else if (ch === "(" || ch === "[") {
+            depth += 1;
+        }
+        else if (ch === ")" || ch === "]") {
+            depth -= 1;
+        }
+        else if (ch === separator && depth === 0) {
+            out.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    out.push(text.slice(start).trim());
+    return out.filter((piece) => piece.length > 0);
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    return trimmed.startsWith('"') && trimmed.endsWith('"')
+        ? trimmed.slice(1, -1)
+        : trimmed;
+}