aberdeen 1.18.2 → 1.19.0

package/dist-docs/assets/aberdeen/dispatcher.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/dispatcher.ts"],
-  "sourcesContent": [
-    "/**\n * Symbol to return when a custom {@link Dispatcher.addRoute} matcher cannot match a segment.\n */\nexport const MATCH_FAILED: unique symbol = Symbol(\"MATCH_FAILED\");\n\n/**\n * Special {@link Dispatcher.addRoute} matcher that matches the rest of the segments as an array of strings.\n */\nexport const MATCH_REST: unique symbol = Symbol(\"MATCH_REST\");\n\ntype Matcher = string | ((segment: string) => any) | typeof MATCH_REST;\n\ntype ExtractParamType<M> =  M extends string\n? never : (\n    M extends ((segment: string) => infer R)\n    ? Exclude<R, typeof MATCH_FAILED>\n    : (M extends typeof MATCH_REST ? string[] : never)\n);\n\ntype ParamsFromMatchers<T extends Matcher[]> = T extends [infer M1, ...infer Rest]\n? (\n    M1 extends Matcher\n    ? (\n        ExtractParamType<M1> extends never\n        ? ParamsFromMatchers<Rest extends Matcher[] ? Rest : []>\n        : [ExtractParamType<M1>, ...ParamsFromMatchers<Rest extends Matcher[] ? Rest : []>]\n    ) : never\n) : [];\n\ninterface DispatcherRoute {\n    matchers: Matcher[];\n    handler: (...params: any[]) => void;\n}\n\n/**\n * Simple route matcher and dispatcher.\n * \n * Example usage:\n * \n * ```ts\n * import * as route from 'aberdeen/route';\n * import { Dispatcher, MATCH_REST } from 'aberdeen/dispatcher';\n * \n * const dispatcher = new Dispatcher();\n * \n * dispatcher.addRoute(\"user\", Number, \"stream\", String, (id, stream) => {\n *    console.log(`User ${id}, stream ${stream}`);\n * });\n *\n * dispatcher.dispatch([\"user\", \"42\", \"stream\", \"music\"]);\n * // Logs: User 42, stream music\n * \n * dispatcher.addRoute(\"search\", MATCH_REST, (terms: string[]) => {\n *     console.log(\"Search terms:\", terms);\n * });\n * \n * dispatcher.dispatch([\"search\", \"classical\", \"piano\"]);\n * // Logs: Search terms: [ 'classical', 'piano' ]\n * ```\n */\nexport class Dispatcher {\n    private routes: Array<DispatcherRoute> = [];\n    \n    /**\n     * Add a route with matchers and a handler function.\n     * @param args An array of matchers followed by a handler function. Each matcher can be:\n     * - A string: matches exactly that string.\n     * - A function: takes a string segment and returns a value (of any type) if it matches, or {@link MATCH_FAILED} if it doesn't match. The return value (if not `MATCH_FAILED` and not `NaN`) is passed as a parameter to the handler function. The standard JavaScript functions `Number` and `String` can be used to match numeric and string segments respectively.\n     * - The special {@link MATCH_REST} symbol: matches the rest of the segments as an array of strings. Only one `MATCH_REST` is allowed.\n     * @template T - Array of matcher types.\n     * @template H - Handler function type, inferred from the matchers.\n     */\n    addRoute<T extends Matcher[], H extends (...args: ParamsFromMatchers<T>) => void>(...args: [...T, H]): void {\n        const matchers = args.slice(0, -1) as Matcher[];\n        const handler = args[args.length - 1] as (...args: any) => any;\n\n        if (typeof handler !== \"function\") {\n            throw new Error(\"Last argument should be a handler function\");\n        }\n        \n        const restCount = matchers.filter(m => m === MATCH_REST).length;\n        if (restCount > 1) {\n            throw new Error(\"Only one MATCH_REST is allowed\");\n        }\n\n        this.routes.push({ matchers, handler });\n    }\n    \n    /**\n     * Dispatches the given segments to the first route handler that matches.\n     * @param segments Array of string segments to match against the added routes. When using this class with the Aberdeen `route` module, one would typically pass `route.current.p`.\n     * @returns True if a matching route was found and handled, false otherwise.\n     */\n    dispatch(segments: string[]): boolean {\n        for (const route of this.routes) {\n            const args = matchRoute(route, segments);\n            if (args) {\n                route.handler(...args);\n                return true;\n            }\n        }\n        return false;\n    }\n}\n\nfunction matchRoute(route: DispatcherRoute, segments: string[]): any[] | undefined {\n    const args: any[] = [];\n    let segmentIndex = 0;\n\n    for (const matcher of route.matchers) {\n        if (matcher === MATCH_REST) {\n            const len = segments.length - (route.matchers.length - 1);\n            if (len < 0) return;\n            args.push(segments.slice(segmentIndex, segmentIndex + len));\n            segmentIndex += len;\n            continue;\n        }\n\n        if (segmentIndex >= segments.length) return;\n        const segment = segments[segmentIndex];\n        \n        if (typeof matcher === \"string\") {\n            if (segment !== matcher) return;\n        } else if (typeof matcher === \"function\") {\n            const result = matcher(segment);\n            if (result === MATCH_FAILED || (typeof result === 'number' && isNaN(result))) return;\n            args.push(result);\n        }\n        \n        segmentIndex++;\n    }\n    if (segmentIndex === segments.length) return args; // success!\n}\n"
-  ],
-  "mappings": ";AAGO,IAAM,eAA8B,OAAO,cAAc;AAKzD,IAAM,aAA4B,OAAO,YAAY;AAAA;AAoDrD,MAAM,WAAW;AAAA,EACZ,SAAiC,CAAC;AAAA,EAW1C,QAAiF,IAAI,MAAuB;AAAA,IACxG,MAAM,WAAW,KAAK,MAAM,GAAG,EAAE;AAAA,IACjC,MAAM,UAAU,KAAK,KAAK,SAAS;AAAA,IAEnC,IAAI,OAAO,YAAY,YAAY;AAAA,MAC/B,MAAM,IAAI,MAAM,4CAA4C;AAAA,IAChE;AAAA,IAEA,MAAM,YAAY,SAAS,OAAO,OAAK,MAAM,UAAU,EAAE;AAAA,IACzD,IAAI,YAAY,GAAG;AAAA,MACf,MAAM,IAAI,MAAM,gCAAgC;AAAA,IACpD;AAAA,IAEA,KAAK,OAAO,KAAK,EAAE,UAAU,QAAQ,CAAC;AAAA;AAAA,EAQ1C,QAAQ,CAAC,UAA6B;AAAA,IAClC,WAAW,SAAS,KAAK,QAAQ;AAAA,MAC7B,MAAM,OAAO,WAAW,OAAO,QAAQ;AAAA,MACvC,IAAI,MAAM;AAAA,QACN,MAAM,QAAQ,GAAG,IAAI;AAAA,QACrB,OAAO;AAAA,MACX;AAAA,IACJ;AAAA,IACA,OAAO;AAAA;AAEf;AAEA,SAAS,UAAU,CAAC,OAAwB,UAAuC;AAAA,EAC/E,MAAM,OAAc,CAAC;AAAA,EACrB,IAAI,eAAe;AAAA,EAEnB,WAAW,WAAW,MAAM,UAAU;AAAA,IAClC,IAAI,YAAY,YAAY;AAAA,MACxB,MAAM,MAAM,SAAS,UAAU,MAAM,SAAS,SAAS;AAAA,MACvD,IAAI,MAAM;AAAA,QAAG;AAAA,MACb,KAAK,KAAK,SAAS,MAAM,cAAc,eAAe,GAAG,CAAC;AAAA,MAC1D,gBAAgB;AAAA,MAChB;AAAA,IACJ;AAAA,IAEA,IAAI,gBAAgB,SAAS;AAAA,MAAQ;AAAA,IACrC,MAAM,UAAU,SAAS;AAAA,IAEzB,IAAI,OAAO,YAAY,UAAU;AAAA,MAC7B,IAAI,YAAY;AAAA,QAAS;AAAA,IAC7B,EAAO,SAAI,OAAO,YAAY,YAAY;AAAA,MACtC,MAAM,SAAS,QAAQ,OAAO;AAAA,MAC9B,IAAI,WAAW,gBAAiB,OAAO,WAAW,YAAY,MAAM,MAAM;AAAA,QAAI;AAAA,MAC9E,KAAK,KAAK,MAAM;AAAA,IACpB;AAAA,IAEA;AAAA,EACJ;AAAA,EACA,IAAI,iBAAiB,SAAS;AAAA,IAAQ,OAAO;AAAA;",
-  "debugId": "EB41818E6FB7C09864756E2164756E21",
-  "names": []
-}

