@realtimex/node-llama-cpp 0.1.0

package/dist/utils/gbnfJson/terminals/GbnfWhitespace.js

@@ -0,0 +1,67 @@
+import { GbnfTerminal } from "../GbnfTerminal.js";
+import { reservedRuleNames } from "./gbnfConsts.js";
+import { GbnfVerbatimText } from "./GbnfVerbatimText.js";
+export class GbnfWhitespace extends GbnfTerminal {
+    scopeState;
+    newLine;
+    constructor(scopeState, { newLine = "before" } = {}) {
+        super();
+        this.scopeState = scopeState;
+        this.newLine = newLine;
+    }
+    getGrammar() {
+        return this._getGrammar();
+    }
+    getGrammarFromResolve() {
+        return this._getGrammar(false);
+    }
+    _getGrammar(wrap = true) {
+        if (this.scopeState.settings.allowNewLines && this.newLine !== false) {
+            const values = [
+                ...(this.newLine === "before"
+                    ? ["[\\n]"]
+                    : []),
+                ...(this.scopeState.currentNestingScope === 0
+                    ? []
+                    : [
+                        or([
+                            verbatimTextRepetition(" ", this.scopeState.currentNestingScope * this.scopeState.settings.scopePadSpaces),
+                            verbatimTextRepetition("\t", this.scopeState.currentNestingScope)
+                        ])
+                    ]),
+                ...(this.newLine === "after"
+                    ? ["[\\n]"]
+                    : [])
+            ];
+            return or([
+                values.join(" "),
+                "[ ]?"
+            ], wrap);
+        }
+        return "[ ]?";
+    }
+    getRuleName() {
+        return reservedRuleNames.whitespace({
+            newLine: this.scopeState.settings.allowNewLines
+                ? this.newLine
+                : false,
+            scopeSpaces: this.scopeState.settings.scopePadSpaces,
+            nestingScope: this.scopeState.currentNestingScope
+        });
+    }
+}
+function or(definitions, wrap = true) {
+    if (!wrap)
+        return definitions.join(" | ");
+    return "(" + definitions.join(" | ") + ")";
+}
+function verbatimTextRepetition(text, count) {
+    const textRepetitionGrammar = new GbnfVerbatimText(text.repeat(count)).getGrammar();
+    if (count <= 1)
+        return textRepetitionGrammar;
+    const textRepetitionGrammarWithRepetition = new GbnfVerbatimText(text).getGrammar() + "{" + count + "}";
+    if (textRepetitionGrammarWithRepetition.length < textRepetitionGrammar.length)
+        return textRepetitionGrammarWithRepetition;
+    return textRepetitionGrammar;
+}
+//# sourceMappingURL=GbnfWhitespace.js.map

package/dist/utils/gbnfJson/terminals/GbnfWhitespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GbnfWhitespace.js","sourceRoot":"","sources":["../../../../src/utils/gbnfJson/terminals/GbnfWhitespace.ts"],"names":[],"mappings":"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"}

package/dist/utils/gbnfJson/terminals/gbnfConsts.d.ts

@@ -0,0 +1,30 @@
+export declare const grammarNoValue = "\"\"";
+export declare const reservedRuleNames: {
+    readonly null: "null-rule";
+    readonly boolean: "boolean-rule";
+    readonly number: {
+        readonly fractional: "fractional-number-rule";
+        readonly integer: "integer-number-rule";
+    };
+    readonly stringChar: "string-char-rule";
+    readonly string: ({ minLength, maxLength }: {
+        minLength: number;
+        maxLength?: number;
+    }) => string;
+    readonly formatString: (format: string) => string;
+    readonly whitespace: ({ newLine, nestingScope, scopeSpaces }: {
+        newLine?: "before" | "after" | false;
+        nestingScope: number;
+        scopeSpaces: number;
+    }) => string;
+    readonly commaWhitespace: ({ newLine, nestingScope, scopeSpaces }: {
+        newLine?: "before" | "after" | false;
+        nestingScope: number;
+        scopeSpaces: number;
+    }) => string;
+    readonly anyJson: ({ allowNewLines, nestingScope, scopeSpaces }: {
+        allowNewLines: boolean;
+        nestingScope: number;
+        scopeSpaces: number;
+    }) => string;
+};

package/dist/utils/gbnfJson/terminals/gbnfConsts.js

