@spyglassmc/core 0.1.0

package/lib/node/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AstNode"), exports);
+__exportStar(require("./BooleanNode"), exports);
+__exportStar(require("./CommentNode"), exports);
+__exportStar(require("./ErrorNode"), exports);
+__exportStar(require("./FileNode"), exports);
+__exportStar(require("./FloatNode"), exports);
+__exportStar(require("./IntegerNode"), exports);
+__exportStar(require("./ListNode"), exports);
+__exportStar(require("./LiteralNode"), exports);
+__exportStar(require("./LongNode"), exports);
+__exportStar(require("./RecordNode"), exports);
+__exportStar(require("./ResourceLocationNode"), exports);
+__exportStar(require("./Sequence"), exports);
+__exportStar(require("./StringNode"), exports);
+__exportStar(require("./SymbolNode"), exports);
+//# sourceMappingURL=index.js.map

package/lib/parser/Parser.d.ts

@@ -0,0 +1,16 @@
+import type { AstNode } from '../node';
+import type { ParserContext } from '../service';
+import type { Source } from '../source';
+/**
+ * A parser.
+ */
+export declare type Parser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Result<N>;
+/**
+ * A parser that always succeeds.
+ */
+export declare type InfallibleParser<N extends Returnable = AstNode> = (this: void, src: Source, ctx: ParserContext) => Success<N>;
+export declare type Result<T extends Returnable> = Success<T> | typeof Failure;
+export declare type Success<T extends Returnable> = T;
+export declare const Failure: unique symbol;
+export declare type Returnable = object | string | number | bigint | boolean | undefined;
+//# sourceMappingURL=Parser.d.ts.map

package/lib/parser/Parser.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Failure = void 0;
+exports.Failure = Symbol('Failure');
+//# sourceMappingURL=Parser.js.map

package/lib/parser/boolean.d.ts

@@ -0,0 +1,4 @@
+import type { BooleanNode } from '../node/BooleanNode';
+import type { InfallibleParser } from './Parser';
+export declare const boolean: InfallibleParser<BooleanNode>;
+//# sourceMappingURL=boolean.d.ts.map

package/lib/parser/boolean.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = void 0;
+const literal_1 = require("./literal");
+const util_1 = require("./util");
+exports.boolean = (0, util_1.map)((0, literal_1.literal)('false', 'true'), res => ({
+    type: 'boolean',
+    range: res.range,
+    value: res.value === '' ? undefined : res.value === 'true',
+}));
+//# sourceMappingURL=boolean.js.map

package/lib/parser/comment.d.ts

@@ -0,0 +1,12 @@
+import type { CommentNode } from '../node';
+import type { Parser } from './Parser';
+interface Options {
+    singleLinePrefixes: Set<string>;
+    includesEol?: boolean;
+}
+/**
+ * `Failure` when three isn't a comment.
+ */
+export declare function comment({ singleLinePrefixes, includesEol }: Options): Parser<CommentNode>;
+export {};
+//# sourceMappingURL=comment.d.ts.map

package/lib/parser/comment.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comment = void 0;
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+/**
+ * `Failure` when three isn't a comment.
+ */
+function comment({ singleLinePrefixes, includesEol }) {
+    return (src, _ctx) => {
+        const start = src.cursor;
+        const ans = {
+            type: 'comment',
+            range: source_1.Range.create(start),
+            comment: '',
+        };
+        for (const prefix of singleLinePrefixes) {
+            if (src.peek(prefix.length) === prefix) {
+                if (includesEol) {
+                    src.nextLine();
+                }
+                else {
+                    src.skipLine();
+                }
+                ans.range.end = src.cursor;
+                ans.comment = src.sliceToCursor(start + prefix.length);
+                return ans;
+            }
+        }
+        return Parser_1.Failure;
+    };
+}
+exports.comment = comment;
+//# sourceMappingURL=comment.js.map

package/lib/parser/empty.d.ts

@@ -0,0 +1,3 @@
+import type { InfallibleParser } from './Parser';
+export declare const empty: InfallibleParser<undefined>;
+//# sourceMappingURL=empty.d.ts.map

package/lib/parser/empty.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.empty = void 0;
+/* istanbul ignore next */
+const empty = () => undefined;
+exports.empty = empty;
+//# sourceMappingURL=empty.js.map

