SYMBOL INDEX (924 symbols across 65 files)

FILE: packages/solid-element/src/index.ts
  type ComponentType (line 10) | type ComponentType<T> = mComponentType<T>;
  function createProps (line 14) | function createProps<T extends object>(raw: T) {
  function lookupContext (line 29) | function lookupContext(el: ICustomElement & { _$owner?: any }) {
  function withSolid (line 43) | function withSolid<T extends object>(ComponentType: ComponentType<T>): C...
  function customElement (line 72) | function customElement<T extends object>(

FILE: packages/solid-ssr/examples/shared/src/router.js
  function RouteHOC (line 6) | function RouteHOC(Comp) {

FILE: packages/solid-ssr/examples/ssg/export.js
  constant PAGES (line 5) | const PAGES = ["index", "profile", "settings"];

FILE: packages/solid-ssr/static/index.cjs
  function run (line 6) | async function run({ entry, output, url }) {

FILE: packages/solid-ssr/static/index.d.ts
  type StaticConfig (line 1) | type StaticConfig = { entry: string; output: string; url: string };

FILE: packages/solid-ssr/static/index.js
  function run (line 10) | async function run({ entry, output, url }) {
  function renderStatic (line 22) | async function renderStatic(config) {

FILE: packages/solid-ssr/static/writeToDisk.cjs
  function write (line 5) | async function write() {

FILE: packages/solid-ssr/static/writeToDisk.js
  function write (line 4) | async function write() {

FILE: packages/solid/bench/bench.cjs
  function main (line 9) | function main() {
  function bench (line 36) | function bench(fn, count, scount) {
  function run (line 42) | function run(fn, n, scount) {
  function createDataSignals (line 81) | function createDataSignals(n, sources) {
  function createComputations0to1 (line 88) | function createComputations0to1(n, sources) {
  function createComputations1to1000 (line 94) | function createComputations1to1000(n, sources) {
  function createComputations1to8 (line 104) | function createComputations1to8(n, sources) {
  function createComputations1to4 (line 119) | function createComputations1to4(n, sources) {
  function createComputations1to2 (line 130) | function createComputations1to2(n, sources) {
  function createComputations1to1 (line 139) | function createComputations1to1(n, sources) {
  function createComputations2to1 (line 147) | function createComputations2to1(n, sources) {
  function createComputations4to1 (line 158) | function createComputations4to1(n, sources) {
  function createComputations8 (line 173) | function createComputations8(n, sources) {
  function createComputations1000to1 (line 197) | function createComputations1000to1(n, sources) {
  function createComputation0 (line 203) | function createComputation0(i) {
  function createComputation1 (line 207) | function createComputation1(s1) {
  function createComputation2 (line 211) | function createComputation2(s1, s2) {
  function createComputation4 (line 215) | function createComputation4(s1, s2, s3, s4) {
  function createComputation8 (line 219) | function createComputation8(s1, s2, s3, s4, s5, s6, s7, s8) {
  function createComputation1000 (line 223) | function createComputation1000(ss, offset) {
  function updateComputations1to1 (line 233) | function updateComputations1to1(n, sources) {
  function updateComputations2to1 (line 241) | function updateComputations2to1(n, sources) {
  function updateComputations4to1 (line 250) | function updateComputations4to1(n, sources) {
  function updateComputations1000to1 (line 261) | function updateComputations1000to1(n, sources) {
  function updateComputations1to2 (line 275) | function updateComputations1to2(n, sources) {
  function updateComputations1to4 (line 284) | function updateComputations1to4(n, sources) {
  function updateComputations1to1000 (line 295) | function updateComputations1to1000(n, sources) {
  function browserNow (line 305) | function browserNow() {
  function nodeNow (line 309) | function nodeNow() {

FILE: packages/solid/bench/libraries/kairo.cjs
  function setData (line 2) | function setData(data, value) {
  function markObserversMaybeStale (line 15) | function markObserversMaybeStale(computation) {
  function accessData (line 42) | function accessData(data) {
  function accessComputation (line 57) | function accessComputation(data) {
  function logUnstable (line 79) | function logUnstable(accessor, data) {
  function collectSourceAndRecomputeComputation (line 111) | function collectSourceAndRecomputeComputation(computation) {
  function untrack (line 135) | function untrack(fn, ...args) {
  function updateComputation (line 142) | function updateComputation(computation) {
  function cleanupComputationOfSingleSource (line 161) | function cleanupComputationOfSingleSource(cell) {
  function cleanupComputation (line 195) | function cleanupComputation(cell, remain) {
  function propagate (line 225) | function propagate(computation) {
  function watch (line 314) | function watch(data, sideEffect) {
  function disposeWatcher (line 336) | function disposeWatcher(watcher) {
  function runInTransaction (line 352) | function runInTransaction(fn) {
  function insertNewSource (line 369) | function insertNewSource(accessing, source) {
  function insertNewObserver (line 393) | function insertNewObserver(accesed, observer, atWhichSlotOfObserver) {
  function createData (line 418) | function createData(value) {
  function createComputation (line 429) | function createComputation(fn, options) {

FILE: packages/solid/bench/libraries/preact.cjs
  function cycleDetected (line 4) | function cycleDetected() {
  constant RUNNING (line 9) | const RUNNING = 1 << 0;
  constant NOTIFIED (line 10) | const NOTIFIED = 1 << 1;
  constant OUTDATED (line 11) | const OUTDATED = 1 << 2;
  constant DISPOSED (line 12) | const DISPOSED = 1 << 3;
  constant HAS_ERROR (line 13) | const HAS_ERROR = 1 << 4;
  constant TRACKING (line 14) | const TRACKING = 1 << 5;
  constant NODE_FREE (line 17) | const NODE_FREE = 1 << 0;
  constant NODE_SUBSCRIBED (line 18) | const NODE_SUBSCRIBED = 1 << 1;
  function startBatch (line 20) | function startBatch() {
  function endBatch (line 24) | function endBatch() {
  function batch (line 65) | function batch(callback) {
  function addDependency (line 89) | function addDependency(signal) {
  function Signal (line 149) | function Signal(value) {
  method get (line 219) | get() {
  method set (line 226) | set(value) {
  function signal (line 252) | function signal(value) {
  function prepareSources (line 256) | function prepareSources(target) {
  function cleanupSources (line 271) | function cleanupSources(target) {
  function Computed (line 304) | function Computed(compute) {
  method get (line 443) | get() {
  function computed (line 459) | function computed(compute) {
  function cleanupEffect (line 463) | function cleanupEffect(effect) {
  function disposeEffect (line 485) | function disposeEffect(effect) {
  function endEffect (line 498) | function endEffect(prevContext) {
  function Effect (line 512) | function Effect(compute) {
  function effect (line 563) | function effect(compute) {
  function createRoot (line 571) | function createRoot(fn) { return fn(); }
  function createSignal (line 572) | function createSignal(value) {

FILE: packages/solid/bench/libraries/rval-mod.cjs
  constant NOT_TRACKING (line 1) | const NOT_TRACKING = 0;
  constant STALE (line 2) | const STALE = 1;
  constant UP_TO_DATE (line 3) | const UP_TO_DATE = 2;
  method currentlyComputing (line 9) | get currentlyComputing() {
  function batch (line 16) | function batch(fn) {
  function runPendingObservers (line 26) | function runPendingObservers() {
  class Signal (line 38) | class Signal {
    method constructor (line 39) | constructor(state) {
    method addListener (line 43) | addListener(listener) {
    method removeListener (line 46) | removeListener(listener) {
    method get (line 49) | get() {
    method set (line 52) | set(newValue) {
  class Computed (line 59) | class Computed {
    method constructor (line 60) | constructor(derivation) {
    method addListener (line 75) | addListener(observer) {
    method removeListener (line 78) | removeListener(observer) {
    method registerDependency (line 81) | registerDependency(sub) {
    method someDependencyHasChanged (line 84) | someDependencyHasChanged() {
    method track (line 99) | track() {
    method get (line 110) | get() {
  function track (line 127) | function track(fn) {
  function registerDependencies (line 134) | function registerDependencies(listener, oldDeps, newDeps) {
  function registerRead (line 147) | function registerRead(observable) {
  function recordInputSet (line 151) | function recordInputSet(deps) {
  function inputSetHasChanged (line 155) | function inputSetHasChanged(deps, inputs) {
  function currentValue (line 158) | function currentValue(dep) {
  function runAll (line 163) | function runAll(fns) {
  function createSignal (line 167) | function createSignal(value) {
  function createMemo (line 172) | function createMemo(derivation) {
  function createRoot (line 177) | function createRoot(fn) {
  function createEffect (line 181) | function createEffect(fn) {

FILE: packages/solid/bench/libraries/s-mod.cjs
  constant ERROR (line 4) | const ERROR = Symbol("error");
  function createRoot (line 6) | function createRoot(fn, detachedOwner) {
  function createSignal (line 34) | function createSignal(value, areEqual) {
  function createEffect (line 53) | function createEffect(fn, value) {
  function createDependentEffect (line 56) | function createDependentEffect(fn, deps, defer) {
  function createMemo (line 71) | function createMemo(fn, value, areEqual) {
  function batch (line 91) | function batch(fn) {
  function sample (line 106) | function sample(fn) {
  function afterEffects (line 114) | function afterEffects(fn) {
  function onCleanup (line 118) | function onCleanup(fn) {
  function onError (line 124) | function onError(fn) {
  function isListening (line 131) | function isListening() {
  function createContext (line 134) | function createContext(defaultValue) {
  function useContext (line 138) | function useContext(context) {
  function getOwner (line 141) | function getOwner() {
  class DataNode (line 146) | class DataNode {
    method constructor (line 147) | constructor(value) {
    method current (line 152) | current() {
    method next (line 159) | next(value) {
  function createComputationNode (line 184) | function createComputationNode(fn, value) {
  function createClock (line 221) | function createClock() {
  function createLog (line 230) | function createLog() {
  class Queue (line 238) | class Queue {
    method constructor (line 239) | constructor() {
    method reset (line 243) | reset() {
    method add (line 246) | add(item) {
    method run (line 249) | run(fn) {
  constant NOTPENDING (line 272) | let NOTPENDING = {},
  constant UNOWNED (line 272) | let NOTPENDING = {},
  function callAll (line 277) | function callAll(ss) {
  function lookup (line 282) | function lookup(owner, key) {
  function resolveChildren (line 287) | function resolveChildren(children) {
  function createProvider (line 299) | function createProvider(id) {
  function logRead (line 309) | function logRead(from) {
  function liftComputation (line 339) | function liftComputation(node) {
  function event (line 348) | function event() {
  function toplevelComputation (line 360) | function toplevelComputation(node) {
  function run (line 378) | function run(clock) {
  function applyDataChange (line 399) | function applyDataChange(data) {
  function updateNode (line 404) | function updateNode(node) {
  function updateComputation (line 427) | function updateComputation(node) {
  function stateStale (line 440) | function stateStale(node) {
  function statePending (line 448) | function statePending(node) {
  function pendingStateStale (line 457) | function pendingStateStale(node) {
  function setDownstreamState (line 469) | function setDownstreamState(node, pending) {
  function markDownstreamComputations (line 480) | function markDownstreamComputations(node, onchange, dirty) {
  function setComputationState (line 491) | function setComputationState(log, stateFn) {
  function markForDisposal (line 501) | function markForDisposal(children, pending, time) {
  function applyUpstreamUpdates (line 518) | function applyUpstreamUpdates(node) {
  function cleanupNode (line 534) | function cleanupNode(node, final) {
  function cleanupSource (line 565) | function cleanupSource(source, slot) {
  function resetComputation (line 586) | function resetComputation(node, flags) {
  function dispose (line 591) | function dispose(node) {

FILE: packages/solid/bench/libraries/s.cjs
  function on (line 52) | function on(value) {
  function callAll (line 64) | function callAll(ss) {
  function Clock (line 152) | function Clock() {
  function DataNode (line 166) | function DataNode(value) {
  function ComputationNode (line 207) | function ComputationNode() {
  function Log (line 236) | function Log() {
  function Queue (line 245) | function Queue() {
  function makeComputationNode (line 279) | function makeComputationNode(fn, value, orphan, sample) {
  function execToplevelComputation (line 299) | function execToplevelComputation(fn, value) {
  function finishToplevelComputation (line 309) | function finishToplevelComputation(owner, listener) {
  function getCandidateNode (line 321) | function getCandidateNode() {
  function recycleOrClaimNode (line 327) | function recycleOrClaimNode(node, fn, value, orphan) {
  function logRead (line 363) | function logRead(from) {
  function logDataRead (line 391) | function logDataRead(data) {
  function logComputationRead (line 395) | function logComputationRead(node) {
  function event (line 399) | function event() {
  function run (line 411) | function run(clock) {
  function applyDataChange (line 431) | function applyDataChange(data) {
  function markComputationsStale (line 436) | function markComputationsStale(log) {
  function markNodeStale (line 447) | function markNodeStale(node) {
  function markOwnedNodesForDisposal (line 457) | function markOwnedNodesForDisposal(owned) {
  function updateNode (line 465) | function updateNode(node) {
  function cleanup (line 478) | function cleanup(node, final) {
  function cleanupSource (line 508) | function cleanupSource(source, slot) {
  function dispose (line 529) | function dispose(node) {
  method createSignal (line 536) | createSignal(init) {

FILE: packages/solid/bench/libraries/sinuous-mod.cjs
  function getChildrenDeep (line 1) | function getChildrenDeep(children, res) {
  constant EMPTY_ARR (line 8) | const EMPTY_ARR = [];
  function isListening (line 16) | function isListening() {
  function createRoot (line 28) | function createRoot(fn) {
  function sample (line 40) | function sample(fn) {
  function batch (line 48) | function batch(fn) {
  class DataNode (line 65) | class DataNode {
    method constructor (line 66) | constructor(value) {
    method current (line 72) | current() {
    method next (line 79) | next(nextValue) {
  function createComputationNode (line 105) | function createComputationNode(observer, value) {
  function removeFreshChildren (line 118) | function removeFreshChildren(u) {
  function onCleanup (line 127) | function onCleanup(fn) {
  function _unsubscribe (line 134) | function _unsubscribe(node) {
  function updateComputation (line 146) | function updateComputation(node) {
  function currentValue (line 179) | function currentValue() {
  function resetUpdate (line 188) | function resetUpdate(node) {

FILE: packages/solid/bench/libraries/sinuous.cjs
  function getChildrenDeep (line 1) | function getChildrenDeep(children) {
  constant EMPTY_ARR (line 8) | const EMPTY_ARR = [];
  function isListening (line 16) | function isListening() {
  function root (line 28) | function root(fn) {
  function sample (line 50) | function sample(fn) {
  function transaction (line 64) | function transaction(fn) {
  function observable (line 88) | function observable(value) {
  function computed (line 145) | function computed(observer, value) {
  function removeFreshChildren (line 196) | function removeFreshChildren(u) {
  function cleanup (line 212) | function cleanup(fn) {
  function _unsubscribe (line 219) | function _unsubscribe(update) {
  function resetUpdate (line 231) | function resetUpdate(update) {

FILE: packages/solid/bench/libraries/usignal.cjs
  class Signal (line 32) | class Signal {
    method constructor (line 34) | constructor(value) {
    method then (line 39) | then() { return this.value }
    method toJSON (line 42) | toJSON() { return this.value }
    method toString (line 45) | toString() { return this.value }
    method valueOf (line 48) | valueOf() { return this.value }
  class Computed (line 52) | class Computed extends Signal {
    method constructor (line 53) | constructor(_, v, o, f) {
    method value (line 61) | get value() {
  class Effect (line 88) | class Effect extends Computed {
    method constructor (line 89) | constructor(_, v, o) {
    method value (line 97) | get value() {
    method async (line 100) | async() {
    method sync (line 109) | sync() {
    method stop (line 125) | stop() {
  class Reactive (line 162) | class Reactive extends Signal {
    method constructor (line 163) | constructor(_, {equals}) {
    method peek (line 168) | peek() { return this._ }
    method value (line 169) | get value() {
    method value (line 176) | set value(_) {
  function createRoot (line 218) | function createRoot(fn) { return fn(); }
  function createSignal (line 219) | function createSignal(value) {

FILE: packages/solid/bench/libraries/vuerx.cjs
  function makeMap (line 7) | function makeMap(str, expectsLowerCase) {
  constant EMPTY_OBJ (line 17) | const EMPTY_OBJ =  Object.freeze({});
  constant ITERATE_KEY (line 53) | const ITERATE_KEY = Symbol( 'iterate' );
  constant MAP_KEY_ITERATE_KEY (line 54) | const MAP_KEY_ITERATE_KEY = Symbol( 'Map key iterate' );
  function isEffect (line 55) | function isEffect(fn) {
  function effect (line 58) | function effect(fn, options = EMPTY_OBJ) {
  function stop (line 68) | function stop(effect) {
  function createReactiveEffect (line 78) | function createReactiveEffect(fn, options) {
  function cleanup (line 106) | function cleanup(effect) {
  function pauseTracking (line 117) | function pauseTracking() {
  function enableTracking (line 121) | function enableTracking() {
  function resetTracking (line 125) | function resetTracking() {
  function track (line 129) | function track(target, type, key) {
  function trigger (line 154) | function trigger(target, type, key, newValue, oldValue, oldTarget) {
  function createGetter (line 254) | function createGetter(isReadonly = false, shallow = false) {
  function createSetter (line 299) | function createSetter(shallow = false) {
  function deleteProperty (line 323) | function deleteProperty(target, key) {
  function has (line 332) | function has(target, key) {
  function ownKeys (line 337) | function ownKeys(target) {
  method set (line 352) | set(target, key) {
  method deleteProperty (line 358) | deleteProperty(target, key) {
  function get$1 (line 381) | function get$1(target, key, wrap) {
  function has$1 (line 396) | function has$1(key) {
  function size (line 406) | function size(target) {
  function add (line 411) | function add(value) {
  function set$1 (line 422) | function set$1(key, value) {
  function deleteEntry (line 444) | function deleteEntry(key) {
  function clear (line 463) | function clear() {
  function createForEach (line 477) | function createForEach(isReadonly) {
  function createIterableMethod (line 492) | function createIterableMethod(method, isReadonly) {
  function createReadonlyMethod (line 522) | function createReadonlyMethod(type) {
  method get (line 532) | get(key) {
  method size (line 535) | get size() {
  method get (line 546) | get(key) {
  method size (line 549) | get size() {
  function createInstrumentationGetter (line 564) | function createInstrumentationGetter(isReadonly) {
  function checkIdentityKeys (line 589) | function checkIdentityKeys(target, has, key) {
  function reactive (line 608) | function reactive(target) {
  function shallowReactive (line 618) | function shallowReactive(target) {
  function readonly (line 621) | function readonly(target) {
  function shallowReadonly (line 628) | function shallowReadonly(target) {
  function createReactiveObject (line 631) | function createReactiveObject(target, isReadonly, baseHandlers, collecti...
  function isReactive (line 655) | function isReactive(value) {
  function isReadonly (line 661) | function isReadonly(value) {
  function isProxy (line 664) | function isProxy(value) {
  function toRaw (line 667) | function toRaw(observed) {
  function markRaw (line 670) | function markRaw(value) {
  function isRef (line 676) | function isRef(r) {
  function ref (line 679) | function ref(value) {
  function shallowRef (line 682) | function shallowRef(value) {
  function createRef (line 685) | function createRef(rawValue, shallow = false) {
  function triggerRef (line 706) | function triggerRef(ref) {
  function unref (line 709) | function unref(ref) {
  function customRef (line 712) | function customRef(factory) {
  function toRefs (line 725) | function toRefs(object) {
  function toRef (line 735) | function toRef(object, key) {
  function computed (line 747) | function computed(getterOrOptions) {
  function createSignal (line 794) | function createSignal(value) {
  function createRoot (line 799) | function createRoot(fn) { return fn(); }

FILE: packages/solid/bench/prototypes/message-noarray.cjs
  constant UNOWNED (line 6) | const UNOWNED = {
  function createRoot (line 16) | function createRoot(fn, detachedOwner) {
  function createSignal (line 40) | function createSignal(value, options) {
  function createComputed (line 67) | function createComputed(fn, value) {
  function createMemo (line 70) | function createMemo(fn, value, options) {
  function batch (line 86) | function batch(fn) {
  function untrack (line 89) | function untrack(fn) {
  function logRead (line 97) | function logRead(node) {
  function writeSignal (line 126) | function writeSignal(node, value) {
  function updateComputation (line 131) | function updateComputation(node, init) {
  function runComputation (line 142) | function runComputation(node, value, time) {
  function createComputation (line 153) | function createComputation(fn, init, pure, options) {
  function runTop (line 177) | function runTop(node) {
  function runUpdates (line 190) | function runUpdates(fn) {
  function completeUpdates (line 203) | function completeUpdates(wait) {
  function runQueue (line 209) | function runQueue(queue) {
  function lookUpstream (line 212) | function lookUpstream(node) {
  function lookUpstreamNode (line 222) | function lookUpstreamNode(node) {
  function markDownstream (line 228) | function markDownstream(node, decrease, stale, top) {
  function markDownstreamNode (line 238) | function markDownstreamNode(o, decrease, stale, top) {
  function runImmediate (line 245) | function runImmediate(node) {
  function runNode (line 255) | function runNode(node) {
  function updateNode (line 266) | function updateNode(node) {
  function cleanNode (line 273) | function cleanNode(node) {
  function cleanupSource (line 296) | function cleanupSource(source, slot) {

FILE: packages/solid/bench/prototypes/message.cjs
  constant UNOWNED (line 6) | const UNOWNED = {
  function createRoot (line 16) | function createRoot(fn, detachedOwner) {
  function createSignal (line 40) | function createSignal(value, options) {
  function createComputed (line 64) | function createComputed(fn, value) {
  function createMemo (line 67) | function createMemo(fn, value, options) {
  function batch (line 77) | function batch(fn) {
  function untrack (line 80) | function untrack(fn) {
  function readSignal (line 88) | function readSignal() {
  function writeSignal (line 109) | function writeSignal(node, value) {
  function updateComputation (line 114) | function updateComputation(node) {
  function runComputation (line 125) | function runComputation(node, value, time) {
  function createComputation (line 136) | function createComputation(fn, init, pure, options) {
  function runTop (line 158) | function runTop(node) {
  function runUpdates (line 171) | function runUpdates(fn) {
  function completeUpdates (line 184) | function completeUpdates(wait) {
  function runQueue (line 190) | function runQueue(queue) {
  function lookUpstream (line 193) | function lookUpstream(node) {
  function markDownstream (line 202) | function markDownstream(node, decrease, stale, top) {
  function runImmediate (line 212) | function runImmediate(node) {
  function runNode (line 221) | function runNode(node) {
  function updateNode (line 232) | function updateNode(node) {
  function cleanNode (line 239) | function cleanNode(node) {

FILE: packages/solid/bench/prototypes/queue-noarray.cjs
  constant ERROR (line 5) | let ERROR = null;
  constant STALE (line 7) | const STALE = 1;
  constant PENDING (line 8) | const PENDING = 2;
  constant UNOWNED (line 9) | const UNOWNED = {
  function createRoot (line 20) | function createRoot(fn, detachedOwner) {
  function createSignal (line 44) | function createSignal(value, options) {
  function createComputed (line 67) | function createComputed(fn, value) {
  function createMemo (line 70) | function createMemo(fn, value, options) {
  function batch (line 91) | function batch(fn) {
  function untrack (line 94) | function untrack(fn) {
  function logRead (line 103) | function logRead(node) {
  function writeSignal (line 132) | function writeSignal(node, value) {
  function queueUpdates (line 151) | function queueUpdates(o) {
  function updateComputation (line 160) | function updateComputation(node) {
  function runComputation (line 171) | function runComputation(node, value, time) {
  function createComputation (line 181) | function createComputation(fn, init, pure, state = STALE, options) {
  function runTop (line 204) | function runTop(node) {
  function runUpdates (line 223) | function runUpdates(fn, init) {
  function completeUpdates (line 239) | function completeUpdates(wait) {
  function runQueue (line 249) | function runQueue(queue) {
  function lookUpstream (line 252) | function lookUpstream(node) {
  function lookUpstreamNode (line 261) | function lookUpstreamNode(source) {
  function markDownstream (line 267) | function markDownstream(node) {
  function markDownstreamNode (line 273) | function markDownstreamNode(o) {
  function cleanNode (line 281) | function cleanNode(node) {
  function cleanupSource (line 303) | function cleanupSource(source, slot) {

FILE: packages/solid/bench/prototypes/queue.cjs
  constant ERROR (line 5) | let ERROR = null;
  constant STALE (line 7) | const STALE = 1;
  constant PENDING (line 8) | const PENDING = 2;
  constant UNOWNED (line 9) | const UNOWNED = {
  function createRoot (line 20) | function createRoot(fn, detachedOwner) {
  function createSignal (line 44) | function createSignal(value, options) {
  function createComputed (line 62) | function createComputed(fn, value) {
  function createMemo (line 65) | function createMemo(fn, value, options) {
  function batch (line 75) | function batch(fn) {
  function untrack (line 78) | function untrack(fn) {
  function readSignal (line 87) | function readSignal() {
  function writeSignal (line 113) | function writeSignal(node, value, isComp) {
  function updateComputation (line 137) | function updateComputation(node) {
  function runComputation (line 148) | function runComputation(node, value, time) {
  function createComputation (line 158) | function createComputation(fn, init, pure, state = STALE, options) {
  function runTop (line 179) | function runTop(node) {
  function runUpdates (line 198) | function runUpdates(fn, init) {
  function completeUpdates (line 214) | function completeUpdates(wait) {
  function runQueue (line 224) | function runQueue(queue) {
  function lookUpstream (line 227) | function lookUpstream(node) {
  function markDownstream (line 237) | function markDownstream(node) {
  function cleanNode (line 248) | function cleanNode(node) {

FILE: packages/solid/h/jsx-runtime/src/index.ts
  function Fragment (line 5) | function Fragment(props: { children: JSX.Element }) {
  function jsx (line 9) | function jsx(type: any, props: any) {

FILE: packages/solid/src/index.ts
  type JSXElement (line 72) | type JSXElement = JSX.Element;
  constant DEV (line 77) | const DEV = IS_DEV ? ({ hooks: DevHooks, writeSignal, registerGraph } as...

FILE: packages/solid/src/reactive/array.ts
  constant FALLBACK (line 12) | const FALLBACK = Symbol("fallback");
  function dispose (line 13) | function dispose(d: (() => void)[]) {
  function mapArray (line 49) | function mapArray<T, U>(
  function indexArray (line 186) | function indexArray<T, U>(

FILE: packages/solid/src/reactive/observable.ts
  type SymbolConstructor (line 17) | interface SymbolConstructor {
  type Observable (line 22) | interface Observable<T> {
  type ObservableObserver (line 29) | type ObservableObserver<T> =
  function observable (line 46) | function observable<T>(input: Accessor<T>): Observable<T> {
  type Producer (line 87) | type Producer<T> =
  function from (line 93) | function from<T>(

FILE: packages/solid/src/reactive/scheduler.ts
  type Task (line 2) | interface Task {
  type NavigatorScheduling (line 10) | type NavigatorScheduling = Navigator & {
  function setupScheduler (line 29) | function setupScheduler() {
  function enqueue (line 87) | function enqueue(taskQueue: Task[], task: Task) {
  function requestCallback (line 104) | function requestCallback(fn: () => void, options?: { timeout: number }):...
  function cancelCallback (line 128) | function cancelCallback(task: Task) {
  function flushWork (line 132) | function flushWork(initialTime: number) {
  function workLoop (line 144) | function workLoop(initialTime: number) {

FILE: packages/solid/src/reactive/signal.ts
  constant IS_DEV (line 32) | const IS_DEV = "_SOLID_DEV_" as string | boolean;
  constant SUPPORTS_PROXY (line 36) | const SUPPORTS_PROXY = typeof Proxy === "function";
  constant ERROR (line 40) | let ERROR: symbol | null = null;
  constant STALE (line 42) | const STALE = 1;
  constant PENDING (line 43) | const PENDING = 2;
  constant UNOWNED (line 44) | const UNOWNED: Owner = {
  constant NO_INIT (line 50) | const NO_INIT = {};
  type ComputationState (line 77) | type ComputationState = 0 | 1 | 2;
  type SourceMapValue (line 79) | interface SourceMapValue {
  type SignalState (line 85) | interface SignalState<T> extends SourceMapValue {
  type Owner (line 95) | interface Owner {
  type Computation (line 104) | interface Computation<Init, Next extends Init = Init> extends Owner {
  type TransitionState (line 117) | interface TransitionState {
  type ExternalSourceFactory (line 129) | type ExternalSourceFactory = <Prev, Next extends Prev = Prev>(
  type ExternalSource (line 134) | interface ExternalSource {
  type RootFunction (line 139) | type RootFunction<T> = (dispose: () => void) => T;
  function createRoot (line 150) | function createRoot<T>(fn: RootFunction<T>, detachedOwner?: typeof Owner...
  type Accessor (line 187) | type Accessor<T> = () => T;
  type Setter (line 189) | type Setter<in out T> = {
  type Signal (line 198) | type Signal<T> = [get: Accessor<T>, set: Setter<T>];
  type SignalOptions (line 200) | interface SignalOptions<T> extends MemoOptions<T> {
  function createSignal (line 229) | function createSignal<T>(
  type BaseOptions (line 263) | interface BaseOptions {
  type NoInfer (line 270) | type NoInfer<T extends any> = [T][T extends any ? 0 : never];
  type EffectOptions (line 272) | interface EffectOptions extends BaseOptions {}
  type EffectFunction (line 275) | type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
  function createComputed (line 298) | function createComputed<Next, Init>(
  function createRenderEffect (line 329) | function createRenderEffect<Next, Init>(
  function createEffect (line 360) | function createEffect<Next, Init>(
  function createReaction (line 386) | function createReaction(onInvalidate: () => void, options?: EffectOption...
  type Memo (line 407) | interface Memo<Prev, Next = Prev> extends SignalState<Next>, Computation...
  type MemoOptions (line 412) | interface MemoOptions<T> extends EffectOptions {
  function createMemo (line 442) | function createMemo<Next extends Prev, Init, Prev>(
  type Unresolved (line 467) | interface Unresolved {
  type Pending (line 475) | interface Pending {
  type Ready (line 483) | interface Ready<T> {
  type Refreshing (line 491) | interface Refreshing<T> {
  type Errored (line 499) | interface Errored {
  type Resource (line 507) | type Resource<T> = Unresolved | Pending | Ready<T> | Refreshing<T> | Err...
  type InitializedResource (line 509) | type InitializedResource<T> = Ready<T> | Refreshing<T> | Errored;
  type ResourceActions (line 511) | type ResourceActions<T, R = unknown> = {
  type ResourceSource (line 516) | type ResourceSource<S> = S | false | null | undefined | (() => S | false...
  type ResourceFetcher (line 518) | type ResourceFetcher<S, T, R = unknown> = (
  type ResourceFetcherInfo (line 523) | type ResourceFetcherInfo<T, R = unknown> = {
  type ResourceOptions (line 528) | type ResourceOptions<T, S = unknown> = {
  type InitializedResourceOptions (line 537) | type InitializedResourceOptions<T, S = unknown> = ResourceOptions<T, S> & {
  type ResourceReturn (line 541) | type ResourceReturn<T, R = unknown> = [Resource<T>, ResourceActions<T | ...
  type InitializedResourceReturn (line 543) | type InitializedResourceReturn<T, R = unknown> = [
  function isPromise (line 548) | function isPromise(v: any): v is Promise<any> {
  function createResource (line 598) | function createResource<T, S, R>(
  type DeferredOptions (line 763) | interface DeferredOptions<T> {
  function createDeferred (line 782) | function createDeferred<T>(source: Accessor<T>, options?: DeferredOption...
  type EqualityCheckerFunction (line 808) | type EqualityCheckerFunction<T, U> = (a: U, b: T) => boolean;
  function createSelector (line 834) | function createSelector<T, U = T>(
  function batch (line 884) | function batch<T>(fn: Accessor<T>): T {
  function untrack (line 895) | function untrack<T>(fn: Accessor<T>): T {
  type ReturnTypes (line 909) | type ReturnTypes<T> = T extends readonly Accessor<unknown>[]
  type AccessorArray (line 916) | type AccessorArray<T> = [...Extract<{ [K in keyof T]: Accessor<T[K]> }, ...
  type OnEffectFunction (line 919) | type OnEffectFunction<S, Prev, Next extends Prev = Prev> = (
  type OnOptions (line 925) | interface OnOptions {
  function on (line 965) | function on<S, Next extends Prev, Prev = Next>(
  function onMount (line 995) | function onMount(fn: () => void) {
  function onCleanup (line 1007) | function onCleanup<T extends () => any>(fn: T): T {
  function catchError (line 1024) | function catchError<T>(fn: () => T, handler: (err: Error) => void) {
  function getListener (line 1038) | function getListener() {
  function getOwner (line 1042) | function getOwner() {
  function runWithOwner (line 1046) | function runWithOwner<T>(o: typeof Owner, fn: () => T): T | undefined {
  function enableScheduling (line 1062) | function enableScheduling(scheduler = requestCallback) {
  function startTransition (line 1073) | function startTransition(fn: () => unknown): Promise<void> {
  type Transition (line 1107) | type Transition = [Accessor<boolean>, (fn: () => void) => Promise<void>];
  function useTransition (line 1120) | function useTransition(): Transition {
  function resumeEffects (line 1124) | function resumeEffects(e: Computation<any>[]) {
  type DevComponent (line 1129) | interface DevComponent<T> extends Memo<unknown> {
  function devComponent (line 1136) | function devComponent<P, V>(Comp: (props: P) => V, props: P): V {
  function registerGraph (line 1156) | function registerGraph(value: SourceMapValue): void {
  type ContextProviderComponent (line 1165) | type ContextProviderComponent<T> = FlowComponent<{ value: T }>;
  type Context (line 1168) | interface Context<T> {
  function createContext (line 1198) | function createContext<T>(
  function useContext (line 1214) | function useContext<T>(context: Context<T>): T {
  type ResolvedJSXElement (line 1221) | type ResolvedJSXElement = Exclude<JSX.Element, JSX.ArrayElement>;
  type ResolvedChildren (line 1222) | type ResolvedChildren = ResolvedJSXElement | ResolvedJSXElement[];
  type ChildrenReturn (line 1223) | type ChildrenReturn = Accessor<ResolvedChildren> & { toArray: () => Reso...
  function children (line 1233) | function children(fn: Accessor<JSX.Element>): ChildrenReturn {
  type SuspenseContextType (line 1246) | type SuspenseContextType = {
  type SuspenseContext (line 1254) | type SuspenseContext = Context<SuspenseContextType | undefined> & {
  function getSuspenseContext (line 1262) | function getSuspenseContext() {
  function enableExternalSource (line 1267) | function enableExternalSource(
  function readSignal (line 1293) | function readSignal(this: SignalState<any> | Memo<any>) {
  function writeSignal (line 1329) | function writeSignal(node: SignalState<any> | Memo<any>, value: any, isC...
  function updateComputation (line 1366) | function updateComputation(node: Computation<any>) {
  function runComputation (line 1390) | function runComputation(node: Computation<any>, value: any, time: number) {
  function createComputation (line 1427) | function createComputation<Next, Init = unknown>(
  function runTop (line 1488) | function runTop(node: Computation<any>) {
  function runUpdates (line 1521) | function runUpdates<T>(fn: () => T, init: boolean) {
  function completeUpdates (line 1539) | function completeUpdates(wait: boolean) {
  function runQueue (line 1589) | function runQueue(queue: Computation<any>[]) {
  function scheduleQueue (line 1593) | function scheduleQueue(queue: Computation<any>[]) {
  function runUserEffects (line 1611) | function runUserEffects(queue: Computation<any>[]) {
  function lookUpstream (line 1635) | function lookUpstream(node: Computation<any>, ignore?: Computation<any>) {
  function markDownstream (line 1651) | function markDownstream(node: Memo<any>) {
  function cleanNode (line 1665) | function cleanNode(node: Owner) {
  function reset (line 1705) | function reset(node: Computation<any>, top?: boolean) {
  function castError (line 1715) | function castError(err: unknown): Error {
  function runErrors (line 1720) | function runErrors(err: unknown, fns: ((err: any) => void)[], owner: Own...
  function handleError (line 1728) | function handleError(err: unknown, owner = Owner) {
  function resolveChildren (line 1743) | function resolveChildren(children: JSX.Element | Accessor<any>): Resolve...
  function createProvider (line 1756) | function createProvider(id: symbol, options?: EffectOptions) {
  type TODO (line 1772) | type TODO = any;
  function onError (line 1783) | function onError(fn: (err: Error) => void): void {
  function mutateContext (line 1795) | function mutateContext(o: Owner, key: symbol, value: any) {

FILE: packages/solid/src/render/Suspense.ts
  type SuspenseListContextType (line 17) | type SuspenseListContextType = {
  type SuspenseListRegisteredState (line 21) | type SuspenseListRegisteredState = { showContent: boolean; showFallback:...
  type SuspenseListState (line 22) | interface SuspenseListState extends Array<SuspenseListRegisteredState> {
  function SuspenseList (line 35) | function SuspenseList(props: {
  function Suspense (line 123) | function Suspense(props: { fallback?: JSX.Element; children: JSX.Element...

FILE: packages/solid/src/render/component.ts
  function enableHydration (line 17) | function enableHydration() {
  type Component (line 25) | type Component<P extends Record<string, any> = {}> = (props: P) => JSX.E...
  type VoidProps (line 32) | type VoidProps<P extends Record<string, any> = {}> = P & { children?: ne...
  type VoidComponent (line 38) | type VoidComponent<P extends Record<string, any> = {}> = Component<VoidP...
  type ParentProps (line 45) | type ParentProps<P extends Record<string, any> = {}> = P & { children?: ...
  type ParentComponent (line 51) | type ParentComponent<P extends Record<string, any> = {}> = Component<Par...
  type FlowProps (line 59) | type FlowProps<P extends Record<string, any> = {}, C = JSX.Element> = P ...
  type FlowComponent (line 66) | type FlowComponent<P extends Record<string, any> = {}, C = JSX.Element> ...
  type PropsWithChildren (line 71) | type PropsWithChildren<P extends Record<string, any> = {}> = ParentProps...
  type ValidComponent (line 73) | type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (st...
  type ComponentProps (line 82) | type ComponentProps<T extends ValidComponent> =
  type Ref (line 94) | type Ref<T> = T | ((val: T) => void);
  function createComponent (line 96) | function createComponent<T extends Record<string, any>>(
  function trueFn (line 115) | function trueFn() {
  method get (line 124) | get(_, property, receiver) {
  method has (line 128) | has(_, property) {
  method getOwnPropertyDescriptor (line 134) | getOwnPropertyDescriptor(_, property) {
  method ownKeys (line 145) | ownKeys(_) {
  type DistributeOverride (line 150) | type DistributeOverride<T, F> = T extends undefined ? F : T;
  type Override (line 151) | type Override<T, U> = T extends any
  type OverrideSpread (line 160) | type OverrideSpread<T, U> = T extends any
  type Simplify (line 171) | type Simplify<T> = T extends any ? { [K in keyof T]: T[K] } : T;
  type _MergeProps (line 172) | type _MergeProps<T extends unknown[], Curr = {}> = T extends [
  type MergeProps (line 185) | type MergeProps<T extends unknown[]> = Simplify<_MergeProps<T>>;
  function resolveSource (line 187) | function resolveSource(s: any) {
  function resolveSources (line 191) | function resolveSources(this: (() => any)[]) {
  function mergeProps (line 198) | function mergeProps<T extends unknown[]>(...sources: T): MergeProps<T> {
  type SplitProps (line 278) | type SplitProps<T, K extends (readonly (keyof T)[])[]> = [
  function splitProps (line 287) | function splitProps<
  function lazy (line 356) | function lazy<T extends Component<any>>(
  function createUniqueId (line 398) | function createUniqueId(): string {

FILE: packages/solid/src/render/flow.ts
  function For (line 34) | function For<T extends readonly any[], U extends JSX.Element>(props: {
  function Index (line 64) | function Index<T extends readonly any[], U extends JSX.Element>(props: {
  type RequiredParameter (line 81) | type RequiredParameter<T> = T extends () => unknown ? never : T;
  function Show (line 101) | function Show<T>(props: {
  type EvalConditions (line 151) | type EvalConditions = readonly [number, Accessor<unknown>, MatchProps<un...
  function Switch (line 167) | function Switch(props: { fallback?: JSX.Element; children: JSX.Element }...
  type MatchProps (line 223) | type MatchProps<T> = {
  function Match (line 250) | function Match<T>(props: MatchProps<T>) {
  function resetErrorBoundaries (line 255) | function resetErrorBoundaries() {
  function ErrorBoundary (line 273) | function ErrorBoundary(props: {

FILE: packages/solid/src/render/hydration.ts
  type HydrationContext (line 3) | type HydrationContext = { id: string; count: number };
  type SharedConfig (line 5) | type SharedConfig = {
  method getContextId (line 24) | getContextId() {
  method getNextContextId (line 27) | getNextContextId() {
  function getContextId (line 32) | function getContextId(count: number) {
  function setHydrateContext (line 38) | function setHydrateContext(context?: HydrationContext): void {
  function nextHydrateContext (line 42) | function nextHydrateContext(): HydrationContext | undefined {

FILE: packages/solid/src/server/reactive.ts
  constant DEV (line 7) | const DEV = undefined;
  type Accessor (line 9) | type Accessor<T> = () => T;
  type Setter (line 10) | type Setter<T> = undefined extends T
  type Signal (line 13) | type Signal<T> = [get: Accessor<T>, set: Setter<T>];
  constant ERROR (line 15) | const ERROR = Symbol("error");
  function castError (line 16) | function castError(err: unknown): Error {
  function handleError (line 21) | function handleError(err: unknown, owner = Owner): void {
  constant UNOWNED (line 33) | const UNOWNED: Owner = { context: null, owner: null, owned: null, cleanu...
  type Owner (line 36) | interface Owner {
  function createOwner (line 43) | function createOwner(): Owner {
  function createRoot (line 52) | function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: t...
  function createSignal (line 76) | function createSignal<T>(
  function createComputed (line 88) | function createComputed<T>(fn: (v?: T) => T, value?: T): void {
  function createEffect (line 101) | function createEffect<T>(fn: (v?: T) => T, value?: T): void {}
  function createReaction (line 103) | function createReaction(fn: () => void) {
  function createMemo (line 109) | function createMemo<T>(fn: (v?: T) => T, value?: T): () => T {
  function createDeferred (line 122) | function createDeferred<T>(source: () => T) {
  function createSelector (line 126) | function createSelector<T>(source: () => T, fn: (k: T, value: T) => bool...
  function batch (line 130) | function batch<T>(fn: () => T): T {
  function on (line 136) | function on<T, U>(
  function onMount (line 154) | function onMount(fn: () => void) {}
  function onCleanup (line 156) | function onCleanup(fn: () => void) {
  function cleanNode (line 164) | function cleanNode(node: Owner) {
  function catchError (line 175) | function catchError<T>(fn: () => T, handler: (err: Error) => void) {
  function getListener (line 188) | function getListener() {
  type Context (line 193) | interface Context<T> {
  function createContext (line 199) | function createContext<T>(defaultValue?: T): Context<T> {
  function useContext (line 204) | function useContext<T>(context: Context<T>): T {
  function getOwner (line 210) | function getOwner() {
  type ChildrenReturn (line 214) | type ChildrenReturn = Accessor<any> & { toArray: () => any[] };
  function children (line 215) | function children(fn: () => any): ChildrenReturn {
  function runWithOwner (line 224) | function runWithOwner<T>(o: typeof Owner, fn: () => T): T | undefined {
  function resolveChildren (line 236) | function resolveChildren(children: any): unknown {
  function createProvider (line 250) | function createProvider(id: symbol) {
  type Task (line 259) | interface Task {
  function requestCallback (line 265) | function requestCallback(fn: () => void, options?: { timeout: number }):...
  function cancelCallback (line 268) | function cancelCallback(task: Task) {}
  function mapArray (line 270) | function mapArray<T, U>(
  function indexArray (line 283) | function indexArray<T, U>(
  type ObservableObserver (line 296) | type ObservableObserver<T> =
  function observable (line 303) | function observable<T>(input: Accessor<T>) {
  function from (line 340) | function from<T>(
  function enableExternalSource (line 361) | function enableExternalSource(factory: any) {}
  function onError (line 366) | function onError(fn: (err: Error) => void): void {
  function mutateContext (line 376) | function mutateContext(o: Owner, key: symbol, value: any) {

FILE: packages/solid/src/server/rendering.ts
  type Component (line 17) | type Component<P = {}> = (props: P) => JSX.Element;
  type VoidProps (line 18) | type VoidProps<P = {}> = P & { children?: never };
  type VoidComponent (line 19) | type VoidComponent<P = {}> = Component<VoidProps<P>>;
  type ParentProps (line 20) | type ParentProps<P = {}> = P & { children?: JSX.Element };
  type ParentComponent (line 21) | type ParentComponent<P = {}> = Component<ParentProps<P>>;
  type FlowProps (line 22) | type FlowProps<P = {}, C = JSX.Element> = P & { children: C };
  type FlowComponent (line 23) | type FlowComponent<P = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
  type Ref (line 24) | type Ref<T> = T | ((val: T) => void);
  type ValidComponent (line 25) | type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (st...
  type ComponentProps (line 26) | type ComponentProps<T extends ValidComponent> =
  function escape (line 35) | function escape(s: any, attr?: boolean) {
  function resolveSSRNode (line 88) | function resolveSSRNode(node: any): string {
  type SharedConfig (line 106) | type SharedConfig = {
  method getContextId (line 113) | getContextId() {
  method getNextContextId (line 117) | getNextContextId() {
  function getContextId (line 124) | function getContextId(count: number) {
  function setHydrateContext (line 130) | function setHydrateContext(context?: HydrationContext): void {
  function nextHydrateContext (line 134) | function nextHydrateContext(): HydrationContext | undefined {
  function createUniqueId (line 144) | function createUniqueId(): string {
  function createComponent (line 148) | function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): ...
  function mergeProps (line 167) | function mergeProps(...sources: any): any {
  function splitProps (line 239) | function splitProps<T>(props: T, ...keys: [(keyof T)[]]) {
  function simpleMap (line 255) | function simpleMap(
  function For (line 270) | function For<T>(props: {
  function Index (line 279) | function Index<T>(props: {
  type RequiredParameter (line 287) | type RequiredParameter<T> = T extends () => unknown ? never : T;
  function Show (line 292) | function Show<T>(props: {
  function Switch (line 306) | function Switch(props: {
  type MatchProps (line 323) | type MatchProps<T> = {
  function Match (line 328) | function Match<T>(props: MatchProps<T>) {
  function resetErrorBoundaries (line 332) | function resetErrorBoundaries() {}
  function ErrorBoundary (line 333) | function ErrorBoundary(props: {
  type Resource (line 367) | interface Resource<T> {
  type SuspenseContextType (line 375) | type SuspenseContextType = {
  type ResourceActions (line 380) | type ResourceActions<T> = { mutate: Setter<T>; refetch: (info?: unknown)...
  type ResourceReturn (line 382) | type ResourceReturn<T> = [Resource<T>, ResourceActions<T>];
  type ResourceSource (line 384) | type ResourceSource<S> = S | false | null | undefined | (() => S | false...
  type ResourceFetcher (line 386) | type ResourceFetcher<S, T> = (k: S, info: ResourceFetcherInfo<T>) => T |...
  type ResourceFetcherInfo (line 388) | type ResourceFetcherInfo<T> = { value: T | undefined; refetching?: unkno...
  type ResourceOptions (line 390) | type ResourceOptions<T> = undefined extends T
  function createResource (line 428) | function createResource<T, S>(
  function lazy (line 548) | function lazy<T extends Component<any>>(
  function suspenseComplete (line 589) | function suspenseComplete(c: SuspenseContextType) {
  function notifySuspense (line 596) | function notifySuspense(contexts: Set<SuspenseContextType>) {
  function enableScheduling (line 606) | function enableScheduling() {}
  function enableHydration (line 608) | function enableHydration() {}
  function startTransition (line 610) | function startTransition(fn: () => any): void {
  function useTransition (line 614) | function useTransition(): [() => boolean, (fn: () => any) => void] {
  type HydrationContext (line 623) | type HydrationContext = {
  function SuspenseList (line 638) | function SuspenseList(props: {
  function Suspense (line 654) | function Suspense(props: { fallback?: string; children: string }) {

FILE: packages/solid/store/src/index.ts
  constant DEV (line 20) | const DEV = IS_DEV ? ({ $NODE, isWrappable, hooks: DevHooks } as const) ...

FILE: packages/solid/store/src/modifiers.ts
  type ReconcileOptions (line 5) | type ReconcileOptions = {
  function applyState (line 10) | function applyState(
  function reconcile (line 129) | function reconcile<T extends U, U>(
  method get (line 144) | get(target, property): any {
  method set (line 154) | set(target, property, value) {
  method deleteProperty (line 159) | deleteProperty(target, property) {
  function produce (line 166) | function produce<T>(fn: (state: T) => void): (state: T) => T {

FILE: packages/solid/store/src/mutable.ts
  function proxyDescriptor (line 17) | function proxyDescriptor(target: StoreNode, property: PropertyKey) {
  method get (line 38) | get(target, property, receiver) {
  method has (line 63) | has(target, property) {
  method set (line 77) | set(target, property, value) {
  method deleteProperty (line 82) | deleteProperty(target, property) {
  function wrap (line 92) | function wrap<T extends StoreNode>(value: T): T {
  function createMutable (line 139) | function createMutable<T extends StoreNode>(state: T, options?: { name?:...
  function modifyMutable (line 151) | function modifyMutable<T>(state: T, modifier: (state: T) => T) {

FILE: packages/solid/store/src/server.ts
  function isWrappable (line 19) | function isWrappable(obj: any) {
  function unwrap (line 27) | function unwrap<T>(item: T): T {
  function setProperty (line 31) | function setProperty(state: any, property: PropertyKey, value: any, forc...
  function mergeStoreNode (line 38) | function mergeStoreNode(state: any, value: any, force?: boolean) {
  function updateArray (line 46) | function updateArray(
  function updatePath (line 63) | function updatePath(current: any, path: any[], traversed: PropertyKey[] ...
  function createStore (line 108) | function createStore<T>(state: T | Store<T>): [Store<T>, SetStoreFunctio...
  function createMutable (line 116) | function createMutable<T>(state: T | Store<T>): T {
  function modifyMutable (line 120) | function modifyMutable<T>(state: T, modifier: (state: T) => T) {
  type ReconcileOptions (line 124) | type ReconcileOptions = {
  function reconcile (line 130) | function reconcile<T extends U, U extends object>(
  function produce (line 150) | function produce<T>(fn: (state: T) => void): (state: T) => T {
  constant DEV (line 157) | const DEV = undefined;

FILE: packages/solid/store/src/store.ts
  constant IS_DEV (line 4) | const IS_DEV = "_SOLID_DEV_" as string | boolean;
  type DataNode (line 16) | type DataNode = {
  type DataNodes (line 20) | type DataNodes = Record<PropertyKey, DataNode | undefined>;
  type OnStoreNodeUpdate (line 22) | type OnStoreNodeUpdate = (
  type StoreNode (line 29) | interface StoreNode {
  type Unwrappable (line 35) | interface Unwrappable {}
  type NotWrappable (line 37) | type NotWrappable =
  type Store (line 47) | type Store<T> = T;
  function wrap (line 49) | function wrap<T extends StoreNode>(value: T): T {
  function isWrappable (line 71) | function isWrappable(obj: any) {
  function unwrap (line 95) | function unwrap<T>(item: any, set = new Set()): T {
  function getNodes (line 122) | function getNodes(target: StoreNode, symbol: typeof $NODE | typeof $HAS)...
  function getNode (line 129) | function getNode(nodes: DataNodes, property: PropertyKey, value?: any) {
  function proxyDescriptor (line 139) | function proxyDescriptor(target: StoreNode, property: PropertyKey) {
  function trackSelf (line 149) | function trackSelf(target: StoreNode) {
  function ownKeys (line 153) | function ownKeys(target: StoreNode) {
  method get (line 159) | get(target, property, receiver) {
  method has (line 183) | has(target, property) {
  method set (line 197) | set() {
  method deleteProperty (line 202) | deleteProperty() {
  function setProperty (line 212) | function setProperty(
  function mergeStoreNode (line 243) | function mergeStoreNode(state: StoreNode, value: Partial<StoreNode>) {
  function updateArray (line 251) | function updateArray(
  function updatePath (line 269) | function updatePath(current: StoreNode, path: any[], traversed: Property...
  type DeepReadonly (line 316) | type DeepReadonly<T> = 0 extends 1 & T
  type DeepMutable (line 324) | type DeepMutable<T> = 0 extends 1 & T
  type CustomPartial (line 332) | type CustomPartial<T> = T extends readonly unknown[]
  type PickMutable (line 338) | type PickMutable<T> = {
  type StorePathRange (line 348) | type StorePathRange = { from?: number; to?: number; by?: number };
  type ArrayFilterFn (line 350) | type ArrayFilterFn<T> = (item: T, index: number) => boolean;
  type StoreSetter (line 352) | type StoreSetter<T, U extends PropertyKey[] = []> =
  type Part (line 357) | type Part<T, K extends KeyOf<T> = KeyOf<T>> =
  type W (line 363) | type W<T> = Exclude<T, NotWrappable>;
  type KeyOf (line 366) | type KeyOf<T> = number extends keyof T // have to check this otherwise t...
  type MutableKeyOf (line 377) | type MutableKeyOf<T> = KeyOf<T> & keyof PickMutable<T>;
  type Rest (line 380) | type Rest<T, U extends PropertyKey[], K extends KeyOf<T> = KeyOf<T>> = [...
  type RestContinue (line 388) | type RestContinue<T, U extends PropertyKey[]> = 0 extends 1 & T
  type RestSetterOrContinue (line 392) | type RestSetterOrContinue<T, U extends PropertyKey[]> = [StoreSetter<T, ...
  type SetStoreFunction (line 394) | interface SetStoreFunction<T> {
  function createStore (line 501) | function createStore<T extends object = {}>(

FILE: packages/solid/store/test/modifiers.spec.ts
  type DataState (line 171) | interface DataState {
  type TodoState (line 243) | interface TodoState {
  type TodoState (line 264) | type TodoState = Array<{

FILE: packages/solid/store/test/mutable.spec.ts
  method greeting (line 34) | get greeting(): string {
  method fullName (line 50) | get fullName(): string {
  method fullName (line 53) | set fullName(value) {
  method b (line 282) | get b() {

FILE: packages/solid/store/test/mutableWithClass.spec.tsx
  class D (line 7) | class D {
    method e (line 9) | get e() {
  class A (line 13) | class A {
    method b (line 15) | get b() {
    method getVal (line 60) | get getVal() {
  class A (line 58) | class A {
    method b (line 15) | get b() {
    method getVal (line 60) | get getVal() {
  class B (line 64) | class B extends A {}

FILE: packages/solid/store/test/store.spec.ts
  method greeting (line 46) | get greeting(): string {
  method greeting (line 62) | get greeting(): string {
  class CustomThing (line 697) | class CustomThing {
    method constructor (line 700) | constructor(value: number) {
    method constructor (line 729) | constructor(value: number) {
  class CustomThing (line 726) | class CustomThing {
    method constructor (line 700) | constructor(value: number) {
    method constructor (line 729) | constructor(value: number) {
  method b (line 758) | get b() {
  type Recursive (line 956) | type Recursive = { a: Recursive };
  type User (line 966) | type User = {
  type A (line 1014) | type A = { a: T; b: Record<string, string>; c: Record<T, string> };

FILE: packages/solid/test/component.bench.ts
  method get (line 13) | get() {
  type Test (line 39) | type Test = {
  function createTest (line 44) | function createTest<T extends (...args: any[]) => any, G extends (...arg...
  type SplitProps (line 80) | type SplitProps = (...args: any[]) => Record<string, any>[];
  method get (line 90) | get(target, property) {
  method has (line 94) | has(target, property) {
  method ownKeys (line 98) | ownKeys(target) {

FILE: packages/solid/test/component.spec.ts
  type SimplePropTypes (line 14) | type SimplePropTypes = {
  method name (line 35) | get name() {
  method a (line 56) | get a() {
  method value (line 71) | get value() {
  method value (line 76) | get value() {
  method a (line 89) | get a() {
  method value2 (line 110) | get value2() {
  method value3 (line 138) | get value3() {
  method a (line 151) | get a() {
  method b (line 156) | get b() {
  method b (line 181) | get b() {
  method b (line 191) | get b() {
  method a (line 235) | get a() {
  method a (line 254) | get a() {
  method a (line 290) | get a() {
  method name (line 330) | get name() {
  method get (line 356) | get() {
  method c (line 424) | get c() {
  method w (line 430) | get w() {
  method color (line 471) | get color() {

FILE: packages/solid/test/component.type-tests.ts
  type Assert (line 3) | type Assert<T extends true> = never;
  type IsExact (line 5) | type IsExact<T, U, I = never> =
  type M1 (line 47) | type M1 = typeof m1;
  type TestM1 (line 48) | type TestM1 = Assert<
  type M2 (line 78) | type M2 = typeof m2;
  type TestM2 (line 79) | type TestM2 = Assert<IsExact<M2, { a?: number }>>;
  type M3 (line 83) | type M3 = typeof m3;
  type TestM3 (line 84) | type TestM3 = Assert<IsExact<M3, { a: number }>>;
  type M4Type (line 87) | type M4Type = {
  function M4 (line 91) | function M4<T extends keyof M4Type = "a">(
  type M5 (line 157) | type M5 = typeof m5;
  type TestM5 (line 158) | type TestM5 = Assert<IsExact<M5, { a: number; b: number; c: number }>>;
  type M6 (line 161) | type M6 = typeof m6;
  type TestM6 (line 162) | type TestM6 = Assert<IsExact<M6, { b: number; c: number }>>;
  type M7 (line 165) | type M7 = typeof m7;
  type TestM7 (line 166) | type TestM7 = Assert<IsExact<M7, { a: number; b: number }>>;
  type M8 (line 169) | type M8 = typeof m8;
  type TestM8 (line 170) | type TestM8 = Assert<IsExact<M8, { b: number }>>;
  type M9 (line 173) | type M9 = typeof m9;
  type TestM9 (line 174) | type TestM9 = Assert<IsExact<M9, { a: number; b: number; c: number }>>;
  type S1 (line 179) | type S1 = typeof s1;
  type TestS1 (line 180) | type TestS1 = Assert<IsExact<S1, [{ a: number }, { b: number }]>>;
  type S2 (line 183) | type S2 = typeof s2;
  type TestS2 (line 184) | type TestS2 = Assert<IsExact<S2, { b: number }>>;
  type S3 (line 187) | type S3 = typeof s3;
  type TestS3 (line 188) | type TestS3 = Assert<IsExact<S3, { a: number }>>;

FILE: packages/solid/test/external-source.spec.ts
  class ExternalSource (line 6) | class ExternalSource<T = any> {
    method constructor (line 9) | constructor(private value: T) {}
    method update (line 11) | update(x: T) {
    method get (line 16) | get() {
    method removeListener (line 24) | removeListener(listener: () => void) {
  function untrackSource (line 31) | function untrackSource<T>(fn: () => T) {

FILE: packages/solid/test/observable.spec.ts
  method next (line 47) | next(v) {

FILE: packages/solid/test/resource.spec.ts
  function fetcher (line 23) | function fetcher(id: string) {
  type User (line 80) | interface User {
  function fetcher (line 92) | function fetcher(_: unknown, { value }: ResourceFetcherInfo<Store<User>>) {
  method user (line 106) | get user() {
  method userLoading (line 109) | get userLoading() {
  function fetcher (line 153) | function fetcher(id: string) {
  function fetcher (line 186) | function fetcher(id: string) {
  type User (line 238) | type User = {
  function fetcher (line 251) | function fetcher() {
  function createDeepSignal (line 256) | function createDeepSignal<T>(value: T, options?: ReconcileOptions): Sign...

FILE: packages/solid/test/resource.type-tests.ts
  type Assert (line 4) | type Assert<T extends true> = T;
  type Equals (line 6) | type Equals<X, Y> =
  type Tests (line 17) | type Tests = Assert<Equals<typeof resourceReturn, ResourceReturn<number,...
  type Tests (line 25) | type Tests = Assert<Equals<typeof k, true | undefined>> &
  type Tests (line 38) | type Tests = Assert<
  type Tests (line 49) | type Tests = Assert<Equals<typeof k, true | undefined>> &
  type ResourceActions (line 55) | type ResourceActions = (typeof resourceReturn)[1];
  type Tests (line 56) | type Tests = Assert<Equals<ResourceActions["mutate"], Setter<number>>>;
  type Tests (line 66) | type Tests = Assert<Equals<typeof resourceReturn, ResourceReturn<number,...
  type Tests (line 74) | type Tests = Assert<Equals<typeof k, number | undefined>> &
  type ResourceActions (line 80) | type ResourceActions = (typeof resourceReturn)[1];
  type Tests (line 81) | type Tests = Assert<Equals<ResourceActions["mutate"], Setter<number | un...
  type Tests (line 90) | type Tests = Assert<
  type Tests (line 101) | type Tests = Assert<Equals<typeof k, number | undefined>> &
  type Tests (line 115) | type Tests = Assert<Equals<typeof resourceValue, string | undefined>> &
  type Test (line 139) | type Test = Assert<Equals<typeof errorValue, never>> &
  type Test (line 157) | type Test = Assert<Equals<typeof errorValue, never>> &

FILE: packages/solid/test/signals.memo.spec.ts
  function init (line 206) | function init() {

FILE: packages/solid/test/signals.type-tests.ts
  class Animal (line 14) | class Animal {
  class Dog (line 17) | class Dog extends Animal {
  function createGenericSignal (line 871) | function createGenericSignal<T>(): Signal<T | undefined> {
  function createInitializedSignal (line 877) | function createInitializedSignal<T>(init: T): Signal<T> {
  type KobalteBaseSelectProps (line 883) | interface KobalteBaseSelectProps<Option, OptGroup = never> {
  type KobaltSingleSelectProps (line 887) | interface KobaltSingleSelectProps<T> {
  type KobaltMultiSelectProps (line 893) | interface KobaltMultiSelectProps<T> {
  type KobaltSelectProps (line 899) | type KobaltSelectProps<Option, OptGroup = never> = (
  type fruits (line 905) | type fruits = "apple" | "banana" | "orange";
  function kobalteSelect (line 909) | function kobalteSelect<T>(props: KobaltSelectProps<T>) {}

FILE: packages/solid/universal/src/index.ts
  function createRenderer (line 7) | function createRenderer<NodeType>(options: RendererOptions<NodeType>): R...

FILE: packages/solid/web/server/index.ts
  function createDynamic (line 22) | function createDynamic<T extends ValidComponent>(
  type DynamicProps (line 37) | type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
  function Dynamic (line 43) | function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX....
  function Portal (line 48) | function Portal(props: { mount?: Node; useShadow?: boolean; children: JS...

FILE: packages/solid/web/src/index.ts
  constant SVG_NAMESPACE (line 38) | const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
  function createElement (line 40) | function createElement(tagName: string, isSVG = false, is = undefined): ...
  function Portal (line 58) | function Portal<T extends boolean = false, S extends boolean = false>(pr...
  type DynamicProps (line 113) | type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
  function createDynamic (line 131) | function createDynamic<T extends ValidComponent>(
  function Dynamic (line 168) | function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX....

FILE: packages/solid/web/src/server-mock.ts
  function throwInBrowser (line 2) | function throwInBrowser(func: Function) {
  function renderToString (line 8) | function renderToString<T>(
  function renderToStringAsync (line 17) | function renderToStringAsync<T>(
  function renderToStream (line 27) | function renderToStream<T>(
  function ssr (line 41) | function ssr(template: string[] | string, ...nodes: any[]): { t: string ...
  function ssrElement (line 42) | function ssrElement(
  function ssrClassList (line 48) | function ssrClassList(value: { [k: string]: boolean }): string {}
  function ssrStyle (line 49) | function ssrStyle(value: { [k: string]: string }): string {}
  function ssrAttribute (line 50) | function ssrAttribute(key: string, value: boolean): string {}
  function ssrHydrationKey (line 51) | function ssrHydrationKey(): string {}
  function resolveSSRNode (line 52) | function resolveSSRNode(node: any): string {}
  function escape (line 53) | function escape(html: string): string {}
  function ssrSpread (line 58) | function ssrSpread(props: any, isSVG: boolean, skipChildren: boolean): v...
  type LegacyResults (line 59) | type LegacyResults = {

FILE: packages/solid/web/storage/src/index.ts
  function provideRequestEvent (line 6) | function provideRequestEvent<T extends RequestEvent, U>(init: T, cb: () ...

FILE: packages/solid/web/test/dynamic.spec.tsx
  type ExampleProps (line 13) | interface ExampleProps {
  type ExampleProps (line 61) | interface ExampleProps {

FILE: packages/solid/web/test/element.spec.tsx
  type Directives (line 10) | interface Directives {

FILE: packages/solid/web/test/for.spec.tsx
  function apply (line 22) | function apply(array: string[]) {
  function apply (line 104) | function apply(array: string[]) {
  function apply (line 195) | function apply(array: string[]) {
  function apply (line 279) | function apply(array: string[]) {

FILE: packages/solid/web/test/index.spec.tsx
  function apply (line 22) | function apply(array: string[]) {
  function apply (line 104) | function apply(array: string[]) {
  function apply (line 195) | function apply(array: string[]) {
  function apply (line 286) | function apply(array: string[]) {

FILE: packages/solid/web/test/show.spec.tsx
  function when (line 77) | function when() {
  function when (line 128) | function when() {
  function when (line 179) | function when() {

FILE: packages/solid/web/test/switch.spec.tsx
  function makeCondition (line 213) | function makeCondition() {

FILE: packages/test-integration/test-imports.mjs
  function checkError (line 1) | function checkError(error) {

FILE: packages/test-integration/tests/downloaded.spec.ts
  function makeTestRepo (line 6) | function makeTestRepo(
  type TestRepo (line 17) | type TestRepo = ReturnType<typeof makeTestRepo>;
  function npmInstaller (line 19) | function npmInstaller(dependencies: string[]) {
  function testPackage (line 24) | async function testPackage(testRepo: TestRepo, dependencies: string[], i...
  function pack (line 52) | function pack(packageRoot: string) {
  function packageExists (line 61) | function packageExists(packageRoot: string) {