@@ -0,0 +1,72 @@
+export const grammarNoValue = '""';
+export const reservedRuleNames = {
+    null: "null-rule",
+    boolean: "boolean-rule",
+    number: {
+        fractional: "fractional-number-rule",
+        integer: "integer-number-rule"
+    },
+    stringChar: "string-char-rule",
+    string({ minLength, maxLength }) {
+        if (minLength === 0 && maxLength == null)
+            return "string-rule";
+        else if (maxLength == null)
+            return [
+                "string-",
+                minLength,
+                "-rule"
+            ].join("");
+        return [
+            "string-",
+            minLength,
+            "-",
+            maxLength,
+            "-rule"
+        ].join("");
+    },
+    formatString(format) {
+        return "string-format-" + format + "-rule";
+    },
+    whitespace({ newLine, nestingScope, scopeSpaces }) {
+        if (!newLine)
+            return "whitespace-no-new-lines-rule";
+        return [
+            "whitespace-",
+            newLine === "before"
+                ? "b"
+                : newLine === "after"
+                    ? "a"
+                    : "n",
+            "-" + nestingScope,
+            "-" + scopeSpaces,
+            "-rule"
+        ].join("");
+    },
+    commaWhitespace({ newLine, nestingScope, scopeSpaces }) {
+        if (!newLine)
+            return "comma-whitespace-no-new-lines-rule";
+        return [
+            "comma-whitespace-",
+            newLine === "before"
+                ? "b"
+                : newLine === "after"
+                    ? "a"
+                    : "n",
+            "-" + nestingScope,
+            "-" + scopeSpaces,
+            "-rule"
+        ].join("");
+    },
+    anyJson({ allowNewLines, nestingScope, scopeSpaces }) {
+        return [
+            "any-json-",
+            !allowNewLines
+                ? "s-"
+                : "",
+            nestingScope,
+            "-" + scopeSpaces,
+            "-rule"
+        ].join("");
+    }
+};
+//# sourceMappingURL=gbnfConsts.js.map

package/dist/utils/gbnfJson/terminals/gbnfConsts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gbnfConsts.js","sourceRoot":"","sources":["../../../../src/utils/gbnfJson/terminals/gbnfConsts.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,CAAC;AACnC,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC7B,IAAI,EAAE,WAAW;IACjB,OAAO,EAAE,cAAc;IACvB,MAAM,EAAE;QACJ,UAAU,EAAE,wBAAwB;QACpC,OAAO,EAAE,qBAAqB;KACjC;IACD,UAAU,EAAE,kBAAkB;IAC9B,MAAM,CAAC,EAAC,SAAS,EAAE,SAAS,EAA0C;QAClE,IAAI,SAAS,KAAK,CAAC,IAAI,SAAS,IAAI,IAAI;YACpC,OAAO,aAAa,CAAC;aACpB,IAAI,SAAS,IAAI,IAAI;YACtB,OAAO;gBACH,SAAS;gBACT,SAAS;gBACT,OAAO;aACV,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAEf,OAAO;YACH,SAAS;YACT,SAAS;YACT,GAAG;YACH,SAAS;YACT,OAAO;SACV,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,CAAC;IACD,YAAY,CAAC,MAAc;QACvB,OAAO,gBAAgB,GAAG,MAAM,GAAG,OAAO,CAAC;IAC/C,CAAC;IACD,UAAU,CAAC,EAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAE7C;QACG,IAAI,CAAC,OAAO;YACR,OAAO,8BAA8B,CAAC;QAE1C,OAAO;YACH,aAAa;YACb,OAAO,KAAK,QAAQ;gBAChB,CAAC,CAAC,GAAG;gBACL,CAAC,CAAC,OAAO,KAAK,OAAO;oBACjB,CAAC,CAAC,GAAG;oBACL,CAAC,CAAC,GAAG;YACb,GAAG,GAAG,YAAY;YAClB,GAAG,GAAG,WAAW;YACjB,OAAO;SACV,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,CAAC;IACD,eAAe,CAAC,EAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAElD;QACG,IAAI,CAAC,OAAO;YACR,OAAO,oCAAoC,CAAC;QAEhD,OAAO;YACH,mBAAmB;YACnB,OAAO,KAAK,QAAQ;gBAChB,CAAC,CAAC,GAAG;gBACL,CAAC,CAAC,OAAO,KAAK,OAAO;oBACjB,CAAC,CAAC,GAAG;oBACL,CAAC,CAAC,GAAG;YACb,GAAG,GAAG,YAAY;YAClB,GAAG,GAAG,WAAW;YACjB,OAAO;SACV,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,CAAC;IACD,OAAO,CAAC,EAAC,aAAa,EAAE,YAAY,EAAE,WAAW,EAEhD;QACG,OAAO;YACH,WAAW;YACX,CAAC,aAAa;gBACV,CAAC,CAAC,IAAI;gBACN,CAAC,CAAC,EAAE;YACR,YAAY;YACZ,GAAG,GAAG,WAAW;YACjB,OAAO;SACV,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,CAAC;CACK,CAAC"}

package/dist/utils/gbnfJson/types.d.ts