package/dist-docs/assets/aberdeen/helpers/reverseSortedSet.d.ts

@@ -1,96 +0,0 @@
-export type ReverseSortedSetPointer = symbol;
-type SkipItem<T> = {
-    [idx: ReverseSortedSetPointer]: T;
-};
-/**
- * A set-like collection of objects that can do iteration sorted by a specified index property.
- * It also allows retrieving an object by its index property, and quickly getting the object
- * that comes immediately after a given object.
- *
- * It's implemented as a skiplist, maintaining all meta-data as part of the objects that it
- * is tracking, for performance.
- */
-export declare class ReverseSortedSet<T extends SkipItem<T>, KeyPropT extends keyof T> {
-    private keyProp;
-    private tail;
-    private symbols;
-    /**
-     * Create an empty SortedSet.
-     *
-     * @param keyProp The name of the property that should be used as the index of this collection. Comparison
-     * using `<` will be done on this property, so it should probably be a number or a string (or something that
-     * has a useful toString-conversion).
-     */
-    constructor(keyProp: KeyPropT);
-    /**
-     * Add an object to the `SortedSet`.
-     *
-     * @param item The object to be added to the set. One or more properties with
-     *  `Symbol` keys will be added to it, for `SortedSet` internals.
-     * @returns `true` if the item was added, or `false` if it was *not* added
-     *  because the item already was part of this set.
-     *
-     * Note that though an item object may only be part of a particular `SortedSet`
-     * once, index properties may be duplicate and an item object may be part of
-     * more than one `SortedSet`.
-     *
-     * **IMPORTANT:** After adding an object, do not modify its index property,
-     * as this will lead to undefined (broken) behavior on the entire set.
-     *
-     * Time complexity: O(log n)
-     */
-    add(item: T): boolean;
-    /**
-     * @param item An object to test for inclusion in the set.
-     * @returns true if this object item is already part of the set.
-     */
-    has(item: T): boolean;
-    /**
-     * Remove and return the last item.
-     * @returns what was previously the last item in the sorted set, or `undefined` if the set was empty.
-     */
-    fetchLast(): T | undefined;
-    /**
-     * @returns whether the set is empty (`true`) or has at least one item (`false`).
-     */
-    isEmpty(): boolean;
-    /**
-     * Retrieve an item object based on its index property value.
-     *
-     * @param indexValue The index property value to search for.
-     * @returns `undefined` if the index property value does not exist in the `SortedSet` or
-     *  otherwise the *first* item object that has this index value (meaning any further
-     *  instances can be iterated using `next()`).
-     *
-     * Time complexity: O(log n)
-     */
-    get(indexValue: T[KeyPropT]): T | undefined;
-    /**
-     * The iterator will go through the items in reverse index-order.
-     */
-    [Symbol.iterator](): IterableIterator<T>;
-    /**
-     * Given an item object, returns the one that comes right before in the set.
-     * @param item The object to start from.
-     * @returns The next object, or `undefined` if there is none.
-     *
-     * Time complexity: O(1)
-     */
-    prev(item: T): T | undefined;
-    /**
-     * Remove an item object from the set, deleting all meta-data keys that
-     * were created on `add()`.
-     * @param item The object to be removed.
-     * @returns `true` on success or `false` when the item was not part of the set.
-     *
-     * Time complexity: O(log n)
-     */
-    remove(item: T): boolean;
-    /**
-     * Remove all items for the set.
-     *
-     * Time complexity: O(n)
-     */
-    clear(): void;
-}
-export {};

