@typed/router 0.31.0 → 1.0.0-beta.0

package/dist/Matcher.js

@@ -0,0 +1,597 @@
+import * as findMyWay from "find-my-way-ts";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { interrupt, isSuccess } from "effect/Exit";
+import { dual, identity } from "effect/Function";
+import * as Result from "effect/Result";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import { makeFormatterDefault } from "effect/SchemaIssue";
+import * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import * as Stream from "effect/Stream";
+import { exit } from "@typed/fx/Fx";
+import { mapEffect } from "@typed/fx/Fx/combinators/mapEffect";
+import { provideServices } from "@typed/fx/Fx/combinators/provide";
+import { skipRepeats } from "@typed/fx/Fx/combinators/skipRepeats";
+import { switchMap } from "@typed/fx/Fx/combinators/switchMap";
+import { unwrap } from "@typed/fx/Fx/combinators/unwrap";
+import { fromEffect, never } from "@typed/fx/Fx/constructors/fromEffect";
+import { succeed } from "@typed/fx/Fx/constructors/succeed";
+import { fromStream } from "@typed/fx/Fx/stream";
+import { isFx } from "@typed/fx/Fx/TypeId";
+import { RefSubject } from "@typed/fx/RefSubject";
+import { CurrentPath, Navigation } from "@typed/navigation/Navigation";
+import * as AST from "./AST.js";
+import { CurrentRoute } from "./CurrentRoute.js";
+import { Join, make as makeRoute } from "./Route.js";
+function isMatchHandlerFn(handler) {
+    return typeof handler === "function";
+}
+function isHandlerOptions(value) {
+    return typeof value === "object" && value !== null && "handler" in value;
+}
+function parseMatchArgs(args) {
+    const [first, second, third] = args;
+    // Single arg: full options object (Overload 9)
+    if (second === undefined) {
+        const opts = first;
+        return {
+            route: opts.route,
+            handler: opts.handler,
+            guard: undefined,
+            layout: opts.layout,
+            catchFn: opts.catch,
+            dependencies: opts.dependencies,
+        };
+    }
+    // Two args
+    if (third === undefined) {
+        if (isHandlerOptions(second)) {
+            // Overload 3: match(route, options)
+            const opts = second;
+            return {
+                route: first,
+                handler: opts.handler,
+                guard: undefined,
+                layout: opts.layout,
+                catchFn: opts.catch,
+                dependencies: opts.dependencies,
+            };
+        }
+        // Overloads 1, 2, 4: match(route, handler)
+        return {
+            route: first,
+            handler: second,
+            guard: undefined,
+            layout: undefined,
+            catchFn: undefined,
+            dependencies: undefined,
+        };
+    }
+    // Three args
+    if (isHandlerOptions(third)) {
+        // Overload 7: match(route, guard, options)
+        const opts = third;
+        return {
+            route: first,
+            handler: opts.handler,
+            guard: second,
+            layout: opts.layout,
+            catchFn: opts.catch,
+            dependencies: opts.dependencies,
+        };
+    }
+    // Overloads 5, 6, 8: match(route, guard, handler)
+    return {
+        route: first,
+        handler: third,
+        guard: second,
+        layout: undefined,
+        catchFn: undefined,
+        dependencies: undefined,
+    };
+}
+class MatcherImpl {
+    cases;
+    constructor(cases) {
+        this.cases = cases;
+        this.match = this.match.bind(this);
+        this.catch = this.catch.bind(this);
+        this.catchTag = this.catchTag.bind(this);
+        this.layout = this.layout.bind(this);
+        this.provide = this.provide.bind(this);
+        this.provideService = this.provideService.bind(this);
+    }
+    match(...args) {
+        const parsed = parseMatchArgs(args);
+        const normalizedGuard = parsed.guard !== undefined
+            ? getGuard(parsed.guard)
+            : defaultGuard();
+        const routeAst = AST.route(parsed.route.ast, parsed.handler, normalizedGuard);
+        let matches = [routeAst];
+        if (parsed.layout !== undefined) {
+            matches = [AST.layout(matches, parsed.layout)];
+        }
+        if (parsed.catchFn !== undefined) {
+            matches = [AST.catchCause(matches, parsed.catchFn)];
+        }
+        if (parsed.dependencies !== undefined && parsed.dependencies.length > 0) {
+            matches = [AST.layer(matches, normalizeDependencies(parsed.dependencies))];
+        }
+        return new MatcherImpl([...this.cases, ...matches]);
+    }
+    prefix(route) {
+        return new MatcherImpl([AST.prefixed(this.cases, route.ast)]);
+    }
+    provide(...layers) {
+        return new MatcherImpl([AST.layer(this.cases, layers)]);
+    }
+    provideService(tag, service) {
+        return this.provideServices(ServiceMap.make(tag, service));
+    }
+    provideServices(services) {
+        return this.provide(Layer.succeedServices(services));
+    }
+    catchCause(f) {
+        return new MatcherImpl([AST.catchCause(this.cases, f)]);
+    }
+    catch(f) {
+        return this.catchCause((causeRef) => unwrap(Effect.gen(function* () {
+            const cause = yield* causeRef;
+            const result = Cause.findFail(cause);
+            if (Result.isFailure(result)) {
+                return fromEffect(Effect.failCause(result.failure));
+            }
+            return f(result.success.error);
+        })));
+    }
+    catchTag(tag, f) {
+        const rethrow = (cause) => fromEffect(Effect.failCause(cause));
+        return new MatcherImpl([
+            AST.catchCause(this.cases, (causeRef) => unwrap(Effect.gen(function* () {
+                const cause = yield* causeRef;
+                const result = Cause.findFail(cause);
+                if (Result.isFailure(result)) {
+                    return rethrow(cause);
+                }
+                if (matchesTag(tag, result.success.error)) {
+                    return f(result.success.error);
+                }
+                return rethrow(cause);
+            }))),
+        ]);
+    }
+    layout(layout) {
+        return new MatcherImpl([
+            AST.layout(this.cases, layout),
+        ]);
+    }
+    pipe() {
+        return pipeArguments(this, arguments);
+    }
+}
+function normalizeHandler(handler) {
+    if (isMatchHandlerFn(handler))
+        return (params) => toFx(handler(params));
+    return () => toFx(handler);
+}
+function toFx(value) {
+    if (isFx(value))
+        return value;
+    if (Stream.isStream(value))
+        return fromStream(value);
+    if (Effect.isEffect(value))
+        return fromEffect(value);
+    return succeed(value);
+}
+export const empty = new MatcherImpl([]);
+export const match = empty.match.bind(empty);
+export class RouteGuardError extends Schema.ErrorClass("@typed/router/RouteGuardError")({
+    _tag: Schema.tag("RouteGuardError"),
+    path: Schema.String,
+    causes: Schema.Array(Schema.Unknown),
+}) {
+}
+export class RouteNotFound extends Schema.ErrorClass("@typed/router/RouteNotFound")({
+    _tag: Schema.tag("RouteNotFound"),
+    path: Schema.String,
+}) {
+}
+export class RouteDecodeError extends Schema.ErrorClass("@typed/router/RouteDecodeError")({
+    _tag: Schema.tag("RouteDecodeError"),
+    path: Schema.String,
+    cause: Schema.String,
+}) {
+}
+export function run(matcher) {
+    return unwrap(Effect.gen(function* () {
+        const fiberId = yield* Effect.fiberId;
+        const rootScope = yield* Effect.scope;
+        const current = yield* CurrentRoute;
+        const prefixed = matcher.prefix(current.route);
+        const entries = compile(prefixed.cases);
+        const router = findMyWay.make({
+            ignoreTrailingSlash: true,
+            caseSensitive: false,
+        });
+        const handlersByPath = new Map();
+        const memoMap = yield* Layer.makeMemoMap;
+        const layerManager = makeLayerManager(memoMap, rootScope, fiberId);
+        const layoutManager = makeLayoutManager(rootScope, fiberId);
+        const catchManager = makeCatchManager(rootScope, fiberId);
+        for (const entry of entries) {
+            const path = entry.route.path;
+            const existing = handlersByPath.get(path);
+            if (existing !== undefined) {
+                existing.push(entry);
+            }
+            else {
+                const list = [entry];
+                handlersByPath.set(path, list);
+                router.all(path, list);
+            }
+        }
+        let currentState = null;
+        return CurrentPath.pipe(mapEffect(Effect.fn(function* (path) {
+            const result = router.find("GET", path);
+            if (result === undefined)
+                return yield* new RouteNotFound({ path });
+            const input = { ...result.params, ...result.searchParams };
+            const entries = result.handler;
+            const guardCauses = [];
+            let matchedEntry = undefined;
+            let matchedParams = undefined;
+            let matchedPrepared = undefined;
+            for (const entry of entries) {
+                const params = yield* Effect.mapErrorEager(entry.decode(input), (cause) => new RouteDecodeError({ path, cause: makeFormatterDefault()(cause.issue) }));
+                const prepared = yield* layerManager.prepare(entry.layers);
+                const guardExit = yield* entry
+                    .guard(params)
+                    .pipe(Effect.provideServices(prepared.services), Effect.exit);
+                if (Exit.isFailure(guardExit)) {
+                    guardCauses.push(guardExit.cause);
+                    yield* prepared.rollback;
+                    continue;
+                }
+                if (Option.isNone(guardExit.value)) {
+                    yield* prepared.rollback;
+                    continue;
+                }
+                matchedEntry = entry;
+                matchedParams = guardExit.value.value;
+                matchedPrepared = prepared;
+                break;
+            }
+            if (matchedEntry === undefined || matchedPrepared === undefined) {
+                return yield* new RouteGuardError({ path, causes: guardCauses });
+            }
+            yield* matchedPrepared.commit;
+            if (currentState !== null && currentState.entry === matchedEntry) {
+                yield* RefSubject.set(currentState.params, matchedParams);
+                yield* layoutManager.updateParams(matchedEntry.layouts, matchedParams);
+                return currentState.fx;
+            }
+            if (currentState !== null) {
+                yield* Scope.close(currentState.scope, interrupt(fiberId));
+                currentState = null;
+            }
+            const scope = yield* Scope.fork(rootScope);
+            const paramsRef = yield* RefSubject.make(matchedParams).pipe(Scope.provide(scope));
+            const preparedServices = matchedPrepared.services;
+            const handlerServices = ServiceMap.merge(preparedServices, ServiceMap.make(Scope.Scope, scope));
+            const handlerFx = matchedEntry
+                .handler(paramsRef)
+                .pipe(provideServices(handlerServices));
+            const withLayouts = yield* layoutManager.apply(matchedEntry.layouts, matchedParams, handlerFx, preparedServices);
+            const withCatches = yield* catchManager.apply(matchedEntry.catches, withLayouts, preparedServices);
+            const fx = withCatches;
+            currentState = {
+                entry: matchedEntry,
+                params: paramsRef,
+                scope,
+                fx,
+            };
+            return currentState.fx;
+        })), skipRepeats, switchMap(identity));
+    }));
+}
+export const catchCause = dual(2, (input, f) => {
+    const eff = Effect.gen(function* () {
+        const fiberId = yield* Effect.fiberId;
+        const rootScope = yield* Effect.scope;
+        const fx = isFx(input) ? input : run(input);
+        const manager = makeCatchManager(rootScope, fiberId);
+        const result = yield* manager.apply([f], fx, ServiceMap.empty());
+        return result;
+    });
+    return unwrap(eff);
+});
+export const catch_ = dual(2, (input, f) => catchCause(input, (causeRef) => unwrap(Effect.gen(function* () {
+    const cause = yield* causeRef;
+    const result = Cause.findFail(cause);
+    if (Result.isFailure(result)) {
+        return fromEffect(Effect.failCause(result.failure));
+    }
+    return f(result.success.error);
+}))));
+export { catch_ as catch };
+export const catchTag = dual(3, (input, k, f) => catchCause(input, (causeRef) => unwrap(Effect.gen(function* () {
+    const cause = yield* causeRef;
+    const result = Cause.findFail(cause);
+    if (Result.isFailure(result)) {
+        return fromEffect(Effect.failCause(result.failure));
+    }
+    if (matchesTag(k, result.success.error)) {
+        return f(result.success.error);
+    }
+    return fromEffect(Effect.fail(result.success.error));
+}))));
+export const redirectTo = (path) => (input) => catchCause(input, (_) => Navigation.navigate(path).pipe(Effect.matchCause({
+    onFailure: () => never,
+    onSuccess: () => never,
+}), unwrap));
+const hasTag = (u) => typeof u === "object" &&
+    u !== null &&
+    "_tag" in u &&
+    typeof u["_tag"] === "string";
+const matchesTag = (tag, error) => {
+    if (!hasTag(error))
+        return false;
+    if (typeof tag === "string")
+        return error._tag === tag;
+    return tag.some((t) => t === error._tag);
+};
+function normalizeDependencies(dependencies) {
+    return dependencies.map((dep) => Layer.isLayer(dep)
+        ? dep
+        : Layer.succeedServices(dep));
+}
+function getGuard(guard) {
+    return "asGuard" in guard ? guard.asGuard() : guard;
+}
+function defaultGuard() {
+    return Effect.succeedSome;
+}
+function mergeLayers(layers) {
+    if (layers.length === 1)
+        return layers[0];
+    let current = layers[0];
+    for (let i = 1; i < layers.length; i++) {
+        current = Layer.merge(current, layers[i]);
+    }
+    return current;
+}
+/**
+ * @internal
+ */
+export function compile(cases) {
+    const entries = [];
+    const visit = (matches, context) => {
+        for (const match of matches) {
+            switch (match.type) {
+                case "route": {
+                    const baseRoute = makeRoute(match.route);
+                    const prefixedRoute = applyPrefixes(baseRoute, context.prefixes);
+                    entries.push({
+                        route: prefixedRoute,
+                        guard: getGuard(match.guard),
+                        handler: normalizeHandler(match.handler),
+                        layers: context.layers,
+                        layouts: context.layouts,
+                        catches: context.catches,
+                        decode: Schema.decodeUnknownEffect(prefixedRoute.paramsSchema),
+                    });
+                    break;
+                }
+                case "layer": {
+                    const merged = mergeLayers(match.deps);
+                    visit(match.matches, {
+                        ...context,
+                        layers: [...context.layers, merged],
+                    });
+                    break;
+                }
+                case "layout": {
+                    visit(match.matches, {
+                        ...context,
+                        layouts: [...context.layouts, match.layout],
+                    });
+                    break;
+                }
+                case "prefixed": {
+                    visit(match.matches, {
+                        ...context,
+                        prefixes: [...context.prefixes, match.prefix],
+                    });
+                    break;
+                }
+                case "catch": {
+                    visit(match.matches, {
+                        ...context,
+                        catches: [...context.catches, match.f],
+                    });
+                    break;
+                }
+            }
+        }
+    };
+    visit(cases, { layers: [], layouts: [], catches: [], prefixes: [] });
+    return entries;
+}
+function applyPrefixes(route, prefixes) {
+    if (prefixes.length === 0)
+        return route;
+    const prefixRoutes = prefixes.map((prefix) => makeRoute(prefix));
+    return Join(...prefixRoutes, route);
+}
+// Parallel scope cleanup helper
+const closeScopes = (scopes, fiberId) => Effect.forEach(scopes, (scope) => Scope.close(scope, interrupt(fiberId)), {
+    concurrency: "unbounded",
+    discard: true,
+});
+/**
+ * @internal
+ */
+export function makeLayerManager(memoMap, rootScope, fiberId) {
+    const states = new Map();
+    let order = [];
+    let cachedDesiredSet = undefined;
+    let cachedOrder = undefined;
+    const prepare = (desired) => Effect.gen(function* () {
+        const desiredSet = cachedOrder === desired
+            ? cachedDesiredSet
+            : ((cachedDesiredSet = new Set(desired)), (cachedOrder = desired), cachedDesiredSet);
+        const removed = order.filter((layer) => !desiredSet.has(layer));
+        const added = [];
+        let services = ServiceMap.empty();
+        for (const layer of desired) {
+            const existing = states.get(layer);
+            if (existing) {
+                services = ServiceMap.merge(services, existing.services);
+                continue;
+            }
+            const scope = yield* Scope.fork(rootScope);
+            const buildExit = yield* Layer.buildWithMemoMap(layer, memoMap, scope).pipe(Effect.provideServices(services), Effect.exit);
+            if (Exit.isFailure(buildExit)) {
+                for (let i = added.length - 1; i >= 0; i--) {
+                    const addedLayer = added[i];
+                    const addedState = states.get(addedLayer);
+                    if (addedState) {
+                        states.delete(addedLayer);
+                        yield* Scope.close(addedState.scope, interrupt(fiberId));
+                    }
+                }
+                yield* Scope.close(scope, buildExit);
+                return yield* Effect.failCause(buildExit.cause);
+            }
+            const servicesForLayer = buildExit.value;
+            services = ServiceMap.merge(services, servicesForLayer);
+            states.set(layer, { scope, services: servicesForLayer });
+            added.push(layer);
+        }
+        const commit = Effect.gen(function* () {
+            for (let i = removed.length - 1; i >= 0; i--) {
+                const layer = removed[i];
+                const state = states.get(layer);
+                if (state) {
+                    states.delete(layer);
+                    yield* Scope.close(state.scope, interrupt(fiberId));
+                }
+            }
+            order = desired;
+        });
+        const rollback = Effect.gen(function* () {
+            for (let i = added.length - 1; i >= 0; i--) {
+                const layer = added[i];
+                const state = states.get(layer);
+                if (state) {
+                    states.delete(layer);
+                    yield* Scope.close(state.scope, interrupt(fiberId));
+                }
+            }
+        });
+        return { services, commit, rollback };
+    });
+    return { prepare };
+}
+/**
+ * @internal
+ */
+export function makeLayoutManager(rootScope, fiberId) {
+    const states = new Map();
+    let active = [];
+    const removeUnused = (layouts) => Effect.gen(function* () {
+        const next = new Set(layouts);
+        const removed = active.filter((layout) => !next.has(layout));
+        const scopes = removed.map((layout) => {
+            const state = states.get(layout);
+            states.delete(layout);
+            return state.scope;
+        });
+        yield* closeScopes(scopes, fiberId);
+        active = layouts;
+    });
+    const apply = (layouts, paramsValue, inner, services) => Effect.gen(function* () {
+        let current = inner;
+        for (let i = layouts.length - 1; i >= 0; i--) {
+            const layout = layouts[i];
+            const state = states.get(layout);
+            if (state === undefined) {
+                const scope = yield* Scope.fork(rootScope);
+                const params = yield* RefSubject.make(paramsValue).pipe(Scope.provide(scope));
+                const content = yield* RefSubject.make(Effect.succeed(current), {
+                    eq: (left, right) => left === right,
+                }).pipe(Scope.provide(scope));
+                const fx = layout({ params, content: content.pipe(switchMap(identity)) }).pipe(provideServices(ServiceMap.merge(services, ServiceMap.make(Scope.Scope, scope))));
+                states.set(layout, { params, content, fx, scope });
+                current = fx;
+            }
+            else {
+                yield* RefSubject.set(state.params, paramsValue);
+                // @effect-diagnostics-next-line floatingEffect:off
+                yield* RefSubject.set(state.content, current);
+                current = state.fx;
+            }
+        }
+        yield* removeUnused(layouts);
+        return current;
+    });
+    const updateParams = (layouts, paramsValue) => Effect.forEach(layouts, (layout) => {
+        const state = states.get(layout);
+        return state !== undefined ? RefSubject.set(state.params, paramsValue) : Effect.void;
+    }, { discard: true });
+    return { apply, updateParams };
+}
+/**
+ * @internal
+ */
+export function makeCatchManager(rootScope, fiberId) {
+    const states = new Map();
+    let active = [];
+    const removeUnused = (catches) => Effect.gen(function* () {
+        const next = new Set(catches);
+        const removed = active.filter((c) => !next.has(c));
+        const scopes = removed.map((c) => {
+            const state = states.get(c);
+            states.delete(c);
+            return state.scope;
+        });
+        yield* closeScopes(scopes, fiberId);
+        active = catches;
+    });
+    const apply = (catches, inner, services) => Effect.gen(function* () {
+        let current = inner;
+        for (let i = catches.length - 1; i >= 0; i--) {
+            const catcher = catches[i];
+            const state = states.get(catcher);
+            if (state === undefined) {
+                const scope = yield* Scope.fork(rootScope);
+                const causes = yield* RefSubject.make(Cause.fail(undefined)).pipe(Scope.provide(scope));
+                const content = yield* RefSubject.make(Effect.succeed(current), {
+                    eq: (left, right) => left === right,
+                }).pipe(Scope.provide(scope));
+                const fallback = catcher(causes).pipe(provideServices(ServiceMap.merge(services, ServiceMap.make(Scope.Scope, scope))));
+                const fx = content.pipe(switchMap(identity), exit, mapEffect(Effect.fn(function* (e) {
+                    if (isSuccess(e))
+                        return succeed(e.value);
+                    yield* RefSubject.set(causes, e.cause);
+                    return fallback;
+                })), skipRepeats, switchMap(identity));
+                states.set(catcher, { causes, content, fx, scope });
+                current = fx;
+            }
+            else {
+                // @effect-diagnostics-next-line floatingEffect:off
+                yield* RefSubject.set(state.content, current);
+                current = state.fx;
+            }
+        }
+        yield* removeUnused(catches);
+        return current;
+    });
+    return { apply };
+}