@@ -0,0 +1,213 @@
+export type GbnfJsonSchemaImmutableType = "string" | "number" | "integer" | "boolean" | "null";
+export type GbnfJsonSchema<Defs extends GbnfJsonDefList<Defs> = Record<any, any>> = GbnfJsonBasicSchema | GbnfJsonConstSchema | GbnfJsonEnumSchema | GbnfJsonOneOfSchema<Defs> | GbnfJsonStringSchema | GbnfJsonObjectSchema<string, Defs> | GbnfJsonArraySchema<Defs> | (keyof Defs extends string ? keyof NoInfer<Defs> extends never ? never : GbnfJsonRefSchema<Defs> : never);
+export type GbnfJsonDefList<Defs extends GbnfJsonDefList<NoInfer<Defs>> = {}> = {
+    readonly [key: string]: GbnfJsonSchema<NoInfer<Defs>>;
+};
+export type GbnfJsonBasicSchema = {
+    readonly type: GbnfJsonSchemaImmutableType | readonly GbnfJsonSchemaImmutableType[];
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+};
+export type GbnfJsonConstSchema = {
+    readonly const: string | number | boolean | null;
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+};
+export type GbnfJsonEnumSchema = {
+    readonly enum: readonly (string | number | boolean | null)[];
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+};
+export type GbnfJsonOneOfSchema<Defs extends GbnfJsonDefList<NoInfer<Defs>> = {}> = {
+    readonly oneOf: readonly GbnfJsonSchema<NoInfer<Defs>>[];
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+    readonly $defs?: Defs;
+};
+export type GbnfJsonStringSchema = GbnfJsonBasicStringSchema | GbnfJsonFormatStringSchema;
+export type GbnfJsonBasicStringSchema = {
+    readonly type: "string";
+    /**
+     * When using `minLength` and/or `maxLength`,
+     * ensure to inform the model as part of the prompt what your expectations are regarding the length of the string.
+     * Not doing this may lead to hallucinations.
+     */
+    readonly minLength?: number;
+    /**
+     * When using `minLength` and/or `maxLength`,
+     * ensure to inform the model as part of the prompt what your expectations are regarding the length of the string.
+     * Not doing this may lead to hallucinations.
+     */
+    readonly maxLength?: number;
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+};
+export type GbnfJsonFormatStringSchema = {
+    readonly type: "string";
+    readonly format: "date-time" | "time" | "date";
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+};
+export type GbnfJsonObjectSchema<Keys extends string = string, Defs extends GbnfJsonDefList<NoInfer<Defs>> = {}> = {
+    readonly type: "object";
+    readonly properties?: {
+        readonly [key in Keys]: GbnfJsonSchema<NoInfer<Defs>>;
+    };
+    /**
+     * Unlike the JSON Schema spec, `additionalProperties` defaults to `false` to avoid breaking existing code.
+     */
+    readonly additionalProperties?: boolean | GbnfJsonSchema<NoInfer<Defs>>;
+    /**
+     * Make sure you define `additionalProperties` for this to have any effect.
+     *
+     * When using `minProperties` and/or `maxProperties`,
+     * ensure to inform the model as part of the prompt what your expectations are regarding the number of keys in the object.
+     * Not doing this may lead to hallucinations.
+     */
+    readonly minProperties?: number;
+    /**
+     * Make sure you define `additionalProperties` for this to have any effect.
+     *
+     * When using `minProperties` and/or `maxProperties`,
+     * ensure to inform the model as part of the prompt what your expectations are regarding the number of keys in the object.
+     * Not doing this may lead to hallucinations.
+     */
+    readonly maxProperties?: number;
+    /**
+     * `required` is always set to all keys in `properties`, and setting it has no effect.
+     *
+     * This limitation is due to how the generation works, and may be fixed in the future.
+     *
+     * This key is part of the type to avoid breaking exiting code (though it was never actually used in the past),
+     * and will be removed in the future.
+     * @deprecated
+     */
+    readonly required?: readonly Keys[];
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+    readonly $defs?: Defs;
+};
+export type GbnfJsonArraySchema<Defs extends GbnfJsonDefList<NoInfer<Defs>> = {}> = {
+    readonly type: "array";
+    readonly items?: GbnfJsonSchema<NoInfer<Defs>>;
+    readonly prefixItems?: readonly GbnfJsonSchema<NoInfer<Defs>>[];
+    /**
+     * When using `minItems` and/or `maxItems`,
+     * ensure to inform the model as part of the prompt what your expectations are regarding the length of the array.
+     * Not doing this may lead to hallucinations.
+     */
+    readonly minItems?: number;
+    /**
+     * When using `minItems` and/or `maxItems`,
+     * ensure to inform the model as part of the prompt what your expectations are regarding the length of the array.
+     * Not doing this may lead to hallucinations.
+     */
+    readonly maxItems?: number;
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+    readonly $defs?: Defs;
+};
+export type GbnfJsonRefSchema<Defs extends GbnfJsonDefList<NoInfer<Defs>> = {}> = {
+    readonly $ref: keyof NoInfer<Defs> extends never ? never : `#/$defs/${OnlyStringKeys<NoInfer<Defs>>}`;
+    /**
+     * A description of what you expect the model to set this value to.
+     *
+     * Only passed to the model when using function calling, and has no effect when using JSON Schema grammar directly.
+     */
+    readonly description?: string;
+    readonly $defs?: Defs;
+};
+/**
+ * Converts a GBNF JSON schema to a TypeScript type
+ */
+export type GbnfJsonSchemaToType<T> = 0 extends 1 & T ? any : GbnfJsonSchemaToTSType<T>;
+export type GbnfJsonSchemaToTSType<T, Defs extends GbnfJsonDefList<NoInfer<Defs>> = {}> = Readonly<GbnfJsonBasicSchema> extends T ? undefined : undefined extends T ? undefined : T extends GbnfJsonBasicStringSchema ? GbnfJsonBasicStringSchemaToType<T> : T extends GbnfJsonFormatStringSchema ? string : T extends GbnfJsonBasicSchema ? GbnfJsonBasicSchemaToType<T["type"]> : T extends GbnfJsonConstSchema ? T["const"] : T extends GbnfJsonEnumSchema ? T["enum"][number] : T extends GbnfJsonOneOfSchema<Record<any, any>> ? GbnfJsonSchemaToTSType<T["oneOf"][number], CombineDefs<NoInfer<Defs>, T["$defs"]>> : T extends GbnfJsonObjectSchema<string, Record<any, any>> ? GbnfJsonObjectSchemaToType<T, NoInfer<Defs>> : T extends GbnfJsonArraySchema<Record<any, any>> ? ArrayTypeToType<T, CombineDefs<NoInfer<Defs>, T["$defs"]>> : T extends GbnfJsonRefSchema<any> ? GbnfJsonRefSchemaToType<T, CombineDefs<NoInfer<Defs>, T["$defs"]>> : undefined;
+type GbnfJsonBasicStringSchemaToType<T extends GbnfJsonBasicStringSchema> = T["maxLength"] extends 0 ? "" : string;
+type GbnfJsonBasicSchemaToType<T extends GbnfJsonBasicSchema["type"]> = T extends GbnfJsonSchemaImmutableType ? ImmutableTypeToType<T> : T[number] extends GbnfJsonSchemaImmutableType ? ImmutableTypeToType<T[number]> : never;
+type ImmutableTypeToType<T extends GbnfJsonSchemaImmutableType> = T extends "string" ? string : T extends "number" ? number : T extends "integer" ? number : T extends "boolean" ? boolean : T extends "null" ? null : never;
+type ArrayTypeToType<T extends GbnfJsonArraySchema<Record<any, any>>, Defs extends GbnfJsonDefList<Defs> = {}, MinItems extends number = T["minItems"] extends number ? T["prefixItems"] extends readonly GbnfJsonSchema[] ? keyof T["prefixItems"] extends T["minItems"] ? T["prefixItems"]["length"] : T["minItems"] : T["minItems"] : T["prefixItems"] extends readonly GbnfJsonSchema[] ? T["prefixItems"]["length"] : 0> = T["prefixItems"] extends readonly GbnfJsonSchema[] ? (MinItems extends T["prefixItems"]["length"] ? (T["maxItems"] extends MinItems ? [
+    ...GbnfJsonOrderedArrayTypes<T["prefixItems"], CombineDefs<Defs, T["$defs"]>>,
+    ...IndexRangeWithSkip<MinItems, T["prefixItems"]["length"], T["items"] extends GbnfJsonSchema ? GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>> : GbnfJsonAnyValue>
+] : [
+    ...GbnfJsonOrderedArrayTypes<T["prefixItems"], CombineDefs<Defs, T["$defs"]>>,
+    ...(T["items"] extends GbnfJsonSchema ? GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>> : GbnfJsonAnyValue)[]
+]) : T["maxItems"] extends MinItems ? [
+    ...GbnfJsonOrderedArrayTypes<T["prefixItems"], CombineDefs<Defs, T["$defs"]>>,
+    ...(T["items"] extends GbnfJsonSchema ? IndexRangeWithSkip<T["maxItems"], T["prefixItems"]["length"], GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>>> : IndexRangeWithSkip<T["maxItems"], T["prefixItems"]["length"], GbnfJsonAnyValue>)
+] : [
+    ...GbnfJsonOrderedArrayTypes<T["prefixItems"], CombineDefs<Defs, T["$defs"]>>,
+    ...IndexRangeWithSkip<MinItems, T["prefixItems"]["length"], T["items"] extends GbnfJsonSchema ? GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>> : GbnfJsonAnyValue>,
+    ...(T["items"] extends GbnfJsonSchema ? GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>> : GbnfJsonAnyValue)[]
+]) : T["items"] extends GbnfJsonSchema ? (MinItems extends 0 ? GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>>[] : T["maxItems"] extends MinItems ? IndexRange<T["maxItems"], GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>>> : [
+    ...IndexRange<MinItems, GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>>>,
+    ...GbnfJsonSchemaToTSType<T["items"], CombineDefs<Defs, T["$defs"]>>[]
+]) : (MinItems extends 0 ? GbnfJsonAnyValue[] : T["maxItems"] extends MinItems ? IndexRange<T["maxItems"], GbnfJsonAnyValue> : [
+    ...IndexRange<MinItems, GbnfJsonAnyValue>,
+    ...GbnfJsonAnyValue[]
+]);
+type GbnfJsonObjectSchemaToType<T extends GbnfJsonObjectSchema<string, Record<any, any>>, Defs extends GbnfJsonDefList<Defs> = {}, Props extends Readonly<Record<string, GbnfJsonSchema>> | undefined = T["properties"], AdditionalProps extends true | false | GbnfJsonSchema | undefined = T["additionalProperties"], PropsMap = Props extends undefined ? {} : {
+    -readonly [P in keyof Props]: GbnfJsonSchemaToTSType<Props[P], CombineDefs<Defs, T["$defs"]>>;
+}, Res = AdditionalProps extends undefined | false ? PropsMap : AdditionalProps extends true ? PropsMap & {
+    [key: string]: GbnfJsonAnyValue;
+} : AdditionalProps extends GbnfJsonSchema ? PropsMap & {
+    [key: string]: GbnfJsonSchemaToTSType<AdditionalProps, CombineDefs<Defs, T["$defs"]>>;
+} : PropsMap> = Res;
+type GbnfJsonRefSchemaToType<T extends GbnfJsonRefSchema<Defs>, Defs extends GbnfJsonDefList<Defs> = {}> = T["$ref"] extends `#/$defs/${infer Key}` ? Key extends keyof Defs ? GbnfJsonSchemaToTSType<Defs[Key], Defs> : never : never;
+type GbnfJsonAnyValue = string | number | boolean | null | GbnfJsonAnyValue[] | {
+    [key: string]: GbnfJsonAnyValue;
+};
+export declare function isGbnfJsonConstSchema(schema: GbnfJsonSchema): schema is GbnfJsonConstSchema;
+export declare function isGbnfJsonEnumSchema(schema: GbnfJsonSchema): schema is GbnfJsonEnumSchema;
+export declare function isGbnfJsonOneOfSchema(schema: GbnfJsonSchema): schema is GbnfJsonOneOfSchema;
+export declare function isGbnfJsonBasicStringSchema(schema: GbnfJsonSchema): schema is GbnfJsonBasicStringSchema;
+export declare function isGbnfJsonFormatStringSchema(schema: GbnfJsonSchema): schema is GbnfJsonFormatStringSchema;
+export declare function isGbnfJsonObjectSchema(schema: GbnfJsonSchema): schema is GbnfJsonObjectSchema;
+export declare function isGbnfJsonArraySchema(schema: GbnfJsonSchema): schema is GbnfJsonArraySchema;
+export declare function isGbnfJsonRefSchema(schema: GbnfJsonSchema): schema is GbnfJsonRefSchema<Record<any, any>>;
+export declare function isGbnfJsonBasicSchemaIncludesType<T extends GbnfJsonSchemaImmutableType>(schema: GbnfJsonBasicSchema, type: T): schema is GbnfJsonBasicSchema & {
+    type: T | (T | GbnfJsonSchemaImmutableType)[];
+};
+type OnlyStringKeys<T extends object> = {
+    [K in keyof T]: K extends string ? K : never;
+}[keyof T];
+type CombineDefs<Defs1 extends GbnfJsonDefList<Defs1>, Param2 extends Defs1 | Defs2 | undefined, Defs2 extends GbnfJsonDefList<Defs2> = {}> = undefined extends NoInfer<Param2> ? Defs1 : Defs1 & Param2;
+type IndexRange<Length extends number, FillType = number, Res = _IndexRange<[], Length, FillType>> = Res;
+type _IndexRange<Value extends FillType[], MaxLength extends number, FillType = number> = Value["length"] extends MaxLength ? Value : _IndexRange<[...Value, FillType], MaxLength, FillType>;
+type IndexRangeWithSkip<Length extends number, SkipFirst extends number, FillType, Res = _IndexRangeWithSkip<[], IndexRange<SkipFirst>, Length, FillType>> = Res;
+type _IndexRangeWithSkip<Value extends FillType[], ConditionValue extends number[], MaxLength extends number, FillType> = ConditionValue["length"] extends MaxLength ? Value : _IndexRangeWithSkip<[...Value, FillType], [...ConditionValue, ConditionValue["length"]], MaxLength, FillType>;
+type GbnfJsonOrderedArrayTypes<T extends readonly GbnfJsonSchema[], Defs extends GbnfJsonDefList<Defs> = {}> = {
+    -readonly [P in keyof T]: GbnfJsonSchemaToTSType<T[P], Defs>;
+};
+export {};

