@agentshouse/mdruntime 0.1.0-alpha.8 → 0.1.0-c009335e08279

package/dist/observation.js

@@ -0,0 +1,85 @@
+export function rowsOf(result) {
+    return 'groups' in result ? result.groups : result.documents;
+}
+function keyedResult(first) {
+    const grouped = 'groups' in first.result;
+    const rows = rowsOf(first.result);
+    const byKey = new Map(first.keys.map((key, index) => [key, rows[index]]));
+    let keys = first.keys;
+    return {
+        value: first.result,
+        next(message) {
+            const change = message;
+            for (const key of change.removed)
+                byKey.delete(key);
+            for (const [key, row] of change.changed)
+                byKey.set(key, row);
+            keys = change.order ?? keys.filter((key) => byKey.has(key));
+            const next = keys.map((key) => byKey.get(key));
+            return grouped
+                ? { groups: next }
+                : { documents: next };
+        },
+    };
+}
+function whole(first) {
+    return { value: first, next: (message) => message };
+}
+export function observed(first, stop, keyed) {
+    const reducer = keyed ? keyedResult(first) : whole(first);
+    let value = reducer.value;
+    let open = true;
+    const listeners = new Set();
+    const end = () => {
+        open = false;
+        listeners.clear();
+    };
+    return {
+        observation: {
+            current: () => value,
+            subscribe(listener) {
+                const entry = { hear: listener };
+                if (open)
+                    listeners.add(entry);
+                return () => {
+                    listeners.delete(entry);
+                };
+            },
+            close() {
+                if (!open)
+                    return;
+                end();
+                stop();
+            },
+        },
+        receive(message) {
+            if (!open)
+                return;
+            value = reducer.next(message);
+            for (const entry of [...listeners]) {
+                if (listeners.has(entry))
+                    entry.hear(value);
+            }
+        },
+        end,
+    };
+}
+export function opened(watch, keyed) {
+    return new Promise((resolve, reject) => {
+        let handle;
+        let stop = () => { };
+        try {
+            stop = watch((message) => {
+                if (handle !== undefined) {
+                    handle.receive(message);
+                    return;
+                }
+                handle = observed(message, () => stop(), keyed);
+                resolve(handle.observation);
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}

package/dist/outcome.d.ts

@@ -1,30 +1,18 @@
+import type { ActionResult } from './adapter.js';
 import type { ChangeBatch } from './change.js';
-export type AffectedState = Readonly<Record<string, string>>;
-export type QueueOutcome = {
-    kind: 'pending';
-} | {
-    kind: 'conflicted';
-    roomVersion: string;
-    affected: AffectedState;
-    text: string;
-} | {
-    kind: 'rejected';
-    affected: AffectedState;
-    text: string;
-} | {
-    kind: 'expired';
+export type CallResult = ActionResult | {
+    kind: 'undeclared';
 };
-export type AcceptedOutcome = {
-    kind: 'accepted';
-    roomVersion: string;
-    author: string;
-    time: string;
+export type Submission = {
+    readonly state: 'waiting' | 'submitted';
+} | {
+    readonly state: 'reset';
+    readonly reset: string;
 };
-export type SubmissionOutcome = QueueOutcome | AcceptedOutcome;
 export type QueueEntry = {
     readonly batch: ChangeBatch;
-    readonly outcome: QueueOutcome;
-};
-export declare function refused(outcome: SubmissionOutcome | undefined): boolean;
-export declare function queuedOutcome(outcome: SubmissionOutcome | undefined): QueueOutcome;
+} & (Submission | {
+    readonly state: 'accepted';
+    readonly roomVersion: string;
+});
 //# sourceMappingURL=outcome.d.ts.map

package/dist/outcome.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outcome.d.ts","sourceRoot":"","sources":["../src/outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAE7D,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAExB,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,eAAe,CAAC;AAE/D,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;CAChC,CAAC;AAEF,wBAAgB,OAAO,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,GAAG,OAAO,CAIvE;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,GAAG,YAAY,CAKlF"}
+{"version":3,"file":"outcome.d.ts","sourceRoot":"","sources":["../src/outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC;AAE/D,MAAM,MAAM,UAAU,GAClB;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,WAAW,CAAA;CAAE,GAC3C;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,MAAM,MAAM,UAAU,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GAAG,CACvD,UAAU,GACV;IAAE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAC/D,CAAC"}

package/dist/outcome.js

@@ -1,13 +1 @@
-export function refused(outcome) {
-    return outcome?.kind === 'conflicted' || outcome?.kind === 'rejected' || outcome?.kind === 'expired';
-}
-export function queuedOutcome(outcome) {
-    if (outcome === undefined || outcome.kind === 'accepted' || outcome.kind === 'pending') {
-        return {
-            kind: 'pending'
-        };
-    }
-    return outcome;
-}
-
-//# sourceMappingURL=outcome.js.map
+export {};

package/dist/overlay.d.ts

@@ -1,8 +1,15 @@
+import type { HeadChange } from './adapter.js';
 import type { ChangeBatch } from './change.js';
-export type Layer = {
+export type Heads = {
+    revisions: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
+};
+export type Layer = Heads & {
     documents: Readonly<Record<string, string>>;
     binaryTargets: readonly string[];
-    revisions: Readonly<Record<string, string>>;
 };
+export declare function sameChange(left: HeadChange | undefined, right: HeadChange | undefined): boolean;
 export declare function overlay(base: Layer, queue: readonly ChangeBatch[]): Layer;
+export declare function sameLayerText(left: Layer, right: Layer): boolean;
+export declare function overlayChanged(base: Layer, queue: readonly ChangeBatch[], previousBase: Layer, previousQueue: readonly ChangeBatch[], previousVisible: Layer): Layer;
 //# sourceMappingURL=overlay.d.ts.map

package/dist/overlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../src/overlay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAU,WAAW,EAAgB,MAAM,aAAa,CAAC;AAErE,MAAM,MAAM,KAAK,GAAG;IAClB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5C,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC7C,CAAC;AAyIF,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,KAAK,CAezE"}
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../src/overlay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAU,WAAW,EAAgB,MAAM,aAAa,CAAC;AAErE,MAAM,MAAM,KAAK,GAAG;IAClB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG;IAC1B,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5C,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,CAAC;AAEF,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,EAAE,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAQ/F;AAoJD,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,KAAK,CAiBzE;AAQD,wBAAgB,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAQhE;AAmBD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,KAAK,EACX,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,YAAY,EAAE,KAAK,EACnB,aAAa,EAAE,SAAS,WAAW,EAAE,EACrC,eAAe,EAAE,KAAK,GACrB,KAAK,CA4FP"}

package/dist/overlay.js

@@ -1,4 +1,12 @@
 import { apply, parse, serialize } from '@agentshouse/mdmodel';
+export function sameChange(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return (left.time === right.time &&
+        left.author?.kind === right.author?.kind &&
+        left.author?.id === right.author?.id &&
+        left.author?.name === right.author?.name);
+}
 const EMPTY_FRONTMATTER = '---\n---\n';
 function at(path, name) {
     return `${path} ${name}`;
@@ -7,7 +15,7 @@ function priorsOf(preconditions) {
     const fields = new Map();
     const sections = new Map();
     const preambles = new Map();
-    for (const precondition of preconditions){
+    for (const precondition of preconditions) {
         if (precondition.kind === 'field') {
             fields.set(at(precondition.path, precondition.name), precondition.value);
         }
@@ -19,25 +27,24 @@ function priorsOf(preconditions) {
         }
     }
     return {
-        field: (path, name)=>fields.get(at(path, name)),
-        section: (path, name)=>sections.get(at(path, name)) ?? '',
-        preamble: (path)=>preambles.get(path) ?? ''
+        field: (path, name) => fields.get(at(path, name)),
+        section: (path, name) => sections.get(at(path, name)) ?? '',
+        preamble: (path) => preambles.get(path) ?? '',
     };
 }
 function compose(fields, sections) {
-    const body = Object.entries(sections).map(([name, value])=>`\n## ${name}\n${value}`).join('');
+    const body = Object.entries(sections)
+        .map(([name, value]) => `\n## ${name}\n${value}`)
+        .join('');
     const skeleton = `${EMPTY_FRONTMATTER}${body}`;
     const opened = parse(skeleton);
-    if (!opened.ok) return skeleton;
+    if (!opened.ok)
+        return skeleton;
     let document = opened.document;
-    for (const [name, value] of Object.entries(fields)){
-        const next = apply(document, {
-            kind: 'field',
-            name,
-            value,
-            prior: undefined
-        });
-        if (next.outcome === 'applied') document = next.document;
+    for (const [name, value] of Object.entries(fields)) {
+        const next = apply(document, { kind: 'field', name, value, prior: undefined });
+        if (next.outcome === 'applied')
+            document = next.document;
     }
     return serialize(document);
 }
@@ -47,50 +54,65 @@ function edited(document, change, priors) {
             kind: 'field',
             name: change.name,
             value: change.value,
-            prior: priors.field(change.path, change.name)
+            prior: priors.field(change.path, change.name),
         });
     }
     if (change.kind === 'preamble') {
         return apply(document, {
             kind: 'preamble',
             value: change.value,
-            prior: priors.preamble(change.path)
+            prior: priors.preamble(change.path),
         });
     }
-    if (change.kind !== 'section') return null;
+    if (change.kind !== 'section')
+        return null;
     return apply(document, {
         kind: 'section',
         name: change.name,
         value: change.value,
-        prior: priors.section(change.path, change.name)
+        prior: priors.section(change.path, change.name),
     });
 }
 function edit(staged, change, priors) {
     const text = staged.documents[change.path];
-    if (text === undefined) return;
+    if (text === undefined)
+        return;
     const parsed = parse(text, change.path);
-    if (!parsed.ok) return;
+    if (!parsed.ok)
+        return;
     const next = edited(parsed.document, change, priors);
-    if (next?.outcome === 'applied') staged.documents[change.path] = serialize(next.document);
+    if (next?.outcome === 'applied')
+        staged.documents[change.path] = serialize(next.document);
 }
 function relocate(staged, from, to) {
     const text = staged.documents[from];
     if (text !== undefined) {
         delete staged.documents[from];
         staged.documents[to] = text;
-    } else if (staged.binaryTargets.delete(from)) {
+    }
+    else if (staged.binaryTargets.delete(from)) {
         staged.binaryTargets.add(to);
-    } else {
+    }
+    else {
         return;
     }
-    const revision = staged.revisions[from];
-    if (revision === undefined) return;
-    delete staged.revisions[from];
-    staged.revisions[to] = revision;
+    moveHead(staged, from, to);
+}
+function moveHead(heads, from, to) {
+    const revision = heads.revisions[from];
+    const change = heads.changes[from];
+    delete heads.revisions[from];
+    delete heads.changes[from];
+    delete heads.changes[to];
+    if (revision !== undefined)
+        heads.revisions[to] = revision;
+    if (change !== undefined)
+        heads.changes[to] = change;
 }
 function erase(staged, path) {
     delete staged.documents[path];
     delete staged.revisions[path];
+    delete staged.changes[path];
     staged.binaryTargets.delete(path);
 }
 function stage(staged, change, priors) {
@@ -99,11 +121,14 @@ function stage(staged, change, priors) {
         return;
     }
     if (change.kind === 'create') {
-        staged.documents[change.path] = compose(change.fields, change.sections);
+        staged.documents[change.path] =
+            'content' in change ? change.content : compose(change.fields, change.sections);
+        delete staged.changes[change.path];
         return;
     }
     if (change.kind === 'replace') {
-        if (staged.documents[change.path] === undefined) return;
+        if (staged.documents[change.path] === undefined)
+            return;
         staged.documents[change.path] = change.content;
         return;
     }
@@ -115,25 +140,144 @@ function stage(staged, change, priors) {
 }
 export function overlay(base, queue) {
     const staged = {
-        documents: {
-            ...base.documents
-        },
+        documents: { ...base.documents },
         binaryTargets: new Set(base.binaryTargets),
-        revisions: {
-            ...base.revisions
-        }
+        revisions: { ...base.revisions },
+        changes: { ...base.changes },
     };
-    for (const batch of queue){
+    for (const batch of queue) {
         const priors = priorsOf(batch.preconditions);
-        for (const change of batch.changes)stage(staged, change, priors);
+        for (const change of batch.changes)
+            stage(staged, change, priors);
     }
     return {
         documents: staged.documents,
-        binaryTargets: [
-            ...staged.binaryTargets
-        ].sort(),
-        revisions: staged.revisions
+        binaryTargets: [...staged.binaryTargets].sort(),
+        revisions: staged.revisions,
+        changes: staged.changes,
+    };
+}
+function pathsOf(batch) {
+    return batch.changes.flatMap((change) => change.kind === 'move' ? [change.path, change.to] : [change.path]);
+}
+export function sameLayerText(left, right) {
+    const paths = Object.keys(left.documents);
+    return (paths.length === Object.keys(right.documents).length &&
+        paths.every((path) => left.documents[path] === right.documents[path]) &&
+        left.binaryTargets.length === right.binaryTargets.length &&
+        left.binaryTargets.every((path) => right.binaryTargets.includes(path)));
+}
+function replayHeads(base, queue) {
+    const heads = { revisions: { ...base.revisions }, changes: { ...base.changes } };
+    for (const batch of queue) {
+        for (const change of batch.changes) {
+            if (change.kind === 'remove') {
+                delete heads.revisions[change.path];
+                delete heads.changes[change.path];
+            }
+            else if (change.kind === 'create') {
+                delete heads.changes[change.path];
+            }
+            else if (change.kind === 'move') {
+                moveHead(heads, change.path, change.to);
+            }
+        }
+    }
+    return heads;
+}
+export function overlayChanged(base, queue, previousBase, previousQueue, previousVisible) {
+    const before = previousQueue.map((batch) => JSON.stringify(batch));
+    const after = queue.map((batch) => JSON.stringify(batch));
+    if (before.length === after.length &&
+        before.every((id, index) => id === after[index]) &&
+        sameLayerText(base, previousBase)) {
+        return {
+            documents: previousVisible.documents,
+            binaryTargets: previousVisible.binaryTargets,
+            ...replayHeads(base, queue),
+        };
+    }
+    const affected = new Set();
+    const paths = new Set([
+        ...Object.keys(base.documents),
+        ...Object.keys(previousBase.documents),
+        ...Object.keys(base.revisions),
+        ...Object.keys(previousBase.revisions),
+        ...Object.keys(base.changes),
+        ...Object.keys(previousBase.changes),
+        ...base.binaryTargets,
+        ...previousBase.binaryTargets,
+    ]);
+    for (const path of paths) {
+        if (base.documents[path] !== previousBase.documents[path] ||
+            base.revisions[path] !== previousBase.revisions[path] ||
+            !sameChange(base.changes[path], previousBase.changes[path]) ||
+            base.binaryTargets.includes(path) !== previousBase.binaryTargets.includes(path))
+            affected.add(path);
+    }
+    const oldIds = new Set(before);
+    const newIds = new Set(after);
+    for (const batch of previousQueue) {
+        if (!newIds.has(JSON.stringify(batch)))
+            for (const path of pathsOf(batch))
+                affected.add(path);
+    }
+    for (const batch of queue) {
+        if (!oldIds.has(JSON.stringify(batch)))
+            for (const path of pathsOf(batch))
+                affected.add(path);
+    }
+    let expanded = true;
+    while (expanded) {
+        expanded = false;
+        for (const batch of queue) {
+            const touched = pathsOf(batch);
+            if (!touched.some((path) => affected.has(path)))
+                continue;
+            for (const path of touched) {
+                if (affected.has(path))
+                    continue;
+                affected.add(path);
+                expanded = true;
+            }
+        }
+    }
+    const documents = {};
+    const revisions = {};
+    const changes = {};
+    for (const path of affected) {
+        if (base.documents[path] !== undefined)
+            documents[path] = base.documents[path];
+        if (base.revisions[path] !== undefined)
+            revisions[path] = base.revisions[path];
+        if (base.changes[path] !== undefined)
+            changes[path] = base.changes[path];
+    }
+    const staged = overlay({
+        documents,
+        revisions,
+        changes,
+        binaryTargets: base.binaryTargets.filter((path) => affected.has(path)),
+    }, queue.filter((batch) => pathsOf(batch).some((path) => affected.has(path))));
+    const mergedDocuments = { ...previousVisible.documents };
+    const mergedRevisions = { ...previousVisible.revisions };
+    const mergedChanges = { ...previousVisible.changes };
+    const mergedTargets = new Set(previousVisible.binaryTargets);
+    for (const path of affected) {
+        delete mergedDocuments[path];
+        delete mergedRevisions[path];
+        delete mergedChanges[path];
+        mergedTargets.delete(path);
+    }
+    Object.assign(mergedDocuments, staged.documents);
+    Object.assign(mergedRevisions, staged.revisions);
+    Object.assign(mergedChanges, staged.changes);
+    for (const path of staged.binaryTargets)
+        mergedTargets.add(path);
+    return {
+        documents: mergedDocuments,
+        revisions: mergedRevisions,
+        changes: mergedChanges,
+        binaryTargets: [...mergedTargets].sort(),
     };
 }
-
-//# sourceMappingURL=overlay.js.map

package/dist/paths.d.ts

@@ -1,5 +1,4 @@
 export declare function normalize(path: string): string | null;
-export declare function resolve(from: string, reference: string): string | null;
 export declare function relative(from: string, target: string): string;
 export declare function beneath(prefix: string, path: string): boolean;
 export declare function covered(prefixes: readonly string[], path: string): boolean;

package/dist/paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYrD;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAW7D;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAK1E"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYrD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAW7D;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAK1E"}

package/dist/paths.js

@@ -4,10 +4,12 @@ function dirname(path) {
 }
 export function normalize(path) {
     const parts = [];
-    for (const part of path.split('/')){
-        if (part === '' || part === '.') continue;
+    for (const part of path.split('/')) {
+        if (part === '' || part === '.')
+            continue;
         if (part === '..') {
-            if (parts.length === 0) return null;
+            if (parts.length === 0)
+                return null;
             parts.pop();
             continue;
         }
@@ -15,33 +17,24 @@ export function normalize(path) {
     }
     return parts.join('/');
 }
-export function resolve(from, reference) {
-    const base = dirname(from);
-    return normalize(base === '' ? reference : `${base}/${reference}`);
-}
 export function relative(from, target) {
-    const base = dirname(from).split('/').filter((part)=>part !== '');
+    const base = dirname(from)
+        .split('/')
+        .filter((part) => part !== '');
     const parts = target.split('/');
     let shared = 0;
-    while(shared < base.length && shared + 1 < parts.length && base[shared] === parts[shared]){
+    while (shared < base.length && shared + 1 < parts.length && base[shared] === parts[shared]) {
         shared += 1;
     }
-    const up = Array.from({
-        length: base.length - shared
-    }, ()=>'..');
-    return [
-        ...up,
-        ...parts.slice(shared)
-    ].join('/');
+    const up = Array.from({ length: base.length - shared }, () => '..');
+    return [...up, ...parts.slice(shared)].join('/');
 }
 export function beneath(prefix, path) {
     return path === prefix || path.startsWith(`${prefix}/`);
 }
 export function covered(prefixes, path) {
-    return prefixes.some((prefix)=>{
+    return prefixes.some((prefix) => {
         const normalized = normalize(prefix);
         return normalized !== null && (normalized === '' || beneath(normalized, path));
     });
 }
-
-//# sourceMappingURL=paths.js.map