package/dist/Parser.d.ts

@@ -0,0 +1,96 @@
+import type { Arg0, Pipe, TypeLambda, TypeLambda1 } from "hkt-core";
+export type Result<Value, Rest extends string> = readonly [value: Value, rest: Rest];
+export interface Parser<Output = unknown> extends TypeLambda<[
+    input: string
+], Result<Output, string>> {
+}
+export type Parse<P extends Parser<unknown>, Input extends string> = Pipe<Input, P>;
+type IsStringLiteral<T extends string> = string extends T ? false : true;
+type StrictEquals<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
+type IsNoProgress<Input extends string, Rest extends string> = IsStringLiteral<Input> extends true ? StrictEquals<Input, Rest> : false;
+export declare namespace Parser {
+    type Any = Parser<unknown>;
+    type Run<P extends Any, Input extends string> = Pipe<Input, P>;
+    interface Succeed<A> extends TypeLambda<[input: string], Result<A, string>> {
+        readonly return: Arg0<this> extends infer Input extends string ? readonly [A, Input] : never;
+    }
+    interface Fail extends TypeLambda<[input: string], never> {
+        readonly return: never;
+    }
+    interface Char<C extends string> extends TypeLambda<[
+        input: string
+    ], Result<C, string> | never> {
+        readonly return: Arg0<this> extends `${C}${infer Rest}` ? readonly [C, Rest] : never;
+    }
+    interface String<S extends string> extends TypeLambda<[
+        input: string
+    ], Result<S, string> | never> {
+        readonly return: Arg0<this> extends `${S}${infer Rest}` ? readonly [S, Rest] : never;
+    }
+    type LowercaseAlphabet = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+    type UppercaseAlphabet = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+    type Alphabet = LowercaseAlphabet | UppercaseAlphabet;
+    type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+    type AlphaNumeric = Alphabet | Digit;
+    type TakeWhileInternal<Input extends string, Allowed extends string, Acc extends string = ""> = Input extends `${infer Head}${infer Tail}` ? Head extends Allowed ? TakeWhileInternal<Tail, Allowed, `${Acc}${Head}`> : readonly [Acc, Input] : readonly [Acc, Input];
+    type TakeWhile1Internal<Input extends string, Allowed extends string> = TakeWhileInternal<Input, Allowed> extends readonly [
+        infer Taken extends string,
+        infer Rest extends string
+    ] ? Taken extends "" ? never : readonly [Taken, Rest] : never;
+    interface TakeWhile<Allowed extends string> extends TypeLambda<[
+        input: string
+    ], Result<string, string>> {
+        readonly return: Arg0<this> extends infer Input extends string ? TakeWhileInternal<Input, Allowed> : never;
+    }
+    interface TakeWhile1<Allowed extends string> extends TypeLambda<[
+        input: string
+    ], Result<string, string> | never> {
+        readonly return: Arg0<this> extends infer Input extends string ? TakeWhile1Internal<Input, Allowed> : never;
+    }
+    interface Map<P extends Any, F extends TypeLambda1> extends Parser<unknown> {
+        readonly return: Arg0<this> extends infer Input extends string ? Pipe<Input, P> extends infer R ? [R] extends [never] ? never : R extends readonly [infer Value, infer Rest extends string] ? readonly [Pipe<Value, F>, Rest] : never : never : never;
+    }
+    interface FlatMap<P extends Any, F extends TypeLambda1> extends Parser<unknown> {
+        readonly return: Arg0<this> extends infer Input extends string ? Pipe<Input, P> extends infer R ? [R] extends [never] ? never : R extends readonly [infer Value, infer Rest extends string] ? Pipe<Value, F> extends infer Next ? [Next] extends [never] ? never : Next extends Any ? Pipe<Rest, Next> : never : never : never : never : never;
+    }
+    interface Zip<P extends Any, Q extends Any> extends Parser<unknown> {
+        readonly return: Arg0<this> extends infer Input extends string ? Pipe<Input, P> extends infer R1 ? [R1] extends [never] ? never : R1 extends readonly [infer Value1, infer Rest1 extends string] ? Pipe<Rest1, Q> extends infer R2 ? [R2] extends [never] ? never : R2 extends readonly [infer Value2, infer Rest2 extends string] ? readonly [readonly [Value1, Value2], Rest2] : never : never : never : never : never;
+    }
+    interface OrElse<P extends Any, Q extends Any> extends Parser<unknown> {
+        readonly return: Arg0<this> extends infer Input extends string ? Pipe<Input, P> extends infer R ? [R] extends [never] ? Pipe<Input, Q> : R extends readonly [infer Value, infer Rest extends string] ? readonly [Value, Rest] : never : never : never;
+    }
+    interface Optional<P extends Any> extends Parser<unknown> {
+        readonly return: Arg0<this> extends infer Input extends string ? Pipe<Input, P> extends infer R ? [R] extends [never] ? readonly [undefined, Input] : R extends readonly [infer Value, infer Rest extends string] ? readonly [Value, Rest] : never : never : never;
+    }
+    type ManyInternal<P extends Any, Input extends string, Acc extends ReadonlyArray<unknown> = readonly []> = Pipe<Input, P> extends infer R ? [R] extends [never] ? readonly [Acc, Input] : R extends readonly [infer Value, infer Rest extends string] ? IsNoProgress<Input, Rest> extends true ? never : ManyInternal<P, Rest, readonly [...Acc, Value]> : never : never;
+    type Many1Internal<P extends Any, Input extends string> = Pipe<Input, P> extends infer R ? [R] extends [never] ? never : R extends readonly [infer Value, infer Rest extends string] ? IsNoProgress<Input, Rest> extends true ? never : ManyInternal<P, Rest, readonly [Value]> : never : never;
+    interface Many<P extends Any> extends Parser<unknown> {
+        readonly return: Arg0<this> extends infer Input extends string ? ManyInternal<P, Input> : never;
+    }
+    interface Many1<P extends Any> extends Parser<unknown> {
+        readonly return: Arg0<this> extends infer Input extends string ? Many1Internal<P, Input> : never;
+    }
+    interface MapTo<F extends TypeLambda1> extends TypeLambda1 {
+        readonly return: Arg0<this> extends infer P extends Any ? Map<P, F> : never;
+    }
+    interface FlatMapTo<F extends TypeLambda1> extends TypeLambda1 {
+        readonly return: Arg0<this> extends infer P extends Any ? FlatMap<P, F> : never;
+    }
+    interface ZipWith<Q extends Any> extends TypeLambda1 {
+        readonly return: Arg0<this> extends infer P extends Any ? Zip<P, Q> : never;
+    }
+    interface OrElseWith<Q extends Any> extends TypeLambda1 {
+        readonly return: Arg0<this> extends infer P extends Any ? OrElse<P, Q> : never;
+    }
+    interface OptionalOf extends TypeLambda1 {
+        readonly return: Arg0<this> extends infer P extends Any ? Optional<P> : never;
+    }
+    interface ManyOf extends TypeLambda1 {
+        readonly return: Arg0<this> extends infer P extends Any ? Many<P> : never;
+    }
+    interface Many1Of extends TypeLambda1 {
+        readonly return: Arg0<this> extends infer P extends Any ? Many1<P> : never;
+    }
+}
+export {};
+//# sourceMappingURL=Parser.d.ts.map