@amritk/generate-parsers 0.6.3 → 0.7.1

package/dist/generators/build-schema.d.ts

@@ -1,6 +1,6 @@
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-import type { HelpersMode } from '#helpers/collect-helpers';
-import type { SchemaExtensions } from '#types/schema-extensions';
+import type { HelpersMode } from '../helpers/collect-helpers.js';
+import type { SchemaExtensions } from '../types/schema-extensions.js';
 /**
  * Represents a generated file with its filename and content.
  */
@@ -9,15 +9,13 @@ export type GeneratedFile = {
     content: string;
 };
 /**
- * Builds all TypeScript files from a JSON Schema by traversing
- * all $ref references recursively.
+ * Builds all TypeScript files from a JSON Schema by traversing its entire
+ * `$ref` / `$dynamicRef` graph (via the shared `@amritk/helpers/walk-ref-graph`
+ * walker, which also seeds `$dynamicAnchor` definitions and rewrites
+ * `$dynamicRef` to `$ref`).
  *
- * Starting from the root schema, this function:
- * 1. Generates a TypeScript file for the root type
- * 2. Extracts all $ref references from the schema
- * 3. Extracts all definitions with $dynamicAnchor (JSON Schema 2020-12 feature)
- * 4. Resolves each ref and generates a TypeScript file for it
- * 5. Recursively processes nested refs until all are handled
+ * For the root schema and each reachable definition this function generates a
+ * TypeScript file, then emits an `index.ts` barrel re-exporting them all.
  *
  * @param rootSchema - The root JSON Schema to build from
  * @param rootTypeName - The name for the root type (e.g., "Document")
@@ -76,3 +74,4 @@ export type GeneratedFile = {
  * ```
  */
 export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean, helpersMode?: HelpersMode, helpersImportPrefix?: string, readonly?: boolean, typeSuffix?: string) => Promise<GeneratedFile[]>;
+//# sourceMappingURL=build-schema.d.ts.map

package/dist/generators/build-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-schema.d.ts","sourceRoot":"","sources":["../../src/generators/build-schema.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,0BAA0B,CAAA;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAahE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,eAAO,MAAM,WAAW,eACV,UAAU,gBACR,MAAM,eACP,gBAAgB,cACjB,OAAO,gBACL,OAAO,WACZ,OAAO,gBACH,WAAW,4EAIvB,OAAO,CAAC,aAAa,EAAE,CAyCzB,CAAA"}

package/dist/generators/build-schema.js