package/dist/utils/gbnfJson/types.js

@@ -0,0 +1,30 @@
+export function isGbnfJsonConstSchema(schema) {
+    return schema.const !== undefined;
+}
+export function isGbnfJsonEnumSchema(schema) {
+    return schema.enum != null;
+}
+export function isGbnfJsonOneOfSchema(schema) {
+    return schema.oneOf != null;
+}
+export function isGbnfJsonBasicStringSchema(schema) {
+    return schema.type === "string" && schema.format == null;
+}
+export function isGbnfJsonFormatStringSchema(schema) {
+    return schema.type === "string" && schema.format != null;
+}
+export function isGbnfJsonObjectSchema(schema) {
+    return schema.type === "object";
+}
+export function isGbnfJsonArraySchema(schema) {
+    return schema.type === "array";
+}
+export function isGbnfJsonRefSchema(schema) {
+    return typeof schema.$ref === "string";
+}
+export function isGbnfJsonBasicSchemaIncludesType(schema, type) {
+    if (schema.type instanceof Array)
+        return schema.type.includes(type);
+    return schema.type === type;
+}
+//# sourceMappingURL=types.js.map

package/dist/utils/gbnfJson/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/utils/gbnfJson/types.ts"],"names":[],"mappings":"AAgXA,MAAM,UAAU,qBAAqB,CAAC,MAAsB;IACxD,OAAQ,MAA8B,CAAC,KAAK,KAAK,SAAS,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,MAAsB;IACvD,OAAQ,MAA6B,CAAC,IAAI,IAAI,IAAI,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,MAAsB;IACxD,OAAQ,MAA8B,CAAC,KAAK,IAAI,IAAI,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,MAAsB;IAC9D,OAAQ,MAAoC,CAAC,IAAI,KAAK,QAAQ,IAAK,MAAqC,CAAC,MAAM,IAAI,IAAI,CAAC;AAC5H,CAAC;AAED,MAAM,UAAU,4BAA4B,CAAC,MAAsB;IAC/D,OAAQ,MAAqC,CAAC,IAAI,KAAK,QAAQ,IAAK,MAAqC,CAAC,MAAM,IAAI,IAAI,CAAC;AAC7H,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,MAAsB;IACzD,OAAQ,MAA+B,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC9D,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,MAAsB;IACxD,OAAQ,MAA8B,CAAC,IAAI,KAAK,OAAO,CAAC;AAC5D,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAsB;IACtD,OAAO,OAAQ,MAA4B,CAAC,IAAI,KAAK,QAAQ,CAAC;AAClE,CAAC;AAED,MAAM,UAAU,iCAAiC,CAC7C,MAA2B,EAAE,IAAO;IAEpC,IAAI,MAAM,CAAC,IAAI,YAAY,KAAK;QAC5B,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAEtC,OAAO,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC;AAChC,CAAC"}