package/dist-docs/assets/aberdeen/prediction.d.ts

@@ -1,33 +0,0 @@
-import type { TargetType } from "./aberdeen.js";
-/**
- * Represents a set of changes that can be applied to proxied objects.
- * This is an opaque type - its internal structure is not part of the public API.
- * @private
- */
-export type Patch = Map<TargetType, Map<any, [any, any]>>;
-/**
- * Run the provided function, while treating all changes to Observables as predictions,
- * meaning they will be reverted when changes come back from the server (or some other
- * async source).
- * @param predictFunc The function to run. It will generally modify some Observables
- * 	to immediately reflect state (as closely as possible) that we expect the server
- *  to communicate back to us later on.
- * @returns A `Patch` object. Don't modify it. This is only meant to be passed to `applyCanon`.
- */
-export declare function applyPrediction(predictFunc: () => void): Patch;
-/**
- * Temporarily revert all outstanding predictions, optionally run the provided function
- * (which will generally make authoritative changes to the data based on a server response),
- * and then attempt to reapply the predictions on top of the new canonical state, dropping
- * any predictions that can no longer be applied cleanly (the data has been modified) or
- * that were specified in `dropPredictions`.
- *
- * All of this is done such that redraws are only triggered if the overall effect is an
- * actual change to an `Observable`.
- * @param canonFunc The function to run without any predictions applied. This will typically
- *  make authoritative changes to the data, based on a server response.
- * @param dropPredictions An optional list of predictions (as returned by `applyPrediction`)
- *  to undo. Typically, when a server response for a certain request is being handled,
- *  you'd want to drop the prediction that was done for that request.
- */
-export declare function applyCanon(canonFunc?: () => void, dropPredictions?: Array<Patch>): void;

