clinuxrulz

type Extract<Type, Union> = Type extends Union ? Type : never;

export type TypeSchema<A> =
    TypeSchemaInvariantMap<unknown, A> |
    TypeSchemaRecursive<A> |
    { type: "MaybeUndefined", elemTypeSchema: TypeSchema<NonNullable<A>>, } | (
    A extends ({ has: true, value: unknown, } | { has: false, }) ? { type: "Optional", elemTypeSchema: TypeSchema<Extract<A, { value: unknown, }>["value"]>, } :
    A extends boolean ? { type: "Boolean", } :
    A extends number ? { type: "Number", } :
    A extends string ? { type: "String", possibleValues?: string[], } :

clinuxrulz

import { SetStoreFunction, Store, createStore, reconcile, unwrap } from "solid-js/store";
import { parseJsonViaPropertiesSchema, writeJsonViaPropertiesSchema } from "../model/PropertiesSchema";
import { Result, err, ok } from "../model/Result";
import { Component, ComponentType, IsComponent, IsComponentType } from "./Component";
import { Registry } from "./Registry";
import { generateUUID } from "three/src/math/MathUtils";
import { parentComponentType } from "./components/ParentComponent";
import { childrenComponentType, ChildrenState } from "./components/ChildrenComponent";
import { Accessor, batch, createMemo, createSignal, onCleanup, untrack } from "solid-js";

clinuxrulz

function ProcessFile {
    param(
        [string]$inputFilename,
        [string]$outputFilename
    )

    $csv = @()
    $sr = New-Object System.IO.StreamReader($inputFilename)
    try {
        while ($true) {

clinuxrulz

Add-Type -ReferencedAssemblies ("Microsoft.Office.Interop.Excel") -TypeDefinition @"
using System;
using System.Collections.Generic;
using Excel = Microsoft.Office.Interop.Excel;

public static class Program {
    public static void Main(string[] args) {
        if (args.Length != 2) {
            Console.WriteLine("Please pass input file name and output file name as arguments.");
            return;

clinuxrulz

import { Vec2 } from "../math/Vec2";
import { Result, err, ok } from "./Result";

export type PropertiesSchema<A> = PropertiesSchemaInvMap<unknown,A> | PropertiesSchema2<A>;

type PropertiesSchemaInvMap<A,B> = {
    type: "InvMap",
    propertiesSchema: PropertiesSchema<A>,
    fn1: (a: A) => B,
    fn2: (b: B) => A,

clinuxrulz

use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
use std::ops::{Deref, DerefMut};

pub struct FgrCtx {
    observer: Rc<Node>,
    dirty_nodes: Vec<Rc<Node>>,
    transaction_depth: usize,
}

clinuxrulz

#[derive(Debug, PartialEq, Eq)]
pub enum ChunkNextResult {
    Empty,
    Char(char),
    Eof,
}

pub struct Chunk<'a> {
    next: Box<dyn FnMut()->ChunkNextResult+'a>,
    unnext_stack: Vec<char>,

clinuxrulz

export class Plugin {
    private src: String;
    private callbacks: any;
    private iframe?: HTMLIFrameElement;
    private messageHandler: (e: MessageEvent) => void;
    private recvMsgHandler: (msg: string) => void;
    private nextCallId: number = 0;
    private resolveMap: any;
    
    onLoad: () => void = () => {};

clinuxrulz

use std::cell::RefCell;
use std::collections::HashSet;
use std::hash::{Hash, Hasher};
use std::rc::Rc;

thread_local! {
    static STRING_FACTORY: RefCell<StringFactory> = RefCell::new(StringFactory::new());
}

struct MyRc<A>(Rc<A>);

clinuxrulz

import { batch, Component, createEffect, createMemo, onCleanup, onMount } from 'solid-js';
import { createStore } from 'solid-js/store';

const Window: Component<{
    title?: string,
    width?: number,
    height?: number,
    initX?: number,
    initY?: number,
}> = (props) => {