package/dist/utils/gbnfJson/utils/GbnfJsonScopeState.d.ts

@@ -0,0 +1,10 @@
+export type GbnfJsonScopeSettings = {
+    readonly allowNewLines: boolean;
+    readonly scopePadSpaces: number;
+};
+export declare class GbnfJsonScopeState {
+    readonly settings: GbnfJsonScopeSettings;
+    readonly currentNestingScope: number;
+    constructor(settings?: GbnfJsonScopeSettings, currentNestingScope?: number);
+    getForNewScope(): GbnfJsonScopeState;
+}

package/dist/utils/gbnfJson/utils/GbnfJsonScopeState.js

@@ -0,0 +1,15 @@
+export class GbnfJsonScopeState {
+    settings;
+    currentNestingScope;
+    constructor(settings = {
+        allowNewLines: true,
+        scopePadSpaces: 4
+    }, currentNestingScope = 0) {
+        this.settings = settings;
+        this.currentNestingScope = currentNestingScope;
+    }
+    getForNewScope() {
+        return new GbnfJsonScopeState(this.settings, this.currentNestingScope + 1);
+    }
+}
+//# sourceMappingURL=GbnfJsonScopeState.js.map

package/dist/utils/gbnfJson/utils/GbnfJsonScopeState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GbnfJsonScopeState.js","sourceRoot":"","sources":["../../../../src/utils/gbnfJson/utils/GbnfJsonScopeState.ts"],"names":[],"mappings":"AAKA,MAAM,OAAO,kBAAkB;IACX,QAAQ,CAAwB;IAChC,mBAAmB,CAAS;IAE5C,YAAmB,WAAkC;QACjD,aAAa,EAAE,IAAI;QACnB,cAAc,EAAE,CAAC;KACpB,EAAE,sBAA8B,CAAC;QAC9B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,mBAAmB,GAAG,mBAAmB,CAAC;IACnD,CAAC;IAEM,cAAc;QACjB,OAAO,IAAI,kBAAkB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,mBAAmB,GAAG,CAAC,CAAC,CAAC;IAC/E,CAAC;CACJ"}

