yongjun21

import { LinkedList } from "./base";
import { OrderedSet } from "./OrderedCollections";

export function delay(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

export function nextTick(): Promise<void> {
  return new Promise(resolve => {
    queueMicrotask(() => {

yongjun21

type Callable = (...args: any[]) => any | Promise<any>;
type Streamable = (...args: any[]) => AsyncIterableIterator<any>;

interface Handler {
  [key: string]: any;
}

interface Callbacks {
  resolve: (value: any) => void;
  reject: (reason?: any) => void;

yongjun21

import SparseBitmask from "./SparseBitmask";
import { bitmaskFromWeightedRuns } from "./bitmaskHelpers";
import { OrderedMap } from "./OrderedCollections";
import { range } from "./base";

/**
 * [Claude generated]
 *
 * `cutAndPasteBitmask3d` copies a 3-D sub-volume (the "cut" box) out of `from`
 * and XOR-pastes it into `to` at an offset position. Both the cut and paste

yongjun21

/**
 * Calculates an ideal viewBox that centers on a target object
 * @param objectBBox - Bounding box of the target object
 * @param assetWidth - Width of the asset
 * @param assetHeight - Height of the asset
 * @param targetCoverage - target percentage of the viewport width or height the object should take up
 * @param viewportAspectRatio - Aspect ratio of the viewport
 * @param minFit - Minimum width and height of the viewport
 * @returns - [offsetX, offsetY, viewportWidth, viewportHeight]
 */

yongjun21

/**
 * [Claude generated]
 *
 * MultiClassBitmask is a layered compositing system for SparseBitmasks — think
 * Photoshop layers for bitmasks. Any number of SparseBitmask layers can be
 * stacked with integer priorities; at each pixel the highest-priority layer
 * that covers it "wins" and determines the rendered value T via a PixelShader.
 * The default shader returns the top mask object itself.
 *
 * --- Internal representation ---

yongjun21

import SparseBitmask, {
  unionRunEnds,
  intersectionRunEnds,
  subtractionRunEnds,
} from "./SparseBitmask";
import {
  cutAndPasteBitmask3d,
  getBoundingBox3d,
  getCentroid3d,
  getWindowedRunLengths3d,

yongjun21

/**
 * Companion modules:
 * - 2D operations and analysis:
 *   https://gist.github.com/yongjun21/567dc9d60b3994587f0109e85537f24c
 * - 3D transforms and spatial operations:
 *   https://gist.github.com/yongjun21/5162276446d90416192e6365c7a6c2e4
 * - Multiclass layer compositing:
 *   https://gist.github.com/yongjun21/9c9f6b9c2ec1e38f5c80d29ead3af864
 *
 * Together, these modules form an end-to-end sparse-mask processing system.

yongjun21

/**
 * [Claude generated]
 *
 * This file implements two data structures — OrderedSet and OrderedMap — that
 * combine a min-heap with a hash map so you get O(log n) insert/delete AND
 * cheap O(1) membership tests, plus the ability to iterate in sorted order
 * without paying a full sort each time.
 *
 * --- OrderedSet ---
 * Internally it maintains two arrays: `heap` (unsorted, heap-ordered) and

yongjun21

import { Stack } from './common.js';

export function decodeBitmask(
  encoded: Uint8Array,
  maxIndex: number
): Iterable<number> {
  return {
    *[Symbol.iterator]() {
      const n = maxIndex + 1;
      const depth = Math.ceil(Math.log2(n));

yongjun21

/**
 * Companion Python encoder:
 * https://gist.github.com/yongjun21/17ebb9d041b0784e76c99e5cae0b6ac0
 *
 * Together, the encoder and decoder form the point-cloud Octree codec
 * used for compact storage, streaming and browser-based review.
 */

const MAX_LEVEL = 30;
const STACK = new Float32Array((7 * MAX_LEVEL + 1) * 4);