@@ -0,0 +1,118 @@
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, resolve as resolvePath } from 'node:path';
+import { generateIndexBarrel } from '@amritk/helpers/generate-index-barrel';
+import { walkRefGraph } from '@amritk/helpers/walk-ref-graph';
+import { applySchemaExtensions } from '../helpers/apply-schema-extensions.js';
+import { generateFile } from './generate-files.js';
+/** Locate the @amritk/helpers package on disk so we can copy its runtime
+ * helper source files into the generated output when in embedded mode. */
+const readHelperSource = async (helper) => {
+    const require = createRequire(import.meta.url);
+    const helpersPkgPath = require.resolve('@amritk/helpers/package.json');
+    const helpersRoot = dirname(helpersPkgPath);
+    return readFile(resolvePath(helpersRoot, 'src', `${helper}.ts`), 'utf-8');
+};
+/**
+ * Builds all TypeScript files from a JSON Schema by traversing its entire
+ * `$ref` / `$dynamicRef` graph (via the shared `@amritk/helpers/walk-ref-graph`
+ * walker, which also seeds `$dynamicAnchor` definitions and rewrites
+ * `$dynamicRef` to `$ref`).
+ *
+ * For the root schema and each reachable definition this function generates a
+ * TypeScript file, then emits an `index.ts` barrel re-exporting them all.
+ *
+ * @param rootSchema - The root JSON Schema to build from
+ * @param rootTypeName - The name for the root type (e.g., "Document")
+ * @param extensions - Optional map of custom extension properties to add to specific definitions.
+ *   Keys are definition names (matching $defs keys), values are records of extension property
+ *   names to their JSON Schema definitions. Extensions are merged as optional properties before
+ *   type and parser generation.
+ * @param typesOnly - When true, only generate TypeScript type definitions without parser functions.
+ * @param logWarnings - When true, the generated parsers emit a console.warn for every input key
+ *   that is not declared in the schema's properties.
+ * @param strict - When true, the generated parsers throw on type/shape mismatches
+ *   (wrong type, missing required property, enum/pattern/min/max violations) instead
+ *   of coercing invalid input to default values.
+ * @param helpersMode - `'package'` (default) emits `import ... from '@amritk/helpers/...'`.
+ *   `'embedded'` emits `import ... from './_helpers/...'` and appends the helper sources
+ *   as additional `GeneratedFile` entries so the output directory is self-contained.
+ * @param helpersImportPrefix - Relative path prefix to the `_helpers/` directory in
+ *   embedded mode. Defaults to `'./'`. The recursive multi-schema build passes `'../'`,
+ *   `'../../'`, etc. so nested parsers can import from a single shared `_helpers/`
+ *   directory while the helper sources are emitted once at the output root.
+ * @param readonly - When true, every property, array, and record in the generated type
+ *   definitions is emitted as `readonly`.
+ * @param typeSuffix - Suffix appended to every type/parser name derived from a `$ref`
+ *   (e.g. `'Object'` → `ContactObject`). Defaults to `''` (no suffix). The root type name
+ *   is used verbatim and is not affected by this suffix.
+ * @returns An array of generated TypeScript files
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   type: "object",
+ *   properties: {
+ *     info: { $ref: "#/$defs/info" }
+ *   },
+ *   $defs: {
+ *     info: {
+ *       type: "object",
+ *       properties: {
+ *         title: { type: "string" }
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * const files = buildSchema(schema, "Document");
+ *
+ * // Types-only mode — no parser functions or runtime helpers included:
+ * const typesFiles = buildSchema(schema, "Document", undefined, true);
+ *
+ * // With extensions:
+ * const filesWithExtensions = buildSchema(schema, "Document", {
+ *   info: {
+ *     'x-internal': { type: 'boolean' },
+ *   },
+ * });
+ * ```
+ */
+export const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = 'package', helpersImportPrefix = './', readonly = false, typeSuffix = '') => {
+    const files = [];
+    const usedHelpers = new Set();
+    walkRefGraph(rootSchema, rootTypeName, { typeSuffix }, (node) => {
+        // `index` is reserved for the barrel below, so never let a definition of
+        // that name overwrite it.
+        if (node.filename === 'index')
+            return;
+        // Extensions are keyed by definition name, which is the node's filename for
+        // both the root (the lowercased root type name) and every `$ref` target.
+        const extended = extensions ? applySchemaExtensions(node.schema, node.filename, extensions) : node.schema;
+        const result = generateFile(extended, node.typeName, {
+            typesOnly: typesOnly ?? false,
+            rootSchema: node.rootSchema,
+            helpersMode,
+            helpersImportPrefix,
+            readonly,
+            typeSuffix,
+            ...(node.ref !== undefined ? { selfRef: node.ref } : {}),
+            ...(logWarnings !== undefined ? { logWarnings } : {}),
+            ...(strict !== undefined ? { strict } : {}),
+        });
+        files.push({ filename: `${node.filename}.ts`, content: result.content });
+        for (const helper of result.usedHelpers)
+            usedHelpers.add(helper);
+    });
+    // In embedded mode, ship the runtime helper source files alongside the parsers so
+    // the output directory is self-contained (no `@amritk/helpers` install required).
+    // typesOnly skips parser generation entirely, so no runtime helpers are needed.
+    if (helpersMode === 'embedded' && !typesOnly) {
+        for (const helper of usedHelpers) {
+            const source = await readHelperSource(helper);
+            files.push({ filename: `_helpers/${helper}.ts`, content: source });
+        }
+    }
+    files.push({ filename: 'index.ts', content: generateIndexBarrel(files, { typesOnly: typesOnly ?? false }) });
+    return files;
+};

package/dist/generators/generate-default-from-pattern.d.ts

@@ -3,3 +3,4 @@
  * Recognizes common patterns and returns appropriate defaults.
  */
 export declare const generateDefaultFromPattern: (pattern: string) => string | null;
+//# sourceMappingURL=generate-default-from-pattern.d.ts.map

