@atproto/lex-builder 0.0.0

package/dist/lex-def-builder.js

@@ -0,0 +1,682 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LexDefBuilder = void 0;
+const tslib_1 = require("tslib");
+const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
+const ts_morph_1 = require("ts-morph");
+const lex_schema_1 = require("@atproto/lex-schema");
+const ref_resolver_js_1 = require("./ref-resolver.js");
+const ts_lang_js_1 = require("./ts-lang.js");
+/**
+ * Utility class to build a TypeScript source file from a lexicon document.
+ */
+class LexDefBuilder {
+    options;
+    file;
+    doc;
+    refResolver;
+    constructor(options, file, doc, indexer) {
+        this.options = options;
+        this.file = file;
+        this.doc = doc;
+        this.refResolver = new ref_resolver_js_1.RefResolver(doc, file, indexer);
+    }
+    pure(code) {
+        return this.options.pureAnnotations ? markPure(code) : code;
+    }
+    async build() {
+        this.file.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                { name: '$nsid', initializer: JSON.stringify(this.doc.id) },
+            ],
+        });
+        this.file.addExportDeclaration({
+            namedExports: [{ name: '$nsid' }],
+        });
+        const defs = Object.keys(this.doc.defs);
+        if (defs.length) {
+            const moduleSpecifier = this.options?.lib ?? '@atproto/lex-schema';
+            this.file
+                .addImportDeclaration({ moduleSpecifier })
+                .addNamedImports([{ name: 'l' }]);
+            for (const hash of defs) {
+                await this.addDef(hash);
+            }
+        }
+    }
+    addUtils(definitions) {
+        const entries = Object.entries(definitions).filter((e) => e[1] != null);
+        if (entries.length) {
+            this.file.addVariableStatement({
+                isExported: true,
+                declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+                declarations: entries.map(([name, initializer]) => ({
+                    name,
+                    initializer,
+                })),
+            });
+        }
+    }
+    async addDef(hash) {
+        const def = Object.hasOwn(this.doc.defs, hash) ? this.doc.defs[hash] : null;
+        if (def == null)
+            return;
+        switch (def.type) {
+            case 'permission-set':
+                return this.addPermissionSet(hash, def);
+            case 'procedure':
+                return this.addProcedure(hash, def);
+            case 'query':
+                return this.addQuery(hash, def);
+            case 'subscription':
+                return this.addSubscription(hash, def);
+            case 'record':
+                return this.addRecord(hash, def);
+            case 'token':
+                return this.addToken(hash, def);
+            case 'object':
+                return this.addObject(hash, def);
+            case 'array':
+                return this.addArray(hash, def);
+            default:
+                await this.addSchema(hash, def, {
+                    type: await this.compileContainedType(def),
+                    schema: await this.compileContainedSchema(def),
+                    validationUtils: true,
+                });
+        }
+    }
+    async addPermissionSet(hash, def) {
+        const permission = def.permissions.map((def) => {
+            const options = stringifyOptionalOptions(def, ['resource', 'type']);
+            return this.pure(`l.permission(${JSON.stringify(def.resource)}, ${options})`);
+        });
+        const options = stringifyOptionalOptions(def, [
+            'type',
+            'description',
+            'permissions',
+        ]);
+        await this.addSchema(hash, def, {
+            schema: this.pure(`l.permissionSet($nsid, [${permission.join(',')}], ${options})`),
+        });
+    }
+    async addProcedure(hash, def) {
+        if (hash !== 'main') {
+            throw new Error(`Definition ${hash} cannot be of type ${def.type}`);
+        }
+        // @TODO Build the types instead of using an inferred type.
+        const ref = await this.addSchema(hash, def, {
+            schema: this.pure(`
+        l.procedure(
+          $nsid,
+          ${await this.compileParamsSchema(def.parameters)},
+          ${await this.compilePayload(def.input)},
+          ${await this.compilePayload(def.output)},
+          ${await this.compileErrors(def.errors)}
+        )
+      `),
+        });
+        this.addUtils({
+            $params: this.pure(`${ref.varName}.parameters`),
+            $input: this.pure(`${ref.varName}.input`),
+            $output: this.pure(`${ref.varName}.output`),
+        });
+        const parametersTypeStmt = this.file.addTypeAlias({
+            isExported: true,
+            name: 'Params',
+            type: `l.InferProcedureParameters<typeof ${ref.varName}>`,
+        });
+        addJsDoc(parametersTypeStmt, def.parameters);
+        const inputTypeStmt = this.file.addTypeAlias({
+            isExported: true,
+            name: 'Input',
+            type: `l.InferProcedureInputBody<typeof ${ref.varName}>`,
+        });
+        addJsDoc(inputTypeStmt, def.input);
+        const outputTypeStmt = this.file.addTypeAlias({
+            isExported: true,
+            name: 'Output',
+            type: `l.InferProcedureOutputBody<typeof ${ref.varName}>`,
+        });
+        addJsDoc(outputTypeStmt, def.output);
+    }
+    async addQuery(hash, def) {
+        if (hash !== 'main') {
+            throw new Error(`Definition ${hash} cannot be of type ${def.type}`);
+        }
+        // @TODO Build the types instead of using an inferred type.
+        const ref = await this.addSchema(hash, def, {
+            schema: this.pure(`
+        l.query(
+          $nsid,
+          ${await this.compileParamsSchema(def.parameters)},
+          ${await this.compilePayload(def.output)},
+          ${await this.compileErrors(def.errors)}
+        )
+      `),
+        });
+        this.addUtils({
+            $params: `${ref.varName}.parameters`,
+            $output: `${ref.varName}.output`,
+        });
+        this.file.addTypeAlias({
+            isExported: true,
+            name: 'Params',
+            type: `l.InferQueryParameters<typeof ${ref.varName}>`,
+        });
+        this.file.addTypeAlias({
+            isExported: true,
+            name: 'Output',
+            type: `l.InferQueryOutputBody<typeof ${ref.varName}>`,
+        });
+    }
+    async addSubscription(hash, def) {
+        if (hash !== 'main') {
+            throw new Error(`Definition ${hash} cannot be of type ${def.type}`);
+        }
+        // @TODO Build the types instead of using an inferred type.
+        const ref = await this.addSchema(hash, def, {
+            schema: this.pure(`
+        l.subscription(
+          $nsid,
+          ${await this.compileParamsSchema(def.parameters)},
+          ${await this.compileBodySchema(def.message?.schema)},
+          ${await this.compileErrors(def.errors)}
+        )
+      `),
+        });
+        this.addUtils({
+            $params: `${ref.varName}.parameters`,
+            $message: `${ref.varName}.message`,
+        });
+        this.file.addTypeAlias({
+            isExported: true,
+            name: 'Params',
+            type: `l.InferSubscriptionParameters<typeof ${ref.varName}>`,
+        });
+        this.file.addTypeAlias({
+            isExported: true,
+            name: 'Message',
+            type: `l.InferSubscriptionMessage<typeof ${ref.varName}>`,
+        });
+    }
+    async addRecord(hash, def) {
+        if (hash !== 'main') {
+            throw new Error(`Definition ${hash} cannot be of type ${def.type}`);
+        }
+        const key = JSON.stringify(def.key ?? 'any');
+        const objectSchema = await this.compileObjectSchema(def.record);
+        const properties = await this.compilePropertiesTypes(def.record);
+        properties.unshift(`$type: ${JSON.stringify(lex_schema_1.l.$type(this.doc.id, hash))}`);
+        await this.addSchema(hash, def, {
+            type: `{ ${properties.join(';')} }`,
+            schema: (ref) => this.pure(`l.record<${key}, ${ref.typeName}>(${key}, $nsid, ${objectSchema})`),
+            objectUtils: true,
+            validationUtils: true,
+        });
+    }
+    async addObject(hash, def) {
+        const objectSchema = await this.compileObjectSchema(def);
+        const properties = await this.compilePropertiesTypes(def);
+        properties.unshift(`$type?: ${JSON.stringify(lex_schema_1.l.$type(this.doc.id, hash))}`);
+        await this.addSchema(hash, def, {
+            type: `{ ${properties.join(';')} }`,
+            schema: (ref) => this.pure(`l.typedObject<${ref.typeName}>($nsid, ${JSON.stringify(hash)}, ${objectSchema})`),
+            objectUtils: true,
+            validationUtils: true,
+        });
+    }
+    async addToken(hash, def) {
+        await this.addSchema(hash, def, {
+            schema: this.pure(`l.token($nsid, ${JSON.stringify(hash)})`),
+            type: JSON.stringify(lex_schema_1.l.$type(this.doc.id, hash)),
+            validationUtils: true,
+        });
+    }
+    async addArray(hash, def) {
+        // @TODO It could be nice to expose the array item type as a separate type.
+        // This was not done (yet) as there is no easy way to name it to avoid
+        // collisions.
+        const itemSchema = await this.compileContainedSchema(def.items);
+        const options = stringifyOptionalOptions(def, [
+            'type',
+            'description',
+            'items',
+        ]);
+        await this.addSchema(hash, def, {
+            type: `(${await this.compileContainedType(def.items)})[]`,
+            // @NOTE Not using compileArraySchema to allow specifying the generic
+            // parameter to l.array<>.
+            schema: (ref) => this.pure(`l.array<${ref.typeName}[number]>(${itemSchema}, ${options})`),
+            validationUtils: true,
+        });
+    }
+    async addSchema(hash, def, { type, schema, objectUtils, validationUtils, }) {
+        const ref = await this.refResolver.resolveLocal(hash);
+        const pub = (0, ref_resolver_js_1.getPublicIdentifiers)(hash);
+        // Fool-proofing
+        (0, node_assert_1.default)((0, ts_lang_js_1.isSafeIdentifier)(ref.varName), 'Expected safe type identifier');
+        (0, node_assert_1.default)((0, ts_lang_js_1.isSafeIdentifier)(ref.typeName), 'Expected safe type identifier');
+        (0, node_assert_1.default)((0, ts_lang_js_1.isSafeIdentifier)(pub.typeName), 'Expected safe type identifier');
+        if (type) {
+            const typeStmt = this.file.addTypeAlias({
+                name: ref.typeName,
+                type: typeof type === 'function' ? type(ref) : type,
+            });
+            addJsDoc(typeStmt, def);
+            this.file.addExportDeclaration({
+                isTypeOnly: true,
+                namedExports: [
+                    {
+                        name: ref.typeName,
+                        alias: ref.typeName === pub.typeName ? undefined : pub.typeName,
+                    },
+                ],
+            });
+        }
+        if (schema) {
+            const constStmt = this.file.addVariableStatement({
+                declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+                declarations: [
+                    {
+                        name: ref.varName,
+                        initializer: typeof schema === 'function' ? schema(ref) : schema,
+                    },
+                ],
+            });
+            addJsDoc(constStmt, def);
+            this.file.addExportDeclaration({
+                namedExports: [
+                    {
+                        name: ref.varName,
+                        alias: ref.varName === pub.varName
+                            ? undefined
+                            : (0, ts_lang_js_1.isSafeIdentifier)(pub.varName)
+                                ? pub.varName
+                                : JSON.stringify(pub.varName),
+                    },
+                ],
+            });
+        }
+        if (hash === 'main' && objectUtils) {
+            this.addUtils({
+                $isTypeOf: markPure(`${ref.varName}.isTypeOf.bind(${ref.varName})`),
+                $build: markPure(`${ref.varName}.build.bind(${ref.varName})`),
+                $type: markPure(`${ref.varName}.$type`),
+            });
+        }
+        if (hash === 'main' && validationUtils) {
+            this.addUtils({
+                $assert: markPure(`${ref.varName}.assert.bind(${ref.varName})`),
+                $check: markPure(`${ref.varName}.check.bind(${ref.varName})`),
+                $maybe: markPure(`${ref.varName}.maybe.bind(${ref.varName})`),
+                $parse: markPure(`${ref.varName}.parse.bind(${ref.varName})`),
+                $validate: markPure(`${ref.varName}.validate.bind(${ref.varName})`),
+            });
+        }
+        return ref;
+    }
+    async compilePayload(def) {
+        if (!def)
+            return this.pure(`l.payload()`);
+        const encodedEncoding = JSON.stringify(def.encoding);
+        if (def.schema) {
+            const bodySchema = await this.compileBodySchema(def.schema);
+            return this.pure(`l.payload(${encodedEncoding}, ${bodySchema})`);
+        }
+        else {
+            return this.pure(`l.payload(${encodedEncoding})`);
+        }
+    }
+    async compileBodySchema(def) {
+        if (!def)
+            return 'undefined';
+        if (def.type === 'object')
+            return this.compileObjectSchema(def);
+        return this.compileContainedSchema(def);
+    }
+    async compileParamsSchema(def) {
+        if (!def)
+            return this.pure(`l.params({})`);
+        const properties = await this.compilePropertiesSchemas(def);
+        const options = stringifyOptionalOptions(def, [
+            'type',
+            'description',
+            'properties',
+        ]);
+        return this.pure(`l.params({${properties.join(',')}}, ${options})`);
+    }
+    async compileErrors(defs) {
+        if (!defs?.length)
+            return '';
+        return JSON.stringify(defs.map((d) => d.name));
+    }
+    async compileObjectSchema(def) {
+        const properties = await this.compilePropertiesSchemas(def);
+        const options = stringifyOptionalOptions(def, [
+            'type',
+            'description',
+            'properties',
+        ]);
+        return this.pure(`l.object({${properties.join(',')}}, ${options})`);
+    }
+    async compilePropertiesSchemas(options) {
+        for (const prop of options.required || []) {
+            if (!Object.hasOwn(options.properties, prop)) {
+                throw new Error(`Required property "${prop}" not found in properties`);
+            }
+        }
+        return Promise.all(Object.entries(options.properties).map(this.compilePropertyEntrySchema, this));
+    }
+    async compilePropertiesTypes(options) {
+        return Promise.all(Object.entries(options.properties).map((entry) => {
+            return this.compilePropertyEntryType(entry, options);
+        }));
+    }
+    async compilePropertyEntrySchema([key, def]) {
+        const name = JSON.stringify(key);
+        const schema = await this.compileContainedSchema(def);
+        return `${name}:${schema}`;
+    }
+    async compilePropertyEntryType([key, def], options) {
+        const isNullable = options.nullable?.includes(key);
+        const isRequired = options.required?.includes(key);
+        const optional = isRequired ? '' : '?';
+        const append = isNullable ? ' | null' : '';
+        const jsDoc = compileLeadingTrivia(def.description) || '';
+        const name = JSON.stringify(key);
+        const type = await this.compileContainedType(def);
+        return `${jsDoc}${name}${optional}:${type}${append}`;
+    }
+    async compileContainedSchema(def) {
+        switch (def.type) {
+            case 'unknown':
+                return this.compileUnknownSchema(def);
+            case 'boolean':
+                return this.compileBooleanSchema(def);
+            case 'integer':
+                return this.compileIntegerSchema(def);
+            case 'string':
+                return this.compileStringSchema(def);
+            case 'bytes':
+                return this.compileBytesSchema(def);
+            case 'blob':
+                return this.compileBlobSchema(def);
+            case 'cid-link':
+                return this.compileCidLinkSchema(def);
+            case 'ref':
+                return this.compileRefSchema(def);
+            case 'union':
+                return this.compileRefUnionSchema(def);
+            case 'array':
+                return this.compileArraySchema(def);
+            default:
+                // @ts-expect-error
+                throw new Error(`Unsupported def type: ${def.type}`);
+        }
+    }
+    async compileContainedType(def) {
+        switch (def.type) {
+            case 'unknown':
+                return this.compileUnknownType(def);
+            case 'boolean':
+                return this.compileBooleanType(def);
+            case 'integer':
+                return this.compileIntegerType(def);
+            case 'string':
+                return this.compileStringType(def);
+            case 'bytes':
+                return this.compileBytesType(def);
+            case 'blob':
+                return this.compileBlobType(def);
+            case 'cid-link':
+                return this.compileCidLinkType(def);
+            case 'ref':
+                return this.compileRefType(def);
+            case 'union':
+                return this.compileRefUnionType(def);
+            case 'array':
+                return this.compileArrayType(def);
+            default:
+                // @ts-expect-error
+                throw new Error(`Unsupported def type: ${def.type}`);
+        }
+    }
+    async compileArraySchema(def) {
+        const itemSchema = await this.compileContainedSchema(def.items);
+        const options = stringifyOptionalOptions(def, [
+            'type',
+            'description',
+            'items',
+        ]);
+        return this.pure(`l.array(${itemSchema}, ${options})`);
+    }
+    async compileArrayType(def) {
+        return `(${await this.compileContainedType(def.items)})[]`;
+    }
+    async compileUnknownSchema(_def) {
+        return this.pure(`l.unknownObject()`);
+    }
+    async compileUnknownType(_def) {
+        return `l.UnknownObject`;
+    }
+    async compileBooleanSchema(def) {
+        if (hasConst(def))
+            return this.compileConstSchema(def);
+        const options = stringifyOptionalOptions(def, ['type', 'description']);
+        return this.pure(`l.boolean(${options})`);
+    }
+    async compileBooleanType(def) {
+        if (hasConst(def))
+            return this.compileConstType(def);
+        return 'boolean';
+    }
+    async compileIntegerSchema(def) {
+        if (hasConst(def)) {
+            const schema = lex_schema_1.l.integer(def);
+            (0, node_assert_1.default)(schema.check(def.const), `Integer const ${def.const} is out of bounds`);
+        }
+        if (hasEnum(def)) {
+            const schema = lex_schema_1.l.integer(def);
+            for (const val of def.enum) {
+                (0, node_assert_1.default)(schema.check(val), `Integer enum value ${val} is out of bounds`);
+            }
+        }
+        if (hasConst(def))
+            return this.compileConstSchema(def);
+        if (hasEnum(def))
+            return this.compileEnumSchema(def);
+        const options = stringifyOptionalOptions(def, ['type', 'description']);
+        return this.pure(`l.integer(${options})`);
+    }
+    async compileIntegerType(def) {
+        if (hasConst(def))
+            return this.compileConstType(def);
+        if (hasEnum(def))
+            return this.compileEnumType(def);
+        return 'number';
+    }
+    async compileStringSchema(def) {
+        if (hasConst(def)) {
+            const schema = lex_schema_1.l.string(def);
+            (0, node_assert_1.default)(schema.check(def.const), `String const "${def.const}" does not match format`);
+        }
+        else if (hasEnum(def)) {
+            const schema = lex_schema_1.l.string(def);
+            for (const val of def.enum) {
+                (0, node_assert_1.default)(schema.check(val), `String enum value "${val}" does not match format`);
+            }
+        }
+        if (hasConst(def))
+            return this.compileConstSchema(def);
+        if (hasEnum(def))
+            return this.compileEnumSchema(def);
+        const options = stringifyOptionalOptions(def, ['type', 'description']);
+        return this.pure(`l.string(${options})`);
+    }
+    async compileStringType(def) {
+        if (hasConst(def))
+            return this.compileConstType(def);
+        if (hasEnum(def))
+            return this.compileEnumType(def);
+        switch (def.format) {
+            case 'datetime':
+                return 'l.Datetime';
+            case 'uri':
+                return 'l.Uri';
+            case 'at-uri':
+                return 'l.AtUri';
+            case 'did':
+                return 'l.Did';
+            case 'handle':
+                return 'l.Handle';
+            case 'at-identifier':
+                return 'l.AtIdentifier';
+            case 'nsid':
+                return 'l.Nsid';
+        }
+        if (def.knownValues?.length) {
+            return (def.knownValues.map((v) => JSON.stringify(v)).join(' | ') +
+                ' | l.UnknownString');
+        }
+        return 'string';
+    }
+    async compileBytesSchema(def) {
+        const options = stringifyOptionalOptions(def, ['type', 'description']);
+        return this.pure(`l.bytes(${options})`);
+    }
+    async compileBytesType(_def) {
+        return 'Uint8Array';
+    }
+    async compileBlobSchema(def) {
+        const opts = this.options.allowLegacyBlobs
+            ? { ...def, allowLegacy: true }
+            : def;
+        const options = stringifyOptionalOptions(opts, ['type', 'description']);
+        return this.pure(`l.blob(${options})`);
+    }
+    async compileBlobType(_def) {
+        return this.options.allowLegacyBlobs
+            ? 'l.BlobRef | l.LegacyBlobRef'
+            : 'l.BlobRef';
+    }
+    async compileCidLinkSchema(def) {
+        const options = stringifyOptionalOptions(def, ['type', 'description']);
+        return this.pure(`l.cidLink(${options})`);
+    }
+    async compileCidLinkType(_def) {
+        return 'l.CID';
+    }
+    async compileRefSchema(def) {
+        const { varName, typeName } = await this.refResolver.resolve(def.ref);
+        // @NOTE "as any" is needed in schemas with circular refs as TypeScript
+        // cannot infer the type of a value that depends on its initializer type
+        return this.pure(`l.ref<${typeName}>((() => ${varName}) as any)`);
+    }
+    async compileRefType(def) {
+        const ref = await this.refResolver.resolve(def.ref);
+        return ref.typeName;
+    }
+    async compileRefUnionSchema(def) {
+        if (def.refs.length === 0 && def.closed) {
+            return this.pure(`l.never()`);
+        }
+        const refs = await Promise.all(def.refs.map(async (ref) => {
+            const { varName, typeName } = await this.refResolver.resolve(ref);
+            // @NOTE "as any" is needed in schemas with circular refs as TypeScript
+            // cannot infer the type of a value that depends on its initializer type
+            return this.pure(`l.typedRef<${typeName}>((() => ${varName}) as any)`);
+        }));
+        return this.pure(`l.typedUnion([${refs.join(',')}], ${def.closed ?? false})`);
+    }
+    async compileRefUnionType(def) {
+        const types = await Promise.all(def.refs.map(async (ref) => {
+            const { typeName } = await this.refResolver.resolve(ref);
+            return `l.TypedRef<${typeName}>`;
+        }));
+        if (!def.closed)
+            types.push('l.TypedObject');
+        return types.join(' | ') || 'never';
+    }
+    async compileConstSchema(def) {
+        if (hasEnum(def) && !def.enum.includes(def.const)) {
+            return this.pure(`l.never()`);
+        }
+        return this.pure(`l.literal(${JSON.stringify(def.const)})`);
+    }
+    async compileConstType(def) {
+        if (hasEnum(def) && !def.enum.includes(def.const)) {
+            return 'never';
+        }
+        return JSON.stringify(def.const);
+    }
+    async compileEnumSchema(def) {
+        if (def.enum.length === 0) {
+            return this.pure(`l.never()`);
+        }
+        if (def.enum.length === 1) {
+            return this.pure(`l.literal(${JSON.stringify(def.enum[0])})`);
+        }
+        return this.pure(`l.enum(${JSON.stringify(def.enum)})`);
+    }
+    async compileEnumType(def) {
+        return def.enum.map((v) => JSON.stringify(v)).join(' | ') || 'never';
+    }
+}
+exports.LexDefBuilder = LexDefBuilder;
+function parseDescription(description) {
+    if (/deprecated/i.test(description)) {
+        const deprecationMatch = description.match(/(\s*deprecated\s*(?:--?|:)?\s*([^-]*)(?:-+)?)/i);
+        if (deprecationMatch) {
+            const [, match, deprecationNotice] = deprecationMatch;
+            return {
+                description: description.replace(match, '').trim(),
+                deprecated: deprecationNotice?.trim() || true,
+            };
+        }
+        else {
+            return {
+                description: description.trim(),
+                deprecated: true,
+            };
+        }
+    }
+    return {
+        description: description.trim(),
+        deprecated: false,
+    };
+}
+function compileLeadingTrivia(description) {
+    if (!description)
+        return undefined;
+    return `\n\n/**${compileJsDoc(description).replaceAll('\n', '\n * ')}\n */\n`;
+}
+function addJsDoc(declaration, def) {
+    if (def?.description) {
+        declaration.addJsDoc(compileJsDoc(def.description));
+    }
+}
+function compileJsDoc(description) {
+    const parsed = parseDescription(description);
+    return `\n${parsed.description}${!parsed.deprecated
+        ? ''
+        : (parsed.description ? '\n\n' : '') +
+            (parsed.deprecated === true
+                ? '@deprecated'
+                : `@deprecated ${parsed.deprecated}`)}`;
+}
+function stringifyOptionalOptions(obj, omit) {
+    const filtered = Object.entries(obj).filter(([k]) => !omit?.includes(k));
+    return filtered.length ? JSON.stringify(Object.fromEntries(filtered)) : '';
+}
+function hasConst(def) {
+    return def.const != null;
+}
+function hasEnum(def) {
+    return def.enum != null;
+}
+function markPure(v) {
+    return `/*#__PURE__*/ ${v}`;
+}
+//# sourceMappingURL=lex-def-builder.js.map