package/lib/parser/error.d.ts

@@ -0,0 +1,8 @@
+import type { ErrorNode } from '../node';
+import type { InfallibleParser } from './Parser';
+/**
+ * Returns an error node containing all the remaining text (including whitespace),
+ * or returns `undefined` if the `Source` has already reached its end.
+ */
+export declare const error: InfallibleParser<ErrorNode | undefined>;
+//# sourceMappingURL=error.d.ts.map

package/lib/parser/error.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const source_1 = require("../source");
+/**
+ * Returns an error node containing all the remaining text (including whitespace),
+ * or returns `undefined` if the `Source` has already reached its end.
+ */
+const error = (src, ctx) => {
+    if (!src.canRead()) {
+        return undefined;
+    }
+    const ans = {
+        type: 'error',
+        range: source_1.Range.create(src, () => src.skipRemaining()),
+    };
+    ctx.err.report((0, locales_1.localize)('error.unparseable-content'), ans);
+    return ans;
+};
+exports.error = error;
+//# sourceMappingURL=error.js.map

package/lib/parser/file.d.ts

@@ -0,0 +1,9 @@
+import type { FileNode } from '../node';
+import { AstNode } from '../node';
+import type { InfallibleParser } from './Parser';
+/**
+ * Dispatches to the corresponding parser for the language.
+ * @throws If there's no parser registered for this language ID.
+ */
+export declare function file(): InfallibleParser<FileNode<AstNode>>;
+//# sourceMappingURL=file.d.ts.map

package/lib/parser/file.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.file = void 0;
+const node_1 = require("../node");
+const source_1 = require("../source");
+const error_1 = require("./error");
+const Parser_1 = require("./Parser");
+/**
+ * Dispatches to the corresponding parser for the language.
+ * @throws If there's no parser registered for this language ID.
+ */
+function file() {
+    return (src, ctx) => {
+        const fullRange = source_1.Range.create(src, src.string.length);
+        const ans = {
+            type: 'file',
+            range: fullRange,
+            children: [],
+            locals: Object.create(null),
+            parserErrors: [],
+        };
+        src.skipWhitespace();
+        const parser = ctx.meta.getParserForLanguageId(ctx.doc.languageId);
+        const result = parser(src, ctx);
+        if (result && result !== Parser_1.Failure) {
+            ans.children.push(result);
+        }
+        if (src.skipWhitespace().canRead()) {
+            ans.children.push((0, error_1.error)(src, ctx));
+        }
+        node_1.AstNode.setParents(ans);
+        ans.parserErrors = ctx.err.dump();
+        return ans;
+    };
+}
+exports.file = file;
+//# sourceMappingURL=file.js.map

package/lib/parser/float.d.ts

@@ -0,0 +1,33 @@
+import type { FloatNode } from '../node';
+import type { ParserContext } from '../service';
+import { Source } from '../source';
+import type { InfallibleParser, Parser } from './Parser';
+interface OptionsBase {
+    pattern: RegExp;
+    /**
+     * Inclusive.
+     */
+    min?: number;
+    /**
+     * Inclusive.
+     */
+    max?: number;
+    /**
+     * A callback function that will be called when the numeral value is out of range.
+     *
+     * Defaults to a function that marks an `Error` at the range of the node.
+     */
+    onOutOfRange?: (ans: FloatNode, src: Source, ctx: ParserContext, options: Options) => void;
+}
+interface FallibleOptions extends OptionsBase {
+    failsOnEmpty: true;
+}
+interface InfallibleOptions extends OptionsBase {
+    failsOnEmpty?: false;
+}
+/** @internal For test only */
+export declare type Options = FallibleOptions | InfallibleOptions;
+export declare function float(options: InfallibleOptions): InfallibleParser<FloatNode>;
+export declare function float(options: FallibleOptions): Parser<FloatNode>;
+export {};
+//# sourceMappingURL=float.d.ts.map