package/dist/generators/generate-default-from-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-default-from-pattern.d.ts","sourceRoot":"","sources":["../../src/generators/generate-default-from-pattern.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,0BAA0B,YAAa,MAAM,KAAG,MAAM,GAAG,IAkCrE,CAAA"}

package/dist/generators/generate-default-from-pattern.js

@@ -0,0 +1,33 @@
+/**
+ * Generates a best-guess default value from a regex pattern.
+ * Recognizes common patterns and returns appropriate defaults.
+ */
+export const generateDefaultFromPattern = (pattern) => {
+    // Email pattern
+    if (pattern.includes('@') || (pattern.includes('[a-zA-Z0-9]') && pattern.includes('\\.'))) {
+        return '"user@example.com"';
+    }
+    // UUID pattern
+    if ((pattern.includes('[0-9a-f]') && pattern.includes('{8}')) || pattern.includes('\\-')) {
+        if (pattern.match(/[0-9a-f].*\{8\}/i) || pattern.match(/[0-9a-fA-F]{8}/)) {
+            return '"00000000-0000-0000-0000-000000000000"';
+        }
+    }
+    // URL pattern
+    if (pattern.includes('https?') || pattern.includes('http')) {
+        return '"https://example.com"';
+    }
+    // Semver pattern (3.1.x, x.y.z, etc)
+    if (pattern.match(/\d.*\\\.\.*\d/)) {
+        return '"1.0.0"';
+    }
+    // ISO date pattern
+    if (pattern.includes('\\d{4}') && pattern.includes('\\d{2}')) {
+        return '"2000-01-01"';
+    }
+    // Phone number patterns
+    if (pattern.includes('\\d{3}') && (pattern.includes('\\d{4}') || pattern.includes('\\d{7}'))) {
+        return '"+1234567890"';
+    }
+    return null;
+};

package/dist/generators/generate-discriminated-union-validation.d.ts

@@ -4,3 +4,4 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Uses a discriminator property to efficiently choose the correct schema.
  */
 export declare const generateDiscriminatedUnionValidation: (accessor: string, schemas: readonly JSONSchema[], discriminatorKey: string, defaultValue: string, isRequired: boolean) => string;
+//# sourceMappingURL=generate-discriminated-union-validation.d.ts.map

package/dist/generators/generate-discriminated-union-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-discriminated-union-validation.d.ts","sourceRoot":"","sources":["../../src/generators/generate-discriminated-union-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAMjE;;;GAGG;AACH,eAAO,MAAM,oCAAoC,aACrC,MAAM,WACP,SAAS,UAAU,EAAE,oBACZ,MAAM,gBACV,MAAM,cACR,OAAO,KAClB,MAqCF,CAAA"}

package/dist/generators/generate-discriminated-union-validation.js

@@ -0,0 +1,38 @@
+import { getDefaultValue } from '../helpers/get-default-value.js';
+import { getDiscriminatorValue } from '../helpers/get-discriminator-value.js';
+import { generateSchemaChecks } from './generate-schema-checks.js';
+/**
+ * Generates a discriminated union validation expression.
+ * Uses a discriminator property to efficiently choose the correct schema.
+ */
+export const generateDiscriminatedUnionValidation = (accessor, schemas, discriminatorKey, defaultValue, isRequired) => {
+    const cases = [];
+    for (const schema of schemas) {
+        const discriminatorValue = getDiscriminatorValue(schema, discriminatorKey);
+        if (discriminatorValue !== null) {
+            const schemaDefault = getDefaultValue(schema);
+            const checks = generateSchemaChecks(accessor, schema);
+            if (checks.length > 0) {
+                // checks[0] is safe: we guard with checks.length > 0 above
+                let combinedChecks = checks[0];
+                for (let i = 1; i < checks.length; i++) {
+                    combinedChecks += ' && ' + checks[i];
+                }
+                cases.push(`${accessor}?.${discriminatorKey} === ${JSON.stringify(discriminatorValue)} && ${combinedChecks} ? ${accessor} : ${schemaDefault}`);
+            }
+            else {
+                cases.push(`${accessor}?.${discriminatorKey} === ${JSON.stringify(discriminatorValue)} ? ${accessor} : ${schemaDefault}`);
+            }
+        }
+    }
+    if (cases.length === 0) {
+        return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+    }
+    // Chain the cases together with ternary operators using a for loop instead of .reduce()
+    // cases[0] is safe: we guard with cases.length === 0 above
+    let result = cases[0];
+    for (let i = 1; i < cases.length; i++) {
+        result = cases[i] + ' : ' + result;
+    }
+    return result;
+};

