@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/prisma/PrismaFileScanner.js

@@ -1,361 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrismaFileScanner = void 0;
-const SourceText_1 = require("../../internal/SourceText");
-const PrismaSyntax_1 = require("./PrismaSyntax");
-const BLOCK_KEYWORDS = new Set([
-    "model",
-    "view",
-    "type",
-    "enum",
-    "datasource",
-    "generator",
-]);
-const MEMBER_BLOCKS = new Set(["model", "view", "type"]);
-/** Locates physical Prisma declarations and documentation without parsing semantics.
- *
- * The whole-schema parser remains responsible for deciding which declarations
- * exist. This scanner supplies its source spans and comment-coordinate maps so
- * those semantic declarations can own accurate sites and documentation.
- */
-class PrismaFileScanner {
-    source;
-    /** Holds raw source lines in scan order, preserving a final empty line.
-     *
-     * Parallel coordinate arrays translate each line's local positions back to
-     * the immutable source snapshot.
-     */
-    lines;
-    /** Stores the UTF-16 offset at which each source line begins.
-     *
-     * Missing defensive entries fall back to the source boundary when malformed
-     * line state is encountered.
-     */
-    lineStarts = [];
-    /** Stores the UTF-16 offset immediately after each line's content.
-     *
-     * Carriage returns are excluded because declaration ranges use content-only
-     * line boundaries.
-     */
-    lineEnds = [];
-    /** Stores the offset of each line's newline character or line terminus.
-     *
-     * Comment-run maps use these positions for newlines introduced between
-     * fragments on different source lines.
-     */
-    newlineOffsets = [];
-    /** Translates scanner offsets into Evidence source ranges.
-     *
-     * All locations and comment carriers use this one coordinate authority.
-     */
-    text;
-    /** Initializes line and coordinate indexes for one immutable source snapshot.
-     *
-     * The scanner borrows no parser session because it deliberately recognizes
-     * only structural Prisma positions and comments.
-     */
-    constructor(source) {
-        this.source = source;
-        this.text = new SourceText_1.SourceText(source.content);
-        this.lines = source.content.split("\n");
-        let offset = 0;
-        for (const raw of this.lines) {
-            const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
-            this.lineStarts.push(offset);
-            this.lineEnds.push(offset + line.length);
-            this.newlineOffsets.push(offset + raw.length);
-            offset += raw.length + 1;
-        }
-    }
-    /** Scans declaration positions and contiguous comment runs for the source.
-     *
-     * It flushes pending comments whenever syntax breaks adjacency, preserving
-     * detached carriers instead of attaching them to a later declaration.
-     */
-    scan() {
-        const locations = new Map();
-        const comments = [];
-        let pending = [];
-        let depth = 0;
-        let block = "";
-        let addressable = false;
-        let commented = false;
-        // A run is attached only at the next recognized location; all other syntax
-        // flushes it so a detached comment cannot document a later declaration.
-        const flush = (key) => {
-            comments.push(...this.runs(pending, key));
-            pending = [];
-        };
-        const record = (key, line) => {
-            if (key === "" || locations.has(key))
-                return;
-            locations.set(key, {
-                key,
-                range: this.text.range(this.lineStarts[line] ?? 0, this.lineEnds[line] ?? this.source.content.length),
-            });
-        };
-        for (let index = 0; index < this.lines.length; ++index) {
-            const parts = this.parts(index, commented);
-            commented = parts.commented;
-            const trimmed = parts.code.trim();
-            if (parts.comment !== undefined) {
-                parts.comment.topLevel = depth === 0;
-                parts.comment.trailing = trimmed !== "";
-                pending.push(parts.comment);
-            }
-            if (trimmed === "") {
-                if (parts.comment === undefined && depth === 0)
-                    flush("");
-                continue;
-            }
-            const opens = count(parts.code, "{");
-            const closes = count(parts.code, "}");
-            if (depth === 0 && opens !== 0) {
-                const head = blockHead(trimmed);
-                block = "";
-                addressable = false;
-                if (head === undefined)
-                    flush("");
-                else {
-                    block = head.name;
-                    addressable = MEMBER_BLOCKS.has(head.keyword);
-                    if (addressable)
-                        record(head.name, index);
-                    flush(head.name);
-                }
-            }
-            else if (depth === 1 && block !== "") {
-                const member = memberName(trimmed);
-                if (member === undefined)
-                    flush("");
-                else {
-                    if (addressable)
-                        record(`${block}.${member}`, index);
-                    flush(`${block}.${member}`);
-                }
-            }
-            else
-                flush("");
-            depth += opens - closes;
-            if (depth <= 0) {
-                depth = 0;
-                block = "";
-                addressable = false;
-            }
-        }
-        flush("");
-        return {
-            source: this.source,
-            locations: Array.from(locations.values()),
-            comments,
-        };
-    }
-    /** Separates code from a line comment while carrying block-comment state.
-     *
-     * Quotes suppress comment delimiters so URL-like and escaped string content
-     * cannot alter declaration scanning or comment attachment.
-     */
-    parts(line, initiallyCommented) {
-        const raw = this.lines[line] ?? "";
-        const content = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
-        const start = this.lineStarts[line] ?? 0;
-        let code = "";
-        let form = initiallyCommented
-            ? "block"
-            : undefined;
-        let commented = initiallyCommented;
-        let quoted = false;
-        let commentStart = -1;
-        let commentEnd = -1;
-        let comment = "";
-        const offsets = [];
-        const ends = [];
-        for (let index = 0; index < content.length; ++index) {
-            const character = content[index] ?? "";
-            if (commented) {
-                if (commentStart < 0)
-                    commentStart = index;
-                if (character === "*" && content[index + 1] === "/") {
-                    commented = false;
-                    commentEnd = index + 2;
-                    ++index;
-                }
-                else {
-                    comment += character;
-                    offsets.push(start + index);
-                    ends.push(start + index + 1);
-                }
-                continue;
-            }
-            if (quoted) {
-                if (character === "\\")
-                    ++index;
-                else if (character === '"')
-                    quoted = false;
-                continue;
-            }
-            if (character === '"') {
-                quoted = true;
-                continue;
-            }
-            if (character === "/" && content[index + 1] === "/") {
-                commentStart = commentStart < 0 ? index : commentStart;
-                const documented = content[index + 2] === "/";
-                form ??= documented ? "doc" : "line";
-                index += documented ? 2 : 1;
-                for (++index; index < content.length; ++index) {
-                    comment += content[index] ?? "";
-                    offsets.push(start + index);
-                    ends.push(start + index + 1);
-                }
-                commentEnd = content.length;
-                break;
-            }
-            if (character === "/" && content[index + 1] === "*") {
-                commentStart = commentStart < 0 ? index : commentStart;
-                form ??= "block";
-                commented = true;
-                ++index;
-                continue;
-            }
-            code += character;
-        }
-        if (form === undefined)
-            return {
-                code,
-                commented,
-            };
-        if (commentEnd < 0)
-            commentEnd = content.length;
-        let trimmed = trimMapped(comment, offsets, ends);
-        if (form === "block" && trimmed.text.startsWith("*"))
-            trimmed = trimMapped(trimmed.text.slice(1), trimmed.offsets.slice(1), trimmed.ends.slice(1));
-        return {
-            code,
-            commented,
-            comment: {
-                form,
-                line,
-                text: trimmed.text,
-                offsets: trimmed.offsets,
-                ends: trimmed.ends,
-                range: this.text.range(start + Math.max(0, commentStart), start + commentEnd),
-                trailing: false,
-                topLevel: false,
-            },
-        };
-    }
-    /** Converts pending fragments into attached and detached documentation runs.
-     *
-     * Ordinary or trailing line comments remain separate carriers, while
-     * non-trailing documentation forms are grouped for one eligible key.
-     */
-    runs(pending, key) {
-        if (pending.length === 0)
-            return [];
-        const output = [];
-        const documenting = pending.filter((comment) => comment.form !== "line" && !comment.trailing);
-        for (const comment of pending)
-            if (comment.form === "line" || comment.trailing)
-                output.push(this.run([comment], "", false, comment.form));
-        if (documenting.length !== 0)
-            output.push(this.run(documenting, key, key === "" &&
-                documenting.every((comment) => comment.topLevel && comment.form === "doc"), "doc"));
-        return output;
-    }
-    /** Builds one mapped run from source-order comment fragments.
-     *
-     * Explicit newline entries preserve a continuous documentation string even
-     * when adjacent source comments occur on different lines.
-     */
-    run(comments, key, fileLevel, form) {
-        const first = comments[0];
-        const last = comments.at(-1);
-        if (first === undefined || last === undefined)
-            throw new Error("A Prisma comment run cannot be empty.");
-        const byLine = new Map(comments.map((comment) => [comment.line, comment]));
-        let text = "";
-        const offsets = [];
-        const ends = [];
-        for (let line = first.line; line <= last.line; ++line) {
-            const comment = byLine.get(line);
-            if (comment !== undefined) {
-                text += comment.text;
-                offsets.push(...comment.offsets);
-                ends.push(...comment.ends);
-            }
-            if (line !== last.line) {
-                const newline = this.newlineOffsets[line] ?? this.source.content.length;
-                text += "\n";
-                offsets.push(newline);
-                ends.push(Math.min(newline + 1, this.source.content.length));
-            }
-        }
-        offsets.push(ends.at(-1) ?? last.range.end.offset);
-        return {
-            form,
-            key,
-            fileLevel,
-            text,
-            offsets,
-            ends,
-            range: this.text.range(first.range.start.offset, last.range.end.offset),
-            commentRanges: comments.map((comment) => comment.range),
-        };
-    }
-}
-exports.PrismaFileScanner = PrismaFileScanner;
-/** Recognizes a top-level Prisma block header from structural source text.
- *
- * It accepts only known block keywords and valid identifiers, leaving semantic
- * acceptance to Prisma's whole-schema parser.
- */
-function blockHead(line) {
-    const fields = line.split(/\s+/u);
-    const keyword = fields[0];
-    const second = fields[1];
-    const name = second === undefined ? undefined : second.replace(/\{$/u, "");
-    if (keyword === undefined ||
-        name === undefined ||
-        !BLOCK_KEYWORDS.has(keyword) ||
-        !PrismaSyntax_1.PrismaSyntax.identifier(name))
-        return undefined;
-    return { keyword, name };
-}
-/** Extracts an addressable member name from one nested block line.
- *
- * Attribute and closing-brace lines cannot introduce member locations.
- */
-function memberName(line) {
-    if (line.startsWith("@") || line.startsWith("}"))
-        return undefined;
-    const name = line.split(/\s+/u)[0];
-    return name !== undefined && PrismaSyntax_1.PrismaSyntax.identifier(name) ? name : undefined;
-}
-/** Counts occurrences of one structural character in code-only source text.
- *
- * Callers invoke this only after comment stripping, so braces inside comments
- * cannot change scanner depth.
- */
-function count(value, character) {
-    return Array.from(value).filter((candidate) => candidate === character)
-        .length;
-}
-/** Trims surrounding whitespace while preserving retained source coordinates.
- *
- * The returned arrays stay aligned with the shortened text, allowing later
- * documentation mapping to identify every retained character precisely.
- */
-function trimMapped(text, offsets, ends) {
-    const start = text.search(/\S/u);
-    if (start < 0)
-        return { text: "", offsets: [], ends: [] };
-    let end = text.length;
-    while (end > start && /\s/u.test(text[end - 1] ?? ""))
-        --end;
-    return {
-        text: text.slice(start, end),
-        offsets: offsets.slice(start, end),
-        ends: ends.slice(start, end),
-    };
-}

package/lib/adapters/prisma/PrismaModelLoader.d.ts

@@ -1,12 +0,0 @@
-import type { IPrismaLoadResult } from "./IPrismaLoadResult";
-import type { IPrismaSchemaFile } from "./IPrismaSchemaFile";
-/**
- * Loads Prisma's resolved schema model through a consumer-compatible WASM bridge.
- *
- * The loader resolves the parser from the consumer first, caches complete
- * schema-set outcomes by parser identity and content digest, and returns detached
- * records that can outlive the WASM call.
- */
-export declare namespace PrismaModelLoader {
-    function load(root: string, files: IPrismaSchemaFile[]): Promise<IPrismaLoadResult>;
-}

package/lib/adapters/prisma/PrismaModelLoader.js

@@ -1,268 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrismaModelLoader = void 0;
-const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
-const node_crypto_1 = require("node:crypto");
-const node_module_1 = require("node:module");
-const node_path_1 = __importDefault(require("node:path"));
-const typia_1 = __importDefault(require("typia"));
-const CanonicalJson_1 = require("../../internal/CanonicalJson");
-const ANSI_PATTERN = /\x1b\[[0-9;]*m/gu;
-const CACHE_LIMIT = 16;
-const cache = new Map();
-/**
- * Loads Prisma's resolved schema model through a consumer-compatible WASM bridge.
- *
- * The loader resolves the parser from the consumer first, caches complete
- * schema-set outcomes by parser identity and content digest, and returns detached
- * records that can outlive the WASM call.
- */
-var PrismaModelLoader;
-(function (PrismaModelLoader) {
-    async function load(root, files) {
-        const parser = resolve(root);
-        const digest = schemaDigest(files);
-        const key = `${parser.origin}\0${parser.version}\0${digest}`;
-        const remembered = cache.get(key);
-        if (remembered !== undefined && remembered.models !== undefined)
-            return { models: structuredClone(remembered.models), digest };
-        if (remembered !== undefined && remembered.problem !== undefined)
-            throw new Error(remembered.problem);
-        let payload;
-        try {
-            payload = parser.getDatamodel(JSON.stringify({
-                prismaSchema: files.map((file) => [file.name, file.source.content]),
-            }));
-        }
-        catch (cause) {
-            const problem = `${failure(cause)} (parsed by @prisma/prisma-schema-wasm@${parser.version} resolved from the ${parser.origin})`;
-            remember(key, { problem });
-            throw new Error(problem);
-        }
-        let datamodel;
-        try {
-            datamodel = (() => {
-                const _ip0 = input => "string" === typeof input["name"];
-                const _ip1 = input => null === input["documentation"] || undefined === input["documentation"] || "string" === typeof input["documentation"];
-                const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".name",
-                    expected: "string",
-                    value: input["name"]
-                }, _errorFactory);
-                const _ap1 = (input, _path, _exceptionable = true) => null === input["documentation"] || undefined === input["documentation"] || "string" === typeof input["documentation"] || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".documentation",
-                    expected: "(null | string | undefined)",
-                    value: input["documentation"]
-                }, _errorFactory);
-                const _ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.models) || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".models",
-                    expected: "Array<IPrismaDatamodelModel>",
-                    value: input.models
-                }, _errorFactory)) && input.models.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".models[" + _index3 + "]",
-                    expected: "IPrismaDatamodelModel",
-                    value: elem
-                }, _errorFactory)) && _ao1(elem, _path + ".models[" + _index3 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".models[" + _index3 + "]",
-                    expected: "IPrismaDatamodelModel",
-                    value: elem
-                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".models",
-                    expected: "Array<IPrismaDatamodelModel>",
-                    value: input.models
-                }, _errorFactory);
-                const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && ((Array.isArray(input.fields) || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".fields",
-                    expected: "Array<IPrismaDatamodelField>",
-                    value: input.fields
-                }, _errorFactory)) && input.fields.every((elem, _index4) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".fields[" + _index4 + "]",
-                    expected: "IPrismaDatamodelField",
-                    value: elem
-                }, _errorFactory)) && _ao2(elem, _path + ".fields[" + _index4 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".fields[" + _index4 + "]",
-                    expected: "IPrismaDatamodelField",
-                    value: elem
-                }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".fields",
-                    expected: "Array<IPrismaDatamodelField>",
-                    value: input.fields
-                }, _errorFactory));
-                const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.kind || _assertGuard_1._assertGuard(_exceptionable, {
-                    method: "typia.json.assertParse",
-                    path: _path + ".kind",
-                    expected: "string",
-                    value: input.kind
-                }, _errorFactory)) && _ap1(input, _path, true && _exceptionable);
-                const _io0 = input => Array.isArray(input.models) && input.models.every(elem => "object" === typeof elem && null !== elem && _io1(elem));
-                const _io1 = input => _ip0(input) && _ip1(input) && (Array.isArray(input.fields) && input.fields.every(elem => "object" === typeof elem && null !== elem && _io2(elem)));
-                const _io2 = input => _ip0(input) && "string" === typeof input.kind && _ip1(input);
-                const __is = input => "object" === typeof input && null !== input && _io0(input);
-                let _errorFactory;
-                const __assert = (input, errorFactory) => {
-                    if (false === __is(input)) {
-                        _errorFactory = errorFactory;
-                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
-                            method: "typia.json.assertParse",
-                            path: _path + "",
-                            expected: "IPrismaDatamodel",
-                            value: input
-                        }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
-                            method: "typia.json.assertParse",
-                            path: _path + "",
-                            expected: "IPrismaDatamodel",
-                            value: input
-                        }, _errorFactory))(input, "$input", true);
-                    }
-                    return input;
-                };
-                return (input, errorFactory) => __assert(JSON.parse(input), errorFactory);
-            })()(payload);
-        }
-        catch (cause) {
-            throw new Error(`The Prisma parser returned an incompatible datamodel payload: ${message(cause)}`);
-        }
-        const models = datamodel.models.map(model);
-        remember(key, { models });
-        return { models: structuredClone(models), digest };
-    }
-    PrismaModelLoader.load = load;
-    function model(input) {
-        return {
-            name: input.name,
-            documentation: input.documentation ?? "",
-            digest: CanonicalJson_1.CanonicalJson.digest(CanonicalJson_1.CanonicalJson.without(input, ["documentation", "fields"])),
-            fields: input.fields.map((field) => ({
-                name: field.name,
-                symbol: field.kind === "object" ? "relation" : "column",
-                documentation: field.documentation ?? "",
-                digest: CanonicalJson_1.CanonicalJson.digest(CanonicalJson_1.CanonicalJson.without(field, ["documentation"])),
-            })),
-        };
-    }
-    function resolve(root) {
-        const failures = [];
-        for (const origin of ["project", "package"]) {
-            try {
-                const resolver = origin === "project"
-                    ? (0, node_module_1.createRequire)(node_path_1.default.join(root, "package.json"))
-                    : (0, node_module_1.createRequire)(__filename);
-                const manifest = resolver("@prisma/prisma-schema-wasm/package.json");
-                const module = resolver("@prisma/prisma-schema-wasm");
-                if (typeof module !== "object" ||
-                    module === null ||
-                    !("get_datamodel" in module) ||
-                    typeof module.get_datamodel !== "function")
-                    throw new Error("the module exposes no get_datamodel function");
-                const getDatamodel = module.get_datamodel;
-                return {
-                    getDatamodel(parameters) {
-                        const output = getDatamodel(parameters);
-                        if (typeof output !== "string")
-                            throw new Error("the parser returned a non-string payload");
-                        return output;
-                    },
-                    version: version(manifest),
-                    origin,
-                };
-            }
-            catch (cause) {
-                failures.push(`${origin}: ${message(cause)}`);
-            }
-        }
-        throw new Error(`No Prisma schema parser could be resolved (${failures.join("; ")}).`);
-    }
-    function version(manifest) {
-        if (typeof manifest === "object" &&
-            manifest !== null &&
-            "version" in manifest &&
-            typeof manifest.version === "string")
-            return manifest.version;
-        return "unknown";
-    }
-    function schemaDigest(files) {
-        const hash = (0, node_crypto_1.createHash)("sha256");
-        for (const file of files) {
-            hash.update(file.name);
-            hash.update("\0");
-            hash.update(file.source.digest);
-            hash.update("\n");
-        }
-        return hash.digest("hex");
-    }
-    function remember(key, entry) {
-        if (cache.has(key))
-            return;
-        while (cache.size >= CACHE_LIMIT) {
-            const oldest = cache.keys().next().value;
-            if (oldest === undefined)
-                break;
-            cache.delete(oldest);
-        }
-        cache.set(key, structuredClone(entry));
-    }
-    function failure(cause) {
-        const raw = message(cause);
-        try {
-            const envelope = JSON.parse(raw);
-            if (typeof envelope === "object" &&
-                envelope !== null &&
-                "message" in envelope &&
-                typeof envelope.message === "string")
-                return envelope.message.replace(ANSI_PATTERN, "").trim();
-        }
-        catch {
-            // A non-JSON error already is the complete parser message.
-        }
-        return raw.replace(ANSI_PATTERN, "").trim();
-    }
-    function message(cause) {
-        return cause instanceof Error ? cause.message : String(cause);
-    }
-})(PrismaModelLoader || (exports.PrismaModelLoader = PrismaModelLoader = {}));