package/lib/parser/float.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.float = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+const fallbackOnOutOfRange = (ans, _src, ctx, options) => {
+    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('float.between', options.min ?? '-∞', options.max ?? '+∞')), ans, 3 /* Error */);
+};
+function float(options) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'float',
+            range: source_1.Range.create(src),
+            value: 0,
+        };
+        if (src.peek() === '-' || src.peek() === '+') {
+            src.skip();
+        }
+        while (src.canRead() && source_1.Source.isDigit(src.peek())) {
+            src.skip();
+        }
+        if (src.trySkip('.')) {
+            while (src.canRead() && source_1.Source.isDigit(src.peek())) {
+                src.skip();
+            }
+        }
+        if (src.peek().toLowerCase() === 'e') {
+            src.skip();
+            if (src.peek() === '-' || src.peek() === '+') {
+                src.skip();
+            }
+            while (src.canRead() && source_1.Source.isDigit(src.peek())) {
+                src.skip();
+            }
+        }
+        ans.range.end = src.cursor;
+        const raw = src.sliceToCursor(ans.range.start);
+        ans.value = parseFloat(raw) || 0;
+        if (!raw) {
+            if (options.failsOnEmpty) {
+                return Parser_1.Failure;
+            }
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('float')), ans);
+        }
+        else if (!options.pattern.test(raw)) {
+            ctx.err.report((0, locales_1.localize)('parser.float.illegal', options.pattern), ans);
+        }
+        else if ((options.min && ans.value < options.min) || (options.max && ans.value > options.max)) {
+            const onOutOfRange = options.onOutOfRange ?? fallbackOnOutOfRange;
+            onOutOfRange(ans, src, ctx, options);
+        }
+        return ans;
+    };
+}
+exports.float = float;
+//# sourceMappingURL=float.js.map

package/lib/parser/index.d.ts

@@ -0,0 +1,17 @@
+export * from './boolean';
+export * from './comment';
+export * from './empty';
+export * from './error';
+export * from './file';
+export { float } from './float';
+export { integer } from './integer';
+export { list } from './list';
+export * from './literal';
+export { long } from './long';
+export * from './Parser';
+export { record } from './record';
+export * from './resourceLocation';
+export * from './string';
+export * from './symbol';
+export * from './util';
+//# sourceMappingURL=index.d.ts.map

package/lib/parser/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/* istanbul ignore file */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.record = exports.long = exports.list = exports.integer = exports.float = void 0;
+__exportStar(require("./boolean"), exports);
+__exportStar(require("./comment"), exports);
+__exportStar(require("./empty"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./file"), exports);
+var float_1 = require("./float");
+Object.defineProperty(exports, "float", { enumerable: true, get: function () { return float_1.float; } });
+var integer_1 = require("./integer");
+Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return integer_1.integer; } });
+var list_1 = require("./list");
+Object.defineProperty(exports, "list", { enumerable: true, get: function () { return list_1.list; } });
+__exportStar(require("./literal"), exports);
+var long_1 = require("./long");
+Object.defineProperty(exports, "long", { enumerable: true, get: function () { return long_1.long; } });
+__exportStar(require("./Parser"), exports);
+var record_1 = require("./record");
+Object.defineProperty(exports, "record", { enumerable: true, get: function () { return record_1.record; } });
+__exportStar(require("./resourceLocation"), exports);
+__exportStar(require("./string"), exports);
+__exportStar(require("./symbol"), exports);
+__exportStar(require("./util"), exports);
+//# sourceMappingURL=index.js.map

package/lib/parser/integer.d.ts

@@ -0,0 +1,33 @@
+import type { IntegerNode } from '../node';
+import type { ParserContext } from '../service';
+import { Source } from '../source';
+import type { InfallibleParser, Parser } from './Parser';
+interface OptionsBase {
+    pattern: RegExp;
+    /**
+     * Inclusive.
+     */
+    min?: number;
+    /**
+     * Inclusive.
+     */
+    max?: number;
+    /**
+     * A callback function that will be called when the numeral value is out of range.
+     *
+     * Defaults to a function that marks an `Error` at the range of the node.
+     */
+    onOutOfRange?: (ans: IntegerNode, src: Source, ctx: ParserContext, options: Options) => void;
+}
+interface FallibleOptions extends OptionsBase {
+    failsOnEmpty: true;
+}
+interface InfallibleOptions extends OptionsBase {
+    failsOnEmpty?: false;
+}
+/** @internal For test only */
+export declare type Options = FallibleOptions | InfallibleOptions;
+export declare function integer(options: InfallibleOptions): InfallibleParser<IntegerNode>;
+export declare function integer(options: FallibleOptions): Parser<IntegerNode>;
+export {};
+//# sourceMappingURL=integer.d.ts.map