package/dist-docs/assets/aberdeen/prediction.js

@@ -1,112 +0,0 @@
-// src/prediction.ts
-import {
-  defaultEmitHandler,
-  withEmitHandler,
-  EMPTY,
-  MAP_SIZE_SYMBOL
-} from "./aberdeen.js";
-function recordPatch(func) {
-  const recordingPatch = new Map;
-  withEmitHandler((target, index, newData, oldData) => {
-    addToPatch(recordingPatch, target, index, newData, oldData);
-  }, func);
-  return recordingPatch;
-}
-function addToPatch(patch, collection, index, newData, oldData) {
-  let collectionMap = patch.get(collection);
-  if (!collectionMap) {
-    collectionMap = new Map;
-    patch.set(collection, collectionMap);
-  }
-  const prev = collectionMap.get(index);
-  const oldData0 = prev ? prev[1] : oldData;
-  if (newData === oldData0)
-    collectionMap.delete(index);
-  else
-    collectionMap.set(index, [newData, oldData0]);
-}
-function emitPatch(patch) {
-  for (const [collection, collectionMap] of patch) {
-    for (const [index, [newData, oldData]] of collectionMap) {
-      defaultEmitHandler(collection, index, newData, oldData);
-    }
-  }
-}
-function mergePatch(target, source, reverse = false) {
-  for (const [collection, collectionMap] of source) {
-    for (const [index, [newData, oldData]] of collectionMap) {
-      addToPatch(target, collection, index, reverse ? oldData : newData, reverse ? newData : oldData);
-    }
-  }
-}
-function silentlyApplyPatch(patch, force = false) {
-  for (const [collection, collectionMap] of patch) {
-    for (const [index, [newData, oldData]] of collectionMap) {
-      if (index === MAP_SIZE_SYMBOL)
-        continue;
-      const actualData = collection instanceof Map ? collection.has(index) ? collection.get(index) : EMPTY : (index in collection) ? collection[index] : EMPTY;
-      if (actualData !== oldData) {
-        if (force)
-          setTimeout(() => {
-            throw new Error(`Applying invalid patch: data ${String(actualData)} is unequal to expected old data ${String(oldData)} for index ${String(index)}`);
-          }, 0);
-        else
-          return false;
-      }
-    }
-  }
-  for (const [collection, collectionMap] of patch) {
-    for (const [index, [newData, oldData]] of collectionMap) {
-      if (index === MAP_SIZE_SYMBOL)
-        continue;
-      if (collection instanceof Map) {
-        if (newData === EMPTY)
-          collection.delete(index);
-        else
-          collection.set(index, newData);
-      } else {
-        if (newData === EMPTY)
-          delete collection[index];
-        else
-          collection[index] = newData;
-      }
-    }
-  }
-  return true;
-}
-var appliedPredictions = [];
-function applyPrediction(predictFunc) {
-  const patch = recordPatch(predictFunc);
-  appliedPredictions.push(patch);
-  emitPatch(patch);
-  return patch;
-}
-function applyCanon(canonFunc, dropPredictions = []) {
-  const resultPatch = new Map;
-  for (const prediction of appliedPredictions)
-    mergePatch(resultPatch, prediction, true);
-  silentlyApplyPatch(resultPatch, true);
-  for (const prediction of dropPredictions) {
-    const pos = appliedPredictions.indexOf(prediction);
-    if (pos >= 0)
-      appliedPredictions.splice(pos, 1);
-  }
-  if (canonFunc)
-    mergePatch(resultPatch, recordPatch(canonFunc));
-  for (let idx = 0;idx < appliedPredictions.length; idx++) {
-    if (silentlyApplyPatch(appliedPredictions[idx])) {
-      mergePatch(resultPatch, appliedPredictions[idx]);
-    } else {
-      appliedPredictions.splice(idx, 1);
-      idx--;
-    }
-  }
-  emitPatch(resultPatch);
-}
-export {
-  applyPrediction,
-  applyCanon
-};
-
-//# debugId=0E6977F82274D4EC64756E2164756E21
-//# sourceMappingURL=prediction.js.map

