nervur 0.23.0 → 0.24.0

package/dist/bodies/strict-tools.js

@@ -1,306 +0,0 @@
-const encoder = new TextEncoder();
-const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
-const HEX = /^(?:[0-9a-f]{2})*$/;
-const NUMBER = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
-const ESCAPES = { '"': '"', '\\': '\\', '/': '/', b: '\b', f: '\f', n: '\n', r: '\r', t: '\t' };
-const define = (target, key, value) => Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
-// An iterative reader, so no nesting a sender writes can exhaust the stack.
-const read = (text) => {
-    const length = text.length;
-    let at = 0;
-    let duplicate = false;
-    let nestedDuplicate = false;
-    let fields = null;
-    const stack = [];
-    const space = () => {
-        while (at < length) {
-            const code = text.charCodeAt(at);
-            if (code !== 0x20 && code !== 0x09 && code !== 0x0a && code !== 0x0d)
-                return;
-            at++;
-        }
-    };
-    const string = () => {
-        if (text[at] !== '"')
-            return null;
-        at++;
-        let out = '';
-        let from = at;
-        while (at < length) {
-            const code = text.charCodeAt(at);
-            if (code === 0x22) {
-                out += text.slice(from, at);
-                at++;
-                return out;
-            }
-            if (code < 0x20)
-                return null;
-            if (code === 0x5c) {
-                out += text.slice(from, at);
-                const escape = text[at + 1];
-                if (escape === 'u') {
-                    const digits = text.slice(at + 2, at + 6);
-                    if (!/^[0-9a-fA-F]{4}$/.test(digits))
-                        return null;
-                    out += String.fromCharCode(Number.parseInt(digits, 16));
-                    at += 6;
-                }
-                else {
-                    const plain = escape === undefined ? undefined : ESCAPES[escape];
-                    if (plain === undefined)
-                        return null;
-                    out += plain;
-                    at += 2;
-                }
-                from = at;
-                continue;
-            }
-            at++;
-        }
-        return null;
-    };
-    const key = (frame) => {
-        const name = string();
-        if (name === null)
-            return false;
-        space();
-        if (text[at] !== ':')
-            return false;
-        at++;
-        space();
-        if (frame.keys.has(name)) {
-            if (stack[0] === frame)
-                duplicate = true;
-            else
-                nestedDuplicate = true;
-        }
-        frame.keys.add(name);
-        frame.key = name;
-        frame.start = at;
-        return true;
-    };
-    for (;;) {
-        space();
-        let value;
-        const char = text[at];
-        if (char === '{') {
-            at++;
-            space();
-            const frame = { object: true, value: {}, keys: new Set(), key: '', start: 0 };
-            if (text[at] === '}') {
-                at++;
-                value = frame.value;
-            }
-            else {
-                stack.push(frame);
-                if (stack.length === 1)
-                    fields = Object.create(null);
-                if (!key(frame))
-                    return null;
-                continue;
-            }
-        }
-        else if (char === '[') {
-            at++;
-            space();
-            if (text[at] === ']') {
-                at++;
-                value = [];
-            }
-            else {
-                stack.push({ object: false, value: [] });
-                continue;
-            }
-        }
-        else if (char === '"') {
-            value = string();
-            if (value === null)
-                return null;
-        }
-        else if (text.startsWith('true', at)) {
-            at += 4;
-            value = true;
-        }
-        else if (text.startsWith('false', at)) {
-            at += 5;
-            value = false;
-        }
-        else if (text.startsWith('null', at)) {
-            at += 4;
-            value = null;
-        }
-        else {
-            NUMBER.lastIndex = at;
-            const number = NUMBER.exec(text);
-            if (number === null)
-                return null;
-            at += number[0].length;
-            value = Number(number[0]);
-        }
-        // The value is whole: set it in its container, and close what it ends.
-        for (;;) {
-            const top = stack.at(-1);
-            if (top === undefined) {
-                space();
-                if (at !== length)
-                    return null;
-                if (!(typeof value === 'object' && value !== null && !Array.isArray(value)))
-                    fields = null;
-                return { value, fields, duplicate, nestedDuplicate };
-            }
-            if (top.object) {
-                if (stack.length === 1 && fields !== null)
-                    fields[top.key] = text.slice(top.start, at);
-                define(top.value, top.key, value);
-                space();
-                if (text[at] === ',') {
-                    at++;
-                    space();
-                    if (!key(top))
-                        return null;
-                    break;
-                }
-                if (text[at] !== '}')
-                    return null;
-            }
-            else {
-                top.value.push(value);
-                space();
-                if (text[at] === ',') {
-                    at++;
-                    break;
-                }
-                if (text[at] !== ']')
-                    return null;
-            }
-            at++;
-            stack.pop();
-            value = top.value;
-        }
-    }
-};
-const canonical = (value) => {
-    if (value === null || typeof value === 'boolean' || typeof value === 'string')
-        return JSON.stringify(value);
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value))
-            throw new TypeError('a number that is not finite has no JSON');
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value))
-        return `[${value.map(canonical).join(',')}]`;
-    if (typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
-        const keys = Object.keys(value).sort();
-        return `{${keys.map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
-    }
-    throw new TypeError('the value is not JSON');
-};
-export class StrictTools {
-    utf8(text) {
-        return encoder.encode(text);
-    }
-    text(bytes) {
-        try {
-            return decoder.decode(bytes);
-        }
-        catch {
-            return null;
-        }
-    }
-    hex(bytes) {
-        let out = '';
-        for (const byte of bytes)
-            out += byte.toString(16).padStart(2, '0');
-        return out;
-    }
-    bytes(hex) {
-        if (typeof hex !== 'string' || !HEX.test(hex))
-            return null;
-        const out = new Uint8Array(hex.length / 2);
-        for (let at = 0; at < out.length; at++)
-            out[at] = Number.parseInt(hex.slice(at * 2, at * 2 + 2), 16);
-        return out;
-    }
-    parse(text) {
-        return read(text);
-    }
-    canonical(value) {
-        return canonical(value);
-    }
-    check(schema, value) {
-        return check(schema, value, 'the value');
-    }
-}
-const typeOf = (value) => {
-    if (value === null)
-        return 'null';
-    if (Array.isArray(value))
-        return 'array';
-    if (typeof value === 'number')
-        return Number.isInteger(value) ? 'integer' : 'number';
-    return typeof value;
-};
-// The closed subset, read as JSON Schema 2020-12 reads it.
-const check = (schema, value, at) => {
-    if (typeof schema !== 'object' || schema === null)
-        return `${at} meets no schema`;
-    const type = schema.type;
-    if (type !== undefined) {
-        const actual = typeOf(value);
-        const fits = actual === type || (type === 'number' && actual === 'integer');
-        if (!fits)
-            return `${at} is not ${type === 'integer' || type === 'array' || type === 'object' ? 'an' : 'a'} ${type}`;
-    }
-    if ('const' in schema && schema.const !== value)
-        return `${at} is not ${JSON.stringify(schema.const)}`;
-    if (Array.isArray(schema.enum) && !schema.enum.includes(value))
-        return `${at} is none of ${JSON.stringify(schema.enum)}`;
-    if (typeof value === 'string') {
-        const length = [...value].length;
-        if (typeof schema.minLength === 'number' && length < schema.minLength)
-            return `${at} is shorter than ${schema.minLength}`;
-        if (typeof schema.maxLength === 'number' && length > schema.maxLength)
-            return `${at} is longer than ${schema.maxLength}`;
-        if (typeof schema.pattern === 'string' && !new RegExp(schema.pattern, 'u').test(value))
-            return `${at} does not match ${schema.pattern}`;
-        if (schema.contentEncoding === 'base16' && !HEX.test(value))
-            return `${at} is not lowercase hex`;
-    }
-    if (typeof value === 'number') {
-        if (typeof schema.minimum === 'number' && value < schema.minimum)
-            return `${at} is below ${schema.minimum}`;
-        if (typeof schema.maximum === 'number' && value > schema.maximum)
-            return `${at} is above ${schema.maximum}`;
-    }
-    if (Array.isArray(value) && schema.items !== undefined) {
-        for (let index = 0; index < value.length; index++) {
-            const found = check(schema.items, value[index], `${at}[${index}]`);
-            if (found !== null)
-                return found;
-        }
-    }
-    if (typeOf(value) === 'object') {
-        const object = value;
-        const properties = (schema.properties ?? {});
-        for (const key of (schema.required ?? []))
-            if (!Object.hasOwn(object, key))
-                return `${at}.${key} is missing`;
-        for (const [key, field] of Object.entries(object)) {
-            const inner = Object.hasOwn(properties, key) ? properties[key] : undefined;
-            if (inner === undefined) {
-                if (schema.additionalProperties === false)
-                    return `${at}.${key} is not allowed`;
-                continue;
-            }
-            const found = check(inner, field, `${at}.${key}`);
-            if (found !== null)
-                return found;
-        }
-    }
-    if (Array.isArray(schema.anyOf)) {
-        const reasons = schema.anyOf.map((branch) => check(branch, value, at));
-        if (!reasons.includes(null))
-            return reasons[0] ?? `${at} meets no branch`;
-    }
-    return null;
-};

package/dist/bodies/vouch.d.ts

@@ -1,20 +0,0 @@
-/** A GET, as a terrain speaks it. */
-export type Fetcher = (url: string, init: {
-    method: 'GET';
-    redirect: 'error';
-    signal: AbortSignal;
-}) => Promise<Response>;
-/**
- * The domains that vouch for `ward`: the host of each address in `at`
- * whose scheme is one of `schemes`, in their order, asked through
- * `fetcher`. A private or loopback host is asked only where
- * `allowPrivate` is set, as a carry dials one.
- */
-export declare const vouchesOf: ({ fetcher, ward, at, schemes, allowPrivate, wait, }: {
-    fetcher: Fetcher;
-    ward: string;
-    at: readonly string[];
-    schemes: readonly string[];
-    allowPrivate?: boolean;
-    wait?: number;
-}) => Promise<string[]>;

package/dist/bodies/vouch.js

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A domain's vouch for a ward, as quo/DOMAIN.md writes it: one GET to
-// `https://<domain>/.well-known/quo`, never redirected, a status of 200,
-// and a body that is one object whose `wards` lists the ward pk. Anything
-// else vouches for nothing. Every carry body answers `vouched` through
-// this, with the fetch its terrain speaks, so a body written by hand reads
-// a vouch as the library's do.
-import { privateHost } from '../quo/frame.js';
-import { StrictTools } from './strict-tools.js';
-/** The largest body a vouch may have. */
-const LARGEST = 1_048_576;
-const WARD = /^[0-9a-f]{128}$/;
-const tools = new StrictTools();
-// The host of each address whose scheme is one of `schemes`, in their order, each once.
-const domainsOf = (at, schemes) => {
-    const hosts = [];
-    for (const address of at) {
-        let url;
-        try {
-            url = new URL(address);
-        }
-        catch {
-            continue;
-        }
-        if (!schemes.includes(url.protocol.slice(0, -1).toLowerCase()))
-            continue;
-        const host = url.hostname.toLowerCase();
-        if (host !== '' && !hosts.includes(host))
-            hosts.push(host);
-    }
-    return hosts;
-};
-// Whether one domain's file lists the ward.
-const vouches = async (fetcher, domain, ward, wait) => {
-    const abort = new AbortController();
-    const timer = setTimeout(() => abort.abort(), wait);
-    try {
-        const response = await fetcher(`https://${domain}/.well-known/quo`, { method: 'GET', redirect: 'error', signal: abort.signal });
-        if (response.status !== 200)
-            return false;
-        const bytes = new Uint8Array(await response.arrayBuffer());
-        if (bytes.length > LARGEST)
-            return false;
-        const text = tools.text(bytes);
-        const parsed = text === null ? null : tools.parse(text);
-        // Two own keys of one name make no vouch, as they make no payload.
-        if (parsed === null || parsed.duplicate)
-            return false;
-        const value = parsed.value;
-        if (value === null || typeof value !== 'object' || Array.isArray(value) || !Array.isArray(value.wards))
-            return false;
-        return value.wards.some((item) => typeof item === 'string' && WARD.test(item) && item === ward);
-    }
-    catch {
-        return false;
-    }
-    finally {
-        clearTimeout(timer);
-    }
-};
-/**
- * The domains that vouch for `ward`: the host of each address in `at`
- * whose scheme is one of `schemes`, in their order, asked through
- * `fetcher`. A private or loopback host is asked only where
- * `allowPrivate` is set, as a carry dials one.
- */
-export const vouchesOf = async ({ fetcher, ward, at, schemes, allowPrivate = false, wait = 30_000, }) => {
-    const asked = domainsOf(at, schemes).filter((domain) => allowPrivate || !privateHost(domain));
-    const found = await Promise.all(asked.map((domain) => vouches(fetcher, domain, ward, wait)));
-    return asked.filter((_, index) => found[index]);
-};

package/dist/bodies/web-carry.d.ts

@@ -1,72 +0,0 @@
-import type { Carry, Sent } from '../foundation.ts';
-/** A WebSocket the ground's listener opened: bytes out, and closing. */
-export interface HeldSocket {
-    send(data: Uint8Array): void;
-    close(): void;
-}
-/** What a handler does with a WebSocket once it is open. */
-export interface Held {
-    /** Settles once what the message asked is answered, so a ground woken per event holds its wake until then. */
-    message(data: Uint8Array | string): void | Promise<void>;
-    close(): void;
-}
-/**
- * Whatever speaks HTTP on a ground. `fetch` answers a request, or `null`
- * where it is not this handler's. `upgrade` takes a WebSocket: the
- * subprotocol it selects, and what it does once the socket is open.
- */
-export interface Handler {
-    fetch(request: Request): Promise<Response | null>;
-    upgrade?(request: Request): {
-        protocol: string;
-        open(socket: HeldSocket): Held;
-    } | null;
-}
-type Door = (box: Uint8Array) => Promise<Uint8Array | null>;
-export declare class WebCarry implements Carry, Handler {
-    #private;
-    /**
-     * `path` is where it listens under the ground's listener, `/quo` where
-     * omitted. `addresses` are written into invitations, or read each time
-     * where the listener's port is known only once it listens. `origins` are
-     * the pages of other origins it answers, by the CORS protocol.
-     */
-    constructor({ path, addresses, origins, allowPrivate, wait, }?: {
-        path?: string;
-        addresses?: readonly string[] | (() => readonly string[]);
-        origins?: readonly string[];
-        allowPrivate?: boolean;
-        wait?: number;
-    });
-    /** A ward's door, answered on the post and on held lines alike. */
-    listen({ ward, door }: {
-        ward: string;
-        door: Door;
-    }): void;
-    /** A ward this handler answers no more. */
-    unlisten({ ward }: {
-        ward: string;
-    }): void;
-    at(_options?: {
-        toward?: string;
-    }): readonly string[];
-    /** The hosts of its `https` and `wss` addresses that vouch for the ward, each read over TLS. */
-    vouched({ ward, at }: {
-        ward: string;
-        at: readonly string[];
-    }): Promise<readonly string[]>;
-    fetch(request: Request): Promise<Response | null>;
-    upgrade(request: Request): {
-        protocol: string;
-        open(socket: HeldSocket): Held;
-    } | null;
-    send({ ward, at, box, wait }: {
-        ward: string;
-        at: readonly string[];
-        box: Uint8Array;
-        wait?: number;
-    }): Promise<Sent>;
-    /** Closes every held line it dialled. */
-    close(): Promise<void>;
-}
-export {};