tarsec 0.0.15 → 0.0.17

package/dist/types.d.ts

@@ -1,113 +0,0 @@
-/** A generic object type. */
-export type PlainObject = Record<string, unknown>;
-/** Represents a parse success with no captures. */
-export type ParserSuccess<T> = {
-    success: true;
-    result: T;
-    rest: string;
-    nextParser?: Parser<any>;
-};
-/** Represents a parse success with captures. Notice nextParser is also a CaptureParser. */
-export type CaptureParserSuccess<T, C extends PlainObject> = {
-    success: true;
-    result: T;
-    rest: string;
-    captures: C;
-    nextParser?: CaptureParser<any, any>;
-};
-/** Represents a parse failure. */
-export type ParserFailure = {
-    success: false;
-    rest: string;
-    message: string;
-};
-export type ParserResult<T> = ParserSuccess<T> | ParserFailure;
-export type CaptureParserResult<T, C extends PlainObject> = CaptureParserSuccess<T, C> | ParserFailure;
-/** A parser is any function that takes a string and returns a ParserResult. */
-export type Parser<T> = (input: string) => ParserResult<T>;
-/** A capture parser is any function that takes a string and returns a CaptureParserResult.
- * A CaptureParserResult is the same as a ParserResult, except it also includes captures,
- * i.e. matches selected using `capture`. */
-export type CaptureParser<T, C extends PlainObject> = (input: string) => CaptureParserResult<T, C>;
-export type GeneralParser<T, C extends PlainObject> = Parser<T> | CaptureParser<T, C>;
-export declare function isCaptureResult<T, C extends PlainObject>(result: ParserResult<T>): result is CaptureParserSuccess<T, C>;
-/** Convenience function to return a ParserSuccess */
-export declare function success<T>(result: T, rest: string): ParserSuccess<T>;
-/** Convenience function to return a CaptureParserSuccess */
-export declare function captureSuccess<T, C extends PlainObject>(result: T, rest: string, captures: C): CaptureParserSuccess<T, C>;
-/** Convenience function to return a ParserFailure */
-export declare function failure(message: string, rest: string): ParserFailure;
-/** Prettify an intersected type, to make it easier to read. */
-export type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-/** see <https://stackoverflow.com/a/50375286/3625> */
-export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-/** Convenience type to get the result type out of a parser. */
-type ExtractResults<T> = T extends Parser<infer U> ? U : never;
-/** Convenience type to get the capture type out of a capture parser. */
-type ExtractCaptures<T> = T extends CaptureParser<any, infer U> ? U : never;
-/** Convenience type where given an array of parsers and capture parsers,
- * it returns the types of the capture parsers, like
- * CaptureParser<string, { name: string }> | CaptureParser<number, { age: number }>
- */
-type ExtractCaptureParsers<T extends readonly GeneralParser<any, any>[]> = Extract<T[number], CaptureParser<any, any>>;
-/** Convenience type where given an array of parsers and capture parsers,
- * it returns a single capture type that merges all the capture types. */
-export type MergedCaptures<T extends readonly GeneralParser<any, any>[]> = Prettify<UnionToIntersection<UnionOfCaptures<T>>>;
-/** Convenience type where given an array of parsers and capture parsers,
- * it first gets the capture parsers, then extracts the capture types,
- * and returns a union of all the capture types. Example:
- * { name: string } | { age: number }
- */
-export type UnionOfCaptures<T extends readonly GeneralParser<any, any>[]> = Prettify<ExtractCaptures<ExtractCaptureParsers<T>>>;
-/** Convenience type where given an array of parsers and capture parsers,
- * it returns true if there are any capture parsers, otherwise false. */
-export type HasCaptureParsers<T extends readonly GeneralParser<any, any>[]> = ExtractCaptureParsers<T> extends never ? false : true;
-/**
- * For a given array of GeneralParsers, if any of them is a CaptureParser,
- * PickParserType says the array is an array of CaptureParsers,
- * otherwise it's an array of Parsers. It also correctly merges
- * the result and capture types. This is useful for a combinator like `or`
- * which is not able to infer its return type correctly.
- */
-export type PickParserType<T extends readonly GeneralParser<any, any>[]> = HasCaptureParsers<T> extends true ? CaptureParser<MergedResults<T>, UnionOfCaptures<T>> : Parser<MergedResults<T>>;
-/** This is used to generate a return type for the `many` and `many1` combinators.
- * Given a parser we want to apply `many` to. Suppose its type is `Parser<string>`.
- * This will return `Parser<string[]>` as the return type.
- *
- * Suppose the parser is a `CaptureParser<string, { name: string }>`.
- * This will return `CaptureParser<string[], { captures: { name: string }[] }>` as the return type.
- */
-export type InferManyReturnType<T extends GeneralParser<any, any>> = T extends CaptureParser<infer R, infer C> ? CaptureParser<R[], {
-    captures: C[];
-}> : T extends Parser<infer R> ? Parser<R[]> : never;
-export type MergedResults<T extends readonly GeneralParser<any, any>[]> = ExtractResults<T[number]>;
-/** Used to create a parser tree for backtracking. */
-export type Node = ParserNode | EmptyNode;
-export type ParserNode = {
-    parent: Node;
-    parser: GeneralParser<any, any> | null;
-    input?: string;
-    child: Node;
-    closed: boolean;
-};
-export type EmptyNode = null;
-/** Convenience function to create a ParserNode. */
-export declare function createNode(parent: Node | null, parser: GeneralParser<any, any>): ParserNode;
-/** Convenience function where, given an array of parsers, it creates a tree we can use for backtracking.
- * This tree is what `seq` use. It's used to keep track of the parsers we've tried so far,
- * so we can backtrack if we need to.
- */
-export declare function createTree(parsers: readonly GeneralParser<any, any>[]): Node;
-/** Used by `within`. */
-export type Matched = {
-    type: "matched";
-    value: string;
-};
-export type Unmatched = {
-    type: "unmatched";
-    value: string;
-};
-export type WithinResult = Matched | Unmatched;
-export {};