package/dist/generators/generate-enum-check.d.ts

@@ -3,3 +3,4 @@
  * Returns a string that checks if the value is in the allowed enum values.
  */
 export declare const generateEnumCheck: (accessor: string, enumValues: readonly unknown[]) => string;
+//# sourceMappingURL=generate-enum-check.d.ts.map

package/dist/generators/generate-enum-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-enum-check.d.ts","sourceRoot":"","sources":["../../src/generators/generate-enum-check.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,aAAc,MAAM,cAAc,SAAS,OAAO,EAAE,KAAG,MAGpF,CAAA"}

package/dist/generators/generate-enum-check.js

@@ -0,0 +1,8 @@
+/**
+ * Generates an enum validation check expression.
+ * Returns a string that checks if the value is in the allowed enum values.
+ */
+export const generateEnumCheck = (accessor, enumValues) => {
+    const serializedEnum = JSON.stringify(enumValues);
+    return `${serializedEnum}.includes(${accessor} as never)`;
+};

package/dist/generators/generate-files.d.ts

@@ -1,5 +1,5 @@
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-import { type HelpersMode, type RuntimeHelperName } from '#helpers/collect-helpers';
+import { type HelpersMode, type RuntimeHelperName } from '../helpers/collect-helpers.js';
 /**
  * Options for controlling what gets generated in a file.
  */
