Search

export function round(number: number, precision = 5) {

return Math.round(number * Math.pow(10, precision)) / Math.pow(10, precision);

import { msToIsoDate } from "https://esm.town/v/rwev/msToIsoDate";

import { msDay as msDay2 } from "https://esm.town/v/stevekrouse/msDay?v=1";

export function adjustMsToWeekday(msDay) {

let date = new Date(msDay);

while (date.getDay() == 0 || date.getDay() == 6) {

const { username, password } = options;

return `Basic ${btoa(`${username}:${password}`)}`;

export function authMiddleware(

handler: (Request) => Promise<Response>,

options: Options,

return new Response("Unauthorized", { status: 401 });

return handler(request);

export default async function(req: Request): Promise<Response> {

return new Response("This is middleware only");

import { email } from "https://esm.town/v/std/email?v=9";

import { currency } from "https://esm.town/v/stevekrouse/currency";

export async function btcPriceAlert() {

const lastBtcPrice: number = await blob.getJSON("lastBtcPrice");

let btcPrice = await currency("usd", "btc");

import { email } from "https://esm.town/v/std/email?v=9";

import { currency } from "https://esm.town/v/stevekrouse/currency";

export async function btcPriceAlert() {

const lastBtcPrice: number = await blob.getJSON("lastBtcPrice");

let btcPrice = await currency("usd", "btc");

import { formatCurrency } from "https://esm.town/v/frankdilo/formatCurrency";

import { convertCurrency } from "https://esm.town/v/frankdilo/convertCurrency";

export async function emailMeExchangeRate() {

const rate = await convertCurrency("eur");

const formattedRate = formatCurrency(rate, 3, "EUR");

export default function stripFences(content: string) {

return content.replace(/```[\s\S]*?\n([\s\S]*?)\n```/g, "$1");

import ky from "npm:ky";

export async function convertUrlToDataURL(url: string | URL): Promise<string> {

const blob = await ky.get(url).blob();

return convertBlobToDataURL(blob);

export function convertBlobToDataURL(blob: Blob): Promise<string> {

return new Promise((resolve, reject) => {

const reader = new FileReader();

const READ_ONLY = true;

created_at: string;

function AddSongForm({ onAdd }: { onAdd: (song: Omit<Song, "id" | "created_at">) => void }) {

const [url, setUrl] = React.useState("");

</form>

function SongCard(

{ song, onDelete, onEdit }: {

</div>

function App() {

const [songs, setSongs] = React.useState<Song[]>([]);

</div>

function client() {

createRoot(document.getElementById("root")!).render(<App />);

client();

export default async function server(req: Request): Promise<Response> {

const { sqlite } = await import("https://esm.town/v/stevekrouse/sqlite");

import { unified } from "https://esm.sh/unified";

import { matter } from "npm:vfile-matter";

export async function stripMetadata(markdown: string) {

const file = await unified()

.use(remarkParse)

import wrapper from "https://esm.town/v/substrate/substrateBadgeMiddleware";

async function handler(req: Request): Promise<Response> {

const html = `

import valTownBadge from "https://esm.town/v/substrate/substrateBadge";

export default function badgeMiddleware(handler, url: string) {

return async function(req: Request): Promise<Response> {

if (req.method !== "GET") return await handler(req);

import { email } from "https://esm.town/v/std/email?v=9";

import { currency } from "https://esm.town/v/stevekrouse/currency";

export default async function btcPriceAlert() {

const lastBtcPrice: number = await blob.getJSON("lastBtcPrice");

let btcPrice = await currency("usd", "btc");

* Renders the provided tag into HTML string.

export function renderTag(tag: TagDescriptor): string {

const content = renderTags(tag.content);

* Renders provided tags into a list of HTML strings.

export function renderTags(tags: Array<HtmlContent>): string[] {

return tags.map(element => {

return renderTag(element);

export function basicTag(tagName: string, content: HtmlContents | undefined = undefined): Tag {

const tag = new Tag(tagName);

return tag;

export function selfClosingTag(tagName: string): Tag {

return new Tag(tagName).makeSelfClose();

export function fragment(content: HtmlContents | undefined = undefined): Tag {

return basicTag("");

Convert an ArrayBuffer into a string

from https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string/

export function ab2str(buf) {

return String.fromCharCode.apply(null, new Uint8Array(buf));

import { createRoot } from "https://esm.sh/react-dom@18.2.0/client";

function WeatherDashboard() {

const [weather, setWeather] = useState(null);

useEffect(() => {

function handleClickOutside(event) {

if (suggestionRef.current && !suggestionRef.current.contains(event.target)) {

return () => document.removeEventListener('mousedown', handleClickOutside);

async function fetchLocationSuggestions(query) {

if (query.length < 2) {

fetchLocationSuggestions(value);

async function selectLocation(selectedLocation) {

setLocationInput(selectedLocation.name);

await fetchWeatherData(selectedLocation);

async function fetchWeatherData(coords) {

try {

setError('Failed to fetch weather data');

async function handleLocationSubmit(e) {

e.preventDefault();

</div>

function client() {

createRoot(document.getElementById("root")).render(<WeatherDashboard />);

if (typeof document !== "undefined") { client(); }

export default async function server(request: Request): Promise<Response> {

return new Response(`