1import { API_URL } from "https://esm.town/v/std/API_URL?v=5";
2export function getMainExport(
3 mod: any,
4 noneOkay?: boolean,
33 return mod[exports[0]];
34}
35export async function set(path: string, value: any) {
36 let resolveResp = await fetch(
37 `${API_URL}/v1/alias/${path}`,
1// SPDX-License-Identifier: 0BSD
2
3export function jsm(strings: TemplateStringsArray, ...values: any[]) {
4 const code = String.raw({ raw: strings }, ...values);
5 return createModuleURL(code, "application/javascript");
6}
7
8export function tsm(strings: TemplateStringsArray, ...values: any[]) {
9 const code = String.raw({ raw: strings }, ...values);
10 return createModuleURL(code, "application/typescript");
11}
12
13export function createModuleURL(code: BlobPart, type: string) {
14 const blob = new Blob([code], { type });
15 return URL.createObjectURL(blob);
18export default router.fetch;
19
20export async function createScreenshot(code: string, theme: string = "dark-plus"): Promise<URL> {
21 const apiUrl = "https://sourcecodeshots.com/api/image/permalink";
22 const { url } = await ky.post(apiUrl, {
29export default app.fetch;
30
31export async function fetchPackageData(scope: string, name: string) {
32 const prefixUrl = "https://api.jsr.io/";
33 const data = await ky.get(`scopes/${scope}/packages/${name}`, { prefixUrl }).json();
1// SPDX-License-Identifier: 0BSD
2
3export function toPairs<T>(seq: Iterable<T>): Iterable<[T, T]> {
4 const groupedPairs = Object.groupBy(seq, (_, index) => Math.floor(index / 2));
5 return Object.values(groupedPairs);
1// SPDX-License-Identifier: 0BSD
2export function createPacketReader({
3 packetStartMarker,
4 packetEndMarker,
9 packetStartMarker += "\n";
10
11 return function readPacket(input: string) {
12 input = input.trim();
13 let offset = input.indexOf(packetStartMarker);
23}
24
25export function createSignedPacketReader({
26 packetStartMarker,
27 signatureStartMarker,
35 signatureStartMarker += "\n";
36
37 return function readSignedPacket(input: string) {
38 input = input.trim();
39 let offset = input.indexOf(packetStartMarker);
1// SPDX-License-Identifier: 0BSD
2
3export function bufferEquals(buffer1: ArrayBuffer, buffer2: ArrayBuffer) {
4 if (buffer1.byteLength !== buffer2.byteLength) return false;
5 let i = 0;
11}
12
13export function splitBuffer(buffer: ArrayBuffer, chunkSize: number) {
14 const chunks = [];
15 let offset = 0;
30export type SigningKey = PublicKey["signingKey"];
31
32export function parsePublicKey(input: string) {
33 const publicKey = parseArmoredKey(input);
34 const publicKeyEncoded = publicKey
40}
41
42export function decodePublicKey(input: string) {
43 input = input.replace(/^reop/, "");
44 return readPublicKeyPacket(base64.baseDecode(input));
45}
46
47export function parseSignedMessage(input: string) {
48 const { content, signature } = parseAmoredMessage(input);
49 const signatureEncoded = signature
61}
62
63export async function verifyMessage(
64 signedMessage: string,
65 getKey: (message: string, signature: SignedMessage["signature"]) => SigningKey,
75}
76
77function readPublicKeyPacket(publicKeyPacket: Uint8Array) {
78 const signingAlgorithm = new TextDecoder().decode(
79 new Uint8Array(publicKeyPacket.buffer, 0, KEY_ALG_LENGTH),
110}
111
112function readSignaturePacket(signaturePacket: Uint8Array) {
113 const algorithm = new TextDecoder().decode(
114 new Uint8Array(signaturePacket.buffer, 0, KEY_ALG_LENGTH),
14
15export type AspeURI = ReturnType<typeof parseAspeURI>;
16export function parseAspeURI(input: string) {
17 const match = input.match(reAspeURI);
18 if (!match) return null;
22
23export type LegacyAspeURI = ReturnType<typeof parseLegacyAspeURI>;
24export function parseLegacyAspeURI(input: string) {
25 const match = input.match(reLegacyAspeURI);
26 if (!match) return null;
29}
30
31export function getKeyId(fingerprint: string) {
32 return formatFingerprint(fingerprint)
33 .split(" ")
36}
37
38export function formatFingerprint(fingerprint: string) {
39 return fingerprint
40 .toUpperCase()
44}
45
46export function calculateFingerprint(asp: string, alg: HashAlgorithm = "shake128", d: number = 160) {
47 const { jwk } = jose.decodeProtectedHeader(asp);
48 if (!["shake128", "shake256"].includes(alg)) {
53}
54
55export function fetchASP(id: string, server = "keyoxide.org") {
56 const url = new URL(`https://keyoxide.org/.well-known/aspe/id/${id}`);
57 url.hostname = server;
39}, []);
40
41export function encode(data: Uint8Array): string {
42 return data.reduce((p, c) => {
43 p += alphabetBytesToChars[c];
46}
47
48export function decode(str: string): Uint8Array {
49 const byts = [];
50 for (const char of str) {