@@ -91,3 +91,4 @@ export type GeneratedFileContent = {
  */
 export declare const generateFile: (schema: JSONSchema, typeName: string, options?: GenerateFileOptions) => GeneratedFileContent;
 export {};
+//# sourceMappingURL=generate-files.d.ts.map

package/dist/generators/generate-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-files.d.ts","sourceRoot":"","sources":["../../src/generators/generate-files.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACvB,MAAM,0BAA0B,CAAA;AAKjC;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7C;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAA;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IACrC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED,iDAAiD;AACjD,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAA;CACrD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,YAAY,WACf,UAAU,YACR,MAAM,YACN,mBAAmB,KAC5B,oBA+CF,CAAA"}

package/dist/generators/generate-files.js

@@ -0,0 +1,74 @@
+import { generateTypeDefinition } from '@amritk/helpers/generate-type-definition';
+import { collectHelpers, } from '../helpers/collect-helpers.js';
+import { collectImports } from '../helpers/collect-imports.js';
+import { generateParserFunction, generateShapeValidator } from './generate-parser-function.js';
+/**
+ * Generates a complete TypeScript file from a JSON Schema.
+ *
+ * The generated file contains imports, type definition, and parser function.
+ * When typesOnly is true, only the type definition is emitted without any parser.
+ *
+ * @param schema - The JSON Schema to generate code from
+ * @param typeName - The name to use for the generated TypeScript type
+ * @param options - Optional settings to control what gets generated
+ * @returns The generated file content and the set of runtime helpers it references
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   type: "object",
+ *   properties: {
+ *     name: { type: "string" },
+ *     age: { type: "number" }
+ *   },
+ *   required: ["name"]
+ * };
+ *
+ * const result = generateFile(schema, "User");
+ * // result contains imports, type User, and parseUser function
+ *
+ * const typesOnly = generateFile(schema, "User", { typesOnly: true });
+ * // typesOnly contains only type-only imports and type User (no parser)
+ * ```
+ */
+export const generateFile = (schema, typeName, options) => {
+    const typesOnly = options?.typesOnly === true;
+    const selfRef = options?.selfRef;
+    const rootSchema = options?.rootSchema;
+    const helpersMode = options?.helpersMode ?? 'package';
+    const typeSuffix = options?.typeSuffix ?? '';
+    const typeDefinition = generateTypeDefinition(schema, typeName, { readonly: options?.readonly ?? false, typeSuffix });
+    if (typesOnly) {
+        // In types-only mode, skip the parser function and use type-only imports
+        const imports = collectImports(schema, { typesOnly: true, selfRef, rootSchema, typeSuffix });
+        let result = '';
+        if (imports.length > 0) {
+            result += imports[0];
+            for (let i = 1; i < imports.length; i++) {
+                result += '\n' + imports[i];
+            }
+            result += '\n\n';
+        }
+        return { content: result + typeDefinition, usedHelpers: new Set() };
+    }
+    const parserFunction = generateParserFunction(schema, typeName, {
+        useRefImports: true,
+        typeSuffix,
+        ...(options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {}),
+        ...(options?.strict !== undefined ? { strict: options.strict } : {}),
+    });
+    const shapeValidator = generateShapeValidator(schema, typeName, true, typeSuffix);
+    const combinedFunctions = `${shapeValidator}\n\n${parserFunction}`;
+    const helpers = collectHelpers(combinedFunctions, helpersMode, options?.helpersImportPrefix);
+    const imports = [...collectImports(schema, { selfRef, rootSchema, typeSuffix }), ...helpers.imports];
+    // Build file output using string concatenation instead of array join for performance
+    let result = '';
+    if (imports.length > 0) {
+        result += imports[0];
+        for (let i = 1; i < imports.length; i++) {
+            result += '\n' + imports[i];
+        }
+        result += '\n\n';
+    }
+    return { content: result + typeDefinition + '\n\n' + combinedFunctions, usedHelpers: helpers.used };
+};

package/dist/generators/generate-non-discriminated-union-validation.d.ts

@@ -4,3 +4,4 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Tries each schema in order until one matches.
  */
 export declare const generateNonDiscriminatedUnionValidation: (accessor: string, schemas: readonly JSONSchema[], defaultValue: string, isRequired: boolean) => string;
+//# sourceMappingURL=generate-non-discriminated-union-validation.d.ts.map

package/dist/generators/generate-non-discriminated-union-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-non-discriminated-union-validation.d.ts","sourceRoot":"","sources":["../../src/generators/generate-non-discriminated-union-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;;GAGG;AACH,eAAO,MAAM,uCAAuC,aACxC,MAAM,WACP,SAAS,UAAU,EAAE,gBAChB,MAAM,cACR,OAAO,KAClB,MA0BF,CAAA"}

package/dist/generators/generate-non-discriminated-union-validation.js

@@ -0,0 +1,28 @@
+import { generateSchemaChecks } from './generate-schema-checks.js';
+/**
+ * Generates a non-discriminated union validation expression.
+ * Tries each schema in order until one matches.
+ */
+export const generateNonDiscriminatedUnionValidation = (accessor, schemas, defaultValue, isRequired) => {
+    const cases = [];
+    for (const schema of schemas) {
+        const checks = generateSchemaChecks(accessor, schema);
+        if (checks.length > 0) {
+            let combinedChecks = checks[0];
+            for (let i = 1; i < checks.length; i++) {
+                combinedChecks += ' && ' + checks[i];
+            }
+            cases.push('(' + combinedChecks + ')');
+        }
+    }
+    if (cases.length === 0) {
+        return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+    }
+    // Try each schema in order
+    let combinedCheck = cases[0];
+    for (let i = 1; i < cases.length; i++) {
+        combinedCheck += ' || ' + cases[i];
+    }
+    const finalDefault = isRequired ? defaultValue : 'undefined';
+    return `(${combinedCheck}) ? ${accessor} : ${finalDefault}`;
+};

package/dist/generators/generate-parser-function.d.ts

@@ -56,3 +56,4 @@ export declare const shapeValidatorFunctionName: (typeName: string) => string;
  */
 export declare const generateShapeValidator: (schema: JSONSchema, typeName: string, useRefImports: boolean, suffix?: string) => string;
 export {};
+//# sourceMappingURL=generate-parser-function.d.ts.map

package/dist/generators/generate-parser-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-parser-function.d.ts","sourceRoot":"","sources":["../../src/generators/generate-parser-function.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAMjE;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;IAChC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAqqCD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,WACzB,UAAU,YACR,MAAM,YACN,qBAAqB,KAC9B,MAEF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,aAAc,MAAM,KAAG,MAAsC,CAAA;AAEpG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,WACzB,UAAU,YACR,MAAM,iBACD,OAAO,sBAErB,MAyDF,CAAA"}