` is just a div.
+
+## The Gist
+```jsx
+import { render } from "solid-js/dom";
+
+const HelloMessage = props =>
Hello {props.name}
;
+
+render(
+ () =>
,
+ document.getElementById("hello-example")
+);
+```
+
+A Simple Component is just a function that accepts properties. Solid uses a `render` function to create the reactive mount point of your application.
+
+The JSX is then compiled down to efficient real DOM expressions:
+
+```js
+import { render, template, insert, createComponent } from "solid-js/dom";
+
+const _tmpl$ = template(`
Hello
`);
+
+const HelloMessage = props => {
+ const _el$ = _tmpl$.cloneNode(true);
+ insert(_el$, () => props.name, null);
+ return _el$;
+};
+
+render(
+ () => createComponent(HelloMessage, { name: "Taylor" }),
+ document.getElementById("hello-example")
+);
+```
+
+That `_el$` is a real div element and `props.name`, `Taylor` in this case, is appended to it's child nodes. Notice that `props.name` is wrapped in a function. That is because that is the only part of this component that will ever execute again. Even if a name is updated from the outside only that one expression will be re-evaluated. The compiler optimizes initial render and the runtime optimizes updates. It's the best of both worlds.
+
+## Installation
+
+You can get started with a simple app with the CLI with by running:
+
+```sh
+> npm init solid app my-app
+```
+
+Use `app-ts` for a TypeScript starter.
+
+_`npm init solid
` is available with npm 6+._
+
+Or you can install the dependencies in your own project. To use Solid with JSX (recommended) run:
+
+```sh
+> npm install solid-js babel-preset-solid
+```
+
+## Solid State
+
+Solid's data management is built off a set of flexible reactive primitives. Similar to React Hooks except instead of whitelisting change for an owning Component they independentally are soley responsible for all the updates.
+
+Solid's State primitive is arguably its most powerful and distinctive one. Through the use of proxies and explicit setters it gives the control of an immutable interface and the performance of a mutable one. The setters support a variety of forms, but to get started set and update state with an object.
+
+```jsx
+import { createState, onCleanup } from "solid-js";
+
+const CountingComponent = () => {
+ const [state, setState] = createState({ counter: 0 });
+
+ const interval = setInterval(
+ () => setState({ counter: state.counter + 1 }),
+ 1000
+ );
+
+ onCleanup(() => clearInterval(interval));
+
+ return {state.counter}
;
+};
+```
+
+Where the magic happens is with computations(effects and memos) which automatically track dependencies.
+
+```js
+const [state, setState] = createState({ user: { firstName: "Jake", lastName: "Smith" }})
+
+createEffect(() =>
+ setState({
+ displayName: `${state.user.firstName} ${state.user.lastName}`
+ })
+);
+
+console.log(state.displayName); // Jake Smith
+setState('user', {firstName: "Jacob" });
+console.log(state.displayName); // Jacob Smith
+```
+
+Whenever any dependency changes the State value will update immediately. Each `setState` statement will notify subscribers synchronously with all changes applied. This means you can depend on the value being set on the next line.
+
+Solid State also exposes a reconcile method used with `setState` that does deep diffing to allow for automatic efficient interopt with immutable store technologies like Redux, Apollo(GraphQL), or RxJS.
+
+```js
+const unsubscribe = store.subscribe(({ todos }) => (
+ setState('todos', reconcile(todos)));
+);
+onCleanup(() => unsubscribe());
+```
+
+## Solid Rendering
+
+Solid's rendering is done by the [DOM Expressions](https://github.com/ryansolid/dom-expressions) library. This library provides a generic optimized runtime for fine grained libraries like Solid with the opportunity to use a number of different Rendering APIs. The best option is to use JSX pre-compilation with [Babel Plugin JSX DOM Expressions](https://github.com/ryansolid/babel-plugin-jsx-dom-expressions) to give the smallest code size, cleanest syntax, and most performant code. The compiler converts JSX to native DOM element instructions and wraps dynamic expressions in reactive computations.
+
+The easiest way to get setup is add `babel-preset-solid` to your .babelrc, or babel config for webpack, or rollup:
+
+```js
+"presets": ["solid"]
+```
+
+Remember even though the syntax is almost identical, there are significant differences between how Solid's JSX works and a library like React. Refer to [JSX Rendering](../master/documentation/rendering.md) for more information.
+
+Alternatively in non-compiled environments you can use Tagged Template Literals [Lit DOM Expressions](https://github.com/ryansolid/lit-dom-expressions) or even HyperScript with [Hyper DOM Expressions](https://github.com/ryansolid/hyper-dom-expressions).
+
+For convenience Solid exports interfaces to runtimes for these as:
+
+```js
+import h from "solid-js/h";
+import html from "solid-js/html";
+```
+
+Remember you still need to install the library separately for these to work.
+
+## Documentation
+
+- [State](https://github.com/ryansolid/solid/blob/master/documentation/state.md)
+- [Signals](https://github.com/ryansolid/solid/blob/master/documentation/signals.md)
+- [JSX Rendering](https://github.com/ryansolid/solid/blob/master/documentation/rendering.md)
+- [Components](https://github.com/ryansolid/solid/blob/master/documentation/components.md)
+- [Context](https://github.com/ryansolid/solid/blob/master/documentation/context.md)
+- [Suspense](https://github.com/ryansolid/solid/blob/master/documentation/suspense.md)
+- [API](https://github.com/ryansolid/solid/blob/master/documentation/api.md)
+- [Comparison with other Libraries](https://github.com/ryansolid/solid/blob/master/documentation/comparison.md)
+- [Storybook](https://github.com/ryansolid/solid/blob/master/documentation/storybook.md)
+
+## Examples
+
+- [Counter](https://codesandbox.io/s/8no2n9k94l) Simple Counter
+- [Simple Todos](https://codesandbox.io/s/lrm786ojqz) Todos with LocalStorage persistence
+- [Simple Routing](https://codesandbox.io/s/jjp8m8nlz5) Use 'switch' control flow for simple routing
+- [Scoreboard](https://codesandbox.io/s/solid-scoreboard-sjpje) Make use of hooks to do some simple transitions
+- [Form Validation](https://codesandbox.io/s/solid-form-validation-2cdti) HTML 5 validators with custom async validation
+- [Styled Components](https://codesandbox.io/s/solid-emotion-slz4d) A simple example of creating Styled Components with Emotion JS.
+- [Counter Context](https://codesandbox.io/s/counter-context-gur76) Implement a global store with Context API
+- [Async Resource](https://codesandbox.io/s/2o4wmxj9zy) Ajax requests to SWAPI with Promise cancellation
+- [Suspense](https://codesandbox.io/s/5v67oym224) Various Async loading with Solid's Suspend control flow
+- [Suspense Tabs](https://codesandbox.io/s/solid-suspense-tabs-vkgpj) Defered loading spinners for smooth UX.
+- [SuspenseList](https://codesandbox.io/s/solid-suspenselist-eorvk) Orchestrating multiple Suspense Components.
+- [Redux Undoable Todos](https://codesandbox.io/s/pkjw38r8mj) Example from Redux site done with Solid.
+- [Simple Todos Template Literals](https://codesandbox.io/s/jpm68z1q33) Simple Todos using Lit DOM Expressions
+- [Simple Todos HyperScript](https://codesandbox.io/s/0vmjlmq94v) Simple Todos using Hyper DOM Expressions
+- [TodoMVC](https://github.com/ryansolid/solid-todomvc) Classic TodoMVC example
+- [Hacker News App](https://github.com/ryansolid/solid-hackernews-app) Small application to showcase Solid and Solid Element
+- [WebComponent Todos](https://github.com/shprink/web-components-todo/tree/master/solid) Showing off Solid Element
+- [JS Framework Benchmark](https://github.com/krausest/js-framework-benchmark/tree/master/frameworks/keyed/solid) The one and only
+- [UIBench Benchmark](https://github.com/ryansolid/solid-uibench) a benchmark tests a variety of UI scenarios.
+- [DBMon Benchmark](https://github.com/ryansolid/solid-dbmon) A benchmark testing ability of libraries to render unoptimized data.
+- [Sierpinski's Triangle Demo](https://github.com/ryansolid/solid-sierpinski-triangle-demo) Solid implementation of the React Fiber demo.
+
+## Related Projects
+
+- [Solid Element](https://github.com/ryansolid/solid/blob/master/packages/solid-element)
+ Extensions to Solid.js that add a Web Component wrapper.
+- [Solid RX](https://github.com/ryansolid/solid/blob/master/packages/solid-rx)
+ Functional Reactive Programming extensions to Solid.js.
+- [DOM Expressions](https://github.com/ryansolid/dom-expressions)
+ The renderer behind Solid.js that enables lightning fast fine grained performance.
+- [Babel Plugin JSX DOM Expressions](https://github.com/ryansolid/babel-plugin-jsx-dom-expressions)
+ Babel plugin that converts JSX to DOM Expressions.
+- [Lit DOM Expressions](https://github.com/ryansolid/lit-dom-expressions)
+ Tagged Template Literal API for DOM Expressions.
+- [Hyper DOM Expressions](https://github.com/ryansolid/hyper-dom-expressions)
+ HyperScript API for DOM Expressions.
+- [Solid Hot Loader](https://github.com/ryansolid/solid-hot-loader)
+ Webpack Loader for HMR for Solid Components.
+- [React Solid State](https://github.com/ryansolid/solid/blob/master/packages/react-solid-state)
+ React Hooks API to use Solid.js paradigm in your existing React apps.
+
+## Articles
+
+- [Designing SolidJS: Suspense](https://itnext.io/designing-solidjs-suspense-f4e92c625cb5?source=friends_link&sk=f06f93d28632daba59048ed3d6d6b0a5) React isn't the only library that stops time.
+- [Designing SolidJS: JSX](https://medium.com/@ryansolid/designing-solidjs-jsx-50ee2b791d4c?source=friends_link&sk=ef3d7ada15b50a6b5b7f5aee2cb8f952) How is it that the syntax born of the Virtual DOM is also secretly the best syntax for Reactive UI libraries?
+- [Designing SolidJS: Immutability](https://medium.com/javascript-in-plain-english/designing-solidjs-immutability-f1e46fe9f321?source=friends_link&sk=912e32c63353ff0e084630bf3b63a8b1) Can Reactive State Management be both Immutable and also the most performant?
+- [Designing SolidJS: Components](https://medium.com/@ryansolid/designing-solidjs-components-8f1ebb88d78b?source=friends_link&sk=cac89d1679d8be2c7bf2b303fabd153c) Exploring Solid's "Vanishing" Components
+- [Designing SolidJS: Reactivity](https://medium.com/@ryansolid/designing-solidjs-reactivity-75180a4c74b4?source=friends_link&sk=dbb9dd46a2e902c199ad3d5c7aeb1566) Finding the right reactivity model for Solid.
+- [Designing SolidJS: Dualities](https://medium.com/@ryansolid/designing-solidjs-dualities-69ee4c08aa03?source=friends_link&sk=161ddd70db4fca50d6f33b6d53056d36) How exploring opposites can help us redefine the whole problem space.
+- [How we wrote the Fastest JavaScript UI Frameworks](https://medium.com/@ryansolid/how-we-wrote-the-fastest-javascript-ui-frameworks-a96f2636431e) How Solid topped the JS Framework Benchmark.
+- [Finding Fine Grained Reactive Programming](https://levelup.gitconnected.com/finding-fine-grained-reactive-programming-89741994ddee?source=friends_link&sk=31c66a70c1dce7dd5f3f4229423ad127) Introduction to the inner workings of Solid's Reactive system.
+- [The Real Cost of UI Components](https://medium.com/better-programming/the-real-cost-of-ui-components-6d2da4aba205?source=friends_link&sk=a412aa18825c8424870d72a556db2169) Comparison of the cost of Components in different UI Libraries.
+- [The Fastest Way to Render the DOM](https://medium.com/@ryansolid/the-fastest-way-to-render-the-dom-e3b226b15ca3?source=friends_link&sk=5ae1688dde789e46cecf5c976e708da5) Comparison of all Solid Renderers against the Fastest Libraries in the World.
+- [JavaScript UI Compilers: Comparing Svelte and Solid](https://medium.com/@ryansolid/javascript-ui-compilers-comparing-svelte-and-solid-cbcba2120cea) A closer look at precompiled UI libraries
+- [Building a Simple JavaScript App with Solid](https://levelup.gitconnected.com/building-a-simple-javascript-app-with-solid-ff17c8836409) Dissecting building TodoMVC with Solid.
+- [Solid — The Best JavaScript UI Library You’ve Never Heard Of](https://levelup.gitconnected.com/solid-the-best-javascript-ui-library-youve-never-heard-of-297b22848ac1?source=friends_link&sk=d61fc9352b4a98c6c9f5f6bd2077a722)
+- [What Every JavaScript Framework Could Learn from React](https://medium.com/@ryansolid/what-every-javascript-framework-could-learn-from-react-1e2bbd9feb09?source=friends_link&sk=75b3f6f90eecc7d210814baa2d5ab52c) The lessons Solid learned from React.
+- [React Hooks: Has React Jumped the Shark?](https://medium.com/js-dojo/react-hooks-has-react-jumped-the-shark-c8cf04e246cf?source=friends_link&sk=a5017cca813ea970b480cc44afb32034) Comparison of React Hooks to Solid.
+- [How I wrote the Fastest JavaScript UI Framework](https://medium.com/@ryansolid/how-i-wrote-the-fastest-javascript-ui-framework-37525b42d6c9?source=friends_link&sk=8eb9387a535a306d1eb96f7ce88c4db5) The key to Solid's performance.
+- [Part 5: JS Frameworks in 2019](https://medium.com/@ryansolid/b-y-o-f-part-5-js-frameworks-in-2019-deb9c4d3e74)
+- [Part 4: Rendering the DOM](https://medium.com/@ryansolid/b-y-o-f-part-4-rendering-the-dom-753657689647)
+- [Part 3: Change Management in JavaScript Frameworks](https://medium.com/@ryansolid/b-y-o-f-part-3-change-management-in-javascript-frameworks-6af6e436f63c)
+- [Part 2: Web Components as Containers](https://medium.com/@ryansolid/b-y-o-f-part-2-web-components-as-containers-85e04a7d96e9)
+- [Part 1: Writing a JS Framework in 2018](https://medium.com/@ryansolid/b-y-o-f-part-1-writing-a-js-framework-in-2018-b02a41026929)
+
+## Status
+
+Solid is mostly feature complete for its v1.0.0 release. The next releases will be mostly bug fixes API tweaks on the road to stability.
\ No newline at end of file
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/h.js b/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/h.js
new file mode 100644
index 0000000000..bab7430be1
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/h.js
@@ -0,0 +1,12 @@
+import { createHyperScript } from 'hyper-dom-expressions';
+import { wrap, insert, createComponent, delegateEvents, classList } from './index.js';
+
+var h = createHyperScript({
+ wrap,
+ insert,
+ createComponent,
+ delegateEvents,
+ classList
+});
+
+export default h;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/html.js b/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/html.js
new file mode 100644
index 0000000000..4e6ea5e121
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/html.js
@@ -0,0 +1,12 @@
+import { createHTML } from 'lit-dom-expressions';
+import { wrap, insert, createComponent, delegateEvents, classList } from './index.js';
+
+var html = createHTML({
+ wrap,
+ insert,
+ createComponent,
+ delegateEvents,
+ classList
+});
+
+export default html;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/index.js b/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/index.js
new file mode 100644
index 0000000000..2e6f47b7f0
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/dist/dom/index.js
@@ -0,0 +1,913 @@
+import { sample, createEffect, runtimeConfig, createContext, useContext, createSignal, equalFn, SuspenseContext, createRoot, createMemo, awaitSuspense, mapArray, onCleanup } from '../index.js';
+export { getContextOwner as currentContext, createEffect as wrap, createMemo as wrapMemo } from '../index.js';
+
+const Types = {
+ ATTRIBUTE: "attribute",
+ PROPERTY: "property"
+},
+ Attributes = {
+ href: {
+ type: Types.ATTRIBUTE
+ },
+ style: {
+ type: Types.PROPERTY,
+ alias: "style.cssText"
+ },
+ for: {
+ type: Types.PROPERTY,
+ alias: "htmlFor"
+ },
+ class: {
+ type: Types.PROPERTY,
+ alias: "className"
+ },
+ spellCheck: {
+ type: Types.PROPERTY,
+ alias: "spellcheck"
+ },
+ allowFullScreen: {
+ type: Types.PROPERTY,
+ alias: "allowFullscreen"
+ },
+ autoCapitalize: {
+ type: Types.PROPERTY,
+ alias: "autocapitalize"
+ },
+ autoFocus: {
+ type: Types.PROPERTY,
+ alias: "autofocus"
+ },
+ autoPlay: {
+ type: Types.PROPERTY,
+ alias: "autoplay"
+ }
+},
+ SVGAttributes = {
+ className: {
+ type: Types.ATTRIBUTE,
+ alias: "class"
+ },
+ htmlFor: {
+ type: Types.ATTRIBUTE,
+ alias: "for"
+ },
+ tabIndex: {
+ type: Types.ATTRIBUTE,
+ alias: "tabindex"
+ },
+ allowReorder: {
+ type: Types.ATTRIBUTE
+ },
+ attributeName: {
+ type: Types.ATTRIBUTE
+ },
+ attributeType: {
+ type: Types.ATTRIBUTE
+ },
+ autoReverse: {
+ type: Types.ATTRIBUTE
+ },
+ baseFrequency: {
+ type: Types.ATTRIBUTE
+ },
+ calcMode: {
+ type: Types.ATTRIBUTE
+ },
+ clipPathUnits: {
+ type: Types.ATTRIBUTE
+ },
+ contentScriptType: {
+ type: Types.ATTRIBUTE
+ },
+ contentStyleType: {
+ type: Types.ATTRIBUTE
+ },
+ diffuseConstant: {
+ type: Types.ATTRIBUTE
+ },
+ edgeMode: {
+ type: Types.ATTRIBUTE
+ },
+ externalResourcesRequired: {
+ type: Types.ATTRIBUTE
+ },
+ filterRes: {
+ type: Types.ATTRIBUTE
+ },
+ filterUnits: {
+ type: Types.ATTRIBUTE
+ },
+ gradientTransform: {
+ type: Types.ATTRIBUTE
+ },
+ gradientUnits: {
+ type: Types.ATTRIBUTE
+ },
+ kernelMatrix: {
+ type: Types.ATTRIBUTE
+ },
+ kernelUnitLength: {
+ type: Types.ATTRIBUTE
+ },
+ keyPoints: {
+ type: Types.ATTRIBUTE
+ },
+ keySplines: {
+ type: Types.ATTRIBUTE
+ },
+ keyTimes: {
+ type: Types.ATTRIBUTE
+ },
+ lengthAdjust: {
+ type: Types.ATTRIBUTE
+ },
+ limitingConeAngle: {
+ type: Types.ATTRIBUTE
+ },
+ markerHeight: {
+ type: Types.ATTRIBUTE
+ },
+ markerUnits: {
+ type: Types.ATTRIBUTE
+ },
+ maskContentUnits: {
+ type: Types.ATTRIBUTE
+ },
+ maskUnits: {
+ type: Types.ATTRIBUTE
+ },
+ numOctaves: {
+ type: Types.ATTRIBUTE
+ },
+ pathLength: {
+ type: Types.ATTRIBUTE
+ },
+ patternContentUnits: {
+ type: Types.ATTRIBUTE
+ },
+ patternTransform: {
+ type: Types.ATTRIBUTE
+ },
+ patternUnits: {
+ type: Types.ATTRIBUTE
+ },
+ pointsAtX: {
+ type: Types.ATTRIBUTE
+ },
+ pointsAtY: {
+ type: Types.ATTRIBUTE
+ },
+ pointsAtZ: {
+ type: Types.ATTRIBUTE
+ },
+ preserveAlpha: {
+ type: Types.ATTRIBUTE
+ },
+ preserveAspectRatio: {
+ type: Types.ATTRIBUTE
+ },
+ primitiveUnits: {
+ type: Types.ATTRIBUTE
+ },
+ refX: {
+ type: Types.ATTRIBUTE
+ },
+ refY: {
+ type: Types.ATTRIBUTE
+ },
+ repeatCount: {
+ type: Types.ATTRIBUTE
+ },
+ repeatDur: {
+ type: Types.ATTRIBUTE
+ },
+ requiredExtensions: {
+ type: Types.ATTRIBUTE
+ },
+ requiredFeatures: {
+ type: Types.ATTRIBUTE
+ },
+ specularConstant: {
+ type: Types.ATTRIBUTE
+ },
+ specularExponent: {
+ type: Types.ATTRIBUTE
+ },
+ spreadMethod: {
+ type: Types.ATTRIBUTE
+ },
+ startOffset: {
+ type: Types.ATTRIBUTE
+ },
+ stdDeviation: {
+ type: Types.ATTRIBUTE
+ },
+ stitchTiles: {
+ type: Types.ATTRIBUTE
+ },
+ surfaceScale: {
+ type: Types.ATTRIBUTE
+ },
+ systemLanguage: {
+ type: Types.ATTRIBUTE
+ },
+ tableValues: {
+ type: Types.ATTRIBUTE
+ },
+ targetX: {
+ type: Types.ATTRIBUTE
+ },
+ targetY: {
+ type: Types.ATTRIBUTE
+ },
+ textLength: {
+ type: Types.ATTRIBUTE
+ },
+ viewBox: {
+ type: Types.ATTRIBUTE
+ },
+ viewTarget: {
+ type: Types.ATTRIBUTE
+ },
+ xChannelSelector: {
+ type: Types.ATTRIBUTE
+ },
+ yChannelSelector: {
+ type: Types.ATTRIBUTE
+ },
+ zoomAndPan: {
+ type: Types.ATTRIBUTE
+ }
+};
+const NonComposedEvents = new Set(["abort", "animationstart", "animationend", "animationiteration", "blur", "change", "copy", "cut", "error", "focus", "load", "loadend", "loadstart", "mouseenter", "mouseleave", "paste", "progress", "reset", "select", "submit", "transitionstart", "transitioncancel", "transitionend", "transitionrun"]);
+
+const eventRegistry = new Set();
+const config = runtimeConfig;
+function template(html, isSVG) {
+ const t = document.createElement('template');
+ t.innerHTML = html;
+ if (t.innerHTML !== html) throw new Error(`Template html does not match input:\n${t.innerHTML}\n${html}`);
+ let node = t.content.firstChild;
+ if (isSVG) node = node.firstChild;
+ return node;
+}
+function createComponent(Comp, props, dynamicKeys) {
+ if (dynamicKeys) {
+ for (let i = 0; i < dynamicKeys.length; i++) dynamicProp(props, dynamicKeys[i]);
+ }
+ return sample(() => Comp(props));
+}
+function delegateEvents(eventNames) {
+ for (let i = 0, l = eventNames.length; i < l; i++) {
+ const name = eventNames[i];
+ if (!eventRegistry.has(name)) {
+ eventRegistry.add(name);
+ document.addEventListener(name, eventHandler);
+ }
+ }
+}
+function clearDelegatedEvents() {
+ for (let name of eventRegistry.keys()) document.removeEventListener(name, eventHandler);
+ eventRegistry.clear();
+}
+function classList(node, value, prev) {
+ const classKeys = Object.keys(value);
+ for (let i = 0, len = classKeys.length; i < len; i++) {
+ const key = classKeys[i],
+ classValue = value[key],
+ classNames = key.split(/\s+/);
+ if (prev && prev[key] === classValue) continue;
+ for (let j = 0, nameLen = classNames.length; j < nameLen; j++) node.classList.toggle(classNames[j], classValue);
+ }
+}
+function spread(node, accessor, isSVG, skipChildren) {
+ if (typeof accessor === 'function') {
+ createEffect(current => spreadExpression(node, accessor(), current, isSVG, skipChildren));
+ } else spreadExpression(node, accessor, undefined, isSVG, skipChildren);
+}
+function insert(parent, accessor, marker, initial) {
+ if (marker !== undefined && !initial) initial = [];
+ if (typeof accessor !== 'function') return insertExpression(parent, accessor, initial, marker);
+ createEffect(current => insertExpression(parent, accessor(), current, marker), initial);
+}
+function renderToString(code, options = {}) {
+ options = {
+ timeoutMs: 10000,
+ ...options
+ };
+ config.hydrate = {
+ id: '',
+ count: 0
+ };
+ const container = document.createElement("div");
+ return new Promise(resolve => {
+ setTimeout(() => resolve(container.innerHTML), options.timeoutMs);
+ if (!code.length) {
+ insert(container, code());
+ resolve(container.innerHTML);
+ } else insert(container, code(() => resolve(container.innerHTML)));
+ });
+}
+function hydrate(code, root) {
+ config.hydrate = {
+ id: '',
+ count: 0,
+ registry: new Map()
+ };
+ const templates = root.querySelectorAll(`*[_hk]`);
+ for (let i = 0; i < templates.length; i++) {
+ const node = templates[i];
+ config.hydrate.registry.set(node.getAttribute('_hk'), node);
+ }
+ code();
+ delete config.hydrate;
+}
+function getNextElement(template, isSSR) {
+ const hydrate = config.hydrate;
+ let node, key;
+ if (!hydrate || !hydrate.registry || !(node = hydrate.registry.get(key = `${hydrate.id}:${hydrate.count++}`))) {
+ const el = template.cloneNode(true);
+ if (isSSR && hydrate) el.setAttribute('_hk', `${hydrate.id}:${hydrate.count++}`);
+ return el;
+ }
+ if (window && window._$HYDRATION) window._$HYDRATION.completed.add(key);
+ return node;
+}
+function getNextMarker(start) {
+ let end = start,
+ count = 0,
+ current = [];
+ if (config.hydrate && config.hydrate.registry) {
+ while (end) {
+ if (end.nodeType === 8) {
+ const v = end.nodeValue;
+ if (v === "#") count++;else if (v === "/") {
+ if (count === 0) return [end, current];
+ count--;
+ }
+ }
+ current.push(end);
+ end = end.nextSibling;
+ }
+ }
+ return [end, current];
+}
+function runHydrationEvents(id) {
+ if (window && window._$HYDRATION) {
+ const {
+ completed,
+ events
+ } = window._$HYDRATION;
+ while (events.length) {
+ const [id, e] = events[0];
+ if (!completed.has(id)) return;
+ eventHandler(e);
+ events.shift();
+ }
+ }
+}
+function generateHydrationEventsScript(eventNames) {
+ return `!function(){function t(t){const e=function t(e){return e&&(e.getAttribute("_hk")||t(e.host&&e.host instanceof Node?e.host:e.parentNode))}(t.composedPath&&t.composedPath()[0]||t.target);e&&!window._$HYDRATION.completed.has(e)&&window._$HYDRATION.events.push([e,t])}window._$HYDRATION={events:[],completed:new Set},["${eventNames.join('","')}"].forEach(e=>document.addEventListener(e,t))}();`;
+}
+function dynamicProp(props, key) {
+ const src = props[key];
+ Object.defineProperty(props, key, {
+ get() {
+ return src();
+ },
+ enumerable: true
+ });
+}
+function lookup(el) {
+ return el && (el.model || lookup(el.host || el.parentNode));
+}
+function eventHandler(e) {
+ const key = `__${e.type}`;
+ let node = e.composedPath && e.composedPath()[0] || e.target;
+ if (e.target !== node) {
+ Object.defineProperty(e, 'target', {
+ configurable: true,
+ value: node
+ });
+ }
+ Object.defineProperty(e, 'currentTarget', {
+ configurable: true,
+ get() {
+ return node;
+ }
+ });
+ while (node !== null) {
+ const handler = node[key];
+ if (handler) {
+ const model = handler.length > 1 ? lookup(node) : undefined;
+ handler(e, model);
+ if (e.cancelBubble) return;
+ }
+ node = node.host && node.host instanceof Node ? node.host : node.parentNode;
+ }
+}
+function spreadExpression(node, props, prevProps = {}, isSVG, skipChildren) {
+ let info;
+ if (!skipChildren && "children" in props) {
+ createEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+ }
+ createEffect(() => {
+ for (const prop in props) {
+ if (prop === "children") continue;
+ const value = props[prop];
+ if (value === prevProps[prop]) continue;
+ if (prop === "style") {
+ Object.assign(node.style, value);
+ } else if (prop === "classList") {
+ classList(node, value, prevProps[prop]);
+ } else if (prop === "ref" || prop === "forwardRef") {
+ value(node);
+ } else if (prop.slice(0, 2) === "on") {
+ const lc = prop.toLowerCase();
+ if (lc !== prop && !NonComposedEvents.has(lc.slice(2))) {
+ const name = lc.slice(2);
+ node[`__${name}`] = value;
+ delegateEvents([name]);
+ } else node[lc] = value;
+ } else if (prop === "events") {
+ for (const eventName in value) node.addEventListener(eventName, value[eventName]);
+ } else if (info = Attributes[prop]) {
+ if (info.type === "attribute") {
+ node.setAttribute(prop, value);
+ } else node[info.alias] = value;
+ } else if (isSVG) {
+ if (info = SVGAttributes[prop]) {
+ if (info.alias) node.setAttribute(info.alias, value);else node.setAttribute(prop, value);
+ } else node.setAttribute(prop.replace(/([A-Z])/g, g => `-${g[0].toLowerCase()}`), value);
+ } else node[prop] = value;
+ prevProps[prop] = value;
+ }
+ });
+ return prevProps;
+}
+function normalizeIncomingArray(normalized, array, unwrap) {
+ let dynamic = false;
+ for (let i = 0, len = array.length; i < len; i++) {
+ let item = array[i],
+ t;
+ if (item instanceof Node) {
+ normalized.push(item);
+ } else if (item == null || item === true || item === false) ; else if (Array.isArray(item)) {
+ dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+ } else if ((t = typeof item) === 'string') {
+ normalized.push(document.createTextNode(item));
+ } else if (t === 'function') {
+ if (unwrap) {
+ const idx = item();
+ dynamic = normalizeIncomingArray(normalized, Array.isArray(idx) ? idx : [idx]) || dynamic;
+ } else {
+ normalized.push(item);
+ dynamic = true;
+ }
+ } else normalized.push(document.createTextNode(item.toString()));
+ }
+ return dynamic;
+}
+function appendNodes(parent, array, marker) {
+ for (let i = 0, len = array.length; i < len; i++) parent.insertBefore(array[i], marker);
+}
+function cleanChildren(parent, current, marker, replacement) {
+ if (marker === undefined) return parent.textContent = '';
+ const node = replacement || document.createTextNode('');
+ if (current.length) {
+ node !== current[0] && parent.replaceChild(node, current[0]);
+ for (let i = current.length - 1; i > 0; i--) parent.removeChild(current[i]);
+ } else parent.insertBefore(node, marker);
+ return [node];
+}
+function insertExpression(parent, value, current, marker, unwrapArray) {
+ while (typeof current === "function") current = current();
+ if (value === current) return current;
+ const t = typeof value,
+ multi = marker !== undefined;
+ parent = multi && current[0] && current[0].parentNode || parent;
+ if (t === 'string' || t === 'number') {
+ if (t === 'number') value = value.toString();
+ if (multi) {
+ let node = current[0];
+ if (node && node.nodeType === 3) {
+ node.data = value;
+ } else node = document.createTextNode(value);
+ current = cleanChildren(parent, current, marker, node);
+ } else {
+ if (current !== '' && typeof current === 'string') {
+ current = parent.firstChild.data = value;
+ } else current = parent.textContent = value;
+ }
+ } else if (value == null || t === 'boolean') {
+ if (config.hydrate && config.hydrate.registry) return current;
+ current = cleanChildren(parent, current, marker);
+ } else if (t === 'function') {
+ createEffect(() => current = insertExpression(parent, value(), current, marker));
+ return () => current;
+ } else if (Array.isArray(value)) {
+ const array = [];
+ if (normalizeIncomingArray(array, value, unwrapArray)) {
+ createEffect(() => current = insertExpression(parent, array, current, marker, true));
+ return () => current;
+ }
+ if (config.hydrate && config.hydrate.registry) return current;
+ if (array.length === 0) {
+ current = cleanChildren(parent, current, marker);
+ if (multi) return current;
+ } else {
+ if (Array.isArray(current)) {
+ if (current.length === 0) {
+ appendNodes(parent, array, marker);
+ } else reconcileArrays(parent, current, array);
+ } else if (current == null || current === '') {
+ appendNodes(parent, array);
+ } else {
+ reconcileArrays(parent, multi && current || [parent.firstChild], array);
+ }
+ }
+ current = array;
+ } else if (value instanceof Node) {
+ if (Array.isArray(current)) {
+ if (multi) return current = cleanChildren(parent, current, marker, value);
+ cleanChildren(parent, current, null, value);
+ } else if (current == null || current === '') {
+ parent.appendChild(value);
+ } else parent.replaceChild(value, parent.firstChild);
+ current = value;
+ }
+ return current;
+}
+var NOMATCH = -1;
+function reconcileArrays(parent, ns, us) {
+ var ulen = us.length,
+ nmin = 0,
+ nmax = ns.length - 1,
+ umin = 0,
+ umax = ulen - 1,
+ n = ns[nmin],
+ u = us[umin],
+ nx = ns[nmax],
+ ux = us[umax],
+ ul = nx.nextSibling,
+ i,
+ loop = true;
+ fixes: while (loop) {
+ loop = false;
+ while (u === n) {
+ umin++;
+ nmin++;
+ if (umin > umax || nmin > nmax) break fixes;
+ u = us[umin];
+ n = ns[nmin];
+ }
+ while (ux === nx) {
+ ul = nx;
+ umax--;
+ nmax--;
+ if (umin > umax || nmin > nmax) break fixes;
+ ux = us[umax];
+ nx = ns[nmax];
+ }
+ while (u === nx) {
+ loop = true;
+ parent.insertBefore(nx, n);
+ umin++;
+ nmax--;
+ if (umin > umax || nmin > nmax) break fixes;
+ u = us[umin];
+ nx = ns[nmax];
+ }
+ while (ux === n) {
+ loop = true;
+ if (ul === null) parent.appendChild(n);else parent.insertBefore(n, ul);
+ ul = n;
+ umax--;
+ nmin++;
+ if (umin > umax || nmin > nmax) break fixes;
+ ux = us[umax];
+ n = ns[nmin];
+ }
+ }
+ if (umin > umax) {
+ while (nmin <= nmax) {
+ parent.removeChild(ns[nmax]);
+ nmax--;
+ }
+ return;
+ }
+ if (nmin > nmax) {
+ while (umin <= umax) {
+ parent.insertBefore(us[umin], ul);
+ umin++;
+ }
+ return;
+ }
+ const P = new Array(umax - umin + 1),
+ I = new Map();
+ for (let i = umin; i <= umax; i++) {
+ P[i] = NOMATCH;
+ I.set(us[i], i);
+ }
+ let reusingNodes = umin + us.length - 1 - umax,
+ toRemove = [];
+ for (let i = nmin; i <= nmax; i++) {
+ if (I.has(ns[i])) {
+ P[I.get(ns[i])] = i;
+ reusingNodes++;
+ } else toRemove.push(i);
+ }
+ if (reusingNodes === 0) {
+ if (n !== parent.firstChild || nx !== parent.lastChild) {
+ for (i = nmin; i <= nmax; i++) parent.removeChild(ns[i]);
+ while (umin <= umax) {
+ parent.insertBefore(us[umin], ul);
+ umin++;
+ }
+ return;
+ }
+ parent.textContent = '';
+ while (umin <= umax) {
+ parent.appendChild(us[umin]);
+ umin++;
+ }
+ return;
+ }
+ var lcs = longestPositiveIncreasingSubsequence(P, umin),
+ nodes = [],
+ tmp = ns[nmin],
+ lisIdx = lcs.length - 1,
+ tmpB;
+ for (let i = nmin; i <= nmax; i++) {
+ nodes[i] = tmp;
+ tmp = tmp.nextSibling;
+ }
+ for (let i = 0; i < toRemove.length; i++) parent.removeChild(nodes[toRemove[i]]);
+ for (let i = umax; i >= umin; i--) {
+ if (lcs[lisIdx] === i) {
+ ul = nodes[P[lcs[lisIdx]]];
+ lisIdx--;
+ } else {
+ tmpB = P[i] === NOMATCH ? us[i] : nodes[P[i]];
+ parent.insertBefore(tmpB, ul);
+ ul = tmpB;
+ }
+ }
+}
+function longestPositiveIncreasingSubsequence(ns, newStart) {
+ let seq = [],
+ is = [],
+ l = -1,
+ pre = new Array(ns.length);
+ for (let i = newStart, len = ns.length; i < len; i++) {
+ let n = ns[i];
+ if (n < 0) continue;
+ let j = findGreatestIndexLEQ(seq, n);
+ if (j !== -1) pre[i] = is[j];
+ if (j === l) {
+ l++;
+ seq[l] = n;
+ is[l] = i;
+ } else if (n < seq[j + 1]) {
+ seq[j + 1] = n;
+ is[j + 1] = i;
+ }
+ }
+ for (let i = is[l]; l >= 0; i = pre[i], l--) {
+ seq[l] = i;
+ }
+ return seq;
+}
+function findGreatestIndexLEQ(seq, n) {
+ var lo = -1,
+ hi = seq.length;
+ if (hi > 0 && seq[hi - 1] <= n) return hi - 1;
+ while (hi - lo > 1) {
+ var mid = Math.floor((lo + hi) / 2);
+ if (seq[mid] > n) {
+ hi = mid;
+ } else {
+ lo = mid;
+ }
+ }
+ return lo;
+}
+
+const SuspenseListContext = createContext();
+function SuspenseList(props) {
+ let index = 0,
+ suspenseSetter,
+ showContent,
+ showFallback;
+ const listContext = useContext(SuspenseListContext);
+ if (listContext) {
+ const [state, stateSetter] = createSignal("running", equalFn);
+ suspenseSetter = stateSetter;
+ [showContent, showFallback] = listContext.register(state);
+ }
+ const registry = [],
+ comp = createComponent(SuspenseListContext.Provider, {
+ value: {
+ register: state => {
+ const [showingContent, showContent] = createSignal(false, equalFn),
+ [showingFallback, showFallback] = createSignal(false, equalFn);
+ registry[index++] = {
+ state,
+ showContent,
+ showFallback
+ };
+ return [showingContent, showingFallback];
+ }
+ },
+ children: () => props.children
+ }, ["children"]);
+ createEffect(() => {
+ const reveal = props.revealOrder,
+ tail = props.tail,
+ visibleContent = showContent ? showContent() : true,
+ visibleFallback = showFallback ? showFallback() : true,
+ reverse = reveal === "backwards";
+ if (reveal === "together") {
+ const all = registry.every(i => i.state() === "running");
+ suspenseSetter && suspenseSetter(all ? "running" : "fallback");
+ registry.forEach(i => {
+ i.showContent(all && visibleContent);
+ i.showFallback(visibleFallback);
+ });
+ return;
+ }
+ let stop = false;
+ for (let i = 0, len = registry.length; i < len; i++) {
+ const n = reverse ? len - i - 1 : i,
+ s = registry[n].state();
+ if (!stop && (s === "running" || s === "suspended")) {
+ registry[n].showContent(visibleContent);
+ registry[n].showFallback(visibleFallback);
+ } else {
+ const next = !stop;
+ if (next && suspenseSetter) suspenseSetter("fallback");
+ if (!tail || next && tail === "collapsed") {
+ registry[n].showFallback(visibleFallback);
+ } else registry[n].showFallback(false);
+ stop = true;
+ registry[n].showContent(next);
+ }
+ }
+ if (!stop && suspenseSetter) suspenseSetter("running");
+ });
+ return comp;
+}
+function Suspense(props) {
+ let counter = 0,
+ t,
+ state = "running",
+ showContent,
+ showFallback,
+ transition;
+ const [get, next] = createSignal(),
+ store = {
+ increment: () => {
+ if (++counter === 1) {
+ if (!store.initializing) {
+ if (SuspenseContext.transition) {
+ state = "suspended";
+ !transition && (transition = SuspenseContext.transition).increment();
+ t = setTimeout(() => (state = "fallback", next()), SuspenseContext.transition.timeoutMs);
+ } else state = "fallback";
+ next();
+ } else state = "fallback";
+ SuspenseContext.increment();
+ }
+ },
+ decrement: () => {
+ if (--counter === 0) {
+ t && clearTimeout(t);
+ if (state !== "running") {
+ state = "running";
+ transition && transition.decrement();
+ transition = undefined;
+ next();
+ SuspenseContext.decrement();
+ }
+ }
+ },
+ state: () => {
+ get();
+ return state;
+ },
+ initializing: true
+ };
+ const listContext = useContext(SuspenseListContext);
+ if (listContext) [showContent, showFallback] = listContext.register(store.state);
+ return createComponent(SuspenseContext.Provider, {
+ value: store,
+ children: () => {
+ let dispose;
+ const rendered = sample(() => props.children),
+ marker = document.createTextNode(""),
+ doc = document.implementation.createHTMLDocument();
+ Object.defineProperty(doc.body, "host", {
+ get() {
+ return marker && marker.parentNode;
+ }
+ });
+ return () => {
+ const value = store.state(),
+ visibleContent = showContent ? showContent() : true,
+ visibleFallback = showFallback ? showFallback() : true;
+ if (store.initializing) store.initializing = false;
+ dispose && dispose();
+ dispose = null;
+ if (value === "running" && visibleContent || value === "suspended") return [marker, rendered];
+ if (!visibleFallback) return [marker];
+ return [marker, props.fallback];
+ };
+ }
+ }, ["children"]);
+}
+
+function render(code, element) {
+ let disposer;
+ createRoot(dispose => {
+ disposer = dispose;
+ insert(element, code());
+ });
+ return disposer;
+}
+function renderToString$1(code, options) {
+ return createRoot(dispose => renderToString(done => {
+ const rendered = code();
+ createEffect(() => {
+ if (!SuspenseContext.active()) {
+ dispose();
+ done();
+ }
+ });
+ return rendered;
+ }, options));
+}
+function hydrate$1(code, element) {
+ let disposer;
+ hydrate(() => {
+ disposer = render(code, element);
+ }, element);
+ return disposer;
+}
+function wrapCondition(fn) {
+ return createMemo(fn, undefined, equalFn);
+}
+function For(props) {
+ const fallback = "fallback" in props && {
+ fallback: () => props.fallback
+ },
+ mapped = awaitSuspense(createMemo(mapArray(() => props.each, props.children, fallback ? fallback : undefined)));
+ return props.transform ? props.transform(mapped) : mapped;
+}
+function Show(props) {
+ const useFallback = "fallback" in props,
+ condition = createMemo(() => !!props.when, undefined, equalFn),
+ mapped = awaitSuspense(createMemo(() => condition() ? sample(() => props.children) : useFallback ? sample(() => props.fallback) : undefined));
+ return props.transform ? props.transform(mapped) : mapped;
+}
+function Switch(props) {
+ let conditions = props.children;
+ Array.isArray(conditions) || (conditions = [conditions]);
+ const useFallback = "fallback" in props,
+ evalConditions = createMemo(() => {
+ for (let i = 0; i < conditions.length; i++) {
+ if (conditions[i].when) return i;
+ }
+ return -1;
+ }, undefined, equalFn),
+ mapped = awaitSuspense(createMemo(() => {
+ const index = evalConditions();
+ return sample(() => index < 0 ? useFallback && props.fallback : conditions[index].children);
+ }));
+ return props.transform ? props.transform(mapped) : mapped;
+}
+function Match(props) {
+ return props;
+}
+function Portal(props) {
+ const {
+ useShadow
+ } = props,
+ container = document.createElement("div"),
+ marker = document.createTextNode(""),
+ mount = props.mount || document.body,
+ renderRoot = useShadow && container.attachShadow ? container.attachShadow({
+ mode: "open"
+ }) : container;
+ Object.defineProperty(container, "host", {
+ get() {
+ return marker.parentNode;
+ }
+ });
+ insert(renderRoot, sample(() => props.children));
+ mount.appendChild(container);
+ props.ref && props.ref(container);
+ onCleanup(() => mount.removeChild(container));
+ return marker;
+}
+
+export { For, Match, Portal, Show, Suspense, SuspenseList, Switch, classList, clearDelegatedEvents, createComponent, delegateEvents, generateHydrationEventsScript, getNextElement, getNextMarker, hydrate$1 as hydrate, insert, render, renderToString$1 as renderToString, runHydrationEvents, spread, template, wrapCondition };
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/dist/index.js b/__tests__/integration/sub-package-json/node_modules/solid-js/dist/index.js
new file mode 100644
index 0000000000..e89ca595fe
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/dist/index.js
@@ -0,0 +1,1305 @@
+let taskIdCounter = 1,
+ isCallbackScheduled = false,
+ isPerformingWork = false,
+ taskQueue = [],
+ currentTask = null,
+ shouldYieldToHost = null,
+ yieldInterval = 5,
+ deadline = 0,
+ maxYieldInterval = 300,
+ scheduleCallback = null,
+ scheduledCallback = null;
+const maxSigned31BitInt = 1073741823;
+function setupScheduler() {
+ if (window && window.MessageChannel) {
+ const channel = new MessageChannel(),
+ port = channel.port2;
+ scheduleCallback = () => port.postMessage(null);
+ channel.port1.onmessage = () => {
+ if (scheduledCallback !== null) {
+ const currentTime = performance.now();
+ deadline = currentTime + yieldInterval;
+ const hasTimeRemaining = true;
+ try {
+ const hasMoreWork = scheduledCallback(hasTimeRemaining, currentTime);
+ if (!hasMoreWork) {
+ scheduledCallback = null;
+ } else port.postMessage(null);
+ } catch (error) {
+ port.postMessage(null);
+ throw error;
+ }
+ }
+ };
+ } else {
+ let _callback;
+ scheduleCallback = () => {
+ if (!_callback) {
+ _callback = scheduledCallback;
+ setTimeout(() => {
+ const currentTime = performance.now();
+ deadline = currentTime + yieldInterval;
+ const hasMoreWork = _callback(true, currentTime);
+ _callback = null;
+ if (hasMoreWork) scheduleCallback();
+ }, 0);
+ }
+ };
+ }
+ if (navigator && navigator.scheduling && navigator.scheduling.isInputPending) {
+ const scheduling = navigator.scheduling;
+ shouldYieldToHost = () => {
+ const currentTime = performance.now();
+ if (currentTime >= deadline) {
+ if (scheduling.isInputPending()) {
+ return true;
+ }
+ return currentTime >= maxYieldInterval;
+ } else {
+ return false;
+ }
+ };
+ } else {
+ shouldYieldToHost = () => performance.now() >= deadline;
+ }
+}
+function enqueue(taskQueue, task) {
+ function findIndex() {
+ let m = 0;
+ let n = taskQueue.length - 1;
+ while (m <= n) {
+ let k = n + m >> 1;
+ let cmp = task.expirationTime - taskQueue[k].expirationTime;
+ if (cmp > 0) m = k + 1;else if (cmp < 0) n = k - 1;else return k;
+ }
+ return m;
+ }
+ taskQueue.splice(findIndex(), 0, task);
+}
+function requestCallback(fn, options) {
+ if (!scheduleCallback) setupScheduler();
+ let startTime = performance.now(),
+ timeout = maxSigned31BitInt;
+ if (options && options.timeout) timeout = options.timeout;
+ const newTask = {
+ id: taskIdCounter++,
+ fn,
+ startTime,
+ expirationTime: startTime + timeout
+ };
+ enqueue(taskQueue, newTask);
+ if (!isCallbackScheduled && !isPerformingWork) {
+ isCallbackScheduled = true;
+ scheduledCallback = flushWork;
+ scheduleCallback();
+ }
+ return newTask;
+}
+function cancelCallback(task) {
+ task.fn = null;
+}
+function flushWork(hasTimeRemaining, initialTime) {
+ isCallbackScheduled = false;
+ isPerformingWork = true;
+ try {
+ return workLoop(hasTimeRemaining, initialTime);
+ } finally {
+ currentTask = null;
+ isPerformingWork = false;
+ }
+}
+function workLoop(hasTimeRemaining, initialTime) {
+ let currentTime = initialTime;
+ currentTask = taskQueue[0] || null;
+ while (currentTask !== null) {
+ if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
+ break;
+ }
+ const callback = currentTask.fn;
+ if (callback !== null) {
+ currentTask.fn = null;
+ const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+ callback(didUserCallbackTimeout);
+ currentTime = performance.now();
+ if (currentTask === taskQueue[0]) {
+ taskQueue.shift();
+ }
+ } else taskQueue.shift();
+ currentTask = taskQueue[0] || null;
+ }
+ return currentTask !== null;
+}
+
+const equalFn = (a, b) => a === b;
+const ERROR = Symbol("error");
+function createRoot(fn, detachedOwner) {
+ detachedOwner && (Owner = detachedOwner);
+ let owner = Owner,
+ listener = Listener,
+ root = fn.length === 0 ? UNOWNED : createComputationNode(null, null),
+ result = undefined,
+ disposer = function _dispose() {
+ if (RunningClock !== null) {
+ RootClock.disposes.add(root);
+ } else {
+ dispose(root);
+ }
+ };
+ Owner = root;
+ Listener = null;
+ try {
+ result = fn(disposer);
+ } catch (err) {
+ const fns = lookup(Owner, ERROR);
+ if (!fns) throw err;
+ fns.forEach(f => f(err));
+ } finally {
+ Owner && afterNode(Owner);
+ Listener = listener;
+ Owner = owner;
+ }
+ return result;
+}
+function createSignal(value, areEqual) {
+ const d = new DataNode(value);
+ let setter;
+ if (areEqual) {
+ let age = -1;
+ setter = v => {
+ if (!areEqual(v, value)) {
+ const time = RootClock.time;
+ if (time === age) {
+ throw new Error(`Conflicting value update: ${v} is not the same as ${value}`);
+ }
+ age = time;
+ value = v;
+ d.next(v);
+ }
+ };
+ } else setter = d.next.bind(d);
+ return [d.current.bind(d), setter];
+}
+function createEffect(fn, value) {
+ createComputationNode(fn, value);
+}
+function createDependentEffect(fn, deps, defer) {
+ const resolved = Array.isArray(deps) ? callAll(deps) : deps;
+ defer = !!defer;
+ createComputationNode(value => {
+ const listener = Listener;
+ resolved();
+ if (defer) defer = false;else {
+ Listener = null;
+ value = fn(value);
+ Listener = listener;
+ }
+ return value;
+ });
+}
+function createMemo(fn, value, areEqual) {
+ var node = createComputationNode(fn, value);
+ node.comparator = areEqual || null;
+ return () => {
+ if (Listener !== null) {
+ const state = node.state;
+ if ((state & 7) !== 0) {
+ liftComputation(node);
+ }
+ if (node.age === RootClock.time && state === 8) {
+ throw new Error("Circular dependency.");
+ }
+ if ((state & 16) === 0) {
+ if (node.log === null) node.log = createLog();
+ logRead(node.log);
+ }
+ }
+ return node.value;
+ };
+}
+function createDeferred(fn, options) {
+ let t,
+ timeout = options ? options.timeoutMs : undefined;
+ const [deferred, setDeferred] = createSignal(fn());
+ createEffect(() => {
+ fn();
+ if (!t || !t.fn) t = requestCallback(() => setDeferred(fn()), timeout !== undefined ? {
+ timeout
+ } : undefined);
+ });
+ return deferred;
+}
+function freeze(fn) {
+ let result = undefined;
+ if (RunningClock !== null) result = fn();else {
+ RunningClock = RootClock;
+ RunningClock.changes.reset();
+ try {
+ result = fn();
+ event();
+ } finally {
+ RunningClock = null;
+ }
+ }
+ return result;
+}
+function sample(fn) {
+ let result,
+ listener = Listener;
+ Listener = null;
+ result = fn();
+ Listener = listener;
+ return result;
+}
+function afterEffects(fn) {
+ if (Owner === null) fn();
+ else if (Owner.afters === null) Owner.afters = [fn];else Owner.afters.push(fn);
+}
+function onCleanup(fn) {
+ if (Owner === null) console.warn("cleanups created outside a `createRoot` or `render` will never be run");else if (Owner.cleanups === null) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
+}
+function onError(fn) {
+ if (Owner === null) console.warn("error handlers created outside a `createRoot` or `render` will never be run");else if (Owner.context === null) Owner.context = {
+ [ERROR]: [fn]
+ };else if (!Owner.context[ERROR]) Owner.context[ERROR] = [fn];else Owner.context[ERROR].push(fn);
+}
+function isListening() {
+ return Listener !== null;
+}
+function createContext(defaultValue) {
+ const id = Symbol("context");
+ return {
+ id,
+ Provider: createProvider(id),
+ defaultValue
+ };
+}
+function useContext(context) {
+ return lookup(Owner, context.id) || context.defaultValue;
+}
+function getContextOwner() {
+ return Owner;
+}
+class DataNode {
+ constructor(value) {
+ this.value = value;
+ this.pending = NOTPENDING;
+ this.log = null;
+ }
+ current() {
+ if (Listener !== null) {
+ if (this.log === null) this.log = createLog();
+ logRead(this.log);
+ }
+ return this.value;
+ }
+ next(value) {
+ if (RunningClock !== null) {
+ if (this.pending !== NOTPENDING) {
+ if (value !== this.pending) {
+ throw new Error("conflicting changes: " + value + " !== " + this.pending);
+ }
+ } else {
+ this.pending = value;
+ RootClock.changes.add(this);
+ }
+ } else {
+ if (this.log !== null) {
+ this.pending = value;
+ RootClock.changes.add(this);
+ event();
+ } else {
+ this.value = value;
+ }
+ }
+ return value;
+ }
+}
+function createComputationNode(fn, value) {
+ const node = {
+ fn,
+ value,
+ age: RootClock.time,
+ state: 0,
+ comparator: null,
+ source1: null,
+ source1slot: 0,
+ sources: null,
+ sourceslots: null,
+ dependents: null,
+ dependentslot: 0,
+ dependentcount: 0,
+ owner: Owner,
+ owned: null,
+ log: null,
+ context: null,
+ cleanups: null,
+ afters: null
+ };
+ if (fn === null) return node;
+ let owner = Owner,
+ listener = Listener;
+ if (owner === null) console.warn("computations created outside a `createRoot` or `render` will never be disposed");
+ Owner = Listener = node;
+ if (RunningClock === null) {
+ toplevelComputation(node);
+ } else {
+ node.value = node.fn(node.value);
+ afterNode(node);
+ }
+ if (owner && owner !== UNOWNED) {
+ if (owner.owned === null) owner.owned = [node];else owner.owned.push(node);
+ }
+ Owner = owner;
+ Listener = listener;
+ return node;
+}
+function createClock() {
+ return {
+ time: 0,
+ changes: new Queue(),
+ updates: new Queue(),
+ disposes: new Queue()
+ };
+}
+function createLog() {
+ return {
+ node1: null,
+ node1slot: 0,
+ nodes: null,
+ nodeslots: null
+ };
+}
+class Queue {
+ constructor() {
+ this.items = [];
+ this.count = 0;
+ }
+ reset() {
+ this.count = 0;
+ }
+ add(item) {
+ this.items[this.count++] = item;
+ }
+ run(fn) {
+ let items = this.items;
+ for (let i = 0; i < this.count; i++) {
+ try {
+ const item = items[i];
+ items[i] = null;
+ fn(item);
+ } catch (err) {
+ const fns = lookup(Owner, ERROR);
+ if (!fns) throw err;
+ fns.forEach(f => f(err));
+ }
+ }
+ this.count = 0;
+ }
+}
+let RootClock = createClock(),
+ RunningClock = null,
+Listener = null,
+Owner = null,
+Pending = null;
+let NOTPENDING = {},
+ UNOWNED = createComputationNode(null, null);
+function callAll(ss) {
+ return function all() {
+ for (let i = 0; i < ss.length; i++) ss[i]();
+ };
+}
+function lookup(owner, key) {
+ return owner && (owner.context && owner.context[key] || owner.owner && lookup(owner.owner, key));
+}
+function resolveChildren(children) {
+ if (typeof children === "function") return createMemo(() => resolveChildren(children()));
+ if (Array.isArray(children)) {
+ const results = [];
+ for (let i = 0; i < children.length; i++) {
+ let result = resolveChildren(children[i]);
+ Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+ }
+ return results;
+ }
+ return children;
+}
+function createProvider(id) {
+ return function provider(props) {
+ let rendered;
+ createComputationNode(() => {
+ Owner.context = {
+ [id]: props.value
+ };
+ rendered = sample(() => resolveChildren(props.children));
+ });
+ return rendered;
+ };
+}
+function logRead(from) {
+ let to = Listener,
+ fromslot,
+ toslot = to.source1 === null ? -1 : to.sources === null ? 0 : to.sources.length;
+ if (from.node1 === null) {
+ from.node1 = to;
+ from.node1slot = toslot;
+ fromslot = -1;
+ } else if (from.nodes === null) {
+ if (from.node1 === to) return;
+ from.nodes = [to];
+ from.nodeslots = [toslot];
+ fromslot = 0;
+ } else {
+ fromslot = from.nodes.length;
+ if (from.nodes[fromslot - 1] === to) return;
+ from.nodes.push(to);
+ from.nodeslots.push(toslot);
+ }
+ if (to.source1 === null) {
+ to.source1 = from;
+ to.source1slot = fromslot;
+ } else if (to.sources === null) {
+ to.sources = [from];
+ to.sourceslots = [fromslot];
+ } else {
+ to.sources.push(from);
+ to.sourceslots.push(fromslot);
+ }
+}
+function liftComputation(node) {
+ if ((node.state & 6) !== 0) {
+ applyUpstreamUpdates(node);
+ }
+ if ((node.state & 1) !== 0) {
+ updateNode(node);
+ }
+ resetComputation(node, 31);
+}
+function event() {
+ let owner = Owner;
+ RootClock.updates.reset();
+ RootClock.time++;
+ try {
+ run(RootClock);
+ } finally {
+ Owner && afterNode(Owner);
+ RunningClock = Listener = null;
+ Owner = owner;
+ }
+}
+function toplevelComputation(node) {
+ RunningClock = RootClock;
+ RootClock.changes.reset();
+ RootClock.updates.reset();
+ try {
+ node.value = node.fn(node.value);
+ if (RootClock.changes.count > 0 || RootClock.updates.count > 0) {
+ RootClock.time++;
+ run(RootClock);
+ }
+ } catch (err) {
+ const fns = lookup(Owner, ERROR);
+ if (!fns) throw err;
+ fns.forEach(f => f(err));
+ } finally {
+ Owner && afterNode(Owner);
+ RunningClock = Owner = Listener = null;
+ }
+}
+function run(clock) {
+ let running = RunningClock,
+ count = 0;
+ RunningClock = clock;
+ clock.disposes.reset();
+ while (clock.changes.count !== 0 || clock.updates.count !== 0 || clock.disposes.count !== 0) {
+ if (count > 0)
+ clock.time++;
+ clock.changes.run(applyDataChange);
+ clock.updates.run(updateNode);
+ clock.disposes.run(dispose);
+ if (count++ > 1e5) {
+ throw new Error("Runaway clock detected");
+ }
+ }
+ RunningClock = running;
+}
+function applyDataChange(data) {
+ data.value = data.pending;
+ data.pending = NOTPENDING;
+ if (data.log) setComputationState(data.log, stateStale);
+}
+function updateNode(node) {
+ const state = node.state;
+ if ((state & 16) === 0) {
+ if ((state & 2) !== 0) {
+ node.dependents[node.dependentslot++] = null;
+ if (node.dependentslot === node.dependentcount) {
+ resetComputation(node, 14);
+ }
+ } else if ((state & 1) !== 0) {
+ if ((state & 4) !== 0) {
+ liftComputation(node);
+ } else if (node.comparator) {
+ const current = updateComputation(node);
+ const comparator = node.comparator;
+ if (!comparator(current, node.value)) {
+ markDownstreamComputations(node, false, true);
+ }
+ } else {
+ updateComputation(node);
+ }
+ }
+ }
+}
+function updateComputation(node) {
+ const value = node.value,
+ owner = Owner,
+ listener = Listener;
+ Owner = Listener = node;
+ node.state = 8;
+ cleanupNode(node, false);
+ node.value = node.fn(node.value);
+ resetComputation(node, 31);
+ Owner = owner;
+ Listener = listener;
+ return value;
+}
+function stateStale(node) {
+ const time = RootClock.time;
+ if (node.age < time) {
+ node.state |= 1;
+ node.age = time;
+ setDownstreamState(node, !!node.comparator);
+ }
+}
+function statePending(node) {
+ const time = RootClock.time;
+ if (node.age < time) {
+ node.state |= 2;
+ let dependents = node.dependents || (node.dependents = []);
+ dependents[node.dependentcount++] = Pending;
+ setDownstreamState(node, true);
+ }
+}
+function pendingStateStale(node) {
+ if ((node.state & 2) !== 0) {
+ node.state = 1;
+ const time = RootClock.time;
+ if (node.age < time) {
+ node.age = time;
+ if (!node.comparator) {
+ markDownstreamComputations(node, false, true);
+ }
+ }
+ }
+}
+function setDownstreamState(node, pending) {
+ RootClock.updates.add(node);
+ if (node.comparator) {
+ const pending = Pending;
+ Pending = node;
+ markDownstreamComputations(node, true, false);
+ Pending = pending;
+ } else {
+ markDownstreamComputations(node, pending, false);
+ }
+}
+function markDownstreamComputations(node, onchange, dirty) {
+ const owned = node.owned;
+ if (owned !== null) {
+ const pending = onchange && !dirty;
+ markForDisposal(owned, pending, RootClock.time);
+ }
+ const log = node.log;
+ if (log !== null) {
+ setComputationState(log, dirty ? pendingStateStale : onchange ? statePending : stateStale);
+ }
+}
+function setComputationState(log, stateFn) {
+ const node1 = log.node1,
+ nodes = log.nodes;
+ if (node1 !== null) stateFn(node1);
+ if (nodes !== null) {
+ for (let i = 0, ln = nodes.length; i < ln; i++) {
+ stateFn(nodes[i]);
+ }
+ }
+}
+function markForDisposal(children, pending, time) {
+ for (let i = 0, ln = children.length; i < ln; i++) {
+ const child = children[i];
+ if (child !== null) {
+ if (pending) {
+ if ((child.state & 16) === 0) {
+ child.state |= 4;
+ }
+ } else {
+ child.age = time;
+ child.state = 16;
+ }
+ const owned = child.owned;
+ if (owned !== null) markForDisposal(owned, pending, time);
+ }
+ }
+}
+function applyUpstreamUpdates(node) {
+ if ((node.state & 4) !== 0) {
+ const owner = node.owner;
+ if ((owner.state & 7) !== 0) liftComputation(owner);
+ node.state &= ~4;
+ }
+ if ((node.state & 2) !== 0) {
+ const slots = node.dependents;
+ for (let i = node.dependentslot, ln = node.dependentcount; i < ln; i++) {
+ const slot = slots[i];
+ if (slot != null) liftComputation(slot);
+ slots[i] = null;
+ }
+ node.state &= ~2;
+ }
+}
+function cleanupNode(node, final) {
+ let source1 = node.source1,
+ sources = node.sources,
+ sourceslots = node.sourceslots,
+ cleanups = node.cleanups,
+ owned = node.owned,
+ i,
+ len;
+ if (cleanups !== null) {
+ for (i = 0; i < cleanups.length; i++) {
+ cleanups[i](final);
+ }
+ node.cleanups = null;
+ }
+ node.context = null;
+ if (owned !== null) {
+ for (i = 0; i < owned.length; i++) {
+ dispose(owned[i]);
+ }
+ node.owned = null;
+ }
+ if (source1 !== null) {
+ cleanupSource(source1, node.source1slot);
+ node.source1 = null;
+ }
+ if (sources !== null) {
+ for (i = 0, len = sources.length; i < len; i++) {
+ cleanupSource(sources.pop(), sourceslots.pop());
+ }
+ }
+}
+function cleanupSource(source, slot) {
+ let nodes = source.nodes,
+ nodeslots = source.nodeslots,
+ last,
+ lastslot;
+ if (slot === -1) {
+ source.node1 = null;
+ } else {
+ last = nodes.pop();
+ lastslot = nodeslots.pop();
+ if (slot !== nodes.length) {
+ nodes[slot] = last;
+ nodeslots[slot] = lastslot;
+ if (lastslot === -1) {
+ last.source1slot = slot;
+ } else {
+ last.sourceslots[lastslot] = slot;
+ }
+ }
+ }
+}
+function afterNode(node) {
+ const afters = node.afters;
+ if (afters !== null) {
+ for (let i = 0; i < afters.length; i++) afters[i]();
+ node.afters = null;
+ }
+}
+function resetComputation(node, flags) {
+ node.state &= ~flags;
+ node.dependentslot = 0;
+ node.dependentcount = 0;
+}
+function dispose(node) {
+ node.fn = null;
+ node.log = null;
+ node.dependents = null;
+ cleanupNode(node, true);
+ resetComputation(node, 31);
+}
+
+const SNODE = Symbol("state-node"),
+ SPROXY = Symbol("state-proxy");
+function wrap(value, traps) {
+ return value[SPROXY] || (value[SPROXY] = new Proxy(value, traps || proxyTraps));
+}
+function isWrappable(obj) {
+ return obj != null && typeof obj === "object" && (obj.__proto__ === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item) {
+ let result, unwrapped, v;
+ if (result = item != null && item._state) return result;
+ if (!isWrappable(item)) return item;
+ if (Array.isArray(item)) {
+ if (Object.isFrozen(item)) item = item.slice(0);
+ for (let i = 0, l = item.length; i < l; i++) {
+ v = item[i];
+ if ((unwrapped = unwrap(v)) !== v) item[i] = unwrapped;
+ }
+ } else {
+ if (Object.isFrozen(item)) item = Object.assign({}, item);
+ let keys = Object.keys(item);
+ for (let i = 0, l = keys.length; i < l; i++) {
+ v = item[keys[i]];
+ if ((unwrapped = unwrap(v)) !== v) item[keys[i]] = unwrapped;
+ }
+ }
+ return item;
+}
+function getDataNodes(target) {
+ let nodes = target[SNODE];
+ if (!nodes) target[SNODE] = nodes = {};
+ return nodes;
+}
+const proxyTraps = {
+ get(target, property) {
+ if (property === "_state") return target;
+ if (property === SPROXY || property === SNODE) return;
+ const value = target[property],
+ wrappable = isWrappable(value);
+ if (isListening() && (typeof value !== "function" || target.hasOwnProperty(property))) {
+ let nodes, node;
+ if (wrappable && (nodes = getDataNodes(value))) {
+ node = nodes._ || (nodes._ = new DataNode());
+ node.current();
+ }
+ nodes = getDataNodes(target);
+ node = nodes[property] || (nodes[property] = new DataNode());
+ node.current();
+ }
+ return wrappable ? wrap(value) : value;
+ },
+ set() {
+ return true;
+ },
+ deleteProperty() {
+ return true;
+ }
+};
+const setterTraps = {
+ get(target, property) {
+ if (property === "_state") return target;
+ const value = target[property];
+ return isWrappable(value) ? new Proxy(value, setterTraps) : value;
+ },
+ set(target, property, value) {
+ setProperty(target, property, unwrap(value));
+ return true;
+ },
+ deleteProperty(target, property) {
+ setProperty(target, property, undefined);
+ return true;
+ }
+};
+function setProperty(state, property, value, force) {
+ if (!force && state[property] === value) return;
+ const notify = Array.isArray(state) || !(property in state);
+ if (value === undefined) {
+ delete state[property];
+ } else state[property] = value;
+ let nodes = getDataNodes(state),
+ node;
+ (node = nodes[property]) && node.next();
+ notify && (node = nodes._) && node.next();
+}
+function mergeState(state, value, force) {
+ const keys = Object.keys(value);
+ for (let i = 0; i < keys.length; i += 1) {
+ const key = keys[i];
+ setProperty(state, key, value[key], force);
+ }
+}
+function updatePath(current, path, traversed = []) {
+ let part,
+ next = current;
+ if (path.length > 1) {
+ part = path.shift();
+ const partType = typeof part,
+ isArray = Array.isArray(current);
+ if (Array.isArray(part)) {
+ for (let i = 0; i < part.length; i++) {
+ updatePath(current, [part[i]].concat(path), [part[i]].concat(traversed));
+ }
+ return;
+ } else if (isArray && partType === "function") {
+ for (let i = 0; i < current.length; i++) {
+ if (part(current[i], i)) updatePath(current, [i].concat(path), [i].concat(traversed));
+ }
+ return;
+ } else if (isArray && partType === "object") {
+ const {
+ from = 0,
+ to = current.length - 1,
+ by = 1
+ } = part;
+ for (let i = from; i <= to; i += by) {
+ updatePath(current, [i].concat(path), [i].concat(traversed));
+ }
+ return;
+ } else if (path.length > 1) {
+ updatePath(current[part], path, [part].concat(traversed));
+ return;
+ }
+ next = current[part];
+ traversed = [part].concat(traversed);
+ }
+ let value = path[0];
+ if (typeof value === "function") {
+ const wrapped = part === undefined || isWrappable(next) ? new Proxy(next, setterTraps) : next;
+ value = value(wrapped, traversed);
+ if (value === wrapped || value === undefined) return;
+ }
+ value = unwrap(value);
+ if (part === undefined || isWrappable(next) && isWrappable(value) && !Array.isArray(value)) {
+ mergeState(next, value);
+ } else setProperty(current, part, value);
+}
+function createState(state) {
+ const unwrappedState = unwrap(state || {});
+ const wrappedState = wrap(unwrappedState);
+ function setState(...args) {
+ freeze(() => updatePath(unwrappedState, args));
+ }
+ return [wrappedState, setState];
+}
+function force(value) {
+ return state => {
+ if (!isWrappable(state)) return value;
+ mergeState(unwrap(state), value, true);
+ };
+}
+
+function applyState(target, parent, property, merge, key) {
+ let previous = parent[property];
+ if (target === previous) return;
+ if (!isWrappable(target) || !isWrappable(previous) || key && target[key] !== previous[key]) {
+ target !== previous && setProperty(parent, property, target);
+ return;
+ }
+ if (Array.isArray(target)) {
+ if (target.length && previous.length && (!merge || key && target[0][key] != null)) {
+ let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+ for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start][key] === target[start][key]); start++) {
+ applyState(target[start], previous, start, merge, key);
+ }
+ const temp = new Array(target.length),
+ newIndices = new Map();
+ for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
+ temp[newEnd] = previous[end];
+ }
+ if (start > newEnd || start > end) {
+ for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
+ for (; j < target.length; j++) {
+ setProperty(previous, j, temp[j]);
+ applyState(target[j], previous, j, merge, key);
+ }
+ if (previous.length > target.length) setProperty(previous, "length", target.length);
+ return;
+ }
+ newIndicesNext = new Array(newEnd + 1);
+ for (j = newEnd; j >= start; j--) {
+ item = target[j];
+ keyVal = key ? item[key] : item;
+ i = newIndices.get(keyVal);
+ newIndicesNext[j] = i === undefined ? -1 : i;
+ newIndices.set(keyVal, j);
+ }
+ for (i = start; i <= end; i++) {
+ item = previous[i];
+ keyVal = key ? item[key] : item;
+ j = newIndices.get(keyVal);
+ if (j !== undefined && j !== -1) {
+ temp[j] = previous[i];
+ j = newIndicesNext[j];
+ newIndices.set(keyVal, j);
+ }
+ }
+ for (j = start; j < target.length; j++) {
+ if (j in temp) {
+ setProperty(previous, j, temp[j]);
+ applyState(target[j], previous, j, merge, key);
+ } else setProperty(previous, j, target[j]);
+ }
+ } else {
+ for (let i = 0, len = target.length; i < len; i++) {
+ applyState(target[i], previous, i, merge, key);
+ }
+ }
+ if (previous.length > target.length) setProperty(previous, "length", target.length);
+ return;
+ }
+ const targetKeys = Object.keys(target);
+ for (let i = 0, len = targetKeys.length; i < len; i++) {
+ applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
+ }
+ const previousKeys = Object.keys(previous);
+ for (let i = 0, len = previousKeys.length; i < len; i++) {
+ if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
+ }
+}
+function reconcile(value, options = {}) {
+ const {
+ merge,
+ key = "id"
+ } = options;
+ return state => {
+ state = unwrap(state);
+ if (!isWrappable(state)) return value;
+ applyState(value, {
+ state
+ }, "state", merge, key);
+ };
+}
+
+const FALLBACK = Symbol("fallback");
+function mapArray(list, mapFn, options) {
+ if (typeof mapFn !== "function") {
+ options = mapFn || {};
+ mapFn = list;
+ return map;
+ }
+ options || (options = {});
+ return map(list);
+ function map(list) {
+ let items = [],
+ mapped = [],
+ disposers = [],
+ len = 0;
+ onCleanup(() => {
+ for (let i = 0, length = disposers.length; i < length; i++) disposers[i]();
+ });
+ return () => {
+ let newItems = list() || [],
+ i,
+ j;
+ return sample(() => {
+ let newLen = newItems.length,
+ newIndices,
+ newIndicesNext,
+ temp,
+ tempdisposers,
+ start,
+ end,
+ newEnd,
+ item;
+ if (newLen === 0) {
+ if (len !== 0) {
+ for (i = 0; i < len; i++) disposers[i]();
+ disposers = [];
+ items = [];
+ mapped = [];
+ len = 0;
+ }
+ if (options.fallback) {
+ items = [FALLBACK];
+ mapped[0] = createRoot(disposer => {
+ disposers[0] = disposer;
+ return options.fallback();
+ });
+ len = 1;
+ }
+ }
+ else if (len === 0) {
+ for (j = 0; j < newLen; j++) {
+ items[j] = newItems[j];
+ mapped[j] = createRoot(mapper);
+ }
+ len = newLen;
+ } else {
+ temp = new Array(newLen);
+ tempdisposers = new Array(newLen);
+ for (start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++);
+ for (end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
+ temp[newEnd] = mapped[end];
+ tempdisposers[newEnd] = disposers[end];
+ }
+ if (start > newEnd) {
+ for (j = end; start <= j; j--) disposers[j]();
+ const rLen = end - start + 1;
+ if (rLen > 0) {
+ mapped.splice(start, rLen);
+ disposers.splice(start, rLen);
+ }
+ items = newItems.slice(0);
+ len = newLen;
+ return mapped;
+ }
+ if (start > end) {
+ for (j = start; j <= newEnd; j++) mapped[j] = createRoot(mapper);
+ for (; j < newLen; j++) {
+ mapped[j] = temp[j];
+ disposers[j] = tempdisposers[j];
+ }
+ items = newItems.slice(0);
+ len = newLen;
+ return mapped;
+ }
+ newIndices = new Map();
+ newIndicesNext = new Array(newEnd + 1);
+ for (j = newEnd; j >= start; j--) {
+ item = newItems[j];
+ i = newIndices.get(item);
+ newIndicesNext[j] = i === undefined ? -1 : i;
+ newIndices.set(item, j);
+ }
+ for (i = start; i <= end; i++) {
+ item = items[i];
+ j = newIndices.get(item);
+ if (j !== undefined && j !== -1) {
+ temp[j] = mapped[i];
+ tempdisposers[j] = disposers[i];
+ j = newIndicesNext[j];
+ newIndices.set(item, j);
+ } else disposers[i]();
+ }
+ for (j = start; j < newLen; j++) {
+ if (j in temp) {
+ mapped[j] = temp[j];
+ disposers[j] = tempdisposers[j];
+ } else mapped[j] = createRoot(mapper);
+ }
+ len = mapped.length = newLen;
+ items = newItems.slice(0);
+ }
+ return mapped;
+ });
+ function mapper(disposer) {
+ disposers[j] = disposer;
+ return mapFn(newItems[j], j);
+ }
+ };
+ }
+}
+function reduceArray(list, fn, seed) {
+ if (arguments.length < 3) {
+ seed = fn;
+ fn = list;
+ return reducer;
+ }
+ return reducer(list);
+ function reducer(list) {
+ return () => {
+ let newList = list() || [],
+ result = seed;
+ return sample(() => {
+ for (let i = 0; i < newList.length; i++) {
+ result = fn(result, newList[i], i);
+ }
+ return result;
+ });
+ };
+ }
+}
+
+function setDefaults(props, defaultProps) {
+ const propKeys = Object.keys(defaultProps);
+ for (let i = 0; i < propKeys.length; i++) {
+ const key = propKeys[i];
+ !(key in props) && (props[key] = defaultProps[key]);
+ }
+}
+function cloneProps(props) {
+ const clone = {},
+ descriptors = Object.getOwnPropertyDescriptors(props);
+ Object.defineProperties(clone, descriptors);
+ return clone;
+}
+
+const runtimeConfig = {};
+function setHydrateContext(context) {
+ runtimeConfig.hydrate = context;
+}
+function nextHydrateContext() {
+ return runtimeConfig.hydrate ? {
+ id: `${runtimeConfig.hydrate.id}.${runtimeConfig.hydrate.count++}`,
+ count: 0,
+ registry: runtimeConfig.hydrate.registry
+ } : undefined;
+}
+
+function createActivityTracker() {
+ let count = 0,
+ active = false;
+ const [read, trigger] = createSignal();
+ return [() => (read(), active), () => count++ === 0 && (active = true, trigger()), () => --count <= 0 && (active = false, trigger())];
+}
+const SuspenseContext = createContext({});
+const [active, increment, decrement] = createActivityTracker();
+SuspenseContext.active = active;
+SuspenseContext.increment = increment;
+SuspenseContext.decrement = decrement;
+function generatePlaceholderPromise(isCancelled) {
+ let p;
+ return p = new Promise((res, rej) => setTimeout(() => (!isCancelled(p) && console.warn("Load not started for read resource by next task"), rej())));
+}
+function createResource(value) {
+ const [s, set] = createSignal(value),
+ [trackPromise, triggerPromise] = createSignal(),
+ [trackLoading, triggerLoading] = createSignal(),
+ contexts = new Set();
+ let loading = value === undefined,
+ error = null,
+ pr;
+ function loadEnd(v) {
+ pr = undefined;
+ freeze(() => {
+ set(v);
+ loading && (loading = false, triggerLoading());
+ for (let c of contexts.keys()) c.decrement();
+ contexts.clear();
+ });
+ }
+ function read() {
+ const c = useContext(SuspenseContext),
+ v = s();
+ if (error) throw error;
+ if (loading && !pr) {
+ load(generatePlaceholderPromise(p => p === pr));
+ }
+ trackPromise();
+ if (pr && c.increment && !contexts.has(c)) {
+ c.increment();
+ contexts.add(c);
+ }
+ return v;
+ }
+ function load(p) {
+ error = null;
+ if (p == null || typeof p !== "object" || !("then" in p)) {
+ pr = undefined;
+ loadEnd(p);
+ } else {
+ pr = p;
+ if (!loading) {
+ loading = true;
+ freeze(() => {
+ triggerLoading();
+ triggerPromise();
+ });
+ }
+ p.then(v => {
+ if (pr !== p) return;
+ loadEnd(v);
+ }, err => {
+ if (pr !== p) return;
+ error = err;
+ loadEnd(undefined);
+ });
+ }
+ return () => (trackLoading(), loading);
+ }
+ return [read, load];
+}
+function createResourceNode(v) {
+ const node = new DataNode(),
+ [read, load] = createResource(v);
+ return {
+ current: () => (read(), node.current()),
+ next: node.next.bind(node),
+ load
+ };
+}
+const resourceTraps = {
+ get(target, property) {
+ if (property === "_state") return target;
+ if (property === SPROXY || property === SNODE) return;
+ const value = target[property],
+ wrappable = isWrappable(value);
+ if (isListening() && (typeof value !== "function" || target.hasOwnProperty(property))) {
+ let nodes, node;
+ if (wrappable && (nodes = getDataNodes(value))) {
+ node = nodes._ || (nodes._ = new DataNode());
+ node.current();
+ }
+ nodes = getDataNodes(target);
+ node = nodes[property] || (nodes[property] = createResourceNode(value));
+ node.current();
+ }
+ return wrappable ? wrap(value) : value;
+ },
+ set() {
+ return true;
+ },
+ deleteProperty() {
+ return true;
+ }
+};
+function createResourceState(state) {
+ const unwrappedState = unwrap(state || {}),
+ wrappedState = wrap(unwrappedState, resourceTraps),
+ loading = {};
+ function setState(...args) {
+ freeze(() => updatePath(unwrappedState, args));
+ }
+ function loadState(v, r) {
+ const nodes = getDataNodes(unwrappedState),
+ keys = Object.keys(v);
+ for (let i = 0; i < keys.length; i++) {
+ const k = keys[i],
+ p = v[k],
+ node = nodes[k] || (nodes[k] = createResourceNode(unwrappedState[k])),
+ resolver = v => (r ? setState(r({
+ [k]: v
+ })) : setProperty(unwrappedState, k, v), v),
+ l = node.load(p && typeof p === "object" && "then" in p ? p.then(resolver) : resolver(p));
+ !(k in loading) && Object.defineProperty(loading, k, {
+ get() {
+ return l();
+ }
+ });
+ }
+ return loading;
+ }
+ return [wrappedState, loadState, setState];
+}
+function lazy(fn) {
+ return props => {
+ const hydrating = runtimeConfig.hydrate && runtimeConfig.hydrate.registry,
+ ctx = nextHydrateContext();
+ let s, r, p;
+ if (hydrating) {
+ [s, r] = createSignal();
+ fn().then(mod => r(mod.default));
+ } else {
+ [s, p] = createResource();
+ p(fn().then(mod => mod.default));
+ }
+ let Comp;
+ return createMemo(() => (Comp = s()) && sample(() => (setHydrateContext(ctx), Comp(props))));
+ };
+}
+function useTransition(config) {
+ const [pending, increment, decrement] = createActivityTracker();
+ return [pending, fn => {
+ const prevTransition = SuspenseContext.transition;
+ SuspenseContext.transition = {
+ timeoutMs: config.timeoutMs,
+ increment,
+ decrement
+ };
+ increment();
+ fn();
+ decrement();
+ afterEffects(() => SuspenseContext.transition = prevTransition);
+ }];
+}
+function awaitSuspense(fn) {
+ const {
+ state
+ } = useContext(SuspenseContext);
+ let cached;
+ return state ? () => state() === "suspended" ? cached : cached = fn() : fn;
+}
+
+export { SuspenseContext, afterEffects, awaitSuspense, cancelCallback, cloneProps, createContext, createDeferred, createDependentEffect, createEffect, createMemo, createResource, createResourceState, createRoot, createSignal, createState, equalFn, force, freeze, getContextOwner, isListening, lazy, mapArray, onCleanup, onError, reconcile, reduceArray, requestCallback, runtimeConfig, sample, setDefaults, unwrap, useContext, useTransition };
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/dom/package.json b/__tests__/integration/sub-package-json/node_modules/solid-js/dom/package.json
new file mode 100644
index 0000000000..32fe97f5ae
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/dom/package.json
@@ -0,0 +1,7 @@
+{
+ "name": "solid-js/dom",
+ "main": "../lib/dom/index.js",
+ "module": "../dist/dom/index.js",
+ "types": "../types/dom/index.d.ts",
+ "sideEffects": false
+}
\ No newline at end of file
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/h/package.json b/__tests__/integration/sub-package-json/node_modules/solid-js/h/package.json
new file mode 100644
index 0000000000..6dd20849a6
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/h/package.json
@@ -0,0 +1,7 @@
+{
+ "name": "solid-js/h",
+ "main": "../lib/dom/h.js",
+ "module": "../dist/dom/h.js",
+ "types": "../types/dom/h.d.ts",
+ "sideEffects": false
+}
\ No newline at end of file
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/html/package.json b/__tests__/integration/sub-package-json/node_modules/solid-js/html/package.json
new file mode 100644
index 0000000000..2ef72549bd
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/html/package.json
@@ -0,0 +1,7 @@
+{
+ "name": "solid-js/html",
+ "main": "../lib/dom/html.js",
+ "module": "../dist/dom/html.js",
+ "types": "../types/dom/html.d.ts",
+ "sideEffects": false
+}
\ No newline at end of file
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/h.js b/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/h.js
new file mode 100644
index 0000000000..4e7e416c42
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/h.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var hyperDomExpressions = require('hyper-dom-expressions');
+var index_js = require('./index.js');
+
+var h = hyperDomExpressions.createHyperScript({
+ wrap: index_js.wrap,
+ insert: index_js.insert,
+ createComponent: index_js.createComponent,
+ delegateEvents: index_js.delegateEvents,
+ classList: index_js.classList
+});
+
+module.exports = h;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/html.js b/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/html.js
new file mode 100644
index 0000000000..fa99a24831
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/html.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var litDomExpressions = require('lit-dom-expressions');
+var index_js = require('./index.js');
+
+var html = litDomExpressions.createHTML({
+ wrap: index_js.wrap,
+ insert: index_js.insert,
+ createComponent: index_js.createComponent,
+ delegateEvents: index_js.delegateEvents,
+ classList: index_js.classList
+});
+
+module.exports = html;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/index.js b/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/index.js
new file mode 100644
index 0000000000..aa75e13d95
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/lib/dom/index.js
@@ -0,0 +1,955 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_js = require('../index.js');
+
+const Types = {
+ ATTRIBUTE: "attribute",
+ PROPERTY: "property"
+},
+ Attributes = {
+ href: {
+ type: Types.ATTRIBUTE
+ },
+ style: {
+ type: Types.PROPERTY,
+ alias: "style.cssText"
+ },
+ for: {
+ type: Types.PROPERTY,
+ alias: "htmlFor"
+ },
+ class: {
+ type: Types.PROPERTY,
+ alias: "className"
+ },
+ spellCheck: {
+ type: Types.PROPERTY,
+ alias: "spellcheck"
+ },
+ allowFullScreen: {
+ type: Types.PROPERTY,
+ alias: "allowFullscreen"
+ },
+ autoCapitalize: {
+ type: Types.PROPERTY,
+ alias: "autocapitalize"
+ },
+ autoFocus: {
+ type: Types.PROPERTY,
+ alias: "autofocus"
+ },
+ autoPlay: {
+ type: Types.PROPERTY,
+ alias: "autoplay"
+ }
+},
+ SVGAttributes = {
+ className: {
+ type: Types.ATTRIBUTE,
+ alias: "class"
+ },
+ htmlFor: {
+ type: Types.ATTRIBUTE,
+ alias: "for"
+ },
+ tabIndex: {
+ type: Types.ATTRIBUTE,
+ alias: "tabindex"
+ },
+ allowReorder: {
+ type: Types.ATTRIBUTE
+ },
+ attributeName: {
+ type: Types.ATTRIBUTE
+ },
+ attributeType: {
+ type: Types.ATTRIBUTE
+ },
+ autoReverse: {
+ type: Types.ATTRIBUTE
+ },
+ baseFrequency: {
+ type: Types.ATTRIBUTE
+ },
+ calcMode: {
+ type: Types.ATTRIBUTE
+ },
+ clipPathUnits: {
+ type: Types.ATTRIBUTE
+ },
+ contentScriptType: {
+ type: Types.ATTRIBUTE
+ },
+ contentStyleType: {
+ type: Types.ATTRIBUTE
+ },
+ diffuseConstant: {
+ type: Types.ATTRIBUTE
+ },
+ edgeMode: {
+ type: Types.ATTRIBUTE
+ },
+ externalResourcesRequired: {
+ type: Types.ATTRIBUTE
+ },
+ filterRes: {
+ type: Types.ATTRIBUTE
+ },
+ filterUnits: {
+ type: Types.ATTRIBUTE
+ },
+ gradientTransform: {
+ type: Types.ATTRIBUTE
+ },
+ gradientUnits: {
+ type: Types.ATTRIBUTE
+ },
+ kernelMatrix: {
+ type: Types.ATTRIBUTE
+ },
+ kernelUnitLength: {
+ type: Types.ATTRIBUTE
+ },
+ keyPoints: {
+ type: Types.ATTRIBUTE
+ },
+ keySplines: {
+ type: Types.ATTRIBUTE
+ },
+ keyTimes: {
+ type: Types.ATTRIBUTE
+ },
+ lengthAdjust: {
+ type: Types.ATTRIBUTE
+ },
+ limitingConeAngle: {
+ type: Types.ATTRIBUTE
+ },
+ markerHeight: {
+ type: Types.ATTRIBUTE
+ },
+ markerUnits: {
+ type: Types.ATTRIBUTE
+ },
+ maskContentUnits: {
+ type: Types.ATTRIBUTE
+ },
+ maskUnits: {
+ type: Types.ATTRIBUTE
+ },
+ numOctaves: {
+ type: Types.ATTRIBUTE
+ },
+ pathLength: {
+ type: Types.ATTRIBUTE
+ },
+ patternContentUnits: {
+ type: Types.ATTRIBUTE
+ },
+ patternTransform: {
+ type: Types.ATTRIBUTE
+ },
+ patternUnits: {
+ type: Types.ATTRIBUTE
+ },
+ pointsAtX: {
+ type: Types.ATTRIBUTE
+ },
+ pointsAtY: {
+ type: Types.ATTRIBUTE
+ },
+ pointsAtZ: {
+ type: Types.ATTRIBUTE
+ },
+ preserveAlpha: {
+ type: Types.ATTRIBUTE
+ },
+ preserveAspectRatio: {
+ type: Types.ATTRIBUTE
+ },
+ primitiveUnits: {
+ type: Types.ATTRIBUTE
+ },
+ refX: {
+ type: Types.ATTRIBUTE
+ },
+ refY: {
+ type: Types.ATTRIBUTE
+ },
+ repeatCount: {
+ type: Types.ATTRIBUTE
+ },
+ repeatDur: {
+ type: Types.ATTRIBUTE
+ },
+ requiredExtensions: {
+ type: Types.ATTRIBUTE
+ },
+ requiredFeatures: {
+ type: Types.ATTRIBUTE
+ },
+ specularConstant: {
+ type: Types.ATTRIBUTE
+ },
+ specularExponent: {
+ type: Types.ATTRIBUTE
+ },
+ spreadMethod: {
+ type: Types.ATTRIBUTE
+ },
+ startOffset: {
+ type: Types.ATTRIBUTE
+ },
+ stdDeviation: {
+ type: Types.ATTRIBUTE
+ },
+ stitchTiles: {
+ type: Types.ATTRIBUTE
+ },
+ surfaceScale: {
+ type: Types.ATTRIBUTE
+ },
+ systemLanguage: {
+ type: Types.ATTRIBUTE
+ },
+ tableValues: {
+ type: Types.ATTRIBUTE
+ },
+ targetX: {
+ type: Types.ATTRIBUTE
+ },
+ targetY: {
+ type: Types.ATTRIBUTE
+ },
+ textLength: {
+ type: Types.ATTRIBUTE
+ },
+ viewBox: {
+ type: Types.ATTRIBUTE
+ },
+ viewTarget: {
+ type: Types.ATTRIBUTE
+ },
+ xChannelSelector: {
+ type: Types.ATTRIBUTE
+ },
+ yChannelSelector: {
+ type: Types.ATTRIBUTE
+ },
+ zoomAndPan: {
+ type: Types.ATTRIBUTE
+ }
+};
+const NonComposedEvents = new Set(["abort", "animationstart", "animationend", "animationiteration", "blur", "change", "copy", "cut", "error", "focus", "load", "loadend", "loadstart", "mouseenter", "mouseleave", "paste", "progress", "reset", "select", "submit", "transitionstart", "transitioncancel", "transitionend", "transitionrun"]);
+
+const eventRegistry = new Set();
+const config = index_js.runtimeConfig;
+function template(html, isSVG) {
+ const t = document.createElement('template');
+ t.innerHTML = html;
+ if (t.innerHTML !== html) throw new Error(`Template html does not match input:\n${t.innerHTML}\n${html}`);
+ let node = t.content.firstChild;
+ if (isSVG) node = node.firstChild;
+ return node;
+}
+function createComponent(Comp, props, dynamicKeys) {
+ if (dynamicKeys) {
+ for (let i = 0; i < dynamicKeys.length; i++) dynamicProp(props, dynamicKeys[i]);
+ }
+ return index_js.sample(() => Comp(props));
+}
+function delegateEvents(eventNames) {
+ for (let i = 0, l = eventNames.length; i < l; i++) {
+ const name = eventNames[i];
+ if (!eventRegistry.has(name)) {
+ eventRegistry.add(name);
+ document.addEventListener(name, eventHandler);
+ }
+ }
+}
+function clearDelegatedEvents() {
+ for (let name of eventRegistry.keys()) document.removeEventListener(name, eventHandler);
+ eventRegistry.clear();
+}
+function classList(node, value, prev) {
+ const classKeys = Object.keys(value);
+ for (let i = 0, len = classKeys.length; i < len; i++) {
+ const key = classKeys[i],
+ classValue = value[key],
+ classNames = key.split(/\s+/);
+ if (prev && prev[key] === classValue) continue;
+ for (let j = 0, nameLen = classNames.length; j < nameLen; j++) node.classList.toggle(classNames[j], classValue);
+ }
+}
+function spread(node, accessor, isSVG, skipChildren) {
+ if (typeof accessor === 'function') {
+ index_js.createEffect(current => spreadExpression(node, accessor(), current, isSVG, skipChildren));
+ } else spreadExpression(node, accessor, undefined, isSVG, skipChildren);
+}
+function insert(parent, accessor, marker, initial) {
+ if (marker !== undefined && !initial) initial = [];
+ if (typeof accessor !== 'function') return insertExpression(parent, accessor, initial, marker);
+ index_js.createEffect(current => insertExpression(parent, accessor(), current, marker), initial);
+}
+function renderToString(code, options = {}) {
+ options = {
+ timeoutMs: 10000,
+ ...options
+ };
+ config.hydrate = {
+ id: '',
+ count: 0
+ };
+ const container = document.createElement("div");
+ return new Promise(resolve => {
+ setTimeout(() => resolve(container.innerHTML), options.timeoutMs);
+ if (!code.length) {
+ insert(container, code());
+ resolve(container.innerHTML);
+ } else insert(container, code(() => resolve(container.innerHTML)));
+ });
+}
+function hydrate(code, root) {
+ config.hydrate = {
+ id: '',
+ count: 0,
+ registry: new Map()
+ };
+ const templates = root.querySelectorAll(`*[_hk]`);
+ for (let i = 0; i < templates.length; i++) {
+ const node = templates[i];
+ config.hydrate.registry.set(node.getAttribute('_hk'), node);
+ }
+ code();
+ delete config.hydrate;
+}
+function getNextElement(template, isSSR) {
+ const hydrate = config.hydrate;
+ let node, key;
+ if (!hydrate || !hydrate.registry || !(node = hydrate.registry.get(key = `${hydrate.id}:${hydrate.count++}`))) {
+ const el = template.cloneNode(true);
+ if (isSSR && hydrate) el.setAttribute('_hk', `${hydrate.id}:${hydrate.count++}`);
+ return el;
+ }
+ if (window && window._$HYDRATION) window._$HYDRATION.completed.add(key);
+ return node;
+}
+function getNextMarker(start) {
+ let end = start,
+ count = 0,
+ current = [];
+ if (config.hydrate && config.hydrate.registry) {
+ while (end) {
+ if (end.nodeType === 8) {
+ const v = end.nodeValue;
+ if (v === "#") count++;else if (v === "/") {
+ if (count === 0) return [end, current];
+ count--;
+ }
+ }
+ current.push(end);
+ end = end.nextSibling;
+ }
+ }
+ return [end, current];
+}
+function runHydrationEvents(id) {
+ if (window && window._$HYDRATION) {
+ const {
+ completed,
+ events
+ } = window._$HYDRATION;
+ while (events.length) {
+ const [id, e] = events[0];
+ if (!completed.has(id)) return;
+ eventHandler(e);
+ events.shift();
+ }
+ }
+}
+function generateHydrationEventsScript(eventNames) {
+ return `!function(){function t(t){const e=function t(e){return e&&(e.getAttribute("_hk")||t(e.host&&e.host instanceof Node?e.host:e.parentNode))}(t.composedPath&&t.composedPath()[0]||t.target);e&&!window._$HYDRATION.completed.has(e)&&window._$HYDRATION.events.push([e,t])}window._$HYDRATION={events:[],completed:new Set},["${eventNames.join('","')}"].forEach(e=>document.addEventListener(e,t))}();`;
+}
+function dynamicProp(props, key) {
+ const src = props[key];
+ Object.defineProperty(props, key, {
+ get() {
+ return src();
+ },
+ enumerable: true
+ });
+}
+function lookup(el) {
+ return el && (el.model || lookup(el.host || el.parentNode));
+}
+function eventHandler(e) {
+ const key = `__${e.type}`;
+ let node = e.composedPath && e.composedPath()[0] || e.target;
+ if (e.target !== node) {
+ Object.defineProperty(e, 'target', {
+ configurable: true,
+ value: node
+ });
+ }
+ Object.defineProperty(e, 'currentTarget', {
+ configurable: true,
+ get() {
+ return node;
+ }
+ });
+ while (node !== null) {
+ const handler = node[key];
+ if (handler) {
+ const model = handler.length > 1 ? lookup(node) : undefined;
+ handler(e, model);
+ if (e.cancelBubble) return;
+ }
+ node = node.host && node.host instanceof Node ? node.host : node.parentNode;
+ }
+}
+function spreadExpression(node, props, prevProps = {}, isSVG, skipChildren) {
+ let info;
+ if (!skipChildren && "children" in props) {
+ index_js.createEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+ }
+ index_js.createEffect(() => {
+ for (const prop in props) {
+ if (prop === "children") continue;
+ const value = props[prop];
+ if (value === prevProps[prop]) continue;
+ if (prop === "style") {
+ Object.assign(node.style, value);
+ } else if (prop === "classList") {
+ classList(node, value, prevProps[prop]);
+ } else if (prop === "ref" || prop === "forwardRef") {
+ value(node);
+ } else if (prop.slice(0, 2) === "on") {
+ const lc = prop.toLowerCase();
+ if (lc !== prop && !NonComposedEvents.has(lc.slice(2))) {
+ const name = lc.slice(2);
+ node[`__${name}`] = value;
+ delegateEvents([name]);
+ } else node[lc] = value;
+ } else if (prop === "events") {
+ for (const eventName in value) node.addEventListener(eventName, value[eventName]);
+ } else if (info = Attributes[prop]) {
+ if (info.type === "attribute") {
+ node.setAttribute(prop, value);
+ } else node[info.alias] = value;
+ } else if (isSVG) {
+ if (info = SVGAttributes[prop]) {
+ if (info.alias) node.setAttribute(info.alias, value);else node.setAttribute(prop, value);
+ } else node.setAttribute(prop.replace(/([A-Z])/g, g => `-${g[0].toLowerCase()}`), value);
+ } else node[prop] = value;
+ prevProps[prop] = value;
+ }
+ });
+ return prevProps;
+}
+function normalizeIncomingArray(normalized, array, unwrap) {
+ let dynamic = false;
+ for (let i = 0, len = array.length; i < len; i++) {
+ let item = array[i],
+ t;
+ if (item instanceof Node) {
+ normalized.push(item);
+ } else if (item == null || item === true || item === false) ; else if (Array.isArray(item)) {
+ dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+ } else if ((t = typeof item) === 'string') {
+ normalized.push(document.createTextNode(item));
+ } else if (t === 'function') {
+ if (unwrap) {
+ const idx = item();
+ dynamic = normalizeIncomingArray(normalized, Array.isArray(idx) ? idx : [idx]) || dynamic;
+ } else {
+ normalized.push(item);
+ dynamic = true;
+ }
+ } else normalized.push(document.createTextNode(item.toString()));
+ }
+ return dynamic;
+}
+function appendNodes(parent, array, marker) {
+ for (let i = 0, len = array.length; i < len; i++) parent.insertBefore(array[i], marker);
+}
+function cleanChildren(parent, current, marker, replacement) {
+ if (marker === undefined) return parent.textContent = '';
+ const node = replacement || document.createTextNode('');
+ if (current.length) {
+ node !== current[0] && parent.replaceChild(node, current[0]);
+ for (let i = current.length - 1; i > 0; i--) parent.removeChild(current[i]);
+ } else parent.insertBefore(node, marker);
+ return [node];
+}
+function insertExpression(parent, value, current, marker, unwrapArray) {
+ while (typeof current === "function") current = current();
+ if (value === current) return current;
+ const t = typeof value,
+ multi = marker !== undefined;
+ parent = multi && current[0] && current[0].parentNode || parent;
+ if (t === 'string' || t === 'number') {
+ if (t === 'number') value = value.toString();
+ if (multi) {
+ let node = current[0];
+ if (node && node.nodeType === 3) {
+ node.data = value;
+ } else node = document.createTextNode(value);
+ current = cleanChildren(parent, current, marker, node);
+ } else {
+ if (current !== '' && typeof current === 'string') {
+ current = parent.firstChild.data = value;
+ } else current = parent.textContent = value;
+ }
+ } else if (value == null || t === 'boolean') {
+ if (config.hydrate && config.hydrate.registry) return current;
+ current = cleanChildren(parent, current, marker);
+ } else if (t === 'function') {
+ index_js.createEffect(() => current = insertExpression(parent, value(), current, marker));
+ return () => current;
+ } else if (Array.isArray(value)) {
+ const array = [];
+ if (normalizeIncomingArray(array, value, unwrapArray)) {
+ index_js.createEffect(() => current = insertExpression(parent, array, current, marker, true));
+ return () => current;
+ }
+ if (config.hydrate && config.hydrate.registry) return current;
+ if (array.length === 0) {
+ current = cleanChildren(parent, current, marker);
+ if (multi) return current;
+ } else {
+ if (Array.isArray(current)) {
+ if (current.length === 0) {
+ appendNodes(parent, array, marker);
+ } else reconcileArrays(parent, current, array);
+ } else if (current == null || current === '') {
+ appendNodes(parent, array);
+ } else {
+ reconcileArrays(parent, multi && current || [parent.firstChild], array);
+ }
+ }
+ current = array;
+ } else if (value instanceof Node) {
+ if (Array.isArray(current)) {
+ if (multi) return current = cleanChildren(parent, current, marker, value);
+ cleanChildren(parent, current, null, value);
+ } else if (current == null || current === '') {
+ parent.appendChild(value);
+ } else parent.replaceChild(value, parent.firstChild);
+ current = value;
+ }
+ return current;
+}
+var NOMATCH = -1;
+function reconcileArrays(parent, ns, us) {
+ var ulen = us.length,
+ nmin = 0,
+ nmax = ns.length - 1,
+ umin = 0,
+ umax = ulen - 1,
+ n = ns[nmin],
+ u = us[umin],
+ nx = ns[nmax],
+ ux = us[umax],
+ ul = nx.nextSibling,
+ i,
+ loop = true;
+ fixes: while (loop) {
+ loop = false;
+ while (u === n) {
+ umin++;
+ nmin++;
+ if (umin > umax || nmin > nmax) break fixes;
+ u = us[umin];
+ n = ns[nmin];
+ }
+ while (ux === nx) {
+ ul = nx;
+ umax--;
+ nmax--;
+ if (umin > umax || nmin > nmax) break fixes;
+ ux = us[umax];
+ nx = ns[nmax];
+ }
+ while (u === nx) {
+ loop = true;
+ parent.insertBefore(nx, n);
+ umin++;
+ nmax--;
+ if (umin > umax || nmin > nmax) break fixes;
+ u = us[umin];
+ nx = ns[nmax];
+ }
+ while (ux === n) {
+ loop = true;
+ if (ul === null) parent.appendChild(n);else parent.insertBefore(n, ul);
+ ul = n;
+ umax--;
+ nmin++;
+ if (umin > umax || nmin > nmax) break fixes;
+ ux = us[umax];
+ n = ns[nmin];
+ }
+ }
+ if (umin > umax) {
+ while (nmin <= nmax) {
+ parent.removeChild(ns[nmax]);
+ nmax--;
+ }
+ return;
+ }
+ if (nmin > nmax) {
+ while (umin <= umax) {
+ parent.insertBefore(us[umin], ul);
+ umin++;
+ }
+ return;
+ }
+ const P = new Array(umax - umin + 1),
+ I = new Map();
+ for (let i = umin; i <= umax; i++) {
+ P[i] = NOMATCH;
+ I.set(us[i], i);
+ }
+ let reusingNodes = umin + us.length - 1 - umax,
+ toRemove = [];
+ for (let i = nmin; i <= nmax; i++) {
+ if (I.has(ns[i])) {
+ P[I.get(ns[i])] = i;
+ reusingNodes++;
+ } else toRemove.push(i);
+ }
+ if (reusingNodes === 0) {
+ if (n !== parent.firstChild || nx !== parent.lastChild) {
+ for (i = nmin; i <= nmax; i++) parent.removeChild(ns[i]);
+ while (umin <= umax) {
+ parent.insertBefore(us[umin], ul);
+ umin++;
+ }
+ return;
+ }
+ parent.textContent = '';
+ while (umin <= umax) {
+ parent.appendChild(us[umin]);
+ umin++;
+ }
+ return;
+ }
+ var lcs = longestPositiveIncreasingSubsequence(P, umin),
+ nodes = [],
+ tmp = ns[nmin],
+ lisIdx = lcs.length - 1,
+ tmpB;
+ for (let i = nmin; i <= nmax; i++) {
+ nodes[i] = tmp;
+ tmp = tmp.nextSibling;
+ }
+ for (let i = 0; i < toRemove.length; i++) parent.removeChild(nodes[toRemove[i]]);
+ for (let i = umax; i >= umin; i--) {
+ if (lcs[lisIdx] === i) {
+ ul = nodes[P[lcs[lisIdx]]];
+ lisIdx--;
+ } else {
+ tmpB = P[i] === NOMATCH ? us[i] : nodes[P[i]];
+ parent.insertBefore(tmpB, ul);
+ ul = tmpB;
+ }
+ }
+}
+function longestPositiveIncreasingSubsequence(ns, newStart) {
+ let seq = [],
+ is = [],
+ l = -1,
+ pre = new Array(ns.length);
+ for (let i = newStart, len = ns.length; i < len; i++) {
+ let n = ns[i];
+ if (n < 0) continue;
+ let j = findGreatestIndexLEQ(seq, n);
+ if (j !== -1) pre[i] = is[j];
+ if (j === l) {
+ l++;
+ seq[l] = n;
+ is[l] = i;
+ } else if (n < seq[j + 1]) {
+ seq[j + 1] = n;
+ is[j + 1] = i;
+ }
+ }
+ for (let i = is[l]; l >= 0; i = pre[i], l--) {
+ seq[l] = i;
+ }
+ return seq;
+}
+function findGreatestIndexLEQ(seq, n) {
+ var lo = -1,
+ hi = seq.length;
+ if (hi > 0 && seq[hi - 1] <= n) return hi - 1;
+ while (hi - lo > 1) {
+ var mid = Math.floor((lo + hi) / 2);
+ if (seq[mid] > n) {
+ hi = mid;
+ } else {
+ lo = mid;
+ }
+ }
+ return lo;
+}
+
+const SuspenseListContext = index_js.createContext();
+function SuspenseList(props) {
+ let index = 0,
+ suspenseSetter,
+ showContent,
+ showFallback;
+ const listContext = index_js.useContext(SuspenseListContext);
+ if (listContext) {
+ const [state, stateSetter] = index_js.createSignal("running", index_js.equalFn);
+ suspenseSetter = stateSetter;
+ [showContent, showFallback] = listContext.register(state);
+ }
+ const registry = [],
+ comp = createComponent(SuspenseListContext.Provider, {
+ value: {
+ register: state => {
+ const [showingContent, showContent] = index_js.createSignal(false, index_js.equalFn),
+ [showingFallback, showFallback] = index_js.createSignal(false, index_js.equalFn);
+ registry[index++] = {
+ state,
+ showContent,
+ showFallback
+ };
+ return [showingContent, showingFallback];
+ }
+ },
+ children: () => props.children
+ }, ["children"]);
+ index_js.createEffect(() => {
+ const reveal = props.revealOrder,
+ tail = props.tail,
+ visibleContent = showContent ? showContent() : true,
+ visibleFallback = showFallback ? showFallback() : true,
+ reverse = reveal === "backwards";
+ if (reveal === "together") {
+ const all = registry.every(i => i.state() === "running");
+ suspenseSetter && suspenseSetter(all ? "running" : "fallback");
+ registry.forEach(i => {
+ i.showContent(all && visibleContent);
+ i.showFallback(visibleFallback);
+ });
+ return;
+ }
+ let stop = false;
+ for (let i = 0, len = registry.length; i < len; i++) {
+ const n = reverse ? len - i - 1 : i,
+ s = registry[n].state();
+ if (!stop && (s === "running" || s === "suspended")) {
+ registry[n].showContent(visibleContent);
+ registry[n].showFallback(visibleFallback);
+ } else {
+ const next = !stop;
+ if (next && suspenseSetter) suspenseSetter("fallback");
+ if (!tail || next && tail === "collapsed") {
+ registry[n].showFallback(visibleFallback);
+ } else registry[n].showFallback(false);
+ stop = true;
+ registry[n].showContent(next);
+ }
+ }
+ if (!stop && suspenseSetter) suspenseSetter("running");
+ });
+ return comp;
+}
+function Suspense(props) {
+ let counter = 0,
+ t,
+ state = "running",
+ showContent,
+ showFallback,
+ transition;
+ const [get, next] = index_js.createSignal(),
+ store = {
+ increment: () => {
+ if (++counter === 1) {
+ if (!store.initializing) {
+ if (index_js.SuspenseContext.transition) {
+ state = "suspended";
+ !transition && (transition = index_js.SuspenseContext.transition).increment();
+ t = setTimeout(() => (state = "fallback", next()), index_js.SuspenseContext.transition.timeoutMs);
+ } else state = "fallback";
+ next();
+ } else state = "fallback";
+ index_js.SuspenseContext.increment();
+ }
+ },
+ decrement: () => {
+ if (--counter === 0) {
+ t && clearTimeout(t);
+ if (state !== "running") {
+ state = "running";
+ transition && transition.decrement();
+ transition = undefined;
+ next();
+ index_js.SuspenseContext.decrement();
+ }
+ }
+ },
+ state: () => {
+ get();
+ return state;
+ },
+ initializing: true
+ };
+ const listContext = index_js.useContext(SuspenseListContext);
+ if (listContext) [showContent, showFallback] = listContext.register(store.state);
+ return createComponent(index_js.SuspenseContext.Provider, {
+ value: store,
+ children: () => {
+ let dispose;
+ const rendered = index_js.sample(() => props.children),
+ marker = document.createTextNode(""),
+ doc = document.implementation.createHTMLDocument();
+ Object.defineProperty(doc.body, "host", {
+ get() {
+ return marker && marker.parentNode;
+ }
+ });
+ return () => {
+ const value = store.state(),
+ visibleContent = showContent ? showContent() : true,
+ visibleFallback = showFallback ? showFallback() : true;
+ if (store.initializing) store.initializing = false;
+ dispose && dispose();
+ dispose = null;
+ if (value === "running" && visibleContent || value === "suspended") return [marker, rendered];
+ if (!visibleFallback) return [marker];
+ return [marker, props.fallback];
+ };
+ }
+ }, ["children"]);
+}
+
+function render(code, element) {
+ let disposer;
+ index_js.createRoot(dispose => {
+ disposer = dispose;
+ insert(element, code());
+ });
+ return disposer;
+}
+function renderToString$1(code, options) {
+ return index_js.createRoot(dispose => renderToString(done => {
+ const rendered = code();
+ index_js.createEffect(() => {
+ if (!index_js.SuspenseContext.active()) {
+ dispose();
+ done();
+ }
+ });
+ return rendered;
+ }, options));
+}
+function hydrate$1(code, element) {
+ let disposer;
+ hydrate(() => {
+ disposer = render(code, element);
+ }, element);
+ return disposer;
+}
+function wrapCondition(fn) {
+ return index_js.createMemo(fn, undefined, index_js.equalFn);
+}
+function For(props) {
+ const fallback = "fallback" in props && {
+ fallback: () => props.fallback
+ },
+ mapped = index_js.awaitSuspense(index_js.createMemo(index_js.mapArray(() => props.each, props.children, fallback ? fallback : undefined)));
+ return props.transform ? props.transform(mapped) : mapped;
+}
+function Show(props) {
+ const useFallback = "fallback" in props,
+ condition = index_js.createMemo(() => !!props.when, undefined, index_js.equalFn),
+ mapped = index_js.awaitSuspense(index_js.createMemo(() => condition() ? index_js.sample(() => props.children) : useFallback ? index_js.sample(() => props.fallback) : undefined));
+ return props.transform ? props.transform(mapped) : mapped;
+}
+function Switch(props) {
+ let conditions = props.children;
+ Array.isArray(conditions) || (conditions = [conditions]);
+ const useFallback = "fallback" in props,
+ evalConditions = index_js.createMemo(() => {
+ for (let i = 0; i < conditions.length; i++) {
+ if (conditions[i].when) return i;
+ }
+ return -1;
+ }, undefined, index_js.equalFn),
+ mapped = index_js.awaitSuspense(index_js.createMemo(() => {
+ const index = evalConditions();
+ return index_js.sample(() => index < 0 ? useFallback && props.fallback : conditions[index].children);
+ }));
+ return props.transform ? props.transform(mapped) : mapped;
+}
+function Match(props) {
+ return props;
+}
+function Portal(props) {
+ const {
+ useShadow
+ } = props,
+ container = document.createElement("div"),
+ marker = document.createTextNode(""),
+ mount = props.mount || document.body,
+ renderRoot = useShadow && container.attachShadow ? container.attachShadow({
+ mode: "open"
+ }) : container;
+ Object.defineProperty(container, "host", {
+ get() {
+ return marker.parentNode;
+ }
+ });
+ insert(renderRoot, index_js.sample(() => props.children));
+ mount.appendChild(container);
+ props.ref && props.ref(container);
+ index_js.onCleanup(() => mount.removeChild(container));
+ return marker;
+}
+
+Object.defineProperty(exports, 'currentContext', {
+ enumerable: true,
+ get: function () {
+ return index_js.getContextOwner;
+ }
+});
+Object.defineProperty(exports, 'wrap', {
+ enumerable: true,
+ get: function () {
+ return index_js.createEffect;
+ }
+});
+Object.defineProperty(exports, 'wrapMemo', {
+ enumerable: true,
+ get: function () {
+ return index_js.createMemo;
+ }
+});
+exports.For = For;
+exports.Match = Match;
+exports.Portal = Portal;
+exports.Show = Show;
+exports.Suspense = Suspense;
+exports.SuspenseList = SuspenseList;
+exports.Switch = Switch;
+exports.classList = classList;
+exports.clearDelegatedEvents = clearDelegatedEvents;
+exports.createComponent = createComponent;
+exports.delegateEvents = delegateEvents;
+exports.generateHydrationEventsScript = generateHydrationEventsScript;
+exports.getNextElement = getNextElement;
+exports.getNextMarker = getNextMarker;
+exports.hydrate = hydrate$1;
+exports.insert = insert;
+exports.render = render;
+exports.renderToString = renderToString$1;
+exports.runHydrationEvents = runHydrationEvents;
+exports.spread = spread;
+exports.template = template;
+exports.wrapCondition = wrapCondition;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/lib/index.js b/__tests__/integration/sub-package-json/node_modules/solid-js/lib/index.js
new file mode 100644
index 0000000000..ea74b0470c
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/lib/index.js
@@ -0,0 +1,1341 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let taskIdCounter = 1,
+ isCallbackScheduled = false,
+ isPerformingWork = false,
+ taskQueue = [],
+ currentTask = null,
+ shouldYieldToHost = null,
+ yieldInterval = 5,
+ deadline = 0,
+ maxYieldInterval = 300,
+ scheduleCallback = null,
+ scheduledCallback = null;
+const maxSigned31BitInt = 1073741823;
+function setupScheduler() {
+ if (window && window.MessageChannel) {
+ const channel = new MessageChannel(),
+ port = channel.port2;
+ scheduleCallback = () => port.postMessage(null);
+ channel.port1.onmessage = () => {
+ if (scheduledCallback !== null) {
+ const currentTime = performance.now();
+ deadline = currentTime + yieldInterval;
+ const hasTimeRemaining = true;
+ try {
+ const hasMoreWork = scheduledCallback(hasTimeRemaining, currentTime);
+ if (!hasMoreWork) {
+ scheduledCallback = null;
+ } else port.postMessage(null);
+ } catch (error) {
+ port.postMessage(null);
+ throw error;
+ }
+ }
+ };
+ } else {
+ let _callback;
+ scheduleCallback = () => {
+ if (!_callback) {
+ _callback = scheduledCallback;
+ setTimeout(() => {
+ const currentTime = performance.now();
+ deadline = currentTime + yieldInterval;
+ const hasMoreWork = _callback(true, currentTime);
+ _callback = null;
+ if (hasMoreWork) scheduleCallback();
+ }, 0);
+ }
+ };
+ }
+ if (navigator && navigator.scheduling && navigator.scheduling.isInputPending) {
+ const scheduling = navigator.scheduling;
+ shouldYieldToHost = () => {
+ const currentTime = performance.now();
+ if (currentTime >= deadline) {
+ if (scheduling.isInputPending()) {
+ return true;
+ }
+ return currentTime >= maxYieldInterval;
+ } else {
+ return false;
+ }
+ };
+ } else {
+ shouldYieldToHost = () => performance.now() >= deadline;
+ }
+}
+function enqueue(taskQueue, task) {
+ function findIndex() {
+ let m = 0;
+ let n = taskQueue.length - 1;
+ while (m <= n) {
+ let k = n + m >> 1;
+ let cmp = task.expirationTime - taskQueue[k].expirationTime;
+ if (cmp > 0) m = k + 1;else if (cmp < 0) n = k - 1;else return k;
+ }
+ return m;
+ }
+ taskQueue.splice(findIndex(), 0, task);
+}
+function requestCallback(fn, options) {
+ if (!scheduleCallback) setupScheduler();
+ let startTime = performance.now(),
+ timeout = maxSigned31BitInt;
+ if (options && options.timeout) timeout = options.timeout;
+ const newTask = {
+ id: taskIdCounter++,
+ fn,
+ startTime,
+ expirationTime: startTime + timeout
+ };
+ enqueue(taskQueue, newTask);
+ if (!isCallbackScheduled && !isPerformingWork) {
+ isCallbackScheduled = true;
+ scheduledCallback = flushWork;
+ scheduleCallback();
+ }
+ return newTask;
+}
+function cancelCallback(task) {
+ task.fn = null;
+}
+function flushWork(hasTimeRemaining, initialTime) {
+ isCallbackScheduled = false;
+ isPerformingWork = true;
+ try {
+ return workLoop(hasTimeRemaining, initialTime);
+ } finally {
+ currentTask = null;
+ isPerformingWork = false;
+ }
+}
+function workLoop(hasTimeRemaining, initialTime) {
+ let currentTime = initialTime;
+ currentTask = taskQueue[0] || null;
+ while (currentTask !== null) {
+ if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
+ break;
+ }
+ const callback = currentTask.fn;
+ if (callback !== null) {
+ currentTask.fn = null;
+ const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+ callback(didUserCallbackTimeout);
+ currentTime = performance.now();
+ if (currentTask === taskQueue[0]) {
+ taskQueue.shift();
+ }
+ } else taskQueue.shift();
+ currentTask = taskQueue[0] || null;
+ }
+ return currentTask !== null;
+}
+
+const equalFn = (a, b) => a === b;
+const ERROR = Symbol("error");
+function createRoot(fn, detachedOwner) {
+ detachedOwner && (Owner = detachedOwner);
+ let owner = Owner,
+ listener = Listener,
+ root = fn.length === 0 ? UNOWNED : createComputationNode(null, null),
+ result = undefined,
+ disposer = function _dispose() {
+ if (RunningClock !== null) {
+ RootClock.disposes.add(root);
+ } else {
+ dispose(root);
+ }
+ };
+ Owner = root;
+ Listener = null;
+ try {
+ result = fn(disposer);
+ } catch (err) {
+ const fns = lookup(Owner, ERROR);
+ if (!fns) throw err;
+ fns.forEach(f => f(err));
+ } finally {
+ Owner && afterNode(Owner);
+ Listener = listener;
+ Owner = owner;
+ }
+ return result;
+}
+function createSignal(value, areEqual) {
+ const d = new DataNode(value);
+ let setter;
+ if (areEqual) {
+ let age = -1;
+ setter = v => {
+ if (!areEqual(v, value)) {
+ const time = RootClock.time;
+ if (time === age) {
+ throw new Error(`Conflicting value update: ${v} is not the same as ${value}`);
+ }
+ age = time;
+ value = v;
+ d.next(v);
+ }
+ };
+ } else setter = d.next.bind(d);
+ return [d.current.bind(d), setter];
+}
+function createEffect(fn, value) {
+ createComputationNode(fn, value);
+}
+function createDependentEffect(fn, deps, defer) {
+ const resolved = Array.isArray(deps) ? callAll(deps) : deps;
+ defer = !!defer;
+ createComputationNode(value => {
+ const listener = Listener;
+ resolved();
+ if (defer) defer = false;else {
+ Listener = null;
+ value = fn(value);
+ Listener = listener;
+ }
+ return value;
+ });
+}
+function createMemo(fn, value, areEqual) {
+ var node = createComputationNode(fn, value);
+ node.comparator = areEqual || null;
+ return () => {
+ if (Listener !== null) {
+ const state = node.state;
+ if ((state & 7) !== 0) {
+ liftComputation(node);
+ }
+ if (node.age === RootClock.time && state === 8) {
+ throw new Error("Circular dependency.");
+ }
+ if ((state & 16) === 0) {
+ if (node.log === null) node.log = createLog();
+ logRead(node.log);
+ }
+ }
+ return node.value;
+ };
+}
+function createDeferred(fn, options) {
+ let t,
+ timeout = options ? options.timeoutMs : undefined;
+ const [deferred, setDeferred] = createSignal(fn());
+ createEffect(() => {
+ fn();
+ if (!t || !t.fn) t = requestCallback(() => setDeferred(fn()), timeout !== undefined ? {
+ timeout
+ } : undefined);
+ });
+ return deferred;
+}
+function freeze(fn) {
+ let result = undefined;
+ if (RunningClock !== null) result = fn();else {
+ RunningClock = RootClock;
+ RunningClock.changes.reset();
+ try {
+ result = fn();
+ event();
+ } finally {
+ RunningClock = null;
+ }
+ }
+ return result;
+}
+function sample(fn) {
+ let result,
+ listener = Listener;
+ Listener = null;
+ result = fn();
+ Listener = listener;
+ return result;
+}
+function afterEffects(fn) {
+ if (Owner === null) fn();
+ else if (Owner.afters === null) Owner.afters = [fn];else Owner.afters.push(fn);
+}
+function onCleanup(fn) {
+ if (Owner === null) console.warn("cleanups created outside a `createRoot` or `render` will never be run");else if (Owner.cleanups === null) Owner.cleanups = [fn];else Owner.cleanups.push(fn);
+}
+function onError(fn) {
+ if (Owner === null) console.warn("error handlers created outside a `createRoot` or `render` will never be run");else if (Owner.context === null) Owner.context = {
+ [ERROR]: [fn]
+ };else if (!Owner.context[ERROR]) Owner.context[ERROR] = [fn];else Owner.context[ERROR].push(fn);
+}
+function isListening() {
+ return Listener !== null;
+}
+function createContext(defaultValue) {
+ const id = Symbol("context");
+ return {
+ id,
+ Provider: createProvider(id),
+ defaultValue
+ };
+}
+function useContext(context) {
+ return lookup(Owner, context.id) || context.defaultValue;
+}
+function getContextOwner() {
+ return Owner;
+}
+class DataNode {
+ constructor(value) {
+ this.value = value;
+ this.pending = NOTPENDING;
+ this.log = null;
+ }
+ current() {
+ if (Listener !== null) {
+ if (this.log === null) this.log = createLog();
+ logRead(this.log);
+ }
+ return this.value;
+ }
+ next(value) {
+ if (RunningClock !== null) {
+ if (this.pending !== NOTPENDING) {
+ if (value !== this.pending) {
+ throw new Error("conflicting changes: " + value + " !== " + this.pending);
+ }
+ } else {
+ this.pending = value;
+ RootClock.changes.add(this);
+ }
+ } else {
+ if (this.log !== null) {
+ this.pending = value;
+ RootClock.changes.add(this);
+ event();
+ } else {
+ this.value = value;
+ }
+ }
+ return value;
+ }
+}
+function createComputationNode(fn, value) {
+ const node = {
+ fn,
+ value,
+ age: RootClock.time,
+ state: 0,
+ comparator: null,
+ source1: null,
+ source1slot: 0,
+ sources: null,
+ sourceslots: null,
+ dependents: null,
+ dependentslot: 0,
+ dependentcount: 0,
+ owner: Owner,
+ owned: null,
+ log: null,
+ context: null,
+ cleanups: null,
+ afters: null
+ };
+ if (fn === null) return node;
+ let owner = Owner,
+ listener = Listener;
+ if (owner === null) console.warn("computations created outside a `createRoot` or `render` will never be disposed");
+ Owner = Listener = node;
+ if (RunningClock === null) {
+ toplevelComputation(node);
+ } else {
+ node.value = node.fn(node.value);
+ afterNode(node);
+ }
+ if (owner && owner !== UNOWNED) {
+ if (owner.owned === null) owner.owned = [node];else owner.owned.push(node);
+ }
+ Owner = owner;
+ Listener = listener;
+ return node;
+}
+function createClock() {
+ return {
+ time: 0,
+ changes: new Queue(),
+ updates: new Queue(),
+ disposes: new Queue()
+ };
+}
+function createLog() {
+ return {
+ node1: null,
+ node1slot: 0,
+ nodes: null,
+ nodeslots: null
+ };
+}
+class Queue {
+ constructor() {
+ this.items = [];
+ this.count = 0;
+ }
+ reset() {
+ this.count = 0;
+ }
+ add(item) {
+ this.items[this.count++] = item;
+ }
+ run(fn) {
+ let items = this.items;
+ for (let i = 0; i < this.count; i++) {
+ try {
+ const item = items[i];
+ items[i] = null;
+ fn(item);
+ } catch (err) {
+ const fns = lookup(Owner, ERROR);
+ if (!fns) throw err;
+ fns.forEach(f => f(err));
+ }
+ }
+ this.count = 0;
+ }
+}
+let RootClock = createClock(),
+ RunningClock = null,
+Listener = null,
+Owner = null,
+Pending = null;
+let NOTPENDING = {},
+ UNOWNED = createComputationNode(null, null);
+function callAll(ss) {
+ return function all() {
+ for (let i = 0; i < ss.length; i++) ss[i]();
+ };
+}
+function lookup(owner, key) {
+ return owner && (owner.context && owner.context[key] || owner.owner && lookup(owner.owner, key));
+}
+function resolveChildren(children) {
+ if (typeof children === "function") return createMemo(() => resolveChildren(children()));
+ if (Array.isArray(children)) {
+ const results = [];
+ for (let i = 0; i < children.length; i++) {
+ let result = resolveChildren(children[i]);
+ Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+ }
+ return results;
+ }
+ return children;
+}
+function createProvider(id) {
+ return function provider(props) {
+ let rendered;
+ createComputationNode(() => {
+ Owner.context = {
+ [id]: props.value
+ };
+ rendered = sample(() => resolveChildren(props.children));
+ });
+ return rendered;
+ };
+}
+function logRead(from) {
+ let to = Listener,
+ fromslot,
+ toslot = to.source1 === null ? -1 : to.sources === null ? 0 : to.sources.length;
+ if (from.node1 === null) {
+ from.node1 = to;
+ from.node1slot = toslot;
+ fromslot = -1;
+ } else if (from.nodes === null) {
+ if (from.node1 === to) return;
+ from.nodes = [to];
+ from.nodeslots = [toslot];
+ fromslot = 0;
+ } else {
+ fromslot = from.nodes.length;
+ if (from.nodes[fromslot - 1] === to) return;
+ from.nodes.push(to);
+ from.nodeslots.push(toslot);
+ }
+ if (to.source1 === null) {
+ to.source1 = from;
+ to.source1slot = fromslot;
+ } else if (to.sources === null) {
+ to.sources = [from];
+ to.sourceslots = [fromslot];
+ } else {
+ to.sources.push(from);
+ to.sourceslots.push(fromslot);
+ }
+}
+function liftComputation(node) {
+ if ((node.state & 6) !== 0) {
+ applyUpstreamUpdates(node);
+ }
+ if ((node.state & 1) !== 0) {
+ updateNode(node);
+ }
+ resetComputation(node, 31);
+}
+function event() {
+ let owner = Owner;
+ RootClock.updates.reset();
+ RootClock.time++;
+ try {
+ run(RootClock);
+ } finally {
+ Owner && afterNode(Owner);
+ RunningClock = Listener = null;
+ Owner = owner;
+ }
+}
+function toplevelComputation(node) {
+ RunningClock = RootClock;
+ RootClock.changes.reset();
+ RootClock.updates.reset();
+ try {
+ node.value = node.fn(node.value);
+ if (RootClock.changes.count > 0 || RootClock.updates.count > 0) {
+ RootClock.time++;
+ run(RootClock);
+ }
+ } catch (err) {
+ const fns = lookup(Owner, ERROR);
+ if (!fns) throw err;
+ fns.forEach(f => f(err));
+ } finally {
+ Owner && afterNode(Owner);
+ RunningClock = Owner = Listener = null;
+ }
+}
+function run(clock) {
+ let running = RunningClock,
+ count = 0;
+ RunningClock = clock;
+ clock.disposes.reset();
+ while (clock.changes.count !== 0 || clock.updates.count !== 0 || clock.disposes.count !== 0) {
+ if (count > 0)
+ clock.time++;
+ clock.changes.run(applyDataChange);
+ clock.updates.run(updateNode);
+ clock.disposes.run(dispose);
+ if (count++ > 1e5) {
+ throw new Error("Runaway clock detected");
+ }
+ }
+ RunningClock = running;
+}
+function applyDataChange(data) {
+ data.value = data.pending;
+ data.pending = NOTPENDING;
+ if (data.log) setComputationState(data.log, stateStale);
+}
+function updateNode(node) {
+ const state = node.state;
+ if ((state & 16) === 0) {
+ if ((state & 2) !== 0) {
+ node.dependents[node.dependentslot++] = null;
+ if (node.dependentslot === node.dependentcount) {
+ resetComputation(node, 14);
+ }
+ } else if ((state & 1) !== 0) {
+ if ((state & 4) !== 0) {
+ liftComputation(node);
+ } else if (node.comparator) {
+ const current = updateComputation(node);
+ const comparator = node.comparator;
+ if (!comparator(current, node.value)) {
+ markDownstreamComputations(node, false, true);
+ }
+ } else {
+ updateComputation(node);
+ }
+ }
+ }
+}
+function updateComputation(node) {
+ const value = node.value,
+ owner = Owner,
+ listener = Listener;
+ Owner = Listener = node;
+ node.state = 8;
+ cleanupNode(node, false);
+ node.value = node.fn(node.value);
+ resetComputation(node, 31);
+ Owner = owner;
+ Listener = listener;
+ return value;
+}
+function stateStale(node) {
+ const time = RootClock.time;
+ if (node.age < time) {
+ node.state |= 1;
+ node.age = time;
+ setDownstreamState(node, !!node.comparator);
+ }
+}
+function statePending(node) {
+ const time = RootClock.time;
+ if (node.age < time) {
+ node.state |= 2;
+ let dependents = node.dependents || (node.dependents = []);
+ dependents[node.dependentcount++] = Pending;
+ setDownstreamState(node, true);
+ }
+}
+function pendingStateStale(node) {
+ if ((node.state & 2) !== 0) {
+ node.state = 1;
+ const time = RootClock.time;
+ if (node.age < time) {
+ node.age = time;
+ if (!node.comparator) {
+ markDownstreamComputations(node, false, true);
+ }
+ }
+ }
+}
+function setDownstreamState(node, pending) {
+ RootClock.updates.add(node);
+ if (node.comparator) {
+ const pending = Pending;
+ Pending = node;
+ markDownstreamComputations(node, true, false);
+ Pending = pending;
+ } else {
+ markDownstreamComputations(node, pending, false);
+ }
+}
+function markDownstreamComputations(node, onchange, dirty) {
+ const owned = node.owned;
+ if (owned !== null) {
+ const pending = onchange && !dirty;
+ markForDisposal(owned, pending, RootClock.time);
+ }
+ const log = node.log;
+ if (log !== null) {
+ setComputationState(log, dirty ? pendingStateStale : onchange ? statePending : stateStale);
+ }
+}
+function setComputationState(log, stateFn) {
+ const node1 = log.node1,
+ nodes = log.nodes;
+ if (node1 !== null) stateFn(node1);
+ if (nodes !== null) {
+ for (let i = 0, ln = nodes.length; i < ln; i++) {
+ stateFn(nodes[i]);
+ }
+ }
+}
+function markForDisposal(children, pending, time) {
+ for (let i = 0, ln = children.length; i < ln; i++) {
+ const child = children[i];
+ if (child !== null) {
+ if (pending) {
+ if ((child.state & 16) === 0) {
+ child.state |= 4;
+ }
+ } else {
+ child.age = time;
+ child.state = 16;
+ }
+ const owned = child.owned;
+ if (owned !== null) markForDisposal(owned, pending, time);
+ }
+ }
+}
+function applyUpstreamUpdates(node) {
+ if ((node.state & 4) !== 0) {
+ const owner = node.owner;
+ if ((owner.state & 7) !== 0) liftComputation(owner);
+ node.state &= ~4;
+ }
+ if ((node.state & 2) !== 0) {
+ const slots = node.dependents;
+ for (let i = node.dependentslot, ln = node.dependentcount; i < ln; i++) {
+ const slot = slots[i];
+ if (slot != null) liftComputation(slot);
+ slots[i] = null;
+ }
+ node.state &= ~2;
+ }
+}
+function cleanupNode(node, final) {
+ let source1 = node.source1,
+ sources = node.sources,
+ sourceslots = node.sourceslots,
+ cleanups = node.cleanups,
+ owned = node.owned,
+ i,
+ len;
+ if (cleanups !== null) {
+ for (i = 0; i < cleanups.length; i++) {
+ cleanups[i](final);
+ }
+ node.cleanups = null;
+ }
+ node.context = null;
+ if (owned !== null) {
+ for (i = 0; i < owned.length; i++) {
+ dispose(owned[i]);
+ }
+ node.owned = null;
+ }
+ if (source1 !== null) {
+ cleanupSource(source1, node.source1slot);
+ node.source1 = null;
+ }
+ if (sources !== null) {
+ for (i = 0, len = sources.length; i < len; i++) {
+ cleanupSource(sources.pop(), sourceslots.pop());
+ }
+ }
+}
+function cleanupSource(source, slot) {
+ let nodes = source.nodes,
+ nodeslots = source.nodeslots,
+ last,
+ lastslot;
+ if (slot === -1) {
+ source.node1 = null;
+ } else {
+ last = nodes.pop();
+ lastslot = nodeslots.pop();
+ if (slot !== nodes.length) {
+ nodes[slot] = last;
+ nodeslots[slot] = lastslot;
+ if (lastslot === -1) {
+ last.source1slot = slot;
+ } else {
+ last.sourceslots[lastslot] = slot;
+ }
+ }
+ }
+}
+function afterNode(node) {
+ const afters = node.afters;
+ if (afters !== null) {
+ for (let i = 0; i < afters.length; i++) afters[i]();
+ node.afters = null;
+ }
+}
+function resetComputation(node, flags) {
+ node.state &= ~flags;
+ node.dependentslot = 0;
+ node.dependentcount = 0;
+}
+function dispose(node) {
+ node.fn = null;
+ node.log = null;
+ node.dependents = null;
+ cleanupNode(node, true);
+ resetComputation(node, 31);
+}
+
+const SNODE = Symbol("state-node"),
+ SPROXY = Symbol("state-proxy");
+function wrap(value, traps) {
+ return value[SPROXY] || (value[SPROXY] = new Proxy(value, traps || proxyTraps));
+}
+function isWrappable(obj) {
+ return obj != null && typeof obj === "object" && (obj.__proto__ === Object.prototype || Array.isArray(obj));
+}
+function unwrap(item) {
+ let result, unwrapped, v;
+ if (result = item != null && item._state) return result;
+ if (!isWrappable(item)) return item;
+ if (Array.isArray(item)) {
+ if (Object.isFrozen(item)) item = item.slice(0);
+ for (let i = 0, l = item.length; i < l; i++) {
+ v = item[i];
+ if ((unwrapped = unwrap(v)) !== v) item[i] = unwrapped;
+ }
+ } else {
+ if (Object.isFrozen(item)) item = Object.assign({}, item);
+ let keys = Object.keys(item);
+ for (let i = 0, l = keys.length; i < l; i++) {
+ v = item[keys[i]];
+ if ((unwrapped = unwrap(v)) !== v) item[keys[i]] = unwrapped;
+ }
+ }
+ return item;
+}
+function getDataNodes(target) {
+ let nodes = target[SNODE];
+ if (!nodes) target[SNODE] = nodes = {};
+ return nodes;
+}
+const proxyTraps = {
+ get(target, property) {
+ if (property === "_state") return target;
+ if (property === SPROXY || property === SNODE) return;
+ const value = target[property],
+ wrappable = isWrappable(value);
+ if (isListening() && (typeof value !== "function" || target.hasOwnProperty(property))) {
+ let nodes, node;
+ if (wrappable && (nodes = getDataNodes(value))) {
+ node = nodes._ || (nodes._ = new DataNode());
+ node.current();
+ }
+ nodes = getDataNodes(target);
+ node = nodes[property] || (nodes[property] = new DataNode());
+ node.current();
+ }
+ return wrappable ? wrap(value) : value;
+ },
+ set() {
+ return true;
+ },
+ deleteProperty() {
+ return true;
+ }
+};
+const setterTraps = {
+ get(target, property) {
+ if (property === "_state") return target;
+ const value = target[property];
+ return isWrappable(value) ? new Proxy(value, setterTraps) : value;
+ },
+ set(target, property, value) {
+ setProperty(target, property, unwrap(value));
+ return true;
+ },
+ deleteProperty(target, property) {
+ setProperty(target, property, undefined);
+ return true;
+ }
+};
+function setProperty(state, property, value, force) {
+ if (!force && state[property] === value) return;
+ const notify = Array.isArray(state) || !(property in state);
+ if (value === undefined) {
+ delete state[property];
+ } else state[property] = value;
+ let nodes = getDataNodes(state),
+ node;
+ (node = nodes[property]) && node.next();
+ notify && (node = nodes._) && node.next();
+}
+function mergeState(state, value, force) {
+ const keys = Object.keys(value);
+ for (let i = 0; i < keys.length; i += 1) {
+ const key = keys[i];
+ setProperty(state, key, value[key], force);
+ }
+}
+function updatePath(current, path, traversed = []) {
+ let part,
+ next = current;
+ if (path.length > 1) {
+ part = path.shift();
+ const partType = typeof part,
+ isArray = Array.isArray(current);
+ if (Array.isArray(part)) {
+ for (let i = 0; i < part.length; i++) {
+ updatePath(current, [part[i]].concat(path), [part[i]].concat(traversed));
+ }
+ return;
+ } else if (isArray && partType === "function") {
+ for (let i = 0; i < current.length; i++) {
+ if (part(current[i], i)) updatePath(current, [i].concat(path), [i].concat(traversed));
+ }
+ return;
+ } else if (isArray && partType === "object") {
+ const {
+ from = 0,
+ to = current.length - 1,
+ by = 1
+ } = part;
+ for (let i = from; i <= to; i += by) {
+ updatePath(current, [i].concat(path), [i].concat(traversed));
+ }
+ return;
+ } else if (path.length > 1) {
+ updatePath(current[part], path, [part].concat(traversed));
+ return;
+ }
+ next = current[part];
+ traversed = [part].concat(traversed);
+ }
+ let value = path[0];
+ if (typeof value === "function") {
+ const wrapped = part === undefined || isWrappable(next) ? new Proxy(next, setterTraps) : next;
+ value = value(wrapped, traversed);
+ if (value === wrapped || value === undefined) return;
+ }
+ value = unwrap(value);
+ if (part === undefined || isWrappable(next) && isWrappable(value) && !Array.isArray(value)) {
+ mergeState(next, value);
+ } else setProperty(current, part, value);
+}
+function createState(state) {
+ const unwrappedState = unwrap(state || {});
+ const wrappedState = wrap(unwrappedState);
+ function setState(...args) {
+ freeze(() => updatePath(unwrappedState, args));
+ }
+ return [wrappedState, setState];
+}
+function force(value) {
+ return state => {
+ if (!isWrappable(state)) return value;
+ mergeState(unwrap(state), value, true);
+ };
+}
+
+function applyState(target, parent, property, merge, key) {
+ let previous = parent[property];
+ if (target === previous) return;
+ if (!isWrappable(target) || !isWrappable(previous) || key && target[key] !== previous[key]) {
+ target !== previous && setProperty(parent, property, target);
+ return;
+ }
+ if (Array.isArray(target)) {
+ if (target.length && previous.length && (!merge || key && target[0][key] != null)) {
+ let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+ for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start][key] === target[start][key]); start++) {
+ applyState(target[start], previous, start, merge, key);
+ }
+ const temp = new Array(target.length),
+ newIndices = new Map();
+ for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
+ temp[newEnd] = previous[end];
+ }
+ if (start > newEnd || start > end) {
+ for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
+ for (; j < target.length; j++) {
+ setProperty(previous, j, temp[j]);
+ applyState(target[j], previous, j, merge, key);
+ }
+ if (previous.length > target.length) setProperty(previous, "length", target.length);
+ return;
+ }
+ newIndicesNext = new Array(newEnd + 1);
+ for (j = newEnd; j >= start; j--) {
+ item = target[j];
+ keyVal = key ? item[key] : item;
+ i = newIndices.get(keyVal);
+ newIndicesNext[j] = i === undefined ? -1 : i;
+ newIndices.set(keyVal, j);
+ }
+ for (i = start; i <= end; i++) {
+ item = previous[i];
+ keyVal = key ? item[key] : item;
+ j = newIndices.get(keyVal);
+ if (j !== undefined && j !== -1) {
+ temp[j] = previous[i];
+ j = newIndicesNext[j];
+ newIndices.set(keyVal, j);
+ }
+ }
+ for (j = start; j < target.length; j++) {
+ if (j in temp) {
+ setProperty(previous, j, temp[j]);
+ applyState(target[j], previous, j, merge, key);
+ } else setProperty(previous, j, target[j]);
+ }
+ } else {
+ for (let i = 0, len = target.length; i < len; i++) {
+ applyState(target[i], previous, i, merge, key);
+ }
+ }
+ if (previous.length > target.length) setProperty(previous, "length", target.length);
+ return;
+ }
+ const targetKeys = Object.keys(target);
+ for (let i = 0, len = targetKeys.length; i < len; i++) {
+ applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
+ }
+ const previousKeys = Object.keys(previous);
+ for (let i = 0, len = previousKeys.length; i < len; i++) {
+ if (target[previousKeys[i]] === undefined) setProperty(previous, previousKeys[i], undefined);
+ }
+}
+function reconcile(value, options = {}) {
+ const {
+ merge,
+ key = "id"
+ } = options;
+ return state => {
+ state = unwrap(state);
+ if (!isWrappable(state)) return value;
+ applyState(value, {
+ state
+ }, "state", merge, key);
+ };
+}
+
+const FALLBACK = Symbol("fallback");
+function mapArray(list, mapFn, options) {
+ if (typeof mapFn !== "function") {
+ options = mapFn || {};
+ mapFn = list;
+ return map;
+ }
+ options || (options = {});
+ return map(list);
+ function map(list) {
+ let items = [],
+ mapped = [],
+ disposers = [],
+ len = 0;
+ onCleanup(() => {
+ for (let i = 0, length = disposers.length; i < length; i++) disposers[i]();
+ });
+ return () => {
+ let newItems = list() || [],
+ i,
+ j;
+ return sample(() => {
+ let newLen = newItems.length,
+ newIndices,
+ newIndicesNext,
+ temp,
+ tempdisposers,
+ start,
+ end,
+ newEnd,
+ item;
+ if (newLen === 0) {
+ if (len !== 0) {
+ for (i = 0; i < len; i++) disposers[i]();
+ disposers = [];
+ items = [];
+ mapped = [];
+ len = 0;
+ }
+ if (options.fallback) {
+ items = [FALLBACK];
+ mapped[0] = createRoot(disposer => {
+ disposers[0] = disposer;
+ return options.fallback();
+ });
+ len = 1;
+ }
+ }
+ else if (len === 0) {
+ for (j = 0; j < newLen; j++) {
+ items[j] = newItems[j];
+ mapped[j] = createRoot(mapper);
+ }
+ len = newLen;
+ } else {
+ temp = new Array(newLen);
+ tempdisposers = new Array(newLen);
+ for (start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++);
+ for (end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
+ temp[newEnd] = mapped[end];
+ tempdisposers[newEnd] = disposers[end];
+ }
+ if (start > newEnd) {
+ for (j = end; start <= j; j--) disposers[j]();
+ const rLen = end - start + 1;
+ if (rLen > 0) {
+ mapped.splice(start, rLen);
+ disposers.splice(start, rLen);
+ }
+ items = newItems.slice(0);
+ len = newLen;
+ return mapped;
+ }
+ if (start > end) {
+ for (j = start; j <= newEnd; j++) mapped[j] = createRoot(mapper);
+ for (; j < newLen; j++) {
+ mapped[j] = temp[j];
+ disposers[j] = tempdisposers[j];
+ }
+ items = newItems.slice(0);
+ len = newLen;
+ return mapped;
+ }
+ newIndices = new Map();
+ newIndicesNext = new Array(newEnd + 1);
+ for (j = newEnd; j >= start; j--) {
+ item = newItems[j];
+ i = newIndices.get(item);
+ newIndicesNext[j] = i === undefined ? -1 : i;
+ newIndices.set(item, j);
+ }
+ for (i = start; i <= end; i++) {
+ item = items[i];
+ j = newIndices.get(item);
+ if (j !== undefined && j !== -1) {
+ temp[j] = mapped[i];
+ tempdisposers[j] = disposers[i];
+ j = newIndicesNext[j];
+ newIndices.set(item, j);
+ } else disposers[i]();
+ }
+ for (j = start; j < newLen; j++) {
+ if (j in temp) {
+ mapped[j] = temp[j];
+ disposers[j] = tempdisposers[j];
+ } else mapped[j] = createRoot(mapper);
+ }
+ len = mapped.length = newLen;
+ items = newItems.slice(0);
+ }
+ return mapped;
+ });
+ function mapper(disposer) {
+ disposers[j] = disposer;
+ return mapFn(newItems[j], j);
+ }
+ };
+ }
+}
+function reduceArray(list, fn, seed) {
+ if (arguments.length < 3) {
+ seed = fn;
+ fn = list;
+ return reducer;
+ }
+ return reducer(list);
+ function reducer(list) {
+ return () => {
+ let newList = list() || [],
+ result = seed;
+ return sample(() => {
+ for (let i = 0; i < newList.length; i++) {
+ result = fn(result, newList[i], i);
+ }
+ return result;
+ });
+ };
+ }
+}
+
+function setDefaults(props, defaultProps) {
+ const propKeys = Object.keys(defaultProps);
+ for (let i = 0; i < propKeys.length; i++) {
+ const key = propKeys[i];
+ !(key in props) && (props[key] = defaultProps[key]);
+ }
+}
+function cloneProps(props) {
+ const clone = {},
+ descriptors = Object.getOwnPropertyDescriptors(props);
+ Object.defineProperties(clone, descriptors);
+ return clone;
+}
+
+const runtimeConfig = {};
+function setHydrateContext(context) {
+ runtimeConfig.hydrate = context;
+}
+function nextHydrateContext() {
+ return runtimeConfig.hydrate ? {
+ id: `${runtimeConfig.hydrate.id}.${runtimeConfig.hydrate.count++}`,
+ count: 0,
+ registry: runtimeConfig.hydrate.registry
+ } : undefined;
+}
+
+function createActivityTracker() {
+ let count = 0,
+ active = false;
+ const [read, trigger] = createSignal();
+ return [() => (read(), active), () => count++ === 0 && (active = true, trigger()), () => --count <= 0 && (active = false, trigger())];
+}
+const SuspenseContext = createContext({});
+const [active, increment, decrement] = createActivityTracker();
+SuspenseContext.active = active;
+SuspenseContext.increment = increment;
+SuspenseContext.decrement = decrement;
+function generatePlaceholderPromise(isCancelled) {
+ let p;
+ return p = new Promise((res, rej) => setTimeout(() => (!isCancelled(p) && console.warn("Load not started for read resource by next task"), rej())));
+}
+function createResource(value) {
+ const [s, set] = createSignal(value),
+ [trackPromise, triggerPromise] = createSignal(),
+ [trackLoading, triggerLoading] = createSignal(),
+ contexts = new Set();
+ let loading = value === undefined,
+ error = null,
+ pr;
+ function loadEnd(v) {
+ pr = undefined;
+ freeze(() => {
+ set(v);
+ loading && (loading = false, triggerLoading());
+ for (let c of contexts.keys()) c.decrement();
+ contexts.clear();
+ });
+ }
+ function read() {
+ const c = useContext(SuspenseContext),
+ v = s();
+ if (error) throw error;
+ if (loading && !pr) {
+ load(generatePlaceholderPromise(p => p === pr));
+ }
+ trackPromise();
+ if (pr && c.increment && !contexts.has(c)) {
+ c.increment();
+ contexts.add(c);
+ }
+ return v;
+ }
+ function load(p) {
+ error = null;
+ if (p == null || typeof p !== "object" || !("then" in p)) {
+ pr = undefined;
+ loadEnd(p);
+ } else {
+ pr = p;
+ if (!loading) {
+ loading = true;
+ freeze(() => {
+ triggerLoading();
+ triggerPromise();
+ });
+ }
+ p.then(v => {
+ if (pr !== p) return;
+ loadEnd(v);
+ }, err => {
+ if (pr !== p) return;
+ error = err;
+ loadEnd(undefined);
+ });
+ }
+ return () => (trackLoading(), loading);
+ }
+ return [read, load];
+}
+function createResourceNode(v) {
+ const node = new DataNode(),
+ [read, load] = createResource(v);
+ return {
+ current: () => (read(), node.current()),
+ next: node.next.bind(node),
+ load
+ };
+}
+const resourceTraps = {
+ get(target, property) {
+ if (property === "_state") return target;
+ if (property === SPROXY || property === SNODE) return;
+ const value = target[property],
+ wrappable = isWrappable(value);
+ if (isListening() && (typeof value !== "function" || target.hasOwnProperty(property))) {
+ let nodes, node;
+ if (wrappable && (nodes = getDataNodes(value))) {
+ node = nodes._ || (nodes._ = new DataNode());
+ node.current();
+ }
+ nodes = getDataNodes(target);
+ node = nodes[property] || (nodes[property] = createResourceNode(value));
+ node.current();
+ }
+ return wrappable ? wrap(value) : value;
+ },
+ set() {
+ return true;
+ },
+ deleteProperty() {
+ return true;
+ }
+};
+function createResourceState(state) {
+ const unwrappedState = unwrap(state || {}),
+ wrappedState = wrap(unwrappedState, resourceTraps),
+ loading = {};
+ function setState(...args) {
+ freeze(() => updatePath(unwrappedState, args));
+ }
+ function loadState(v, r) {
+ const nodes = getDataNodes(unwrappedState),
+ keys = Object.keys(v);
+ for (let i = 0; i < keys.length; i++) {
+ const k = keys[i],
+ p = v[k],
+ node = nodes[k] || (nodes[k] = createResourceNode(unwrappedState[k])),
+ resolver = v => (r ? setState(r({
+ [k]: v
+ })) : setProperty(unwrappedState, k, v), v),
+ l = node.load(p && typeof p === "object" && "then" in p ? p.then(resolver) : resolver(p));
+ !(k in loading) && Object.defineProperty(loading, k, {
+ get() {
+ return l();
+ }
+ });
+ }
+ return loading;
+ }
+ return [wrappedState, loadState, setState];
+}
+function lazy(fn) {
+ return props => {
+ const hydrating = runtimeConfig.hydrate && runtimeConfig.hydrate.registry,
+ ctx = nextHydrateContext();
+ let s, r, p;
+ if (hydrating) {
+ [s, r] = createSignal();
+ fn().then(mod => r(mod.default));
+ } else {
+ [s, p] = createResource();
+ p(fn().then(mod => mod.default));
+ }
+ let Comp;
+ return createMemo(() => (Comp = s()) && sample(() => (setHydrateContext(ctx), Comp(props))));
+ };
+}
+function useTransition(config) {
+ const [pending, increment, decrement] = createActivityTracker();
+ return [pending, fn => {
+ const prevTransition = SuspenseContext.transition;
+ SuspenseContext.transition = {
+ timeoutMs: config.timeoutMs,
+ increment,
+ decrement
+ };
+ increment();
+ fn();
+ decrement();
+ afterEffects(() => SuspenseContext.transition = prevTransition);
+ }];
+}
+function awaitSuspense(fn) {
+ const {
+ state
+ } = useContext(SuspenseContext);
+ let cached;
+ return state ? () => state() === "suspended" ? cached : cached = fn() : fn;
+}
+
+exports.SuspenseContext = SuspenseContext;
+exports.afterEffects = afterEffects;
+exports.awaitSuspense = awaitSuspense;
+exports.cancelCallback = cancelCallback;
+exports.cloneProps = cloneProps;
+exports.createContext = createContext;
+exports.createDeferred = createDeferred;
+exports.createDependentEffect = createDependentEffect;
+exports.createEffect = createEffect;
+exports.createMemo = createMemo;
+exports.createResource = createResource;
+exports.createResourceState = createResourceState;
+exports.createRoot = createRoot;
+exports.createSignal = createSignal;
+exports.createState = createState;
+exports.equalFn = equalFn;
+exports.force = force;
+exports.freeze = freeze;
+exports.getContextOwner = getContextOwner;
+exports.isListening = isListening;
+exports.lazy = lazy;
+exports.mapArray = mapArray;
+exports.onCleanup = onCleanup;
+exports.onError = onError;
+exports.reconcile = reconcile;
+exports.reduceArray = reduceArray;
+exports.requestCallback = requestCallback;
+exports.runtimeConfig = runtimeConfig;
+exports.sample = sample;
+exports.setDefaults = setDefaults;
+exports.unwrap = unwrap;
+exports.useContext = useContext;
+exports.useTransition = useTransition;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/package.json b/__tests__/integration/sub-package-json/node_modules/solid-js/package.json
new file mode 100644
index 0000000000..ac82ad7d71
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/package.json
@@ -0,0 +1,59 @@
+{
+ "_from": "solid-js@^0.16.7",
+ "_id": "solid-js@0.16.7",
+ "_inBundle": false,
+ "_integrity": "sha512-05P9VHmolhFczJoJ3ewtU9EPXzu021yJ//Lan9IgH+y+cE9381oOOLeIjg7ay2wS0jnyBsIVITEUXqSsjrgbbQ==",
+ "_location": "/solid-js",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "solid-js@^0.16.7",
+ "name": "solid-js",
+ "escapedName": "solid-js",
+ "rawSpec": "^0.16.7",
+ "saveSpec": null,
+ "fetchSpec": "^0.16.7"
+ },
+ "_requiredBy": [
+ "/"
+ ],
+ "_resolved": "https://registry.npmjs.org/solid-js/-/solid-js-0.16.7.tgz",
+ "_shasum": "c0c5052511e8b0e57d74a0cc23ccbb8e8a863547",
+ "_spec": "solid-js@^0.16.7",
+ "_where": "/Users/fks/Code/pika-tools/snowpack/__tests__/integration/sub-package-json",
+ "author": {
+ "name": "Ryan Carniato"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "A declarative JavaScript library for building user interfaces.",
+ "files": [
+ "dist",
+ "dom",
+ "h",
+ "html",
+ "lib",
+ "types"
+ ],
+ "gitHead": "1f0d766ee46e0e3bd1df84c549817b2d3ae24b29",
+ "homepage": "https://github.com/ryansolid/solid#readme",
+ "license": "MIT",
+ "main": "lib/index.js",
+ "module": "dist/index.js",
+ "name": "solid-js",
+ "scripts": {
+ "bench": "node --allow-natives-syntax bench/bench.js",
+ "build": "npm-run-all -cnl build:*",
+ "build:js": "rollup -c",
+ "build:types": "tsc && ncp ./src/dom/runtime.d.ts ./types/dom/runtime.d.ts",
+ "prebuild": "rimraf dist/* lib/* types/* && dom-expressions",
+ "report:coverage": "cat ./coverage/lcov.info | ../../node_modules/coveralls/bin/coveralls.js && rm -rf ./coverage",
+ "test": "jest && npm run test:types",
+ "test:coverage": "jest --coverage && npm run test:types",
+ "test:types": "tsc --project tsconfig.test.json"
+ },
+ "sideEffects": false,
+ "types": "types/index.d.ts",
+ "version": "0.16.7"
+}
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/array.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/array.d.ts
new file mode 100644
index 0000000000..8121e45c57
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/array.d.ts
@@ -0,0 +1,8 @@
+export declare function mapArray(mapFn: (v: T, i: number) => U, options?: {
+ fallback?: () => U;
+}): (list: () => T[]) => () => U[];
+export declare function mapArray(list: () => T[], mapFn: (v: T, i: number) => U, options?: {
+ fallback?: () => U;
+}): () => U[];
+export declare function reduceArray(fn: (memo: U, value: T, i: number) => U, seed: U): (list: () => T[]) => () => U;
+export declare function reduceArray(list: () => T[], fn: (memo: U, value: T, i: number) => U, seed: U): () => U;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/component.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/component.d.ts
new file mode 100644
index 0000000000..1e19ca7b1a
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/component.d.ts
@@ -0,0 +1,2 @@
+export declare function setDefaults(props: T, defaultProps: T): void;
+export declare function cloneProps(props: T): T;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/Suspense.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/Suspense.d.ts
new file mode 100644
index 0000000000..f6a252c046
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/Suspense.d.ts
@@ -0,0 +1,9 @@
+export declare function SuspenseList(props: {
+ children: any;
+ revealOrder: "forwards" | "backwards" | "together";
+ tail?: "collapsed" | "hidden";
+}): any;
+export declare function Suspense(props: {
+ fallback: any;
+ children: any;
+}): any;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/h.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/h.d.ts
new file mode 100644
index 0000000000..b2e8cd1183
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/h.d.ts
@@ -0,0 +1,3 @@
+///
+declare const _default: import("hyper-dom-expressions").HyperScript;
+export default _default;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/html.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/html.d.ts
new file mode 100644
index 0000000000..b0e29a9130
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/html.d.ts
@@ -0,0 +1,3 @@
+///
+declare const _default: import("lit-dom-expressions").HTMLTag;
+export default _default;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/index.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/index.d.ts
new file mode 100644
index 0000000000..d2e424d528
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/index.d.ts
@@ -0,0 +1,39 @@
+export * from "./runtime";
+export * from "./Suspense";
+import { createMemo } from "../index.js";
+declare type MountableElement = Element | Document | ShadowRoot | DocumentFragment;
+export declare function render(code: () => any, element: MountableElement): () => void;
+export declare function renderToString(code: () => any, options: {
+ timeoutMs?: number;
+}): Promise;
+export declare function hydrate(code: () => any, element: MountableElement): () => void;
+export { createMemo as wrapMemo };
+export declare function wrapCondition(fn: () => T): () => T;
+export declare function For(props: {
+ each: T[];
+ fallback?: any;
+ transform?: (mapped: () => U[]) => () => U[];
+ children: (item: T) => U;
+}): () => U[];
+export declare function Show(props: {
+ when: boolean;
+ fallback?: T;
+ transform?: (mapped: () => T | undefined) => () => T | undefined;
+ children: T;
+}): () => T | undefined;
+export declare function Switch(props: {
+ fallback?: T;
+ transform?: (mapped: () => T) => () => T;
+ children: any;
+}): () => any;
+declare type MatchProps = {
+ when: boolean;
+ children: any;
+};
+export declare function Match(props: MatchProps): MatchProps;
+export declare function Portal(props: {
+ mount?: MountableElement;
+ useShadow?: boolean;
+ ref?: (e: HTMLDivElement) => void;
+ children: any;
+}): Text;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/runtime.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/runtime.d.ts
new file mode 100644
index 0000000000..b06573387a
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/dom/runtime.d.ts
@@ -0,0 +1,44 @@
+export function template(html: string, isSVG?: boolean): Element;
+export function wrap(fn: (prev?: T) => T, init?: T): any;
+export function wrapCondition(fn: () => any): () => any;
+export function insert(
+ parent: Element | Document | ShadowRoot | DocumentFragment,
+ accessor: any,
+ init?: any,
+ marker?: Node
+): any;
+export function createComponent(
+ Comp: (props: any) => any,
+ props: any,
+ dynamicKeys?: string[]
+): any;
+export function delegateEvents(eventNames: string[]): void;
+export function clearDelegatedEvents(): void;
+export function spread(
+ node: Element,
+ accessor: any,
+ isSVG?: Boolean,
+ skipChildren?: Boolean
+): void;
+export function classList(
+ node: Element,
+ value: { [k: string]: boolean },
+ prev?: { [k: string]: boolean }
+): void;
+export function currentContext(): any;
+export function renderToString(
+ fn: (done?: () => void) => any,
+ options?: {
+ timeoutMs?: number;
+ }
+): Promise;
+export function hydrate(
+ fn: () => unknown,
+ node: Element | Document | ShadowRoot | DocumentFragment
+): void;
+export function getNextElement(
+ template: HTMLTemplateElement,
+ isSSR: boolean
+): Node;
+export function getNextMarker(start: Node): [Node, Array];
+export function generateHydrationEventsScript(eventNames: string[]): string;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/index.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/index.d.ts
new file mode 100644
index 0000000000..a303c4aad1
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/index.d.ts
@@ -0,0 +1,8 @@
+export { createRoot, createSignal, createEffect, createDeferred, createDependentEffect, createMemo, isListening, onCleanup, onError, sample, freeze, createContext, useContext, getContextOwner, equalFn, afterEffects } from "./signal";
+export { createState, unwrap, force } from "./state";
+export { reconcile } from "./reconcile";
+export * from "./array";
+export * from "./component";
+export * from "./resource";
+export * from "./scheduler";
+export { runtimeConfig } from "./shared";
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/reconcile.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/reconcile.d.ts
new file mode 100644
index 0000000000..1e39568d11
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/reconcile.d.ts
@@ -0,0 +1,7 @@
+import { Wrapped, NotWrappable } from "./state";
+declare type ReconcileOptions = {
+ key?: string | null;
+ merge?: boolean;
+};
+export declare function reconcile(value: T | Wrapped, options?: ReconcileOptions): (state: T extends NotWrappable ? T : Wrapped) => void;
+export {};
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/resource.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/resource.d.ts
new file mode 100644
index 0000000000..615199760d
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/resource.d.ts
@@ -0,0 +1,40 @@
+import { Context } from "./signal";
+import { StateNode, SetStateFunction, Wrapped } from "./state";
+declare type SuspenseState = "running" | "suspended" | "fallback";
+declare type SuspenseContextType = {
+ increment?: () => void;
+ decrement?: () => void;
+ state?: () => SuspenseState;
+ initializing?: boolean;
+};
+declare type SuspenseConfig = {
+ timeoutMs: number;
+};
+export declare const SuspenseContext: Context & {
+ transition?: {
+ timeoutMs: number;
+ increment(): void;
+ decrement(): void;
+ };
+ active?(): boolean;
+ increment?(): void;
+ decrement?(): void;
+};
+export declare function createResource(value?: T): [() => T | undefined, (p?: Promise) => () => boolean];
+declare type LoadStateFunction = {
+ (v: {
+ [P in keyof T]: Promise | T[P];
+ }, reconcilerFn?: (v: Partial) => (state: Wrapped) => void): {
+ [P in keyof T]: boolean;
+ };
+};
+export declare function createResourceState(state: T | Wrapped): [Wrapped, LoadStateFunction, SetStateFunction];
+interface ComponentType {
+ (props: T): any;
+}
+export declare function lazy>(fn: () => Promise<{
+ default: T;
+}>): T;
+export declare function useTransition(config: SuspenseConfig): [() => boolean, (fn: () => any) => void];
+export declare function awaitSuspense(fn: () => T): () => T;
+export {};
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/scheduler.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/scheduler.d.ts
new file mode 100644
index 0000000000..a915c542fb
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/scheduler.d.ts
@@ -0,0 +1,10 @@
+export interface Task {
+ id: number;
+ fn: ((didTimeout: boolean) => void) | null;
+ startTime: number;
+ expirationTime: number;
+}
+export declare function requestCallback(fn: () => void, options?: {
+ timeout: number;
+}): Task;
+export declare function cancelCallback(task: Task): void;
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/shared.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/shared.d.ts
new file mode 100644
index 0000000000..f9b3c752ec
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/shared.d.ts
@@ -0,0 +1,11 @@
+declare type HydrationContext = {
+ id: string;
+ count: number;
+ registry?: Map;
+};
+export declare const runtimeConfig: {
+ hydrate?: HydrationContext;
+};
+export declare function setHydrateContext(context?: HydrationContext): void;
+export declare function nextHydrateContext(): HydrationContext | undefined;
+export {};
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/signal.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/signal.d.ts
new file mode 100644
index 0000000000..dea897ac58
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/signal.d.ts
@@ -0,0 +1,61 @@
+export declare const equalFn: (a: T, b: T) => boolean;
+export declare function createRoot(fn: (dispose: () => void) => T, detachedOwner?: ComputationNode): T;
+export declare function createSignal(value?: T, areEqual?: (prev: T, next: T) => boolean): [() => T, (v: T) => void];
+export declare function createEffect(fn: (v?: T) => T, value?: T): void;
+export declare function createDependentEffect(fn: (v?: T) => T, deps: (() => any) | (() => any)[], defer?: boolean): void;
+export declare function createMemo(fn: (v: T | undefined) => T, value?: T, areEqual?: (prev: T, next: T) => boolean): () => T;
+export declare function createDeferred(fn: () => T, options?: {
+ timeoutMs: number;
+}): () => T;
+export declare function freeze(fn: () => T): T;
+export declare function sample(fn: () => T): T;
+export declare function afterEffects(fn: () => void): void;
+export declare function onCleanup(fn: (final: boolean) => void): void;
+export declare function onError(fn: (err: any) => void): void;
+export declare function isListening(): boolean;
+export interface Context {
+ id: symbol;
+ Provider: (props: {
+ value: T;
+ children: any;
+ }) => any;
+ defaultValue?: T;
+}
+export declare function createContext(defaultValue?: T): Context;
+export declare function useContext(context: Context): T;
+export declare function getContextOwner(): ComputationNode | null;
+export declare class DataNode {
+ value?: any;
+ pending: any;
+ log: Log | null;
+ constructor(value?: any);
+ current(): any;
+ next(value: any): any;
+}
+declare type ComputationNode = {
+ fn: ((v: T) => T) | null;
+ value: T | undefined;
+ comparator: null | ((a: T, b: T) => boolean);
+ age: number;
+ state: number;
+ source1: null | Log;
+ source1slot: number;
+ sources: null | Log[];
+ sourceslots: null | number[];
+ dependents: null | (ComputationNode | null)[];
+ dependentslot: number;
+ dependentcount: number;
+ owner: ComputationNode | null;
+ log: Log | null;
+ context: any;
+ owned: ComputationNode[] | null;
+ cleanups: ((final: boolean) => void)[] | null;
+ afters: ((() => void)[]) | null;
+};
+declare type Log = {
+ node1: null | ComputationNode;
+ node1slot: number;
+ nodes: null | ComputationNode[];
+ nodeslots: null | number[];
+};
+export {};
diff --git a/__tests__/integration/sub-package-json/node_modules/solid-js/types/state.d.ts b/__tests__/integration/sub-package-json/node_modules/solid-js/types/state.d.ts
new file mode 100644
index 0000000000..776e5d54b2
--- /dev/null
+++ b/__tests__/integration/sub-package-json/node_modules/solid-js/types/state.d.ts
@@ -0,0 +1,45 @@
+export declare const SNODE: unique symbol, SPROXY: unique symbol;
+export declare type StateNode = {
+ [SNODE]?: any;
+ [SPROXY]?: any;
+ [k: string]: any;
+ [k: number]: any;
+};
+declare type AddSymbolToPrimitive = T extends {
+ [Symbol.toPrimitive]: infer V;
+} ? {
+ [Symbol.toPrimitive]: V;
+} : {};
+declare type AddCallable = T extends {
+ (...x: any[]): infer V;
+} ? {
+ (...x: Parameters): V;
+} : {};
+export declare type NotWrappable = string | number | boolean | Function | null;
+export declare type Wrapped = {
+ [P in keyof T]: T[P] extends object ? Wrapped : T[P];
+} & {
+ _state?: T;
+} & AddSymbolToPrimitive & AddCallable;
+declare type StateSetter = Partial | ((prevState: T extends NotWrappable ? T : Wrapped, traversed?: (string | number)[]) => Partial | void);
+declare type StatePathRange = {
+ from?: number;
+ to?: number;
+ by?: number;
+};
+declare type StatePathPart = string | number | (string | number)[] | StatePathRange | ((item: any, index: number) => boolean);
+declare type StatePath = [keyof T, StatePathPart, StateSetter] | [keyof T, StatePathPart, StatePathPart, StateSetter] | [keyof T, StatePathPart, StatePathPart, StatePathPart, StateSetter] | [keyof T, StatePathPart, StatePathPart, StatePathPart, StatePathPart, StateSetter] | [keyof T, StatePathPart, StatePathPart, StatePathPart, StatePathPart, StatePathPart, StateSetter] | [keyof T, StatePathPart, StatePathPart, StatePathPart, StatePathPart, StatePathPart, StatePathPart, StateSetter];
+export declare function wrap(value: T, traps?: ProxyHandler): Wrapped;
+export declare function isWrappable(obj: any): boolean;
+export declare function unwrap(item: any): T;
+export declare function getDataNodes(target: StateNode): any;
+export declare function setProperty(state: StateNode, property: string | number, value: any, force?: boolean): void;
+export declare function updatePath(current: StateNode, path: any[], traversed?: (number | string)[]): void;
+export interface SetStateFunction {
+ (update: StateSetter): void;
+ (part: A, update: StateSetter): void;
+ (...path: StatePath): void;
+}
+export declare function createState(state: T | Wrapped): [Wrapped, SetStateFunction];
+export declare function force(value: T | Wrapped): (state: T extends NotWrappable ? T : Wrapped) => void;
+export {};
diff --git a/__tests__/integration/sub-package-json/package-lock.json b/__tests__/integration/sub-package-json/package-lock.json
new file mode 100644
index 0000000000..f713400a7e
--- /dev/null
+++ b/__tests__/integration/sub-package-json/package-lock.json
@@ -0,0 +1,11 @@
+{
+ "requires": true,
+ "lockfileVersion": 1,
+ "dependencies": {
+ "solid-js": {
+ "version": "0.16.7",
+ "resolved": "https://registry.npmjs.org/solid-js/-/solid-js-0.16.7.tgz",
+ "integrity": "sha512-05P9VHmolhFczJoJ3ewtU9EPXzu021yJ//Lan9IgH+y+cE9381oOOLeIjg7ay2wS0jnyBsIVITEUXqSsjrgbbQ=="
+ }
+ }
+}
diff --git a/__tests__/integration/sub-package-json/package.json b/__tests__/integration/sub-package-json/package.json
new file mode 100644
index 0000000000..d79cfbbc7e
--- /dev/null
+++ b/__tests__/integration/sub-package-json/package.json
@@ -0,0 +1,13 @@
+{
+ "scripts": {
+ "TEST": "node ../../../pkg/dist-node/index.bin.js"
+ },
+ "snowpack": {
+ "webDependencies": [
+ "solid-js/dom"
+ ]
+ },
+ "dependencies": {
+ "solid-js": "^0.16.7"
+ }
+}
diff --git a/src/util.ts b/src/util.ts
index 318d1c4709..8c25c6b651 100644
--- a/src/util.ts
+++ b/src/util.ts
@@ -10,6 +10,26 @@ import path from 'path';
* but now with export map support in Node v13 that's no longer possible.
*/
export function resolveDependencyManifest(dep: string, cwd: string) {
+ // Attempt #1: Resolve the dependency manifest normally. This works for most
+ // packages, but fails when the package defines an export map that doesn't
+ // include a package.json. If we detect that to be the reason for failure,
+ // move on to our custom implementation.
+ try {
+ const depManifest = require.resolve(`${dep}/package.json`, {paths: [cwd]});
+ return [depManifest, require(depManifest)];
+ } catch (err) {
+ if (err.code === 'MODULE_NOT_FOUND' && err.message.includes(`'./package.json'`)) {
+ // its most likely an export map issue, move on to our manual resolver.
+ } else {
+ throw err;
+ }
+ }
+
+ // Attempt #2: Resolve the dependency manifest manually. This involves resolving
+ // the dep itself to find the entrypoint file, and then haphazardly replacing the
+ // file path within the package with a "./package.json" instead. It's not as
+ // thorough as Attempt #1, but it should work well until export maps become more
+ // established & move out of experimental mode.
let result = [null, null] as [string | null, any | null];
try {
const fullPath = require.resolve(dep, {paths: [cwd]});