package/dist-docs/assets/aberdeen/prediction.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/prediction.ts"],
-  "sourcesContent": [
-    "import {\n\tdefaultEmitHandler,\n\twithEmitHandler,\n\tEMPTY,\n\tMAP_SIZE_SYMBOL,\n} from \"./aberdeen.js\";\nimport type { TargetType } from \"./aberdeen.js\";\n\n/**\n * Represents a set of changes that can be applied to proxied objects.\n * This is an opaque type - its internal structure is not part of the public API.\n * @private\n */\nexport type Patch = Map<TargetType, Map<any, [any, any]>>;\n\nfunction recordPatch(func: () => void): Patch {\n\tconst recordingPatch = new Map();\n\twithEmitHandler((target, index, newData, oldData) => {\n\t\taddToPatch(recordingPatch, target, index, newData, oldData);\n\t}, func);\n\treturn recordingPatch;\n}\n\nfunction addToPatch(\n\tpatch: Patch,\n\tcollection: TargetType,\n\tindex: any,\n\tnewData: any,\n\toldData: any,\n) {\n\tlet collectionMap = patch.get(collection);\n\tif (!collectionMap) {\n\t\tcollectionMap = new Map();\n\t\tpatch.set(collection, collectionMap);\n\t}\n\tconst prev = collectionMap.get(index);\n\tconst oldData0 = prev ? prev[1] : oldData;\n\tif (newData === oldData0) collectionMap.delete(index);\n\telse collectionMap.set(index, [newData, oldData0]);\n}\n\nfunction emitPatch(patch: Patch) {\n\tfor (const [collection, collectionMap] of patch) {\n\t\tfor (const [index, [newData, oldData]] of collectionMap) {\n\t\t\tdefaultEmitHandler(collection, index, newData, oldData);\n\t\t}\n\t}\n}\n\nfunction mergePatch(target: Patch, source: Patch, reverse = false) {\n\tfor (const [collection, collectionMap] of source) {\n\t\tfor (const [index, [newData, oldData]] of collectionMap) {\n\t\t\taddToPatch(\n\t\t\t\ttarget,\n\t\t\t\tcollection,\n\t\t\t\tindex,\n\t\t\t\treverse ? oldData : newData,\n\t\t\t\treverse ? newData : oldData,\n\t\t\t);\n\t\t}\n\t}\n}\n\nfunction silentlyApplyPatch(patch: Patch, force = false): boolean {\n\tfor (const [collection, collectionMap] of patch) {\n\t\tfor (const [index, [newData, oldData]] of collectionMap) {\n\t\t\t// MAP_SIZE_SYMBOL is synthetic - size is derived from add/delete operations\n\t\t\tif (index === MAP_SIZE_SYMBOL) continue;\n\t\t\tconst actualData =\n\t\t\t\tcollection instanceof Map\n\t\t\t\t\t? collection.has(index)\n\t\t\t\t\t\t? collection.get(index)\n\t\t\t\t\t\t: EMPTY\n\t\t\t\t\t: index in (collection as any)\n\t\t\t\t\t\t? (collection as any)[index]\n\t\t\t\t\t\t: EMPTY;\n\t\t\tif (actualData !== oldData) {\n\t\t\t\tif (force)\n\t\t\t\t\tsetTimeout(() => {\n\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t`Applying invalid patch: data ${String(actualData)} is unequal to expected old data ${String(oldData)} for index ${String(index)}`,\n\t\t\t\t\t\t);\n\t\t\t\t\t}, 0);\n\t\t\t\telse return false;\n\t\t\t}\n\t\t}\n\t}\n\tfor (const [collection, collectionMap] of patch) {\n\t\tfor (const [index, [newData, oldData]] of collectionMap) {\n\t\t\tif (index === MAP_SIZE_SYMBOL) continue;\n\t\t\tif (collection instanceof Map) {\n\t\t\t\tif (newData === EMPTY) collection.delete(index);\n\t\t\t\telse collection.set(index, newData);\n\t\t\t} else {\n\t\t\t\tif (newData === EMPTY) delete (collection as any)[index];\n\t\t\t\telse (collection as any)[index] = newData;\n\t\t\t}\n\t\t}\n\t}\n\treturn true;\n}\n\nconst appliedPredictions: Array<Patch> = [];\n\n/**\n * Run the provided function, while treating all changes to Observables as predictions,\n * meaning they will be reverted when changes come back from the server (or some other\n * async source).\n * @param predictFunc The function to run. It will generally modify some Observables\n * \tto immediately reflect state (as closely as possible) that we expect the server\n *  to communicate back to us later on.\n * @returns A `Patch` object. Don't modify it. This is only meant to be passed to `applyCanon`.\n */\nexport function applyPrediction(predictFunc: () => void): Patch {\n\tconst patch = recordPatch(predictFunc);\n\tappliedPredictions.push(patch);\n\temitPatch(patch);\n\treturn patch;\n}\n\n/**\n * Temporarily revert all outstanding predictions, optionally run the provided function\n * (which will generally make authoritative changes to the data based on a server response),\n * and then attempt to reapply the predictions on top of the new canonical state, dropping\n * any predictions that can no longer be applied cleanly (the data has been modified) or\n * that were specified in `dropPredictions`.\n *\n * All of this is done such that redraws are only triggered if the overall effect is an\n * actual change to an `Observable`.\n * @param canonFunc The function to run without any predictions applied. This will typically\n *  make authoritative changes to the data, based on a server response.\n * @param dropPredictions An optional list of predictions (as returned by `applyPrediction`)\n *  to undo. Typically, when a server response for a certain request is being handled,\n *  you'd want to drop the prediction that was done for that request.\n */\nexport function applyCanon(\n\tcanonFunc?: () => void,\n\tdropPredictions: Array<Patch> = [],\n) {\n\tconst resultPatch = new Map();\n\tfor (const prediction of appliedPredictions)\n\t\tmergePatch(resultPatch, prediction, true);\n\tsilentlyApplyPatch(resultPatch, true);\n\n\tfor (const prediction of dropPredictions) {\n\t\tconst pos = appliedPredictions.indexOf(prediction);\n\t\tif (pos >= 0) appliedPredictions.splice(pos, 1);\n\t}\n\tif (canonFunc) mergePatch(resultPatch, recordPatch(canonFunc));\n\n\tfor (let idx = 0; idx < appliedPredictions.length; idx++) {\n\t\tif (silentlyApplyPatch(appliedPredictions[idx])) {\n\t\t\tmergePatch(resultPatch, appliedPredictions[idx]);\n\t\t} else {\n\t\t\tappliedPredictions.splice(idx, 1);\n\t\t\tidx--;\n\t\t}\n\t}\n\n\temitPatch(resultPatch);\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "0E6977F82274D4EC64756E2164756E21",
-  "names": []
-}