package/lib/parser/integer.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integer = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+const fallbackOnOutOfRange = (ans, _src, ctx, options) => {
+    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('integer.between', options.min ?? '-∞', options.max ?? '+∞')), ans, 3 /* Error */);
+};
+function integer(options) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'integer',
+            range: source_1.Range.create(src),
+            value: 0,
+        };
+        if (src.peek() === '-' || src.peek() === '+') {
+            src.skip();
+        }
+        while (src.canRead() && source_1.Source.isDigit(src.peek())) {
+            src.skip();
+        }
+        ans.range.end = src.cursor;
+        const raw = src.sliceToCursor(ans.range.start);
+        const isOnlySign = raw === '-' || raw === '+';
+        if (!isOnlySign) {
+            ans.value = Number(raw);
+        }
+        if (!raw) {
+            if (options.failsOnEmpty) {
+                return Parser_1.Failure;
+            }
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('integer')), ans);
+        }
+        else if (!options.pattern.test(raw) || isOnlySign) {
+            ctx.err.report((0, locales_1.localize)('parser.integer.illegal', options.pattern), ans);
+        }
+        else if ((options.min !== undefined && ans.value < options.min) || (options.max !== undefined && ans.value > options.max)) {
+            const onOutOfRange = options.onOutOfRange ?? fallbackOnOutOfRange;
+            onOutOfRange(ans, src, ctx, options);
+        }
+        return ans;
+    };
+}
+exports.integer = integer;
+//# sourceMappingURL=integer.js.map

package/lib/parser/list.d.ts

@@ -0,0 +1,12 @@
+import type { AstNode, ListNode } from '../node';
+import type { InfallibleParser, Parser } from './Parser';
+/** @internal For test only */
+export interface Options<V extends AstNode> {
+    start: string;
+    value: Parser<V>;
+    sep: string;
+    trailingSep: boolean;
+    end: string;
+}
+export declare function list<V extends AstNode>({ start, value, sep, trailingSep, end }: Options<V>): InfallibleParser<ListNode<V>>;
+//# sourceMappingURL=list.d.ts.map

package/lib/parser/list.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+const util_1 = require("./util");
+function list({ start, value, sep, trailingSep, end }) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'list',
+            range: source_1.Range.create(src),
+            children: [],
+        };
+        if (src.trySkip(start)) {
+            src.skipWhitespace();
+            let requiresValueSep = false;
+            let hasValueSep = false;
+            while (src.canRead() && src.peek(end.length) !== end) {
+                const itemStart = src.cursor;
+                let valueNode;
+                // Item sep of the last item.
+                if (requiresValueSep && !hasValueSep) {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(sep)), src);
+                }
+                // Value.
+                src.skipWhitespace();
+                const { result, endCursor, updateSrcAndCtx } = (0, util_1.attempt)(value, src, ctx);
+                if (result === Parser_1.Failure || endCursor === src.cursor) {
+                    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('parser.list.value')), source_1.Range.create(src, () => src.skipUntilOrEnd(sep, end, '\r', '\n')));
+                }
+                else {
+                    updateSrcAndCtx();
+                    valueNode = result;
+                }
+                // Item sep.
+                let sepRange = undefined;
+                src.skipWhitespace();
+                requiresValueSep = true;
+                if (hasValueSep = src.peek(sep.length) === sep) {
+                    sepRange = source_1.Range.create(src, () => src.skip(sep.length));
+                }
+                // Create item.
+                ans.children.push({
+                    type: 'item',
+                    range: source_1.Range.create(itemStart, src),
+                    ...valueNode ? { children: [valueNode] } : {},
+                    value: valueNode,
+                    sep: sepRange,
+                });
+                src.skipWhitespace();
+            }
+            // Trailing item sep.
+            if (hasValueSep && !trailingSep) {
+                ctx.err.report((0, locales_1.localize)('parser.list.trailing-sep'), ans.children[ans.children.length - 1].sep);
+            }
+            // End.
+            if (!src.trySkip(end)) {
+                ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(end)), src);
+            }
+        }
+        else {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localeQuote)(start)), src);
+        }
+        ans.range.end = src.cursor;
+        return ans;
+    };
+}
+exports.list = list;
+//# sourceMappingURL=list.js.map

package/lib/parser/literal.d.ts