package/dist/types.js

@@ -1,40 +0,0 @@
-export function isCaptureResult(result) {
-    return "captures" in result;
-}
-/** Convenience function to return a ParserSuccess */
-export function success(result, rest) {
-    return { success: true, result, rest };
-}
-/** Convenience function to return a CaptureParserSuccess */
-export function captureSuccess(result, rest, captures) {
-    return { success: true, result, rest, captures };
-}
-/** Convenience function to return a ParserFailure */
-export function failure(message, rest) {
-    return { success: false, message, rest };
-}
-/** Convenience function to create a ParserNode. */
-export function createNode(parent, parser) {
-    return {
-        parent,
-        parser,
-        child: null,
-        closed: false,
-    };
-}
-/** Convenience function where, given an array of parsers, it creates a tree we can use for backtracking.
- * This tree is what `seq` use. It's used to keep track of the parsers we've tried so far,
- * so we can backtrack if we need to.
- */
-export function createTree(parsers) {
-    if (parsers.length === 0) {
-        return null;
-    }
-    const rootNode = createNode(null, parsers[0]);
-    let currentNode = rootNode;
-    for (let i = 1; i < parsers.length; i++) {
-        currentNode.child = createNode(currentNode, parsers[i]);
-        currentNode = currentNode.child;
-    }
-    return rootNode;
-}

package/dist/utils.d.ts

@@ -1,8 +0,0 @@
-import { Node } from "./types.js";
-export declare function escape(str: any): string;
-export declare function merge(a: any | any[], b: any | any[]): any[];
-export declare function mergeCaptures(a: Record<string, any>, b: Record<string, any>): Record<string, any>;
-export declare function findAncestorWithNextParser(node: Node, count?: number): [Node, number];
-export declare function popMany(arr: any[], count: number): void;
-export declare function round(num: number, places?: number): number;
-export declare function shorten(str: string, length?: number): string;

package/dist/utils.js

@@ -1,57 +0,0 @@
-export function escape(str) {
-    return JSON.stringify(str);
-}
-export function merge(a, b) {
-    if (Array.isArray(a) && Array.isArray(b)) {
-        return [...a, ...b];
-    }
-    else if (Array.isArray(a)) {
-        return [...a, b];
-    }
-    else if (Array.isArray(b)) {
-        return [a, ...b];
-    }
-    else {
-        return [a, b];
-    }
-}
-export function mergeCaptures(a, b) {
-    const result = {};
-    Object.keys(a).forEach((key) => {
-        result[key] = a[key];
-    });
-    Object.keys(b).forEach((key) => {
-        if (result[key]) {
-            result[key] = merge(result[key], b[key]);
-        }
-        else {
-            result[key] = b[key];
-        }
-    });
-    return result;
-}
-export function findAncestorWithNextParser(node, count = 0) {
-    if (node === null)
-        return [null, count];
-    if (!node.closed) {
-        return [node, count];
-    }
-    if (node.parent) {
-        return findAncestorWithNextParser(node.parent, count + 1);
-    }
-    return [null, count];
-}
-export function popMany(arr, count) {
-    for (let i = 0; i < count; i++) {
-        arr.pop();
-    }
-}
-export function round(num, places = 2) {
-    return Math.round(num * 10 ** places) / 10 ** places;
-}
-export function shorten(str, length = 250) {
-    if (str.length > length) {
-        return str.substring(0, length) + "...";
-    }
-    return str;
-}