package/dist/utils/gbnfJson/utils/defsScope.d.ts

@@ -0,0 +1,7 @@
+import { MultiKeyMap } from "lifecycle-utils";
+import { GbnfJsonSchema } from "../types.js";
+export declare class DefScopeDefs {
+    defScopeDefs: MultiKeyMap<[string, GbnfJsonSchema], Record<string, GbnfJsonSchema>>;
+    registerDefs(scopeDefs: Record<string, GbnfJsonSchema>): void;
+}
+export declare function joinDefs(parent: Record<string, GbnfJsonSchema>, current?: Record<string, GbnfJsonSchema>): Record<string, GbnfJsonSchema>;

package/dist/utils/gbnfJson/utils/defsScope.js

@@ -0,0 +1,17 @@
+import { MultiKeyMap } from "lifecycle-utils";
+export class DefScopeDefs {
+    defScopeDefs = new MultiKeyMap();
+    registerDefs(scopeDefs) {
+        for (const [defName, def] of Object.entries(scopeDefs))
+            this.defScopeDefs.set([defName, def], scopeDefs);
+    }
+}
+export function joinDefs(parent, current) {
+    if (current == null || Object.keys(current).length === 0)
+        return parent;
+    return {
+        ...parent,
+        ...current
+    };
+}
+//# sourceMappingURL=defsScope.js.map