@@ -0,0 +1,5 @@
+import type { LiteralNode, LiteralOptions } from '../node/LiteralNode';
+import type { InfallibleParser } from './Parser';
+export declare function literal(...pool: string[]): InfallibleParser<LiteralNode>;
+export declare function literal(options: LiteralOptions): InfallibleParser<LiteralNode>;
+//# sourceMappingURL=literal.d.ts.map

package/lib/parser/literal.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.literal = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const source_1 = require("../source");
+function literal(...param) {
+    const options = getOptions(param);
+    return (src, ctx) => {
+        const ans = {
+            type: 'literal',
+            range: source_1.Range.create(src),
+            options,
+            value: '',
+        };
+        for (const expected of options.pool) {
+            if (src.trySkip(expected)) {
+                ans.value = expected;
+                ans.range.end = src.cursor;
+                return ans;
+            }
+        }
+        ctx.err.report((0, locales_1.localize)('expected', options.pool), ans);
+        return ans;
+    };
+}
+exports.literal = literal;
+function getOptions(param) {
+    let ans;
+    if (typeof param[0] === 'object') {
+        ans = param[0];
+    }
+    else {
+        ans = {
+            pool: param,
+        };
+    }
+    // Sort the pool from longest to shortest.
+    ans.pool = ans.pool.sort((a, b) => b.length - a.length);
+    return ans;
+}
+//# sourceMappingURL=literal.js.map

package/lib/parser/long.d.ts

@@ -0,0 +1,33 @@
+import type { LongNode } from '../node';
+import type { ParserContext } from '../service';
+import { Source } from '../source';
+import type { InfallibleParser, Parser } from './Parser';
+interface OptionsBase {
+    pattern: RegExp;
+    /**
+     * Inclusive.
+     */
+    min?: bigint;
+    /**
+     * Inclusive.
+     */
+    max?: bigint;
+    /**
+     * A callback function that will be called when the numeral value is out of range.
+     *
+     * Defaults to a function that marks an `Error` at the range of the node.
+     */
+    onOutOfRange?: (ans: LongNode, src: Source, ctx: ParserContext, options: Options) => void;
+}
+interface FallibleOptions extends OptionsBase {
+    failsOnEmpty: true;
+}
+interface InfallibleOptions extends OptionsBase {
+    failsOnEmpty?: false;
+}
+/** @internal For test only */
+export declare type Options = FallibleOptions | InfallibleOptions;
+export declare function long(options: InfallibleOptions): InfallibleParser<LongNode>;
+export declare function long(options: FallibleOptions): Parser<LongNode>;
+export {};
+//# sourceMappingURL=long.d.ts.map

package/lib/parser/long.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.long = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const source_1 = require("../source");
+const Parser_1 = require("./Parser");
+const fallbackOnOutOfRange = (ans, _src, ctx, options) => {
+    ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('long.between', options.min ?? '-∞', options.max ?? '+∞')), ans, 3 /* Error */);
+};
+function long(options) {
+    return (src, ctx) => {
+        const ans = {
+            type: 'long',
+            range: source_1.Range.create(src),
+            value: 0n,
+        };
+        if (src.peek() === '-' || src.peek() === '+') {
+            src.skip();
+        }
+        while (src.canRead() && source_1.Source.isDigit(src.peek())) {
+            src.skip();
+        }
+        ans.range.end = src.cursor;
+        const raw = src.sliceToCursor(ans.range.start);
+        let isOnlySign = false;
+        try {
+            ans.value = BigInt(raw);
+        }
+        catch (_) {
+            // `raw` might be "+" or "-" here.
+            isOnlySign = true;
+        }
+        if (!raw) {
+            if (options.failsOnEmpty) {
+                return Parser_1.Failure;
+            }
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('long')), ans);
+        }
+        else if (!options.pattern.test(raw) || isOnlySign) {
+            ctx.err.report((0, locales_1.localize)('parser.long.illegal', options.pattern), ans);
+        }
+        else if ((options.min && ans.value < options.min) || (options.max && ans.value > options.max)) {
+            const onOutOfRange = options.onOutOfRange ?? fallbackOnOutOfRange;
+            onOutOfRange(ans, src, ctx, options);
+        }
+        return ans;
+    };
+}
+exports.long = long;
+//# sourceMappingURL=long.js.map