webstrand

// MIT License 2024 Webstrand
import tseslint from "typescript-eslint";
import {RuleListener, RuleModule} from "@typescript-eslint/utils/ts-eslint";

export default tseslint.config(
	tseslint.configs.strictTypeCheckedOnly, // no idea, the files don't match if this is missing
	{
		plugins: {
			webstrand: {
				rules: {

webstrand

#!/usr/bin/env -S unshare -Umr -- bash
set -euo pipefail;
tmpfile=$(mktemp);
cpp -P -E tsconfig.json | FILE=$1 jq '.files = [env.FILE] | del(.include)' > $tmpfile;
mount --bind $tmpfile tsconfig.json;
rm $tmpfile;
exec pnpm exec tsc -p tsconfig.json

webstrand

import {type JSX, createMemo, createRoot, onCleanup} from "solid-js";
import {Public, type RemapOperations, enshroudOperations, remapArray} from "./remap.mts";

export interface RemapOperationsConcrete<key, value, reference> extends RemapOperations<key, value, reference> {
	create: (ref: reference, key: key) => value;
	intoKey: (ref: reference) => key;
}

export function RemapKeyed<key, val, ref>(props: {
	refs: ArrayLike<ref>;

webstrand

#![feature(error_generic_member_access)]
use i3_ipc::{event, reply, I3Stream};
use itertools::Itertools;
use nix::sys::memfd::memfd_create;
use nix::sys::memfd::MemFdCreateFlag;
use std::backtrace::Backtrace;
use std::cmp;
use std::collections::HashMap;
use std::error::Error;
use std::fs::File;

webstrand

interface Maplike<key, value> {
    get(key: key): [value] | undefined;
    set(key: key, value?: value): void;
    delete(key: key): boolean;
}

interface Setlike<value>  {
    get(value: value): [unknown] | undefined;
    set(value: value): void;
    delete(value: value): boolean;

webstrand

import { bench, do_not_optimize, run } from './node_modules/mitata/src/main.mjs';

const ub = 100_000;

const adHoc = {
	[Symbol.iterator]() {
		return {
			i: 0,
			next() {
				return this.i < ub ? { value: this.i++ } : { done: true }

webstrand

const retainment = new WeakMap<WeakRef<WeakKey>, unknown>();

export class MapWeak<K, V extends WeakKey> implements Map<K, V> {
	#map: Map<K, WeakRef<V>>;
	#finalizer = new FinalizationRegistry<K>(key => {
		this.#map.delete(key);
	});

	constructor(entries?: Iterable<readonly [K, V]> | null | undefined) {
		const entriesWeak: ConstructorParameters<typeof Map<K, WeakRef<V>>>[0] =

webstrand

function ordgroupIterable<reference, key>(
	refs: Accessor<Iterable<reference>>, 
	keyFn: (ref: reference) => key
): Accessor<ReadonlyMap<key, Accessor<readonly reference[]>>> {
	const signals = createMemo((keyset: Map<key, Signal<readonly reference[]>>) => {
		const exists = new Set();
		let changed = false;

		// Check for group creations
		const ord: key[] =  [];

webstrand

#!/bin/bash
set -euo pipefail
shopt -s lastpipe

name="temporary-vault"
already_set_path=
path="$(pwd)"

_usage() {
	local status=${1:-0}

webstrand

export class SharedMap<K extends string, V> extends Map<string, V> {
	storageKey: string;
	subscriptions = new Set<(added: Iterable<string>, deleted: Iterable<string>) => void>;
	updatedKeys!: Set<string>;
	deletedKeys!: Set<string>;
	timeoutId = 0;

	validateValue;
	deserializeValue;
	serializeValue;