package/dist/utils/gbnfJson/utils/defsScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defsScope.js","sourceRoot":"","sources":["../../../../src/utils/gbnfJson/utils/defsScope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAG5C,MAAM,OAAO,YAAY;IACd,YAAY,GAA0E,IAAI,WAAW,EAAE,CAAC;IAExG,YAAY,CAAC,SAAyC;QACzD,KAAK,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC;YAClD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE,SAAS,CAAC,CAAC;IACzD,CAAC;CACJ;AAED,MAAM,UAAU,QAAQ,CACpB,MAAsC,EACtC,OAAwC;IAExC,IAAI,OAAO,IAAI,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC;QACpD,OAAO,MAAM,CAAC;IAElB,OAAO;QACH,GAAG,MAAM;QACT,GAAG,OAAO;KACb,CAAC;AACN,CAAC"}

package/dist/utils/gbnfJson/utils/getGbnfJsonTerminalForGbnfJsonSchema.d.ts

@@ -0,0 +1,5 @@
+import { GbnfTerminal } from "../GbnfTerminal.js";
+import { GbnfGrammarGenerator } from "../GbnfGrammarGenerator.js";
+import { GbnfJsonSchema } from "../types.js";
+import { GbnfJsonScopeState } from "./GbnfJsonScopeState.js";
+export declare function getGbnfJsonTerminalForGbnfJsonSchema(schema: GbnfJsonSchema, grammarGenerator: GbnfGrammarGenerator, scopeState?: GbnfJsonScopeState, defs?: Record<string, GbnfJsonSchema>): GbnfTerminal;

package/dist/utils/gbnfJson/utils/getGbnfJsonTerminalForGbnfJsonSchema.js