package/lib/adapters/prisma/PrismaSyntax.d.ts

@@ -1,9 +0,0 @@
-/**
- * Shared lexical rules that do not determine Prisma schema semantics.
- *
- * Target and position helpers use these checks for safe identifier spelling;
- * the Prisma WASM parser remains the authority on whether a schema is valid.
- */
-export declare namespace PrismaSyntax {
-    function identifier(value: string): boolean;
-}

package/lib/adapters/prisma/PrismaSyntax.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrismaSyntax = void 0;
-const LETTER = /^\p{L}$/u;
-const NUMBER = /^\p{N}$/u;
-/**
- * Shared lexical rules that do not determine Prisma schema semantics.
- *
- * Target and position helpers use these checks for safe identifier spelling;
- * the Prisma WASM parser remains the authority on whether a schema is valid.
- */
-var PrismaSyntax;
-(function (PrismaSyntax) {
-    function identifier(value) {
-        const characters = Array.from(value);
-        const first = characters[0];
-        return (first !== undefined &&
-            initial(first) &&
-            characters
-                .slice(1)
-                .every((character) => initial(character) || character === "_" || character === "-"));
-    }
-    PrismaSyntax.identifier = identifier;
-    function initial(character) {
-        return LETTER.test(character) || NUMBER.test(character);
-    }
-})(PrismaSyntax || (exports.PrismaSyntax = PrismaSyntax = {}));