package/dist-docs/assets/aberdeen/route.d.ts

@@ -1,137 +0,0 @@
-type NavType = "load" | "back" | "forward" | "go" | "push";
-/**
-* The class for the global `route` object.
-*/
-export interface Route {
-    /** The current path of the URL as a string. For instance `"/"` or `"/users/123/feed"`. Paths are normalized to always start with a `/` and never end with a `/` (unless it's the root path). */
-    path: string;
-    /** An convenience array containing path segments, mapping to `path`. For instance `[]` (for `"/"`) or `['users', '123', 'feed']` (for `"/users/123/feed"`). */
-    p: string[];
-    /** The hash fragment including the leading `#`, or an empty string. For instance `"#my_section"` or `""`. */
-    hash: string;
-    /** The query string interpreted as search parameters. So `"a=x&b=y"` becomes `{a: "x", b: "y"}`. */
-    search: Record<string, string>;
-    /** An object to be used for any additional data you want to associate with the current page. Data should be JSON-compatible. */
-    state: Record<string, any>;
-    /** The navigation depth of the current session. Starts at 1. Writing to this property has no effect. */
-    depth: number;
-    /** The navigation action that got us to this page. Writing to this property has no effect.
-    - `"load"`: An initial page load.
-    - `"back"` or `"forward"`: When we navigated backwards or forwards in the stack.
-    - `"go"`: When we added a new page on top of the stack.
-    - `"push"`: When we added a new page on top of the stack, merging with the current page.
-    Mostly useful for page transition animations. Writing to this property has no effect.
-    */
-    nav: NavType;
-}
-/**
- * Configure logging on route changes.
- * @param value `true` to enable logging to console, `false` to disable logging, or a custom logging function. Defaults to `false`.
- */
-export declare function setLog(value: boolean | ((...args: any[]) => void)): void;
-type RouteTarget = string | (string | number)[] | Partial<Omit<Omit<Route, "p">, "search"> & {
-    /** An convenience array containing path segments, mapping to `path`. For instance `[]` (for `"/"`) or `['users', 123, 'feed']` (for `"/users/123/feed"`). Values may be integers but will be converted to strings.*/
-    p: (string | number)[];
-    /** The query string interpreted as search parameters. So `"a=x&b=y"` becomes `{a: "x", b: "y", c: 42}`. Values may be integers but will be converted to strings. */
-    search: Record<string, string | number>;
-}>;
-/**
-* Navigate to a new URL by pushing a new history entry.
-*
-* Note that this happens synchronously, immediately updating `route` and processing any reactive updates based on that.
-*
-* @param target A subset of the {@link Route} properties to navigate to. If neither `p` nor `path` is given, the current path is used. For other properties, an empty/default value is assumed if not given. For convenience:
-* - You may pass a string instead of an object, which is interpreted as the `path`.
-* - You may pass an array instead of an object, which is interpreted as the `p` array.
-* - If you pass `p`, it may contain numbers, which will be converted to strings.
-* - If you pass `search`, its values may be numbers, which will be converted to strings.
-*
-* Examples:
-* ```js
-* // Navigate to /users/123
-* route.go("/users/123");
-*
-* // Navigate to /users/123?tab=feed#top
-* route.go({p: ["users", 123], search: {tab: "feed"}, hash: "top"});
-* ```
-*/
-export declare function go(target: RouteTarget, nav?: NavType): void;
-/**
- * Returns `true` if the current route matches `target`.
- *
- * Path must match exactly. Any search params specified in `target` must be present
- * in the current URL, but extra params in the current URL are allowed.
- *
- * Reactive: only reevaluates when the path changes to/from the target path, and
- * when target k/v search pairs are (un)set.
- *
- * Primary usage: 'active' status for menu items.
- *
- * @example
- * ```js
- * // This example assumes interceptLinks() has been called
- * A('a.my-button text=Users href=/users .is-active=', route.matchCurrent('/users'));
- *
- * // Alternatively a route object can be given
- * route.matchCurrent({path: '/users', search: {tab: 'profile'}});
- * ```
- */
-export declare function matchCurrent(target: RouteTarget): boolean;
-/**
- * Modify the current route by merging `target` into it (using {@link aberdeen.merge | A.merge}), pushing a new history entry.
- *
- * This is useful for things like opening modals or side panels, where you want a browser back action to return to the previous state.
- *
- * @param target Same as for {@link go}, but merged into the current route instead deleting all state.
- * @param nav The navigation type to use. Defaults to `undefined`, meaning the navigation type is unchanged from the current route,
- *  preventing unwanted page transition animations.
- */
-export declare function push(target: RouteTarget, nav?: NavType): void;
-/**
- * Try to go back in history to the first entry that matches the given target. If none is found, the given state will replace the current page. This is useful for "cancel" or "close" actions that should return to the previous page if possible, but create a new page if not (for instance when arriving at the current page through a direct link).
- *
- * Consider using {@link up} to go up in the path hierarchy.
- *
- * @param target The target route to go back to. May be a subset of {@link Route}, or a string (for `path`), or an array of strings (for `p`).
- */
-export declare function back(target?: RouteTarget): void;
-/**
-* Navigate up in the path hierarchy, by going back to the first history entry
-* that has a shorter path than the current one. If there's none, we just shorten
-* the current path.
-*
-* Note that going back in browser history happens asynchronously, so `route` will not be updated immediately.
-*/
-export declare function up(stripCount?: number): void;
-/**
-* The global {@link Route} object reflecting the current URL and browser history state. Changes you make to this affect the current browser history item (modifying the URL if needed).
-*/
-export declare const current: Route;
-/**
-* Restore and store the vertical and horizontal scroll position for
-* the parent element to the page state.
-*
-* @param {string} name - A unique (within this page) name for this
-* scrollable element. Defaults to 'main'.
-*
-* The scroll position will be persisted in `route.aux.scroll.<name>`.
-*/
-export declare function persistScroll(name?: string): void;
-/**
- * Intercept clicks and Enter key presses on links (`<a>` tags) and use Aberdeen routing
- * instead of browser navigation for local paths (paths without a protocol or host).
- *
- * This allows you to use regular HTML anchor tags for navigation without needing to
- * manually attach click handlers to each link.
- *
- * @example
- * ```js
- * // In your root component:
- * route.interceptLinks();
- *
- * // Now you can use regular anchor tags:
- * A('a text=About href=/corporate/about');
- * ```
- */
-export declare function interceptLinks(): void;
-export {};