@@ -0,0 +1,143 @@
+import { GbnfOr } from "../terminals/GbnfOr.js";
+import { GbnfObjectMap } from "../terminals/GbnfObjectMap.js";
+import { GbnfStringValue } from "../terminals/GbnfStringValue.js";
+import { GbnfArray } from "../terminals/GbnfArray.js";
+import { GbnfString } from "../terminals/GbnfString.js";
+import { GbnfNumber } from "../terminals/GbnfNumber.js";
+import { GbnfBoolean } from "../terminals/GbnfBoolean.js";
+import { GbnfNull } from "../terminals/GbnfNull.js";
+import { isGbnfJsonArraySchema, isGbnfJsonBasicSchemaIncludesType, isGbnfJsonConstSchema, isGbnfJsonEnumSchema, isGbnfJsonObjectSchema, isGbnfJsonOneOfSchema, isGbnfJsonBasicStringSchema, isGbnfJsonFormatStringSchema, isGbnfJsonRefSchema } from "../types.js";
+import { getConsoleLogPrefix } from "../../getConsoleLogPrefix.js";
+import { GbnfAnyJson } from "../terminals/GbnfAnyJson.js";
+import { GbnfFormatString } from "../terminals/GbnfFormatString.js";
+import { GbnfRef } from "../terminals/GbnfRef.js";
+import { getGbnfJsonTerminalForLiteral } from "./getGbnfJsonTerminalForLiteral.js";
+import { GbnfJsonScopeState } from "./GbnfJsonScopeState.js";
+import { joinDefs } from "./defsScope.js";
+const maxNestingScope = 512;
+export function getGbnfJsonTerminalForGbnfJsonSchema(schema, grammarGenerator, scopeState = new GbnfJsonScopeState(), defs = {}) {
+    if (scopeState.currentNestingScope >= maxNestingScope)
+        throw new Error("Maximum nesting scope exceeded. Ensure that your schema does not have circular references or excessive nesting.");
+    if (isGbnfJsonRefSchema(schema)) {
+        const currentDefs = joinDefs(defs, schema.$defs);
+        grammarGenerator.registerDefs(currentDefs);
+        const ref = schema?.$ref;
+        const referencePrefix = "#/$defs/";
+        if (ref == null || !ref.startsWith(referencePrefix)) {
+            console.warn(getConsoleLogPrefix(true, false), `Reference "${ref}" does not start with "${referencePrefix}". ` +
+                'Using an "any" type instead of a reference.');
+            return new GbnfAnyJson(scopeState);
+        }
+        const defName = ref.slice(referencePrefix.length);
+        const def = currentDefs[defName];
+        if (def == null) {
+            console.warn(getConsoleLogPrefix(true, false), `Reference "${ref}" does not point to an existing definition. ` +
+                'Using an "any" type instead of a reference.');
+            return new GbnfAnyJson(scopeState);
+        }
+        return new GbnfRef({
+            getValueTerminal() {
+                const scopeDefs = grammarGenerator.defScopeDefs.get([defName, def]);
+                return getGbnfJsonTerminalForGbnfJsonSchema(def, grammarGenerator, new GbnfJsonScopeState({
+                    allowNewLines: false,
+                    scopePadSpaces: scopeState.settings.scopePadSpaces
+                }, 0), scopeDefs ?? {});
+            },
+            def,
+            defName
+        });
+    }
+    else if (isGbnfJsonOneOfSchema(schema)) {
+        const currentDefs = joinDefs(defs, schema.$defs);
+        grammarGenerator.registerDefs(currentDefs);
+        const values = schema.oneOf
+            .map((altSchema) => (getGbnfJsonTerminalForGbnfJsonSchema(altSchema, grammarGenerator, scopeState, currentDefs)));
+        return new GbnfOr(values);
+    }
+    else if (isGbnfJsonConstSchema(schema)) {
+        return getGbnfJsonTerminalForLiteral(schema.const);
+    }
+    else if (isGbnfJsonEnumSchema(schema)) {
+        return new GbnfOr(schema.enum.map((item) => getGbnfJsonTerminalForLiteral(item)));
+    }
+    else if (isGbnfJsonObjectSchema(schema)) {
+        const propertiesEntries = Object.entries(schema.properties ?? {});
+        const currentDefs = joinDefs(defs, schema.$defs);
+        grammarGenerator.registerDefs(currentDefs);
+        let maxProperties = schema.maxProperties;
+        if (schema.properties != null && maxProperties != null && maxProperties < propertiesEntries.length) {
+            console.warn(getConsoleLogPrefix(true, false), `maxProperties (${maxProperties}) must be greater than or equal to ` +
+                `properties object keys number (${propertiesEntries.length}). ` +
+                "Using properties object keys number as maxProperties.");
+            maxProperties = propertiesEntries.length;
+        }
+        return new GbnfObjectMap({
+            fields: propertiesEntries.map(([propName, propSchema]) => {
+                return {
+                    required: true,
+                    key: new GbnfStringValue(propName),
+                    value: getGbnfJsonTerminalForGbnfJsonSchema(propSchema, grammarGenerator, scopeState.getForNewScope(), currentDefs)
+                };
+            }),
+            additionalProperties: (schema.additionalProperties == null || schema.additionalProperties === false)
+                ? undefined
+                : schema.additionalProperties === true
+                    ? new GbnfAnyJson(scopeState.getForNewScope())
+                    : getGbnfJsonTerminalForGbnfJsonSchema(schema.additionalProperties, grammarGenerator, scopeState.getForNewScope(), currentDefs),
+            minProperties: schema.minProperties,
+            maxProperties,
+            scopeState
+        });
+    }
+    else if (isGbnfJsonArraySchema(schema)) {
+        const currentDefs = joinDefs(defs, schema.$defs);
+        grammarGenerator.registerDefs(currentDefs);
+        let maxItems = schema.maxItems;
+        if (schema.prefixItems != null && maxItems != null && maxItems < schema.prefixItems.length) {
+            console.warn(getConsoleLogPrefix(true, false), `maxItems (${maxItems}) must be greater than or equal to prefixItems array length (${schema.prefixItems.length}). ` +
+                "Using prefixItems length as maxItems.");
+            maxItems = schema.prefixItems.length;
+        }
+        return new GbnfArray({
+            items: schema.items == null
+                ? undefined
+                : getGbnfJsonTerminalForGbnfJsonSchema(schema.items, grammarGenerator, scopeState.getForNewScope(), currentDefs),
+            prefixItems: schema.prefixItems == null
+                ? undefined
+                : schema.prefixItems.map((item) => (getGbnfJsonTerminalForGbnfJsonSchema(item, grammarGenerator, scopeState.getForNewScope(), currentDefs))),
+            minItems: schema.minItems,
+            maxItems,
+            scopeState
+        });
+    }
+    else if (isGbnfJsonBasicStringSchema(schema)) {
+        const minLength = Math.max(0, schema.minLength ?? 0);
+        let maxLength = schema.maxLength;
+        if (maxLength != null && maxLength < minLength) {
+            console.warn(getConsoleLogPrefix(true, false), `maxLength (${maxLength}) must be greater than or equal to minLength (${minLength}). ` +
+                "Using minLength as maxLength.");
+            maxLength = minLength;
+        }
+        return new GbnfString({
+            minLength,
+            maxLength
+        });
+    }
+    else if (isGbnfJsonFormatStringSchema(schema))
+        return new GbnfFormatString(schema.format);
+    const terminals = [];
+    if (isGbnfJsonBasicSchemaIncludesType(schema, "string"))
+        terminals.push(new GbnfString());
+    if (isGbnfJsonBasicSchemaIncludesType(schema, "number"))
+        terminals.push(new GbnfNumber({ allowFractional: true }));
+    if (isGbnfJsonBasicSchemaIncludesType(schema, "integer"))
+        terminals.push(new GbnfNumber({ allowFractional: false }));
+    if (isGbnfJsonBasicSchemaIncludesType(schema, "boolean"))
+        terminals.push(new GbnfBoolean());
+    if (isGbnfJsonBasicSchemaIncludesType(schema, "null"))
+        terminals.push(new GbnfNull());
+    if (terminals.length === 0)
+        terminals.push(new GbnfNull());
+    return new GbnfOr(terminals);
+}
+//# sourceMappingURL=getGbnfJsonTerminalForGbnfJsonSchema.js.map